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