1//===- PowerPCInstrFormats.td - PowerPC Instruction Formats --*- tablegen -*-=// 2// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6// 7//===----------------------------------------------------------------------===// 8 9//===----------------------------------------------------------------------===// 10// 11// PowerPC instruction formats 12 13class I<bits<6> opcode, dag OOL, dag IOL, string asmstr, InstrItinClass itin> 14 : Instruction { 15 field bits<32> Inst; 16 field bits<32> SoftFail = 0; 17 let Size = 4; 18 19 bit PPC64 = 0; // Default value, override with isPPC64 20 21 let Namespace = "PPC"; 22 let Inst{0-5} = opcode; 23 let OutOperandList = OOL; 24 let InOperandList = IOL; 25 let AsmString = asmstr; 26 let Itinerary = itin; 27 28 bits<1> PPC970_First = 0; 29 bits<1> PPC970_Single = 0; 30 bits<1> PPC970_Cracked = 0; 31 bits<3> PPC970_Unit = 0; 32 33 /// These fields correspond to the fields in PPCInstrInfo.h. Any changes to 34 /// these must be reflected there! See comments there for what these are. 35 let TSFlags{0} = PPC970_First; 36 let TSFlags{1} = PPC970_Single; 37 let TSFlags{2} = PPC970_Cracked; 38 let TSFlags{5-3} = PPC970_Unit; 39 40 // Indicate that this instruction is of type X-Form Load or Store 41 bits<1> XFormMemOp = 0; 42 let TSFlags{6} = XFormMemOp; 43 44 // Indicate that this instruction is prefixed. 45 bits<1> Prefixed = 0; 46 let TSFlags{7} = Prefixed; 47 48 // Fields used for relation models. 49 string BaseName = ""; 50 51 // For cases where multiple instruction definitions really represent the 52 // same underlying instruction but with one definition for 64-bit arguments 53 // and one for 32-bit arguments, this bit breaks the degeneracy between 54 // the two forms and allows TableGen to generate mapping tables. 55 bit Interpretation64Bit = 0; 56} 57 58class PPC970_DGroup_First { bits<1> PPC970_First = 1; } 59class PPC970_DGroup_Single { bits<1> PPC970_Single = 1; } 60class PPC970_DGroup_Cracked { bits<1> PPC970_Cracked = 1; } 61class PPC970_MicroCode; 62 63class PPC970_Unit_Pseudo { bits<3> PPC970_Unit = 0; } 64class PPC970_Unit_FXU { bits<3> PPC970_Unit = 1; } 65class PPC970_Unit_LSU { bits<3> PPC970_Unit = 2; } 66class PPC970_Unit_FPU { bits<3> PPC970_Unit = 3; } 67class PPC970_Unit_CRU { bits<3> PPC970_Unit = 4; } 68class PPC970_Unit_VALU { bits<3> PPC970_Unit = 5; } 69class PPC970_Unit_VPERM { bits<3> PPC970_Unit = 6; } 70class PPC970_Unit_BRU { bits<3> PPC970_Unit = 7; } 71 72class XFormMemOp { bits<1> XFormMemOp = 1; } 73 74// Two joined instructions; used to emit two adjacent instructions as one. 75// The itinerary from the first instruction is used for scheduling and 76// classification. 77class I2<bits<6> opcode1, bits<6> opcode2, dag OOL, dag IOL, string asmstr, 78 InstrItinClass itin> 79 : Instruction { 80 field bits<64> Inst; 81 field bits<64> SoftFail = 0; 82 let Size = 8; 83 84 bit PPC64 = 0; // Default value, override with isPPC64 85 86 let Namespace = "PPC"; 87 let Inst{0-5} = opcode1; 88 let Inst{32-37} = opcode2; 89 let OutOperandList = OOL; 90 let InOperandList = IOL; 91 let AsmString = asmstr; 92 let Itinerary = itin; 93 94 bits<1> PPC970_First = 0; 95 bits<1> PPC970_Single = 0; 96 bits<1> PPC970_Cracked = 0; 97 bits<3> PPC970_Unit = 0; 98 99 /// These fields correspond to the fields in PPCInstrInfo.h. Any changes to 100 /// these must be reflected there! See comments there for what these are. 101 let TSFlags{0} = PPC970_First; 102 let TSFlags{1} = PPC970_Single; 103 let TSFlags{2} = PPC970_Cracked; 104 let TSFlags{5-3} = PPC970_Unit; 105 106 // Fields used for relation models. 107 string BaseName = ""; 108 bit Interpretation64Bit = 0; 109} 110 111// Base class for all X-Form memory instructions 112class IXFormMemOp<bits<6> opcode, dag OOL, dag IOL, string asmstr, 113 InstrItinClass itin> 114 :I<opcode, OOL, IOL, asmstr, itin>, XFormMemOp; 115 116// 1.7.1 I-Form 117class IForm<bits<6> opcode, bit aa, bit lk, dag OOL, dag IOL, string asmstr, 118 InstrItinClass itin, list<dag> pattern> 119 : I<opcode, OOL, IOL, asmstr, itin> { 120 let Pattern = pattern; 121 bits<24> LI; 122 123 let Inst{6-29} = LI; 124 let Inst{30} = aa; 125 let Inst{31} = lk; 126} 127 128// 1.7.2 B-Form 129class BForm<bits<6> opcode, bit aa, bit lk, dag OOL, dag IOL, string asmstr> 130 : I<opcode, OOL, IOL, asmstr, IIC_BrB> { 131 bits<7> BIBO; // 2 bits of BI and 5 bits of BO. 132 bits<3> CR; 133 bits<14> BD; 134 135 bits<5> BI; 136 let BI{0-1} = BIBO{5-6}; 137 let BI{2-4} = CR{0-2}; 138 139 let Inst{6-10} = BIBO{4-0}; 140 let Inst{11-15} = BI; 141 let Inst{16-29} = BD; 142 let Inst{30} = aa; 143 let Inst{31} = lk; 144} 145 146class BForm_1<bits<6> opcode, bits<5> bo, bit aa, bit lk, dag OOL, dag IOL, 147 string asmstr> 148 : BForm<opcode, aa, lk, OOL, IOL, asmstr> { 149 let BIBO{4-0} = bo; 150 let BIBO{6-5} = 0; 151 let CR = 0; 152} 153 154class BForm_2<bits<6> opcode, bits<5> bo, bits<5> bi, bit aa, bit lk, 155 dag OOL, dag IOL, string asmstr> 156 : I<opcode, OOL, IOL, asmstr, IIC_BrB> { 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 166class BForm_3<bits<6> opcode, bit aa, bit lk, 167 dag OOL, dag IOL, string asmstr> 168 : I<opcode, OOL, IOL, asmstr, IIC_BrB> { 169 bits<5> BO; 170 bits<5> BI; 171 bits<14> BD; 172 173 let Inst{6-10} = BO; 174 let Inst{11-15} = BI; 175 let Inst{16-29} = BD; 176 let Inst{30} = aa; 177 let Inst{31} = lk; 178} 179 180class BForm_3_at<bits<6> opcode, bit aa, bit lk, 181 dag OOL, dag IOL, string asmstr> 182 : I<opcode, OOL, IOL, asmstr, IIC_BrB> { 183 bits<5> BO; 184 bits<2> at; 185 bits<5> BI; 186 bits<14> BD; 187 188 let Inst{6-8} = BO{4-2}; 189 let Inst{9-10} = at; 190 let Inst{11-15} = BI; 191 let Inst{16-29} = BD; 192 let Inst{30} = aa; 193 let Inst{31} = lk; 194} 195 196class BForm_4<bits<6> opcode, bits<5> bo, bit aa, bit lk, 197 dag OOL, dag IOL, string asmstr> 198 : I<opcode, OOL, IOL, asmstr, IIC_BrB> { 199 bits<5> BI; 200 bits<14> BD; 201 202 let Inst{6-10} = bo; 203 let Inst{11-15} = BI; 204 let Inst{16-29} = BD; 205 let Inst{30} = aa; 206 let Inst{31} = lk; 207} 208 209// 1.7.3 SC-Form 210class SCForm<bits<6> opcode, bits<1> xo, 211 dag OOL, dag IOL, string asmstr, InstrItinClass itin, 212 list<dag> pattern> 213 : I<opcode, OOL, IOL, asmstr, itin> { 214 bits<7> LEV; 215 216 let Pattern = pattern; 217 218 let Inst{20-26} = LEV; 219 let Inst{30} = xo; 220} 221 222// 1.7.4 D-Form 223class DForm_base<bits<6> opcode, dag OOL, dag IOL, string asmstr, 224 InstrItinClass itin, list<dag> pattern> 225 : I<opcode, OOL, IOL, asmstr, itin> { 226 bits<5> A; 227 bits<5> B; 228 bits<16> C; 229 230 let Pattern = pattern; 231 232 let Inst{6-10} = A; 233 let Inst{11-15} = B; 234 let Inst{16-31} = C; 235} 236 237class DForm_1<bits<6> opcode, dag OOL, dag IOL, string asmstr, 238 InstrItinClass itin, list<dag> pattern> 239 : I<opcode, OOL, IOL, asmstr, itin> { 240 bits<5> A; 241 bits<21> Addr; 242 243 let Pattern = pattern; 244 245 let Inst{6-10} = A; 246 let Inst{11-15} = Addr{20-16}; // Base Reg 247 let Inst{16-31} = Addr{15-0}; // Displacement 248} 249 250class DForm_1a<bits<6> opcode, dag OOL, dag IOL, string asmstr, 251 InstrItinClass itin, list<dag> pattern> 252 : I<opcode, OOL, IOL, asmstr, itin> { 253 bits<5> A; 254 bits<16> C; 255 bits<5> B; 256 257 let Pattern = pattern; 258 259 let Inst{6-10} = A; 260 let Inst{11-15} = B; 261 let Inst{16-31} = C; 262} 263 264 265class DForm_2<bits<6> opcode, dag OOL, dag IOL, string asmstr, 266 InstrItinClass itin, list<dag> pattern> 267 : DForm_base<opcode, OOL, IOL, asmstr, itin, pattern> { 268 269 // Even though ADDIC_rec does not really have an RC bit, provide 270 // the declaration of one here so that isRecordForm has something to set. 271 bit RC = 0; 272} 273 274class DForm_2_r0<bits<6> opcode, dag OOL, dag IOL, string asmstr, 275 InstrItinClass itin, list<dag> pattern> 276 : I<opcode, OOL, IOL, asmstr, itin> { 277 bits<5> A; 278 bits<16> B; 279 280 let Pattern = pattern; 281 282 let Inst{6-10} = A; 283 let Inst{11-15} = 0; 284 let Inst{16-31} = B; 285} 286 287class DForm_4<bits<6> opcode, dag OOL, dag IOL, string asmstr, 288 InstrItinClass itin, list<dag> pattern> 289 : I<opcode, OOL, IOL, asmstr, itin> { 290 bits<5> B; 291 bits<5> A; 292 bits<16> C; 293 294 let Pattern = pattern; 295 296 let Inst{6-10} = A; 297 let Inst{11-15} = B; 298 let Inst{16-31} = C; 299} 300 301class DForm_4_zero<bits<6> opcode, dag OOL, dag IOL, string asmstr, 302 InstrItinClass itin, list<dag> pattern> 303 : DForm_1<opcode, OOL, IOL, asmstr, itin, pattern> { 304 let A = 0; 305 let Addr = 0; 306} 307 308class DForm_4_fixedreg_zero<bits<6> opcode, bits<5> R, dag OOL, dag IOL, 309 string asmstr, InstrItinClass itin, 310 list<dag> pattern> 311 : DForm_4<opcode, OOL, IOL, asmstr, itin, pattern> { 312 let A = R; 313 let B = R; 314 let C = 0; 315} 316 317class IForm_and_DForm_1<bits<6> opcode1, bit aa, bit lk, bits<6> opcode2, 318 dag OOL, dag IOL, string asmstr, 319 InstrItinClass itin, list<dag> pattern> 320 : I2<opcode1, opcode2, OOL, IOL, asmstr, itin> { 321 bits<5> A; 322 bits<21> Addr; 323 324 let Pattern = pattern; 325 bits<24> LI; 326 327 let Inst{6-29} = LI; 328 let Inst{30} = aa; 329 let Inst{31} = lk; 330 331 let Inst{38-42} = A; 332 let Inst{43-47} = Addr{20-16}; // Base Reg 333 let Inst{48-63} = Addr{15-0}; // Displacement 334} 335 336// This is used to emit BL8+NOP. 337class IForm_and_DForm_4_zero<bits<6> opcode1, bit aa, bit lk, bits<6> opcode2, 338 dag OOL, dag IOL, string asmstr, 339 InstrItinClass itin, list<dag> pattern> 340 : IForm_and_DForm_1<opcode1, aa, lk, opcode2, 341 OOL, IOL, asmstr, itin, pattern> { 342 let A = 0; 343 let Addr = 0; 344} 345 346class DForm_5<bits<6> opcode, dag OOL, dag IOL, string asmstr, 347 InstrItinClass itin> 348 : I<opcode, OOL, IOL, asmstr, itin> { 349 bits<3> BF; 350 bits<1> L; 351 bits<5> RA; 352 bits<16> I; 353 354 let Inst{6-8} = BF; 355 let Inst{9} = 0; 356 let Inst{10} = L; 357 let Inst{11-15} = RA; 358 let Inst{16-31} = I; 359} 360 361class DForm_5_ext<bits<6> opcode, dag OOL, dag IOL, string asmstr, 362 InstrItinClass itin> 363 : DForm_5<opcode, OOL, IOL, asmstr, itin> { 364 let L = PPC64; 365} 366 367class DForm_6<bits<6> opcode, dag OOL, dag IOL, string asmstr, 368 InstrItinClass itin> 369 : DForm_5<opcode, OOL, IOL, asmstr, itin>; 370 371class DForm_6_ext<bits<6> opcode, dag OOL, dag IOL, string asmstr, 372 InstrItinClass itin> 373 : DForm_6<opcode, OOL, IOL, asmstr, itin> { 374 let L = PPC64; 375} 376 377 378// 1.7.5 DS-Form 379class DSForm_1<bits<6> opcode, bits<2> 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<19> DS_RA; 384 385 let Pattern = pattern; 386 387 let Inst{6-10} = RST; 388 let Inst{11-15} = DS_RA{18-14}; // Register # 389 let Inst{16-29} = DS_RA{13-0}; // Displacement. 390 let Inst{30-31} = xo; 391} 392 393// ISA V3.0B 1.6.6 DX-Form 394class DXForm<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr, 395 InstrItinClass itin, list<dag> pattern> 396 : I<opcode, OOL, IOL, asmstr, itin> { 397 bits<5> RT; 398 bits<16> D; 399 400 let Pattern = pattern; 401 402 let Inst{6-10} = RT; 403 let Inst{11-15} = D{5-1}; // d1 404 let Inst{16-25} = D{15-6}; // d0 405 let Inst{26-30} = xo; 406 let Inst{31} = D{0}; // d2 407} 408 409// DQ-Form: [PO T RA DQ TX XO] or [PO S RA DQ SX XO] 410class DQ_RD6_RS5_DQ12<bits<6> opcode, bits<3> xo, dag OOL, dag IOL, 411 string asmstr, InstrItinClass itin, list<dag> pattern> 412 : I<opcode, OOL, IOL, asmstr, itin> { 413 bits<6> XT; 414 bits<17> DS_RA; 415 416 let Pattern = pattern; 417 418 let Inst{6-10} = XT{4-0}; 419 let Inst{11-15} = DS_RA{16-12}; // Register # 420 let Inst{16-27} = DS_RA{11-0}; // Displacement. 421 let Inst{28} = XT{5}; 422 let Inst{29-31} = xo; 423} 424 425// 1.7.6 X-Form 426class XForm_base_r3xo<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 427 InstrItinClass itin, list<dag> pattern> 428 : I<opcode, OOL, IOL, asmstr, itin> { 429 bits<5> RST; 430 bits<5> A; 431 bits<5> B; 432 433 let Pattern = pattern; 434 435 bit RC = 0; // set by isRecordForm 436 437 let Inst{6-10} = RST; 438 let Inst{11-15} = A; 439 let Inst{16-20} = B; 440 let Inst{21-30} = xo; 441 let Inst{31} = RC; 442} 443 444class XForm_base_r3xo_memOp<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 445 string asmstr, InstrItinClass itin, 446 list<dag> pattern> 447 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern>, XFormMemOp; 448 449class XForm_tlb<bits<10> xo, dag OOL, dag IOL, string asmstr, 450 InstrItinClass itin> : XForm_base_r3xo<31, xo, OOL, IOL, asmstr, itin, []> { 451 let RST = 0; 452} 453 454class XForm_attn<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 455 InstrItinClass itin> 456 : I<opcode, OOL, IOL, asmstr, itin> { 457 let Inst{21-30} = xo; 458} 459 460// This is the same as XForm_base_r3xo, but the first two operands are swapped 461// when code is emitted. 462class XForm_base_r3xo_swapped 463 <bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 464 InstrItinClass itin> 465 : I<opcode, OOL, IOL, asmstr, itin> { 466 bits<5> A; 467 bits<5> RST; 468 bits<5> B; 469 470 bit RC = 0; // set by isRecordForm 471 472 let Inst{6-10} = RST; 473 let Inst{11-15} = A; 474 let Inst{16-20} = B; 475 let Inst{21-30} = xo; 476 let Inst{31} = RC; 477} 478 479 480class XForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 481 InstrItinClass itin, list<dag> pattern> 482 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern>; 483 484class XForm_1_memOp<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 485 InstrItinClass itin, list<dag> pattern> 486 : XForm_base_r3xo_memOp<opcode, xo, OOL, IOL, asmstr, itin, pattern>; 487 488class XForm_1a<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 489 InstrItinClass itin, list<dag> pattern> 490 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 491 let RST = 0; 492} 493 494class XForm_rs<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 495 InstrItinClass itin, list<dag> pattern> 496 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 497 let A = 0; 498 let B = 0; 499} 500 501class XForm_tlbws<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 502 InstrItinClass itin, list<dag> pattern> 503 : I<opcode, OOL, IOL, asmstr, itin> { 504 bits<5> RST; 505 bits<5> A; 506 bits<1> WS; 507 508 let Pattern = pattern; 509 510 let Inst{6-10} = RST; 511 let Inst{11-15} = A; 512 let Inst{20} = WS; 513 let Inst{21-30} = xo; 514 let Inst{31} = 0; 515} 516 517class XForm_6<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 518 InstrItinClass itin, list<dag> pattern> 519 : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> { 520 let Pattern = pattern; 521} 522 523class XForm_8<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 524 InstrItinClass itin, list<dag> pattern> 525 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern>; 526 527class XForm_8_memOp<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 528 InstrItinClass itin, list<dag> pattern> 529 : XForm_base_r3xo_memOp<opcode, xo, OOL, IOL, asmstr, itin, pattern>; 530 531class XForm_10<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 532 InstrItinClass itin, list<dag> pattern> 533 : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> { 534 let Pattern = pattern; 535} 536 537class XForm_11<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 538 InstrItinClass itin, list<dag> pattern> 539 : XForm_base_r3xo_swapped<opcode, xo, OOL, IOL, asmstr, itin> { 540 let B = 0; 541 let Pattern = pattern; 542} 543 544class XForm_16<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 545 InstrItinClass itin> 546 : I<opcode, OOL, IOL, asmstr, itin> { 547 bits<3> BF; 548 bits<1> L; 549 bits<5> RA; 550 bits<5> RB; 551 552 let Inst{6-8} = BF; 553 let Inst{9} = 0; 554 let Inst{10} = L; 555 let Inst{11-15} = RA; 556 let Inst{16-20} = RB; 557 let Inst{21-30} = xo; 558 let Inst{31} = 0; 559} 560 561class XForm_icbt<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 562 InstrItinClass itin> 563 : I<opcode, OOL, IOL, asmstr, itin> { 564 bits<4> CT; 565 bits<5> RA; 566 bits<5> RB; 567 568 let Inst{6} = 0; 569 let Inst{7-10} = CT; 570 let Inst{11-15} = RA; 571 let Inst{16-20} = RB; 572 let Inst{21-30} = xo; 573 let Inst{31} = 0; 574} 575 576class XForm_sr<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 577 InstrItinClass itin> 578 : I<opcode, OOL, IOL, asmstr, itin> { 579 bits<5> RS; 580 bits<4> SR; 581 582 let Inst{6-10} = RS; 583 let Inst{12-15} = SR; 584 let Inst{21-30} = xo; 585} 586 587class XForm_mbar<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 588 InstrItinClass itin> 589 : I<opcode, OOL, IOL, asmstr, itin> { 590 bits<5> MO; 591 592 let Inst{6-10} = MO; 593 let Inst{21-30} = xo; 594} 595 596class XForm_srin<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 597 InstrItinClass itin> 598 : I<opcode, OOL, IOL, asmstr, itin> { 599 bits<5> RS; 600 bits<5> RB; 601 602 let Inst{6-10} = RS; 603 let Inst{16-20} = RB; 604 let Inst{21-30} = xo; 605} 606 607class XForm_mtmsr<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 608 InstrItinClass itin> 609 : I<opcode, OOL, IOL, asmstr, itin> { 610 bits<5> RS; 611 bits<1> L; 612 613 let Inst{6-10} = RS; 614 let Inst{15} = L; 615 let Inst{21-30} = xo; 616} 617 618class XForm_16_ext<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 619 InstrItinClass itin> 620 : XForm_16<opcode, xo, OOL, IOL, asmstr, itin> { 621 let L = PPC64; 622} 623 624class XForm_17<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 625 InstrItinClass itin> 626 : I<opcode, OOL, IOL, asmstr, itin> { 627 bits<3> BF; 628 bits<5> FRA; 629 bits<5> FRB; 630 631 let Inst{6-8} = BF; 632 let Inst{9-10} = 0; 633 let Inst{11-15} = FRA; 634 let Inst{16-20} = FRB; 635 let Inst{21-30} = xo; 636 let Inst{31} = 0; 637} 638 639class XForm_17a<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 640 InstrItinClass itin, list<dag> pattern> 641 : XForm_17<opcode, xo, OOL, IOL, asmstr, itin > { 642 let FRA = 0; 643 let Pattern = pattern; 644} 645 646class XForm_18<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 647 InstrItinClass itin, list<dag> pattern> 648 : I<opcode, OOL, IOL, asmstr, itin> { 649 bits<5> FRT; 650 bits<5> FRA; 651 bits<5> FRB; 652 653 let Pattern = pattern; 654 655 let Inst{6-10} = FRT; 656 let Inst{11-15} = FRA; 657 let Inst{16-20} = FRB; 658 let Inst{21-30} = xo; 659 let Inst{31} = 0; 660} 661 662class XForm_19<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 663 InstrItinClass itin, list<dag> pattern> 664 : XForm_18<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 665 let FRA = 0; 666} 667 668class XForm_20<bits<6> opcode, bits<6> xo, dag OOL, dag IOL, string asmstr, 669 InstrItinClass itin, list<dag> pattern> 670 : I<opcode, OOL, IOL, asmstr, itin> { 671 bits<5> FRT; 672 bits<5> FRA; 673 bits<5> FRB; 674 bits<4> tttt; 675 676 let Pattern = pattern; 677 678 let Inst{6-10} = FRT; 679 let Inst{11-15} = FRA; 680 let Inst{16-20} = FRB; 681 let Inst{21-24} = tttt; 682 let Inst{25-30} = xo; 683 let Inst{31} = 0; 684} 685 686class XForm_24<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 687 InstrItinClass itin, list<dag> pattern> 688 : I<opcode, OOL, IOL, asmstr, itin> { 689 let Pattern = pattern; 690 let Inst{6-10} = 31; 691 let Inst{11-15} = 0; 692 let Inst{16-20} = 0; 693 let Inst{21-30} = xo; 694 let Inst{31} = 0; 695} 696 697class XForm_24_sync<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 698 string asmstr, InstrItinClass itin, list<dag> pattern> 699 : I<opcode, OOL, IOL, asmstr, itin> { 700 bits<2> L; 701 702 let Pattern = pattern; 703 let Inst{6-8} = 0; 704 let Inst{9-10} = L; 705 let Inst{11-15} = 0; 706 let Inst{16-20} = 0; 707 let Inst{21-30} = xo; 708 let Inst{31} = 0; 709} 710 711class XForm_24_eieio<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 712 string asmstr, InstrItinClass itin, list<dag> pattern> 713 : XForm_24_sync<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 714 let L = 0; 715} 716 717class XForm_25<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 718 InstrItinClass itin, list<dag> pattern> 719 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 720} 721 722class XForm_25_memOp<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 723 string asmstr, InstrItinClass itin, list<dag> pattern> 724 : XForm_base_r3xo_memOp<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 725} 726 727// [PO RT /// RB XO RC] 728class XForm_26<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 729 InstrItinClass itin, list<dag> pattern> 730 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 731 let A = 0; 732} 733 734class XForm_28_memOp<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 735 string asmstr, InstrItinClass itin, list<dag> pattern> 736 : XForm_base_r3xo_memOp<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 737} 738 739class XForm_28<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 740 InstrItinClass itin, list<dag> pattern> 741 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 742} 743 744// This is used for MFFS, MTFSB0, MTFSB1. 42 is arbitrary; this series of 745// numbers presumably relates to some document, but I haven't found it. 746class XForm_42<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 747 InstrItinClass itin, list<dag> pattern> 748 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 749 let Pattern = pattern; 750 751 bit RC = 0; // set by isRecordForm 752 753 let Inst{6-10} = RST; 754 let Inst{11-20} = 0; 755 let Inst{21-30} = xo; 756 let Inst{31} = RC; 757} 758class XForm_43<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 759 InstrItinClass itin, list<dag> pattern> 760 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 761 let Pattern = pattern; 762 bits<5> FM; 763 764 bit RC = 0; // set by isRecordForm 765 766 let Inst{6-10} = FM; 767 let Inst{11-20} = 0; 768 let Inst{21-30} = xo; 769 let Inst{31} = RC; 770} 771 772class XForm_44<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 773 InstrItinClass itin> 774 : I<opcode, OOL, IOL, asmstr, itin> { 775 bits<5> RT; 776 bits<3> BFA; 777 778 let Inst{6-10} = RT; 779 let Inst{11-13} = BFA; 780 let Inst{14-15} = 0; 781 let Inst{16-20} = 0; 782 let Inst{21-30} = xo; 783 let Inst{31} = 0; 784} 785 786class XForm_45<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 787 InstrItinClass itin> 788 : I<opcode, OOL, IOL, asmstr, itin> { 789 bits<5> RT; 790 bits<2> L; 791 792 let Inst{6-10} = RT; 793 let Inst{11-13} = 0; 794 let Inst{14-15} = L; 795 let Inst{16-20} = 0; 796 let Inst{21-30} = xo; 797 let Inst{31} = 0; 798} 799 800class X_FRT5_XO2_XO3_XO10<bits<6> opcode, bits<2> xo1, bits<3> xo2, bits<10> xo, 801 dag OOL, dag IOL, string asmstr, InstrItinClass itin, 802 list<dag> pattern> 803 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 804 let Pattern = pattern; 805 806 let Inst{6-10} = RST; 807 let Inst{11-12} = xo1; 808 let Inst{13-15} = xo2; 809 let Inst{16-20} = 0; 810 let Inst{21-30} = xo; 811 let Inst{31} = 0; 812} 813 814class X_FRT5_XO2_XO3_FRB5_XO10<bits<6> opcode, bits<2> xo1, bits<3> xo2, 815 bits<10> xo, dag OOL, dag IOL, string asmstr, 816 InstrItinClass itin, list<dag> pattern> 817 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 818 let Pattern = pattern; 819 bits<5> FRB; 820 821 let Inst{6-10} = RST; 822 let Inst{11-12} = xo1; 823 let Inst{13-15} = xo2; 824 let Inst{16-20} = FRB; 825 let Inst{21-30} = xo; 826 let Inst{31} = 0; 827} 828 829class X_FRT5_XO2_XO3_DRM3_XO10<bits<6> opcode, bits<2> xo1, bits<3> xo2, 830 bits<10> xo, dag OOL, dag IOL, string asmstr, 831 InstrItinClass itin, list<dag> pattern> 832 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 833 let Pattern = pattern; 834 bits<3> DRM; 835 836 let Inst{6-10} = RST; 837 let Inst{11-12} = xo1; 838 let Inst{13-15} = xo2; 839 let Inst{16-17} = 0; 840 let Inst{18-20} = DRM; 841 let Inst{21-30} = xo; 842 let Inst{31} = 0; 843} 844 845class X_FRT5_XO2_XO3_RM2_X10<bits<6> opcode, bits<2> xo1, bits<3> xo2, 846 bits<10> xo, dag OOL, dag IOL, string asmstr, 847 InstrItinClass itin, list<dag> pattern> 848 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 849 let Pattern = pattern; 850 bits<2> RM; 851 852 let Inst{6-10} = RST; 853 let Inst{11-12} = xo1; 854 let Inst{13-15} = xo2; 855 let Inst{16-18} = 0; 856 let Inst{19-20} = RM; 857 let Inst{21-30} = xo; 858 let Inst{31} = 0; 859} 860 861 862class XForm_0<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 863 InstrItinClass itin, list<dag> pattern> 864 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 865 let RST = 0; 866 let A = 0; 867 let B = 0; 868} 869 870class XForm_16b<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 871 InstrItinClass itin, list<dag> pattern> 872 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 873 let RST = 0; 874 let A = 0; 875} 876 877class XForm_htm0<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 878 string asmstr, InstrItinClass itin, list<dag> pattern> 879 : I<opcode, OOL, IOL, asmstr, itin> { 880 bit R; 881 882 bit RC = 1; 883 884 let Inst{6-9} = 0; 885 let Inst{10} = R; 886 let Inst{11-20} = 0; 887 let Inst{21-30} = xo; 888 let Inst{31} = RC; 889} 890 891class XForm_htm1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 892 string asmstr, InstrItinClass itin, list<dag> pattern> 893 : I<opcode, OOL, IOL, asmstr, itin> { 894 bit A; 895 896 bit RC = 1; 897 898 let Inst{6} = A; 899 let Inst{7-20} = 0; 900 let Inst{21-30} = xo; 901 let Inst{31} = RC; 902} 903 904class XForm_htm2<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 905 InstrItinClass itin, list<dag> pattern> 906 : I<opcode, OOL, IOL, asmstr, itin> { 907 bit L; 908 909 bit RC = 0; // set by isRecordForm 910 911 let Inst{7-9} = 0; 912 let Inst{10} = L; 913 let Inst{11-20} = 0; 914 let Inst{21-30} = xo; 915 let Inst{31} = RC; 916} 917 918class XForm_htm3<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 919 InstrItinClass itin, list<dag> pattern> 920 : I<opcode, OOL, IOL, asmstr, itin> { 921 bits<3> BF; 922 923 bit RC = 0; 924 925 let Inst{6-8} = BF; 926 let Inst{9-20} = 0; 927 let Inst{21-30} = xo; 928 let Inst{31} = RC; 929} 930 931// [PO RT RA RB XO /] 932class X_BF3_L1_RS5_RS5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 933 string asmstr, InstrItinClass itin, list<dag> pattern> 934 : I<opcode, OOL, IOL, asmstr, itin> { 935 bits<3> BF; 936 bits<1> L; 937 bits<5> RA; 938 bits<5> RB; 939 940 let Pattern = pattern; 941 942 let Inst{6-8} = BF; 943 let Inst{9} = 0; 944 let Inst{10} = L; 945 let Inst{11-15} = RA; 946 let Inst{16-20} = RB; 947 let Inst{21-30} = xo; 948 let Inst{31} = 0; 949} 950 951// Same as XForm_17 but with GPR's and new naming convention 952class X_BF3_RS5_RS5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 953 string asmstr, InstrItinClass itin, list<dag> pattern> 954 : I<opcode, OOL, IOL, asmstr, itin> { 955 bits<3> BF; 956 bits<5> RA; 957 bits<5> RB; 958 959 let Pattern = pattern; 960 961 let Inst{6-8} = BF; 962 let Inst{9-10} = 0; 963 let Inst{11-15} = RA; 964 let Inst{16-20} = RB; 965 let Inst{21-30} = xo; 966 let Inst{31} = 0; 967} 968 969// e.g. [PO VRT XO VRB XO /] or [PO VRT XO VRB XO RO] 970class X_RD5_XO5_RS5<bits<6> opcode, bits<5> xo2, bits<10> xo, dag OOL, dag IOL, 971 string asmstr, InstrItinClass itin, list<dag> pattern> 972 : XForm_base_r3xo<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 973 let A = xo2; 974} 975 976class X_BF3_DCMX7_RS5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 977 string asmstr, InstrItinClass itin, list<dag> pattern> 978 : I<opcode, OOL, IOL, asmstr, itin> { 979 bits<3> BF; 980 bits<7> DCMX; 981 bits<5> VB; 982 983 let Pattern = pattern; 984 985 let Inst{6-8} = BF; 986 let Inst{9-15} = DCMX; 987 let Inst{16-20} = VB; 988 let Inst{21-30} = xo; 989 let Inst{31} = 0; 990} 991 992class X_RD6_IMM8<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 993 string asmstr, InstrItinClass itin, list<dag> pattern> 994 : I<opcode, OOL, IOL, asmstr, itin> { 995 bits<6> XT; 996 bits<8> IMM8; 997 998 let Pattern = pattern; 999 1000 let Inst{6-10} = XT{4-0}; 1001 let Inst{11-12} = 0; 1002 let Inst{13-20} = IMM8; 1003 let Inst{21-30} = xo; 1004 let Inst{31} = XT{5}; 1005} 1006 1007// XForm_base_r3xo for instructions such as P9 atomics where we don't want 1008// to specify an SDAG pattern for matching. 1009class X_RD5_RS5_IM5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 1010 string asmstr, InstrItinClass itin> 1011 : XForm_base_r3xo_memOp<opcode, xo, OOL, IOL, asmstr, itin, []> { 1012} 1013 1014class X_BF3<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1015 InstrItinClass itin> 1016 : XForm_17<opcode, xo, OOL, IOL, asmstr, itin> { 1017 let FRA = 0; 1018 let FRB = 0; 1019} 1020 1021// [PO /// L RA RB XO /] 1022class X_L1_RS5_RS5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 1023 string asmstr, InstrItinClass itin, list<dag> pattern> 1024 : XForm_16<opcode, xo, OOL, IOL, asmstr, itin> { 1025 let BF = 0; 1026 let Pattern = pattern; 1027 1028 bit RC = 0; 1029 let Inst{31} = RC; 1030} 1031 1032// XX*-Form (VSX) 1033class XX1Form<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1034 InstrItinClass itin, list<dag> pattern> 1035 : I<opcode, OOL, IOL, asmstr, itin> { 1036 bits<6> XT; 1037 bits<5> A; 1038 bits<5> B; 1039 1040 let Pattern = pattern; 1041 1042 let Inst{6-10} = XT{4-0}; 1043 let Inst{11-15} = A; 1044 let Inst{16-20} = B; 1045 let Inst{21-30} = xo; 1046 let Inst{31} = XT{5}; 1047} 1048 1049class XX1Form_memOp<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 1050 string asmstr, InstrItinClass itin, list<dag> pattern> 1051 : XX1Form<opcode, xo, OOL, IOL, asmstr, itin, pattern>, XFormMemOp; 1052 1053class XX1_RS6_RD5_XO<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 1054 string asmstr, InstrItinClass itin, list<dag> pattern> 1055 : XX1Form<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 1056 let B = 0; 1057} 1058 1059class XX2Form<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, string asmstr, 1060 InstrItinClass itin, list<dag> pattern> 1061 : I<opcode, OOL, IOL, asmstr, itin> { 1062 bits<6> XT; 1063 bits<6> XB; 1064 1065 let Pattern = pattern; 1066 1067 let Inst{6-10} = XT{4-0}; 1068 let Inst{11-15} = 0; 1069 let Inst{16-20} = XB{4-0}; 1070 let Inst{21-29} = xo; 1071 let Inst{30} = XB{5}; 1072 let Inst{31} = XT{5}; 1073} 1074 1075class XX2Form_1<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, string asmstr, 1076 InstrItinClass itin, list<dag> pattern> 1077 : I<opcode, OOL, IOL, asmstr, itin> { 1078 bits<3> CR; 1079 bits<6> XB; 1080 1081 let Pattern = pattern; 1082 1083 let Inst{6-8} = CR; 1084 let Inst{9-15} = 0; 1085 let Inst{16-20} = XB{4-0}; 1086 let Inst{21-29} = xo; 1087 let Inst{30} = XB{5}; 1088 let Inst{31} = 0; 1089} 1090 1091class XX2Form_2<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, string asmstr, 1092 InstrItinClass itin, list<dag> pattern> 1093 : I<opcode, OOL, IOL, asmstr, itin> { 1094 bits<6> XT; 1095 bits<6> XB; 1096 bits<2> D; 1097 1098 let Pattern = pattern; 1099 1100 let Inst{6-10} = XT{4-0}; 1101 let Inst{11-13} = 0; 1102 let Inst{14-15} = D; 1103 let Inst{16-20} = XB{4-0}; 1104 let Inst{21-29} = xo; 1105 let Inst{30} = XB{5}; 1106 let Inst{31} = XT{5}; 1107} 1108 1109class XX2_RD6_UIM5_RS6<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, 1110 string asmstr, InstrItinClass itin, list<dag> pattern> 1111 : I<opcode, OOL, IOL, asmstr, itin> { 1112 bits<6> XT; 1113 bits<6> XB; 1114 bits<5> UIM5; 1115 1116 let Pattern = pattern; 1117 1118 let Inst{6-10} = XT{4-0}; 1119 let Inst{11-15} = UIM5; 1120 let Inst{16-20} = XB{4-0}; 1121 let Inst{21-29} = xo; 1122 let Inst{30} = XB{5}; 1123 let Inst{31} = XT{5}; 1124} 1125 1126// [PO T XO B XO BX /] 1127class XX2_RD5_XO5_RS6<bits<6> opcode, bits<5> xo2, bits<9> xo, dag OOL, dag IOL, 1128 string asmstr, InstrItinClass itin, list<dag> pattern> 1129 : I<opcode, OOL, IOL, asmstr, itin> { 1130 bits<5> RT; 1131 bits<6> XB; 1132 1133 let Pattern = pattern; 1134 1135 let Inst{6-10} = RT; 1136 let Inst{11-15} = xo2; 1137 let Inst{16-20} = XB{4-0}; 1138 let Inst{21-29} = xo; 1139 let Inst{30} = XB{5}; 1140 let Inst{31} = 0; 1141} 1142 1143// [PO T XO B XO BX TX] 1144class XX2_RD6_XO5_RS6<bits<6> opcode, bits<5> xo2, bits<9> xo, dag OOL, dag IOL, 1145 string asmstr, InstrItinClass itin, list<dag> pattern> 1146 : I<opcode, OOL, IOL, asmstr, itin> { 1147 bits<6> XT; 1148 bits<6> XB; 1149 1150 let Pattern = pattern; 1151 1152 let Inst{6-10} = XT{4-0}; 1153 let Inst{11-15} = xo2; 1154 let Inst{16-20} = XB{4-0}; 1155 let Inst{21-29} = xo; 1156 let Inst{30} = XB{5}; 1157 let Inst{31} = XT{5}; 1158} 1159 1160class XX2_BF3_DCMX7_RS6<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, 1161 string asmstr, InstrItinClass itin, list<dag> pattern> 1162 : I<opcode, OOL, IOL, asmstr, itin> { 1163 bits<3> BF; 1164 bits<7> DCMX; 1165 bits<6> XB; 1166 1167 let Pattern = pattern; 1168 1169 let Inst{6-8} = BF; 1170 let Inst{9-15} = DCMX; 1171 let Inst{16-20} = XB{4-0}; 1172 let Inst{21-29} = xo; 1173 let Inst{30} = XB{5}; 1174 let Inst{31} = 0; 1175} 1176 1177class XX2_RD6_DCMX7_RS6<bits<6> opcode, bits<4> xo1, bits<3> xo2, 1178 dag OOL, dag IOL, string asmstr, InstrItinClass itin, 1179 list<dag> pattern> 1180 : I<opcode, OOL, IOL, asmstr, itin> { 1181 bits<6> XT; 1182 bits<7> DCMX; 1183 bits<6> XB; 1184 1185 let Pattern = pattern; 1186 1187 let Inst{6-10} = XT{4-0}; 1188 let Inst{11-15} = DCMX{4-0}; 1189 let Inst{16-20} = XB{4-0}; 1190 let Inst{21-24} = xo1; 1191 let Inst{25} = DCMX{6}; 1192 let Inst{26-28} = xo2; 1193 let Inst{29} = DCMX{5}; 1194 let Inst{30} = XB{5}; 1195 let Inst{31} = XT{5}; 1196} 1197 1198class XForm_XD6_RA5_RB5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, 1199 string asmstr, InstrItinClass itin, list<dag> pattern> 1200 : I<opcode, OOL, IOL, asmstr, itin> { 1201 bits<11> D_RA_XD; 1202 bits<5> RB; 1203 1204 let Pattern = pattern; 1205 1206 let Inst{6-10} = D_RA_XD{4-0}; // D 1207 let Inst{11-15} = D_RA_XD{10-6}; // RA 1208 let Inst{16-20} = RB; 1209 let Inst{21-30} = xo; 1210 let Inst{31} = D_RA_XD{5}; // DX 1211} 1212 1213class XX3Form<bits<6> opcode, bits<8> xo, dag OOL, dag IOL, string asmstr, 1214 InstrItinClass itin, list<dag> pattern> 1215 : I<opcode, OOL, IOL, asmstr, itin> { 1216 bits<6> XT; 1217 bits<6> XA; 1218 bits<6> XB; 1219 1220 let Pattern = pattern; 1221 1222 let Inst{6-10} = XT{4-0}; 1223 let Inst{11-15} = XA{4-0}; 1224 let Inst{16-20} = XB{4-0}; 1225 let Inst{21-28} = xo; 1226 let Inst{29} = XA{5}; 1227 let Inst{30} = XB{5}; 1228 let Inst{31} = XT{5}; 1229} 1230 1231class XX3Form_SameOp<bits<6> opcode, bits<8> xo, dag OOL, dag IOL, string asmstr, 1232 InstrItinClass itin, list<dag> pattern> 1233 : XX3Form<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 1234 let XA = XT; 1235 let XB = XT; 1236} 1237 1238class XX3Form_1<bits<6> opcode, bits<8> xo, dag OOL, dag IOL, string asmstr, 1239 InstrItinClass itin, list<dag> pattern> 1240 : I<opcode, OOL, IOL, asmstr, itin> { 1241 bits<3> CR; 1242 bits<6> XA; 1243 bits<6> XB; 1244 1245 let Pattern = pattern; 1246 1247 let Inst{6-8} = CR; 1248 let Inst{9-10} = 0; 1249 let Inst{11-15} = XA{4-0}; 1250 let Inst{16-20} = XB{4-0}; 1251 let Inst{21-28} = xo; 1252 let Inst{29} = XA{5}; 1253 let Inst{30} = XB{5}; 1254 let Inst{31} = 0; 1255} 1256 1257class XX3Form_2<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr, 1258 InstrItinClass itin, list<dag> pattern> 1259 : I<opcode, OOL, IOL, asmstr, itin> { 1260 bits<6> XT; 1261 bits<6> XA; 1262 bits<6> XB; 1263 bits<2> D; 1264 1265 let Pattern = pattern; 1266 1267 let Inst{6-10} = XT{4-0}; 1268 let Inst{11-15} = XA{4-0}; 1269 let Inst{16-20} = XB{4-0}; 1270 let Inst{21} = 0; 1271 let Inst{22-23} = D; 1272 let Inst{24-28} = xo; 1273 let Inst{29} = XA{5}; 1274 let Inst{30} = XB{5}; 1275 let Inst{31} = XT{5}; 1276} 1277 1278class XX3Form_Rc<bits<6> opcode, bits<7> xo, dag OOL, dag IOL, string asmstr, 1279 InstrItinClass itin, list<dag> pattern> 1280 : I<opcode, OOL, IOL, asmstr, itin> { 1281 bits<6> XT; 1282 bits<6> XA; 1283 bits<6> XB; 1284 1285 let Pattern = pattern; 1286 1287 bit RC = 0; // set by isRecordForm 1288 1289 let Inst{6-10} = XT{4-0}; 1290 let Inst{11-15} = XA{4-0}; 1291 let Inst{16-20} = XB{4-0}; 1292 let Inst{21} = RC; 1293 let Inst{22-28} = xo; 1294 let Inst{29} = XA{5}; 1295 let Inst{30} = XB{5}; 1296 let Inst{31} = XT{5}; 1297} 1298 1299class XX4Form<bits<6> opcode, bits<2> xo, dag OOL, dag IOL, string asmstr, 1300 InstrItinClass itin, list<dag> pattern> 1301 : I<opcode, OOL, IOL, asmstr, itin> { 1302 bits<6> XT; 1303 bits<6> XA; 1304 bits<6> XB; 1305 bits<6> XC; 1306 1307 let Pattern = pattern; 1308 1309 let Inst{6-10} = XT{4-0}; 1310 let Inst{11-15} = XA{4-0}; 1311 let Inst{16-20} = XB{4-0}; 1312 let Inst{21-25} = XC{4-0}; 1313 let Inst{26-27} = xo; 1314 let Inst{28} = XC{5}; 1315 let Inst{29} = XA{5}; 1316 let Inst{30} = XB{5}; 1317 let Inst{31} = XT{5}; 1318} 1319 1320// DCB_Form - Form X instruction, used for dcb* instructions. 1321class DCB_Form<bits<10> xo, bits<5> immfield, dag OOL, dag IOL, string asmstr, 1322 InstrItinClass itin, list<dag> pattern> 1323 : I<31, OOL, IOL, asmstr, itin> { 1324 bits<5> A; 1325 bits<5> B; 1326 1327 let Pattern = pattern; 1328 1329 let Inst{6-10} = immfield; 1330 let Inst{11-15} = A; 1331 let Inst{16-20} = B; 1332 let Inst{21-30} = xo; 1333 let Inst{31} = 0; 1334} 1335 1336class DCB_Form_hint<bits<10> xo, dag OOL, dag IOL, string asmstr, 1337 InstrItinClass itin, list<dag> pattern> 1338 : I<31, OOL, IOL, asmstr, itin> { 1339 bits<5> TH; 1340 bits<5> A; 1341 bits<5> B; 1342 1343 let Pattern = pattern; 1344 1345 let Inst{6-10} = TH; 1346 let Inst{11-15} = A; 1347 let Inst{16-20} = B; 1348 let Inst{21-30} = xo; 1349 let Inst{31} = 0; 1350} 1351 1352// DSS_Form - Form X instruction, used for altivec dss* instructions. 1353class DSS_Form<bits<1> T, bits<10> xo, dag OOL, dag IOL, string asmstr, 1354 InstrItinClass itin, list<dag> pattern> 1355 : I<31, OOL, IOL, asmstr, itin> { 1356 bits<2> STRM; 1357 bits<5> A; 1358 bits<5> B; 1359 1360 let Pattern = pattern; 1361 1362 let Inst{6} = T; 1363 let Inst{7-8} = 0; 1364 let Inst{9-10} = STRM; 1365 let Inst{11-15} = A; 1366 let Inst{16-20} = B; 1367 let Inst{21-30} = xo; 1368 let Inst{31} = 0; 1369} 1370 1371// 1.7.7 XL-Form 1372class XLForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1373 InstrItinClass itin, list<dag> pattern> 1374 : I<opcode, OOL, IOL, asmstr, itin> { 1375 bits<5> CRD; 1376 bits<5> CRA; 1377 bits<5> CRB; 1378 1379 let Pattern = pattern; 1380 1381 let Inst{6-10} = CRD; 1382 let Inst{11-15} = CRA; 1383 let Inst{16-20} = CRB; 1384 let Inst{21-30} = xo; 1385 let Inst{31} = 0; 1386} 1387 1388class XLForm_1_np<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1389 InstrItinClass itin, list<dag> pattern> 1390 : XLForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 1391 let CRD = 0; 1392 let CRA = 0; 1393 let CRB = 0; 1394} 1395 1396class XLForm_1_gen<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1397 InstrItinClass itin, list<dag> pattern> 1398 : XLForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 1399 bits<5> RT; 1400 bits<5> RB; 1401 1402 let CRD = RT; 1403 let CRA = 0; 1404 let CRB = RB; 1405} 1406 1407class XLForm_1_ext<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1408 InstrItinClass itin, list<dag> pattern> 1409 : I<opcode, OOL, IOL, asmstr, itin> { 1410 bits<5> CRD; 1411 1412 let Pattern = pattern; 1413 1414 let Inst{6-10} = CRD; 1415 let Inst{11-15} = CRD; 1416 let Inst{16-20} = CRD; 1417 let Inst{21-30} = xo; 1418 let Inst{31} = 0; 1419} 1420 1421class XLForm_2<bits<6> opcode, bits<10> xo, bit lk, dag OOL, dag IOL, string asmstr, 1422 InstrItinClass itin, list<dag> pattern> 1423 : I<opcode, OOL, IOL, asmstr, itin> { 1424 bits<5> BO; 1425 bits<5> BI; 1426 bits<2> BH; 1427 1428 let Pattern = pattern; 1429 1430 let Inst{6-10} = BO; 1431 let Inst{11-15} = BI; 1432 let Inst{16-18} = 0; 1433 let Inst{19-20} = BH; 1434 let Inst{21-30} = xo; 1435 let Inst{31} = lk; 1436} 1437 1438class XLForm_2_br<bits<6> opcode, bits<10> xo, bit lk, 1439 dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern> 1440 : XLForm_2<opcode, xo, lk, OOL, IOL, asmstr, itin, pattern> { 1441 bits<7> BIBO; // 2 bits of BI and 5 bits of BO. 1442 bits<3> CR; 1443 1444 let BO = BIBO{4-0}; 1445 let BI{0-1} = BIBO{5-6}; 1446 let BI{2-4} = CR{0-2}; 1447 let BH = 0; 1448} 1449 1450class XLForm_2_br2<bits<6> opcode, bits<10> xo, bits<5> bo, bit lk, 1451 dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern> 1452 : XLForm_2<opcode, xo, lk, OOL, IOL, asmstr, itin, pattern> { 1453 let BO = bo; 1454 let BH = 0; 1455} 1456 1457class XLForm_2_ext<bits<6> opcode, bits<10> xo, bits<5> bo, bits<5> bi, bit lk, 1458 dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern> 1459 : XLForm_2<opcode, xo, lk, OOL, IOL, asmstr, itin, pattern> { 1460 let BO = bo; 1461 let BI = bi; 1462 let BH = 0; 1463} 1464 1465class XLForm_3<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1466 InstrItinClass itin> 1467 : I<opcode, OOL, IOL, asmstr, itin> { 1468 bits<3> BF; 1469 bits<3> BFA; 1470 1471 let Inst{6-8} = BF; 1472 let Inst{9-10} = 0; 1473 let Inst{11-13} = BFA; 1474 let Inst{14-15} = 0; 1475 let Inst{16-20} = 0; 1476 let Inst{21-30} = xo; 1477 let Inst{31} = 0; 1478} 1479 1480class XLForm_4<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1481 InstrItinClass itin> 1482 : I<opcode, OOL, IOL, asmstr, itin> { 1483 bits<3> BF; 1484 bit W; 1485 bits<4> U; 1486 1487 bit RC = 0; 1488 1489 let Inst{6-8} = BF; 1490 let Inst{9-10} = 0; 1491 let Inst{11-14} = 0; 1492 let Inst{15} = W; 1493 let Inst{16-19} = U; 1494 let Inst{20} = 0; 1495 let Inst{21-30} = xo; 1496 let Inst{31} = RC; 1497} 1498 1499class XLForm_S<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1500 InstrItinClass itin, list<dag> pattern> 1501 : I<opcode, OOL, IOL, asmstr, itin> { 1502 bits<1> S; 1503 1504 let Pattern = pattern; 1505 1506 let Inst{6-19} = 0; 1507 let Inst{20} = S; 1508 let Inst{21-30} = xo; 1509 let Inst{31} = 0; 1510} 1511 1512class XLForm_2_and_DSForm_1<bits<6> opcode1, bits<10> xo1, bit lk, 1513 bits<6> opcode2, bits<2> xo2, 1514 dag OOL, dag IOL, string asmstr, 1515 InstrItinClass itin, list<dag> pattern> 1516 : I2<opcode1, opcode2, OOL, IOL, asmstr, itin> { 1517 bits<5> BO; 1518 bits<5> BI; 1519 bits<2> BH; 1520 1521 bits<5> RST; 1522 bits<19> DS_RA; 1523 1524 let Pattern = pattern; 1525 1526 let Inst{6-10} = BO; 1527 let Inst{11-15} = BI; 1528 let Inst{16-18} = 0; 1529 let Inst{19-20} = BH; 1530 let Inst{21-30} = xo1; 1531 let Inst{31} = lk; 1532 1533 let Inst{38-42} = RST; 1534 let Inst{43-47} = DS_RA{18-14}; // Register # 1535 let Inst{48-61} = DS_RA{13-0}; // Displacement. 1536 let Inst{62-63} = xo2; 1537} 1538 1539class XLForm_2_ext_and_DSForm_1<bits<6> opcode1, bits<10> xo1, 1540 bits<5> bo, bits<5> bi, bit lk, 1541 bits<6> opcode2, bits<2> xo2, 1542 dag OOL, dag IOL, string asmstr, 1543 InstrItinClass itin, list<dag> pattern> 1544 : XLForm_2_and_DSForm_1<opcode1, xo1, lk, opcode2, xo2, 1545 OOL, IOL, asmstr, itin, pattern> { 1546 let BO = bo; 1547 let BI = bi; 1548 let BH = 0; 1549} 1550 1551class XLForm_2_ext_and_DForm_1<bits<6> opcode1, bits<10> xo1, bits<5> bo, 1552 bits<5> bi, bit lk, bits<6> opcode2, dag OOL, 1553 dag IOL, string asmstr, InstrItinClass itin, 1554 list<dag> pattern> 1555 : I2<opcode1, opcode2, OOL, IOL, asmstr, itin> { 1556 1557 bits<5> RST; 1558 bits<21> D_RA; 1559 1560 let Pattern = pattern; 1561 1562 let Inst{6-10} = bo; 1563 let Inst{11-15} = bi; 1564 let Inst{16-18} = 0; 1565 let Inst{19-20} = 0; // Unused (BH) 1566 let Inst{21-30} = xo1; 1567 let Inst{31} = lk; 1568 1569 let Inst{38-42} = RST; 1570 let Inst{43-47} = D_RA{20-16}; // Base Register 1571 let Inst{48-63} = D_RA{15-0}; // Displacement 1572} 1573 1574// 1.7.8 XFX-Form 1575class XFXForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1576 InstrItinClass itin> 1577 : I<opcode, OOL, IOL, asmstr, itin> { 1578 bits<5> RT; 1579 bits<10> SPR; 1580 1581 let Inst{6-10} = RT; 1582 let Inst{11} = SPR{4}; 1583 let Inst{12} = SPR{3}; 1584 let Inst{13} = SPR{2}; 1585 let Inst{14} = SPR{1}; 1586 let Inst{15} = SPR{0}; 1587 let Inst{16} = SPR{9}; 1588 let Inst{17} = SPR{8}; 1589 let Inst{18} = SPR{7}; 1590 let Inst{19} = SPR{6}; 1591 let Inst{20} = SPR{5}; 1592 let Inst{21-30} = xo; 1593 let Inst{31} = 0; 1594} 1595 1596class XFXForm_1_ext<bits<6> opcode, bits<10> xo, bits<10> spr, 1597 dag OOL, dag IOL, string asmstr, InstrItinClass itin> 1598 : XFXForm_1<opcode, xo, OOL, IOL, asmstr, itin> { 1599 let SPR = spr; 1600} 1601 1602class XFXForm_3<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1603 InstrItinClass itin> 1604 : I<opcode, OOL, IOL, asmstr, itin> { 1605 bits<5> RT; 1606 1607 let Inst{6-10} = RT; 1608 let Inst{11-20} = 0; 1609 let Inst{21-30} = xo; 1610 let Inst{31} = 0; 1611} 1612 1613class XFXForm_3p<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1614 InstrItinClass itin, list<dag> pattern> 1615 : I<opcode, OOL, IOL, asmstr, itin> { 1616 bits<5> RT; 1617 bits<10> Entry; 1618 let Pattern = pattern; 1619 1620 let Inst{6-10} = RT; 1621 let Inst{11-20} = Entry; 1622 let Inst{21-30} = xo; 1623 let Inst{31} = 0; 1624} 1625 1626class XFXForm_5<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1627 InstrItinClass itin> 1628 : I<opcode, OOL, IOL, asmstr, itin> { 1629 bits<8> FXM; 1630 bits<5> rS; 1631 1632 let Inst{6-10} = rS; 1633 let Inst{11} = 0; 1634 let Inst{12-19} = FXM; 1635 let Inst{20} = 0; 1636 let Inst{21-30} = xo; 1637 let Inst{31} = 0; 1638} 1639 1640class XFXForm_5a<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1641 InstrItinClass itin> 1642 : I<opcode, OOL, IOL, asmstr, itin> { 1643 bits<5> ST; 1644 bits<8> FXM; 1645 1646 let Inst{6-10} = ST; 1647 let Inst{11} = 1; 1648 let Inst{12-19} = FXM; 1649 let Inst{20} = 0; 1650 let Inst{21-30} = xo; 1651 let Inst{31} = 0; 1652} 1653 1654class XFXForm_7<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1655 InstrItinClass itin> 1656 : XFXForm_1<opcode, xo, OOL, IOL, asmstr, itin>; 1657 1658class XFXForm_7_ext<bits<6> opcode, bits<10> xo, bits<10> spr, 1659 dag OOL, dag IOL, string asmstr, InstrItinClass itin> 1660 : XFXForm_7<opcode, xo, OOL, IOL, asmstr, itin> { 1661 let SPR = spr; 1662} 1663 1664// XFL-Form - MTFSF 1665// This is probably 1.7.9, but I don't have the reference that uses this 1666// numbering scheme... 1667class XFLForm<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1668 InstrItinClass itin, list<dag>pattern> 1669 : I<opcode, OOL, IOL, asmstr, itin> { 1670 bits<8> FM; 1671 bits<5> rT; 1672 1673 bit RC = 0; // set by isRecordForm 1674 let Pattern = pattern; 1675 1676 let Inst{6} = 0; 1677 let Inst{7-14} = FM; 1678 let Inst{15} = 0; 1679 let Inst{16-20} = rT; 1680 let Inst{21-30} = xo; 1681 let Inst{31} = RC; 1682} 1683 1684class XFLForm_1<bits<6> opcode, bits<10> xo, dag OOL, dag IOL, string asmstr, 1685 InstrItinClass itin, list<dag>pattern> 1686 : I<opcode, OOL, IOL, asmstr, itin> { 1687 bit L; 1688 bits<8> FLM; 1689 bit W; 1690 bits<5> FRB; 1691 1692 bit RC = 0; // set by isRecordForm 1693 let Pattern = pattern; 1694 1695 let Inst{6} = L; 1696 let Inst{7-14} = FLM; 1697 let Inst{15} = W; 1698 let Inst{16-20} = FRB; 1699 let Inst{21-30} = xo; 1700 let Inst{31} = RC; 1701} 1702 1703// 1.7.10 XS-Form - SRADI. 1704class XSForm_1<bits<6> opcode, bits<9> xo, dag OOL, dag IOL, string asmstr, 1705 InstrItinClass itin, list<dag> pattern> 1706 : I<opcode, OOL, IOL, asmstr, itin> { 1707 bits<5> A; 1708 bits<5> RS; 1709 bits<6> SH; 1710 1711 bit RC = 0; // set by isRecordForm 1712 let Pattern = pattern; 1713 1714 let Inst{6-10} = RS; 1715 let Inst{11-15} = A; 1716 let Inst{16-20} = SH{4,3,2,1,0}; 1717 let Inst{21-29} = xo; 1718 let Inst{30} = SH{5}; 1719 let Inst{31} = RC; 1720} 1721 1722// 1.7.11 XO-Form 1723class XOForm_1<bits<6> opcode, bits<9> xo, bit oe, dag OOL, dag IOL, string asmstr, 1724 InstrItinClass itin, list<dag> pattern> 1725 : I<opcode, OOL, IOL, asmstr, itin> { 1726 bits<5> RT; 1727 bits<5> RA; 1728 bits<5> RB; 1729 1730 let Pattern = pattern; 1731 1732 bit RC = 0; // set by isRecordForm 1733 1734 let Inst{6-10} = RT; 1735 let Inst{11-15} = RA; 1736 let Inst{16-20} = RB; 1737 let Inst{21} = oe; 1738 let Inst{22-30} = xo; 1739 let Inst{31} = RC; 1740} 1741 1742class XOForm_3<bits<6> opcode, bits<9> xo, bit oe, 1743 dag OOL, dag IOL, string asmstr, InstrItinClass itin, list<dag> pattern> 1744 : XOForm_1<opcode, xo, oe, OOL, IOL, asmstr, itin, pattern> { 1745 let RB = 0; 1746} 1747 1748// 1.7.12 A-Form 1749class AForm_1<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr, 1750 InstrItinClass itin, list<dag> pattern> 1751 : I<opcode, OOL, IOL, asmstr, itin> { 1752 bits<5> FRT; 1753 bits<5> FRA; 1754 bits<5> FRC; 1755 bits<5> FRB; 1756 1757 let Pattern = pattern; 1758 1759 bit RC = 0; // set by isRecordForm 1760 1761 let Inst{6-10} = FRT; 1762 let Inst{11-15} = FRA; 1763 let Inst{16-20} = FRB; 1764 let Inst{21-25} = FRC; 1765 let Inst{26-30} = xo; 1766 let Inst{31} = RC; 1767} 1768 1769class AForm_2<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr, 1770 InstrItinClass itin, list<dag> pattern> 1771 : AForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 1772 let FRC = 0; 1773} 1774 1775class AForm_3<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr, 1776 InstrItinClass itin, list<dag> pattern> 1777 : AForm_1<opcode, xo, OOL, IOL, asmstr, itin, pattern> { 1778 let FRB = 0; 1779} 1780 1781class AForm_4<bits<6> opcode, bits<5> xo, dag OOL, dag IOL, string asmstr, 1782 InstrItinClass itin, list<dag> pattern> 1783 : I<opcode, OOL, IOL, asmstr, itin> { 1784 bits<5> RT; 1785 bits<5> RA; 1786 bits<5> RB; 1787 bits<5> COND; 1788 1789 let Pattern = pattern; 1790 1791 let Inst{6-10} = RT; 1792 let Inst{11-15} = RA; 1793 let Inst{16-20} = RB; 1794 let Inst{21-25} = COND; 1795 let Inst{26-30} = xo; 1796 let Inst{31} = 0; 1797} 1798 1799// 1.7.13 M-Form 1800class MForm_1<bits<6> opcode, dag OOL, dag IOL, string asmstr, 1801 InstrItinClass itin, list<dag> pattern> 1802 : I<opcode, OOL, IOL, asmstr, itin> { 1803 bits<5> RA; 1804 bits<5> RS; 1805 bits<5> RB; 1806 bits<5> MB; 1807 bits<5> ME; 1808 1809 let Pattern = pattern; 1810 1811 bit RC = 0; // set by isRecordForm 1812 1813 let Inst{6-10} = RS; 1814 let Inst{11-15} = RA; 1815 let Inst{16-20} = RB; 1816 let Inst{21-25} = MB; 1817 let Inst{26-30} = ME; 1818 let Inst{31} = RC; 1819} 1820 1821class MForm_2<bits<6> opcode, dag OOL, dag IOL, string asmstr, 1822 InstrItinClass itin, list<dag> pattern> 1823 : MForm_1<opcode, OOL, IOL, asmstr, itin, pattern> { 1824} 1825 1826// 1.7.14 MD-Form 1827class MDForm_1<bits<6> opcode, bits<3> xo, dag OOL, dag IOL, string asmstr, 1828 InstrItinClass itin, list<dag> pattern> 1829 : I<opcode, OOL, IOL, asmstr, itin> { 1830 bits<5> RA; 1831 bits<5> RS; 1832 bits<6> SH; 1833 bits<6> MBE; 1834 1835 let Pattern = pattern; 1836 1837 bit RC = 0; // set by isRecordForm 1838 1839 let Inst{6-10} = RS; 1840 let Inst{11-15} = RA; 1841 let Inst{16-20} = SH{4,3,2,1,0}; 1842 let Inst{21-26} = MBE{4,3,2,1,0,5}; 1843 let Inst{27-29} = xo; 1844 let Inst{30} = SH{5}; 1845 let Inst{31} = RC; 1846} 1847 1848class MDSForm_1<bits<6> opcode, bits<4> xo, dag OOL, dag IOL, string asmstr, 1849 InstrItinClass itin, list<dag> pattern> 1850 : I<opcode, OOL, IOL, asmstr, itin> { 1851 bits<5> RA; 1852 bits<5> RS; 1853 bits<5> RB; 1854 bits<6> MBE; 1855 1856 let Pattern = pattern; 1857 1858 bit RC = 0; // set by isRecordForm 1859 1860 let Inst{6-10} = RS; 1861 let Inst{11-15} = RA; 1862 let Inst{16-20} = RB; 1863 let Inst{21-26} = MBE{4,3,2,1,0,5}; 1864 let Inst{27-30} = xo; 1865 let Inst{31} = RC; 1866} 1867 1868 1869// E-1 VA-Form 1870 1871// VAForm_1 - DACB ordering. 1872class VAForm_1<bits<6> xo, dag OOL, dag IOL, string asmstr, 1873 InstrItinClass itin, list<dag> pattern> 1874 : I<4, OOL, IOL, asmstr, itin> { 1875 bits<5> VD; 1876 bits<5> VA; 1877 bits<5> VC; 1878 bits<5> VB; 1879 1880 let Pattern = pattern; 1881 1882 let Inst{6-10} = VD; 1883 let Inst{11-15} = VA; 1884 let Inst{16-20} = VB; 1885 let Inst{21-25} = VC; 1886 let Inst{26-31} = xo; 1887} 1888 1889// VAForm_1a - DABC ordering. 1890class VAForm_1a<bits<6> xo, dag OOL, dag IOL, string asmstr, 1891 InstrItinClass itin, list<dag> pattern> 1892 : I<4, OOL, IOL, asmstr, itin> { 1893 bits<5> VD; 1894 bits<5> VA; 1895 bits<5> VB; 1896 bits<5> VC; 1897 1898 let Pattern = pattern; 1899 1900 let Inst{6-10} = VD; 1901 let Inst{11-15} = VA; 1902 let Inst{16-20} = VB; 1903 let Inst{21-25} = VC; 1904 let Inst{26-31} = xo; 1905} 1906 1907class VAForm_2<bits<6> xo, dag OOL, dag IOL, string asmstr, 1908 InstrItinClass itin, list<dag> pattern> 1909 : I<4, OOL, IOL, asmstr, itin> { 1910 bits<5> VD; 1911 bits<5> VA; 1912 bits<5> VB; 1913 bits<4> SH; 1914 1915 let Pattern = pattern; 1916 1917 let Inst{6-10} = VD; 1918 let Inst{11-15} = VA; 1919 let Inst{16-20} = VB; 1920 let Inst{21} = 0; 1921 let Inst{22-25} = SH; 1922 let Inst{26-31} = xo; 1923} 1924 1925// E-2 VX-Form 1926class VXForm_1<bits<11> xo, dag OOL, dag IOL, string asmstr, 1927 InstrItinClass itin, list<dag> pattern> 1928 : I<4, OOL, IOL, asmstr, itin> { 1929 bits<5> VD; 1930 bits<5> VA; 1931 bits<5> VB; 1932 1933 let Pattern = pattern; 1934 1935 let Inst{6-10} = VD; 1936 let Inst{11-15} = VA; 1937 let Inst{16-20} = VB; 1938 let Inst{21-31} = xo; 1939} 1940 1941class VXForm_setzero<bits<11> xo, dag OOL, dag IOL, string asmstr, 1942 InstrItinClass itin, list<dag> pattern> 1943 : VXForm_1<xo, OOL, IOL, asmstr, itin, pattern> { 1944 let VA = VD; 1945 let VB = VD; 1946} 1947 1948 1949class VXForm_2<bits<11> xo, dag OOL, dag IOL, string asmstr, 1950 InstrItinClass itin, list<dag> pattern> 1951 : I<4, OOL, IOL, asmstr, itin> { 1952 bits<5> VD; 1953 bits<5> VB; 1954 1955 let Pattern = pattern; 1956 1957 let Inst{6-10} = VD; 1958 let Inst{11-15} = 0; 1959 let Inst{16-20} = VB; 1960 let Inst{21-31} = xo; 1961} 1962 1963class VXForm_3<bits<11> xo, dag OOL, dag IOL, string asmstr, 1964 InstrItinClass itin, list<dag> pattern> 1965 : I<4, OOL, IOL, asmstr, itin> { 1966 bits<5> VD; 1967 bits<5> IMM; 1968 1969 let Pattern = pattern; 1970 1971 let Inst{6-10} = VD; 1972 let Inst{11-15} = IMM; 1973 let Inst{16-20} = 0; 1974 let Inst{21-31} = xo; 1975} 1976 1977/// VXForm_4 - VX instructions with "VD,0,0" register fields, like mfvscr. 1978class VXForm_4<bits<11> xo, dag OOL, dag IOL, string asmstr, 1979 InstrItinClass itin, list<dag> pattern> 1980 : I<4, OOL, IOL, asmstr, itin> { 1981 bits<5> VD; 1982 1983 let Pattern = pattern; 1984 1985 let Inst{6-10} = VD; 1986 let Inst{11-15} = 0; 1987 let Inst{16-20} = 0; 1988 let Inst{21-31} = xo; 1989} 1990 1991/// VXForm_5 - VX instructions with "0,0,VB" register fields, like mtvscr. 1992class VXForm_5<bits<11> xo, dag OOL, dag IOL, string asmstr, 1993 InstrItinClass itin, list<dag> pattern> 1994 : I<4, OOL, IOL, asmstr, itin> { 1995 bits<5> VB; 1996 1997 let Pattern = pattern; 1998 1999 let Inst{6-10} = 0; 2000 let Inst{11-15} = 0; 2001 let Inst{16-20} = VB; 2002 let Inst{21-31} = xo; 2003} 2004 2005// e.g. [PO VRT EO VRB XO] 2006class VXForm_RD5_XO5_RS5<bits<11> xo, bits<5> eo, dag OOL, dag IOL, 2007 string asmstr, InstrItinClass itin, list<dag> pattern> 2008 : I<4, OOL, IOL, asmstr, itin> { 2009 bits<5> RD; 2010 bits<5> VB; 2011 2012 let Pattern = pattern; 2013 2014 let Inst{6-10} = RD; 2015 let Inst{11-15} = eo; 2016 let Inst{16-20} = VB; 2017 let Inst{21-31} = xo; 2018} 2019 2020/// VXForm_CR - VX crypto instructions with "VRT, VRA, ST, SIX" 2021class VXForm_CR<bits<11> xo, dag OOL, dag IOL, string asmstr, 2022 InstrItinClass itin, list<dag> pattern> 2023 : I<4, OOL, IOL, asmstr, itin> { 2024 bits<5> VD; 2025 bits<5> VA; 2026 bits<1> ST; 2027 bits<4> SIX; 2028 2029 let Pattern = pattern; 2030 2031 let Inst{6-10} = VD; 2032 let Inst{11-15} = VA; 2033 let Inst{16} = ST; 2034 let Inst{17-20} = SIX; 2035 let Inst{21-31} = xo; 2036} 2037 2038/// VXForm_BX - VX crypto instructions with "VRT, VRA, 0 - like vsbox" 2039class VXForm_BX<bits<11> xo, dag OOL, dag IOL, string asmstr, 2040 InstrItinClass itin, list<dag> pattern> 2041 : I<4, OOL, IOL, asmstr, itin> { 2042 bits<5> VD; 2043 bits<5> VA; 2044 2045 let Pattern = pattern; 2046 2047 let Inst{6-10} = VD; 2048 let Inst{11-15} = VA; 2049 let Inst{16-20} = 0; 2050 let Inst{21-31} = xo; 2051} 2052 2053// E-4 VXR-Form 2054class VXRForm_1<bits<10> xo, dag OOL, dag IOL, string asmstr, 2055 InstrItinClass itin, list<dag> pattern> 2056 : I<4, OOL, IOL, asmstr, itin> { 2057 bits<5> VD; 2058 bits<5> VA; 2059 bits<5> VB; 2060 bit RC = 0; 2061 2062 let Pattern = pattern; 2063 2064 let Inst{6-10} = VD; 2065 let Inst{11-15} = VA; 2066 let Inst{16-20} = VB; 2067 let Inst{21} = RC; 2068 let Inst{22-31} = xo; 2069} 2070 2071// VX-Form: [PO VRT EO VRB 1 PS XO] 2072class VX_RD5_EO5_RS5_PS1_XO9<bits<5> eo, bits<9> xo, 2073 dag OOL, dag IOL, string asmstr, 2074 InstrItinClass itin, list<dag> pattern> 2075 : I<4, OOL, IOL, asmstr, itin> { 2076 bits<5> VD; 2077 bits<5> VB; 2078 bit PS; 2079 2080 let Pattern = pattern; 2081 2082 let Inst{6-10} = VD; 2083 let Inst{11-15} = eo; 2084 let Inst{16-20} = VB; 2085 let Inst{21} = 1; 2086 let Inst{22} = PS; 2087 let Inst{23-31} = xo; 2088} 2089 2090// VX-Form: [PO VRT VRA VRB 1 PS XO] or [PO VRT VRA VRB 1 / XO] 2091class VX_RD5_RSp5_PS1_XO9<bits<9> xo, dag OOL, dag IOL, string asmstr, 2092 InstrItinClass itin, list<dag> pattern> 2093 : I<4, OOL, IOL, asmstr, itin> { 2094 bits<5> VD; 2095 bits<5> VA; 2096 bits<5> VB; 2097 bit PS; 2098 2099 let Pattern = pattern; 2100 2101 let Inst{6-10} = VD; 2102 let Inst{11-15} = VA; 2103 let Inst{16-20} = VB; 2104 let Inst{21} = 1; 2105 let Inst{22} = PS; 2106 let Inst{23-31} = xo; 2107} 2108 2109class Z23Form_8<bits<6> opcode, bits<8> xo, dag OOL, dag IOL, string asmstr, 2110 InstrItinClass itin, list<dag> pattern> 2111 : I<opcode, OOL, IOL, asmstr, itin> { 2112 bits<5> VRT; 2113 bit R; 2114 bits<5> VRB; 2115 bits<2> idx; 2116 2117 let Pattern = pattern; 2118 2119 bit RC = 0; // set by isRecordForm 2120 2121 let Inst{6-10} = VRT; 2122 let Inst{11-14} = 0; 2123 let Inst{15} = R; 2124 let Inst{16-20} = VRB; 2125 let Inst{21-22} = idx; 2126 let Inst{23-30} = xo; 2127 let Inst{31} = RC; 2128} 2129 2130//===----------------------------------------------------------------------===// 2131// EmitTimePseudo won't have encoding information for the [MC]CodeEmitter 2132// stuff 2133class PPCEmitTimePseudo<dag OOL, dag IOL, string asmstr, list<dag> pattern> 2134 : I<0, OOL, IOL, asmstr, NoItinerary> { 2135 let isCodeGenOnly = 1; 2136 let PPC64 = 0; 2137 let Pattern = pattern; 2138 let Inst{31-0} = 0; 2139 let hasNoSchedulingInfo = 1; 2140} 2141 2142// Instruction that require custom insertion support 2143// a.k.a. ISelPseudos, however, these won't have isPseudo set 2144class PPCCustomInserterPseudo<dag OOL, dag IOL, string asmstr, 2145 list<dag> pattern> 2146 : PPCEmitTimePseudo<OOL, IOL, asmstr, pattern> { 2147 let usesCustomInserter = 1; 2148} 2149 2150// PostRAPseudo will be expanded in expandPostRAPseudo, isPseudo flag in td 2151// files is set only for PostRAPseudo 2152class PPCPostRAExpPseudo<dag OOL, dag IOL, string asmstr, list<dag> pattern> 2153 : PPCEmitTimePseudo<OOL, IOL, asmstr, pattern> { 2154 let isPseudo = 1; 2155} 2156 2157class PseudoXFormMemOp<dag OOL, dag IOL, string asmstr, list<dag> pattern> 2158 : PPCPostRAExpPseudo<OOL, IOL, asmstr, pattern>, XFormMemOp; 2159 2160