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 class DSForm_1a<bits<6> opcode, bits<2> xo, dag OOL, dag IOL, string asmstr,
 364                 InstrItinClass itin, list<dag> pattern>
 365          : I<opcode, OOL, IOL, asmstr, itin> {
 366    bits<5>  RST;
 367    bits<14> DS;
 368    bits<5>  RA;
 369
 370    let Pattern = pattern;
 371
 372    let Inst{6-10}  = RST;
 373    let Inst{11-15} = RA;
 374    let Inst{16-29} = DS;
 375    let Inst{30-31} = xo;
 376 }
 377
 378 // 1.7.6 X-Form
 379 class XForm_base_r3xo<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 380                       InstrItinClass itin, list<dag> pattern>
 381   : I<opcode, OOL, IOL, asmstr, itin> {
 382   bits<5> RST;
 383   bits<5> A;
 384   bits<5> B;
 385
 386   let Pattern = pattern;
 387
 388   bit RC = 0;    // set by isDOT
 389
 390   let Inst{6-10}  = RST;
 391   let Inst{11-15} = A;
 392   let Inst{16-20} = B;
 393   let Inst{21-30} = xo;
 394   let Inst{31}    = RC;
 395 }
 396
 397 // This is the same as XForm_base_r3xo, but the first two operands are swapped
 398 // when code is emitted.
 399 class XForm_base_r3xo_swapped
 400         <bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 401         InstrItinClass itin>
 402   : I<opcode, OOL, IOL, asmstr, itin> {
 403   bits<5> A;
 404   bits<5> RST;
 405   bits<5> B;
 406
 407   bit RC = 0;    // set by isDOT
 408
 409   let Inst{6-10}  = RST;
 410   let Inst{11-15} = A;
 411   let Inst{16-20} = B;
 412   let Inst{21-30} = xo;
 413   let Inst{31}    = RC;
 414 }
 415
 416
 417 class XForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 418               InstrItinClass itin, list<dag> pattern>
 419   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern>;
 420
 421 class XForm_1a<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 422               InstrItinClass itin, list<dag> pattern>
 423   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 424   let RST = 0;
 425 }
 426
 427 class XForm_rs<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 428               InstrItinClass itin, list<dag> pattern>
 429   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 430   let A = 0;
 431   let B = 0;
 432 }
 433
 434 class XForm_6<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 435               InstrItinClass itin, list<dag> pattern>
 436   : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> {
 437   let Pattern = pattern;
 438 }
 439
 440 class XForm_8<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 441               InstrItinClass itin, list<dag> pattern>
 442   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern>;
 443
 444 class XForm_10<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 445                InstrItinClass itin, list<dag> pattern>
 446   : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> {
 447     let Pattern = pattern;
 448 }
 449
 450 class XForm_11<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 451                InstrItinClass itin, list<dag> pattern>
 452   : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> {
 453   let B = 0;
 454   let Pattern = pattern;
 455 }
 456
 457 class XForm_16<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 458                InstrItinClass itin>
 459          : I<opcode, OOL, IOL, asmstr, itin> {
 460   bits<3> BF;
 461   bits<1> L;
 462   bits<5> RA;
 463   bits<5> RB;
 464
 465   let Inst{6-8}   = BF;
 466   let Inst{9}     = 0;
 467   let Inst{10}    = L;
 468   let Inst{11-15} = RA;
 469   let Inst{16-20} = RB;
 470   let Inst{21-30} = xo;
 471   let Inst{31}    = 0;
 472 }
 473
 474 class XForm_mtmsr<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 475                 InstrItinClass itin>
 476          : I<opcode, OOL, IOL, asmstr, itin> {
 477   bits<5> RS;
 478   bits<1> L;
 479
 480   let Inst{6-10} = RS;
 481   let Inst{15} = L;
 482   let Inst{21-30} = xo;
 483 }
 484
 485 class XForm_16_ext<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 486                    InstrItinClass itin>
 487   : XForm_16<opcode, xo, OOL, IOL, asmstr, itin> {
 488   let L = PPC64;
 489 }
 490
 491 class XForm_17<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 492                InstrItinClass itin>
 493          : I<opcode, OOL, IOL, asmstr, itin> {
 494   bits<3> BF;
 495   bits<5> FRA;
 496   bits<5> FRB;
 497
 498   let Inst{6-8}   = BF;
 499   let Inst{9-10}  = 0;
 500   let Inst{11-15} = FRA;
 501   let Inst{16-20} = FRB;
 502   let Inst{21-30} = xo;
 503   let Inst{31}    = 0;
 504 }
 505
 506 class XForm_24<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 507                InstrItinClass itin, list<dag> pattern>
 508   : I<opcode, OOL, IOL, asmstr, itin> {
 509   let Pattern = pattern;
 510   let Inst{6-10}  = 31;
 511   let Inst{11-15} = 0;
 512   let Inst{16-20} = 0;
 513   let Inst{21-30} = xo;
 514   let Inst{31}    = 0;
 515 }
 516
 517 class XForm_24_sync<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 518                string asmstr, InstrItinClass itin, list<dag> pattern>
 519   : I<opcode, OOL, IOL, asmstr, itin> {
 520   bits<2> L;
 521
 522   let Pattern = pattern;
 523   let Inst{6-8}   = 0;
 524   let Inst{9-10}  = L;
 525   let Inst{11-15} = 0;
 526   let Inst{16-20} = 0;
 527   let Inst{21-30} = xo;
 528   let Inst{31}    = 0;
 529 }
 530
 531 class XForm_24_eieio<bits<6> opcode, bits<10> xo, dag OOL, dag IOL,
 532                string asmstr, InstrItinClass itin, list<dag> pattern>
 533   : XForm_24_sync<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 534   let L = 0;
 535 }
 536
 537 class XForm_25<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 538                InstrItinClass itin, list<dag> pattern>
 539   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 540 }
 541
 542 class XForm_26<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 543                InstrItinClass itin, list<dag> pattern>
 544   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 545   let A = 0;
 546 }
 547
 548 class XForm_28<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 549                InstrItinClass itin, list<dag> pattern>
 550   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 551 }
 552
 553 // This is used for MFFS, MTFSB0, MTFSB1.  42 is arbitrary; this series of
 554 // numbers presumably relates to some document, but I haven't found it.
 555 class XForm_42<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 556               InstrItinClass itin, list<dag> pattern>
 557   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 558   let Pattern = pattern;
 559
 560   bit RC = 0;    // set by isDOT
 561
 562   let Inst{6-10}  = RST;
 563   let Inst{11-20} = 0;
 564   let Inst{21-30} = xo;
 565   let Inst{31}    = RC;
 566 }
 567 class XForm_43<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 568               InstrItinClass itin, list<dag> pattern>
 569   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 570   let Pattern = pattern;
 571   bits<5> FM;
 572
 573   bit RC = 0;    // set by isDOT
 574
 575   let Inst{6-10}  = FM;
 576   let Inst{11-20} = 0;
 577   let Inst{21-30} = xo;
 578   let Inst{31}    = RC;
 579 }
 580
 581 class XForm_0<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 582               InstrItinClass itin, list<dag> pattern>
 583   : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 584   let RST = 0;
 585   let A = 0;
 586   let B = 0;
 587 }
 588
 589 class XForm_16b<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 }
 595
 596 // DCB_Form - Form X instruction, used for dcb* instructions.
 597 class DCB_Form<bits<10> xo, bits<5> immfield, dag OOL, dag IOL, string asmstr,
 598                       InstrItinClass itin, list<dag> pattern>
 599   : I<31, OOL, IOL, asmstr, itin> {
 600   bits<5> A;
 601   bits<5> B;
 602
 603   let Pattern = pattern;
 604
 605   let Inst{6-10}  = immfield;
 606   let Inst{11-15} = A;
 607   let Inst{16-20} = B;
 608   let Inst{21-30} = xo;
 609   let Inst{31}    = 0;
 610 }
 611
 612
 613 // DSS_Form - Form X instruction, used for altivec dss* instructions.
 614 class DSS_Form<bits<10> xo, dag OOL, dag IOL, string asmstr,
 615                       InstrItinClass itin, list<dag> pattern>
 616   : I<31, OOL, IOL, asmstr, itin> {
 617   bits<1> T;
 618   bits<2> STRM;
 619   bits<5> A;
 620   bits<5> B;
 621
 622   let Pattern = pattern;
 623
 624   let Inst{6}     = T;
 625   let Inst{7-8}   = 0;
 626   let Inst{9-10}  = STRM;
 627   let Inst{11-15} = A;
 628   let Inst{16-20} = B;
 629   let Inst{21-30} = xo;
 630   let Inst{31}    = 0;
 631 }
 632
 633 // 1.7.7 XL-Form
 634 class XLForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 635                InstrItinClass itin, list<dag> pattern>
 636     : I<opcode, OOL, IOL, asmstr, itin> {
 637   bits<5> CRD;
 638   bits<5> CRA;
 639   bits<5> CRB;
 640
 641   let Pattern = pattern;
 642
 643   let Inst{6-10}  = CRD;
 644   let Inst{11-15} = CRA;
 645   let Inst{16-20} = CRB;
 646   let Inst{21-30} = xo;
 647   let Inst{31}    = 0;
 648 }
 649
 650 class XLForm_1_ext<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 651                InstrItinClass itin, list<dag> pattern>
 652     : I<opcode, OOL, IOL, asmstr, itin> {
 653   bits<5> CRD;
 654
 655   let Pattern = pattern;
 656
 657   let Inst{6-10}  = CRD;
 658   let Inst{11-15} = CRD;
 659   let Inst{16-20} = CRD;
 660   let Inst{21-30} = xo;
 661   let Inst{31}    = 0;
 662 }
 663
 664 class XLForm_2<bits<6> opcode, bits<10> xo, bit lk, dag OOL, dag IOL, string asmstr,
 665                InstrItinClass itin, list<dag> pattern>
 666     : I<opcode, OOL, IOL, asmstr, itin> {
 667   bits<5> BO;
 668   bits<5> BI;
 669   bits<2> BH;
 670
 671   let Pattern = pattern;
 672
 673   let Inst{6-10}  = BO;
 674   let Inst{11-15} = BI;
 675   let Inst{16-18} = 0;
 676   let Inst{19-20} = BH;
 677   let Inst{21-30} = xo;
 678   let Inst{31}    = lk;
 679 }
 680
 681 class XLForm_2_br<bits<6> opcode, bits<10> xo, bit lk,
 682                   dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
 683   : XLForm_2<opcode, xo, lk, OOL, IOL, asmstr, itin, pattern> {
 684   bits<7> BIBO;  // 2 bits of BI and 5 bits of BO.
 685   bits<3>  CR;
 686
 687   let BO = BIBO{4-0};
 688   let BI{0-1} = BIBO{5-6};
 689   let BI{2-4} = CR{0-2};
 690   let BH = 0;
 691 }
 692
 693 class XLForm_2_br2<bits<6> opcode, bits<10> xo, bits<5> bo, bit lk,
 694                    dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
 695   : XLForm_2<opcode, xo, lk, OOL, IOL, asmstr, itin, pattern> {
 696   let BO = bo;
 697   let BH = 0;
 698 }
 699
 700 class XLForm_2_ext<bits<6> opcode, bits<10> xo, bits<5> bo,  bits<5> bi, bit lk,
 701                   dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
 702   : XLForm_2<opcode, xo, lk, OOL, IOL, asmstr, itin, pattern> {
 703   let BO = bo;
 704   let BI = bi;
 705   let BH = 0;
 706 }
 707
 708 class XLForm_3<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 709                InstrItinClass itin>
 710          : I<opcode, OOL, IOL, asmstr, itin> {
 711   bits<3> BF;
 712   bits<3> BFA;
 713
 714   let Inst{6-8}   = BF;
 715   let Inst{9-10}  = 0;
 716   let Inst{11-13} = BFA;
 717   let Inst{14-15} = 0;
 718   let Inst{16-20} = 0;
 719   let Inst{21-30} = xo;
 720   let Inst{31}    = 0;
 721 }
 722
 723 // 1.7.8 XFX-Form
 724 class XFXForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 725                 InstrItinClass itin>
 726          : I<opcode, OOL, IOL, asmstr, itin> {
 727   bits<5>  RT;
 728   bits<10> SPR;
 729
 730   let Inst{6-10}  = RT;
 731   let Inst{11}    = SPR{4};
 732   let Inst{12}    = SPR{3};
 733   let Inst{13}    = SPR{2};
 734   let Inst{14}    = SPR{1};
 735   let Inst{15}    = SPR{0};
 736   let Inst{16}    = SPR{9};
 737   let Inst{17}    = SPR{8};
 738   let Inst{18}    = SPR{7};
 739   let Inst{19}    = SPR{6};
 740   let Inst{20}    = SPR{5};
 741   let Inst{21-30} = xo;
 742   let Inst{31}    = 0;
 743 }
 744
 745 class XFXForm_1_ext<bits<6> opcode, bits<10> xo, bits<10> spr,
 746                    dag OOL, dag IOL, string asmstr, InstrItinClass itin>
 747   : XFXForm_1<opcode, xo, OOL, IOL, asmstr, itin> {
 748   let SPR = spr;
 749 }
 750
 751 class XFXForm_3<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 752                 InstrItinClass itin>
 753          : I<opcode, OOL, IOL, asmstr, itin> {
 754   bits<5>  RT;
 755
 756   let Inst{6-10}  = RT;
 757   let Inst{11-20} = 0;
 758   let Inst{21-30} = xo;
 759   let Inst{31}    = 0;
 760 }
 761
 762 class XFXForm_5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 763                 InstrItinClass itin>
 764   : I<opcode, OOL, IOL, asmstr, itin> {
 765   bits<8>  FXM;
 766   bits<5>  rS;
 767
 768   let Inst{6-10}  = rS;
 769   let Inst{11}    = 0;
 770   let Inst{12-19} = FXM;
 771   let Inst{20}    = 0;
 772   let Inst{21-30} = xo;
 773   let Inst{31}    = 0;
 774 }
 775
 776 class XFXForm_5a<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 777                  InstrItinClass itin>
 778   : I<opcode, OOL, IOL, asmstr, itin> {
 779   bits<5>  ST;
 780   bits<8>  FXM;
 781
 782   let Inst{6-10}  = ST;
 783   let Inst{11}    = 1;
 784   let Inst{12-19} = FXM;
 785   let Inst{20}    = 0;
 786   let Inst{21-30} = xo;
 787   let Inst{31}    = 0;
 788 }
 789
 790 class XFXForm_7<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 791                 InstrItinClass itin>
 792   : XFXForm_1<opcode, xo, OOL, IOL, asmstr, itin>;
 793
 794 class XFXForm_7_ext<bits<6> opcode, bits<10> xo, bits<10> spr,
 795                     dag OOL, dag IOL, string asmstr, InstrItinClass itin>
 796   : XFXForm_7<opcode, xo, OOL, IOL, asmstr, itin> {
 797   let SPR = spr;
 798 }
 799
 800 // XFL-Form - MTFSF
 801 // This is probably 1.7.9, but I don't have the reference that uses this
 802 // numbering scheme...
 803 class XFLForm<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr,
 804               InstrItinClass itin, list<dag>pattern>
 805   : I<opcode, OOL, IOL, asmstr, itin> {
 806   bits<8> FM;
 807   bits<5> rT;
 808
 809   bit RC = 0;    // set by isDOT
 810   let Pattern = pattern;
 811
 812   let Inst{6} = 0;
 813   let Inst{7-14}  = FM;
 814   let Inst{15} = 0;
 815   let Inst{16-20} = rT;
 816   let Inst{21-30} = xo;
 817   let Inst{31}    = RC;
 818 }
 819
 820 // 1.7.10 XS-Form - SRADI.
 821 class XSForm_1<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, string asmstr,
 822                InstrItinClass itin, list<dag> pattern>
 823          : I<opcode, OOL, IOL, asmstr, itin> {
 824   bits<5> A;
 825   bits<5> RS;
 826   bits<6> SH;
 827
 828   bit RC = 0;    // set by isDOT
 829   let Pattern = pattern;
 830
 831   let Inst{6-10}  = RS;
 832   let Inst{11-15} = A;
 833   let Inst{16-20} = SH{4,3,2,1,0};
 834   let Inst{21-29} = xo;
 835   let Inst{30}    = SH{5};
 836   let Inst{31}    = RC;
 837 }
 838
 839 // 1.7.11 XO-Form
 840 class XOForm_1<bits<6> opcode, bits<9> xo, bit oe, dag OOL, dag IOL, string asmstr,
 841                InstrItinClass itin, list<dag> pattern>
 842          : I<opcode, OOL, IOL, asmstr, itin> {
 843   bits<5> RT;
 844   bits<5> RA;
 845   bits<5> RB;
 846
 847   let Pattern = pattern;
 848
 849   bit RC = 0;    // set by isDOT
 850
 851   let Inst{6-10}  = RT;
 852   let Inst{11-15} = RA;
 853   let Inst{16-20} = RB;
 854   let Inst{21}    = oe;
 855   let Inst{22-30} = xo;
 856   let Inst{31}    = RC;
 857 }
 858
 859 class XOForm_3<bits<6> opcode, bits<9> xo, bit oe,
 860                dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern>
 861   : XOForm_1<opcode, xo, oe, OOL, IOL, asmstr, itin, pattern> {
 862   let RB = 0;
 863 }
 864
 865 // 1.7.12 A-Form
 866 class AForm_1<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
 867               InstrItinClass itin, list<dag> pattern>
 868          : I<opcode, OOL, IOL, asmstr, itin> {
 869   bits<5> FRT;
 870   bits<5> FRA;
 871   bits<5> FRC;
 872   bits<5> FRB;
 873
 874   let Pattern = pattern;
 875
 876   bit RC = 0;    // set by isDOT
 877
 878   let Inst{6-10}  = FRT;
 879   let Inst{11-15} = FRA;
 880   let Inst{16-20} = FRB;
 881   let Inst{21-25} = FRC;
 882   let Inst{26-30} = xo;
 883   let Inst{31}    = RC;
 884 }
 885
 886 class AForm_2<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
 887               InstrItinClass itin, list<dag> pattern>
 888   : AForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 889   let FRC = 0;
 890 }
 891
 892 class AForm_3<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
 893               InstrItinClass itin, list<dag> pattern>
 894   : AForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> {
 895   let FRB = 0;
 896 }
 897
 898 class AForm_4<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr,
 899               InstrItinClass itin, list<dag> pattern>
 900          : I<opcode, OOL, IOL, asmstr, itin> {
 901   bits<5> RT;
 902   bits<5> RA;
 903   bits<5> RB;
 904   bits<5> COND;
 905
 906   let Pattern = pattern;
 907
 908   let Inst{6-10}  = RT;
 909   let Inst{11-15} = RA;
 910   let Inst{16-20} = RB;
 911   let Inst{21-25} = COND;
 912   let Inst{26-30} = xo;
 913   let Inst{31}    = 0;
 914 }
 915
 916 // 1.7.13 M-Form
 917 class MForm_1<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 918               InstrItinClass itin, list<dag> pattern>
 919     : I<opcode, OOL, IOL, asmstr, itin> {
 920   bits<5> RA;
 921   bits<5> RS;
 922   bits<5> RB;
 923   bits<5> MB;
 924   bits<5> ME;
 925
 926   let Pattern = pattern;
 927
 928   bit RC = 0;    // set by isDOT
 929
 930   let Inst{6-10}  = RS;
 931   let Inst{11-15} = RA;
 932   let Inst{16-20} = RB;
 933   let Inst{21-25} = MB;
 934   let Inst{26-30} = ME;
 935   let Inst{31}    = RC;
 936 }
 937
 938 class MForm_2<bits<6> opcode, dag OOL, dag IOL, string asmstr,
 939               InstrItinClass itin, list<dag> pattern>
 940   : MForm_1<opcode, OOL, IOL, asmstr, itin, pattern> {
 941 }
 942
 943 // 1.7.14 MD-Form
 944 class MDForm_1<bits<6> opcode, bits<3> xo, dag OOL, dag IOL, string asmstr,
 945                InstrItinClass itin, list<dag> pattern>
 946     : I<opcode, OOL, IOL, asmstr, itin> {
 947   bits<5> RA;
 948   bits<5> RS;
 949   bits<6> SH;
 950   bits<6> MBE;
 951
 952   let Pattern = pattern;
 953
 954   bit RC = 0;    // set by isDOT
 955
 956   let Inst{6-10}  = RS;
 957   let Inst{11-15} = RA;
 958   let Inst{16-20} = SH{4,3,2,1,0};
 959   let Inst{21-26} = MBE{4,3,2,1,0,5};
 960   let Inst{27-29} = xo;
 961   let Inst{30}    = SH{5};
 962   let Inst{31}    = RC;
 963 }
 964
 965 class MDSForm_1<bits<6> opcode, bits<4> xo, dag OOL, dag IOL, string asmstr,
 966                 InstrItinClass itin, list<dag> pattern>
 967     : I<opcode, OOL, IOL, asmstr, itin> {
 968   bits<5> RA;
 969   bits<5> RS;
 970   bits<5> RB;
 971   bits<6> MBE;
 972
 973   let Pattern = pattern;
 974
 975   bit RC = 0;    // set by isDOT
 976
 977   let Inst{6-10}  = RS;
 978   let Inst{11-15} = RA;
 979   let Inst{16-20} = RB;
 980   let Inst{21-26} = MBE{4,3,2,1,0,5};
 981   let Inst{27-30} = xo;
 982   let Inst{31}    = RC;
 983 }
 984
 985
 986 // E-1 VA-Form
 987
 988 // VAForm_1 - DACB ordering.
 989 class VAForm_1<bits<6> xo, dag OOL, dag IOL, string asmstr,
 990                InstrItinClass itin, list<dag> pattern>
 991     : I<4, OOL, IOL, asmstr, itin> {
 992   bits<5> VD;
 993   bits<5> VA;
 994   bits<5> VC;
 995   bits<5> VB;
 996
 997   let Pattern = pattern;
 998
 999   let Inst{6-10}  = VD;
1000   let Inst{11-15} = VA;
1001   let Inst{16-20} = VB;
1002   let Inst{21-25} = VC;
1003   let Inst{26-31} = xo;
1004 }
1005
1006 // VAForm_1a - DABC ordering.
1007 class VAForm_1a<bits<6> xo, dag OOL, dag IOL, string asmstr,
1008                 InstrItinClass itin, list<dag> pattern>
1009     : I<4, OOL, IOL, asmstr, itin> {
1010   bits<5> VD;
1011   bits<5> VA;
1012   bits<5> VB;
1013   bits<5> VC;
1014
1015   let Pattern = pattern;
1016
1017   let Inst{6-10}  = VD;
1018   let Inst{11-15} = VA;
1019   let Inst{16-20} = VB;
1020   let Inst{21-25} = VC;
1021   let Inst{26-31} = xo;
1022 }
1023
1024 class VAForm_2<bits<6> xo, dag OOL, dag IOL, string asmstr,
1025                InstrItinClass itin, list<dag> pattern>
1026     : I<4, OOL, IOL, asmstr, itin> {
1027   bits<5> VD;
1028   bits<5> VA;
1029   bits<5> VB;
1030   bits<4> SH;
1031
1032   let Pattern = pattern;
1033
1034   let Inst{6-10}  = VD;
1035   let Inst{11-15} = VA;
1036   let Inst{16-20} = VB;
1037   let Inst{21}    = 0;
1038   let Inst{22-25} = SH;
1039   let Inst{26-31} = xo;
1040 }
1041
1042 // E-2 VX-Form
1043 class VXForm_1<bits<11> xo, dag OOL, dag IOL, string asmstr,
1044                InstrItinClass itin, list<dag> pattern>
1045     : I<4, OOL, IOL, asmstr, itin> {
1046   bits<5> VD;
1047   bits<5> VA;
1048   bits<5> VB;
1049
1050   let Pattern = pattern;
1051
1052   let Inst{6-10}  = VD;
1053   let Inst{11-15} = VA;
1054   let Inst{16-20} = VB;
1055   let Inst{21-31} = xo;
1056 }
1057
1058 class VXForm_setzero<bits<11> xo, dag OOL, dag IOL, string asmstr,
1059                InstrItinClass itin, list<dag> pattern>
1060     : VXForm_1<xo, OOL, IOL, asmstr, itin, pattern> {
1061   let VA = VD;
1062   let VB = VD;
1063 }
1064
1065
1066 class VXForm_2<bits<11> xo, dag OOL, dag IOL, string asmstr,
1067                InstrItinClass itin, list<dag> pattern>
1068     : I<4, OOL, IOL, asmstr, itin> {
1069   bits<5> VD;
1070   bits<5> VB;
1071
1072   let Pattern = pattern;
1073
1074   let Inst{6-10}  = VD;
1075   let Inst{11-15} = 0;
1076   let Inst{16-20} = VB;
1077   let Inst{21-31} = xo;
1078 }
1079
1080 class VXForm_3<bits<11> xo, dag OOL, dag IOL, string asmstr,
1081                InstrItinClass itin, list<dag> pattern>
1082     : I<4, OOL, IOL, asmstr, itin> {
1083   bits<5> VD;
1084   bits<5> IMM;
1085
1086   let Pattern = pattern;
1087
1088   let Inst{6-10}  = VD;
1089   let Inst{11-15} = IMM;
1090   let Inst{16-20} = 0;
1091   let Inst{21-31} = xo;
1092 }
1093
1094 /// VXForm_4 - VX instructions with "VD,0,0" register fields, like mfvscr.
1095 class VXForm_4<bits<11> xo, dag OOL, dag IOL, string asmstr,
1096                InstrItinClass itin, list<dag> pattern>
1097     : I<4, OOL, IOL, asmstr, itin> {
1098   bits<5> VD;
1099
1100   let Pattern = pattern;
1101
1102   let Inst{6-10}  = VD;
1103   let Inst{11-15} = 0;
1104   let Inst{16-20} = 0;
1105   let Inst{21-31} = xo;
1106 }
1107
1108 /// VXForm_5 - VX instructions with "0,0,VB" register fields, like mtvscr.
1109 class VXForm_5<bits<11> xo, dag OOL, dag IOL, string asmstr,
1110                InstrItinClass itin, list<dag> pattern>
1111     : I<4, OOL, IOL, asmstr, itin> {
1112   bits<5> VB;
1113
1114   let Pattern = pattern;
1115
1116   let Inst{6-10}  = 0;
1117   let Inst{11-15} = 0;
1118   let Inst{16-20} = VB;
1119   let Inst{21-31} = xo;
1120 }
1121
1122 // E-4 VXR-Form
1123 class VXRForm_1<bits<10> xo, dag OOL, dag IOL, string asmstr,
1124                InstrItinClass itin, list<dag> pattern>
1125     : I<4, OOL, IOL, asmstr, itin> {
1126   bits<5> VD;
1127   bits<5> VA;
1128   bits<5> VB;
1129   bit RC = 0;
1130
1131   let Pattern = pattern;
1132
1133   let Inst{6-10}  = VD;
1134   let Inst{11-15} = VA;
1135   let Inst{16-20} = VB;
1136   let Inst{21}    = RC;
1137   let Inst{22-31} = xo;
1138 }
1139
1140 //===----------------------------------------------------------------------===//
1141 class Pseudo<dag OOL, dag IOL, string asmstr, list<dag> pattern>
1142     : I<0, OOL, IOL, asmstr, NoItinerary> {
1143   let isCodeGenOnly = 1;
1144   let PPC64 = 0;
1145   let Pattern = pattern;
1146   let Inst{31-0} = 0;
1147 }