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