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