lib/Target/R600/SIInstrFormats.td

   1 //===-- SIInstrFormats.td - SI Instruction Encodings ----------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // SI Instruction format definitions.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 class InstSI <dag outs, dag ins, string asm, list<dag> pattern> :
  15     AMDGPUInst<outs, ins, asm, pattern>, PredicateControl {
  16
  17   field bits<1> VM_CNT = 0;
  18   field bits<1> EXP_CNT = 0;
  19   field bits<1> LGKM_CNT = 0;
  20
  21   field bits<1> SALU = 0;
  22   field bits<1> VALU = 0;
  23
  24   field bits<1> SOP1 = 0;
  25   field bits<1> SOP2 = 0;
  26   field bits<1> SOPC = 0;
  27   field bits<1> SOPK = 0;
  28   field bits<1> SOPP = 0;
  29
  30   field bits<1> VOP1 = 0;
  31   field bits<1> VOP2 = 0;
  32   field bits<1> VOP3 = 0;
  33   field bits<1> VOPC = 0;
  34
  35   field bits<1> MUBUF = 0;
  36   field bits<1> MTBUF = 0;
  37   field bits<1> SMRD = 0;
  38   field bits<1> DS = 0;
  39   field bits<1> MIMG = 0;
  40   field bits<1> FLAT = 0;
  41   field bits<1> WQM = 0;
  42
  43   // These need to be kept in sync with the enum in SIInstrFlags.
  44   let TSFlags{0} = VM_CNT;
  45   let TSFlags{1} = EXP_CNT;
  46   let TSFlags{2} = LGKM_CNT;
  47
  48   let TSFlags{3} = SALU;
  49   let TSFlags{4} = VALU;
  50
  51   let TSFlags{5} = SOP1;
  52   let TSFlags{6} = SOP2;
  53   let TSFlags{7} = SOPC;
  54   let TSFlags{8} = SOPK;
  55   let TSFlags{9} = SOPP;
  56
  57   let TSFlags{10} = VOP1;
  58   let TSFlags{11} = VOP2;
  59   let TSFlags{12} = VOP3;
  60   let TSFlags{13} = VOPC;
  61
  62   let TSFlags{14} = MUBUF;
  63   let TSFlags{15} = MTBUF;
  64   let TSFlags{16} = SMRD;
  65   let TSFlags{17} = DS;
  66   let TSFlags{18} = MIMG;
  67   let TSFlags{19} = FLAT;
  68   let TSFlags{20} = WQM;
  69
  70   // Most instructions require adjustments after selection to satisfy
  71   // operand requirements.
  72   let hasPostISelHook = 1;
  73   let SchedRW = [Write32Bit];
  74 }
  75
  76 class Enc32 {
  77
  78   field bits<32> Inst;
  79   int Size = 4;
  80 }
  81
  82 class Enc64 {
  83
  84   field bits<64> Inst;
  85   int Size = 8;
  86 }
  87
  88 let Uses = [EXEC] in {
  89
  90 class VOPAnyCommon <dag outs, dag ins, string asm, list<dag> pattern> :
  91     InstSI <outs, ins, asm, pattern> {
  92
  93   let mayLoad = 0;
  94   let mayStore = 0;
  95   let hasSideEffects = 0;
  96   let UseNamedOperandTable = 1;
  97   let VALU = 1;
  98 }
  99
 100 class VOPCCommon <dag ins, string asm, list<dag> pattern> :
 101     VOPAnyCommon <(outs VCCReg:$dst), ins, asm, pattern> {
 102
 103   let DisableEncoding = "$dst";
 104   let VOPC = 1;
 105   let Size = 4;
 106 }
 107
 108 class VOP1Common <dag outs, dag ins, string asm, list<dag> pattern> :
 109     VOPAnyCommon <outs, ins, asm, pattern> {
 110
 111   let VOP1 = 1;
 112   let Size = 4;
 113 }
 114
 115 class VOP2Common <dag outs, dag ins, string asm, list<dag> pattern> :
 116     VOPAnyCommon <outs, ins, asm, pattern> {
 117
 118   let VOP2 = 1;
 119   let Size = 4;
 120 }
 121
 122 class VOP3Common <dag outs, dag ins, string asm, list<dag> pattern> :
 123     VOPAnyCommon <outs, ins, asm, pattern> {
 124
 125   // Using complex patterns gives VOP3 patterns a very high complexity rating,
 126   // but standalone patterns are almost always prefered, so we need to adjust the
 127   // priority lower.  The goal is to use a high number to reduce complexity to
 128   // zero (or less than zero).
 129   let AddedComplexity = -1000;
 130
 131   let VOP3 = 1;
 132   int Size = 8;
 133 }
 134
 135 } // End Uses = [EXEC]
 136
 137 //===----------------------------------------------------------------------===//
 138 // Scalar operations
 139 //===----------------------------------------------------------------------===//
 140
 141 class SOP1e <bits<8> op> : Enc32 {
 142
 143   bits<7> SDST;
 144   bits<8> SSRC0;
 145
 146   let Inst{7-0} = SSRC0;
 147   let Inst{15-8} = op;
 148   let Inst{22-16} = SDST;
 149   let Inst{31-23} = 0x17d; //encoding;
 150 }
 151
 152 class SOP2e <bits<7> op> : Enc32 {
 153
 154   bits<7> SDST;
 155   bits<8> SSRC0;
 156   bits<8> SSRC1;
 157
 158   let Inst{7-0} = SSRC0;
 159   let Inst{15-8} = SSRC1;
 160   let Inst{22-16} = SDST;
 161   let Inst{29-23} = op;
 162   let Inst{31-30} = 0x2; // encoding
 163 }
 164
 165 class SOPCe <bits<7> op> : Enc32 {
 166
 167   bits<8> SSRC0;
 168   bits<8> SSRC1;
 169
 170   let Inst{7-0} = SSRC0;
 171   let Inst{15-8} = SSRC1;
 172   let Inst{22-16} = op;
 173   let Inst{31-23} = 0x17e;
 174 }
 175
 176 class SOPKe <bits<5> op> : Enc32 {
 177
 178   bits <7> SDST;
 179   bits <16> SIMM16;
 180
 181   let Inst{15-0} = SIMM16;
 182   let Inst{22-16} = SDST;
 183   let Inst{27-23} = op;
 184   let Inst{31-28} = 0xb; //encoding
 185 }
 186
 187 class SOPPe <bits<7> op> : Enc32 {
 188
 189   bits <16> simm16;
 190
 191   let Inst{15-0} = simm16;
 192   let Inst{22-16} = op;
 193   let Inst{31-23} = 0x17f; // encoding
 194 }
 195
 196 class SMRDe <bits<5> op, bits<1> imm> : Enc32 {
 197
 198   bits<7> SDST;
 199   bits<7> SBASE;
 200   bits<8> OFFSET;
 201
 202   let Inst{7-0} = OFFSET;
 203   let Inst{8} = imm;
 204   let Inst{14-9} = SBASE{6-1};
 205   let Inst{21-15} = SDST;
 206   let Inst{26-22} = op;
 207   let Inst{31-27} = 0x18; //encoding
 208 }
 209
 210 let SchedRW = [WriteSALU] in {
 211 class SOP1 <dag outs, dag ins, string asm, list<dag> pattern> :
 212     InstSI<outs, ins, asm, pattern> {
 213   let mayLoad = 0;
 214   let mayStore = 0;
 215   let hasSideEffects = 0;
 216   let SALU = 1;
 217   let SOP1 = 1;
 218 }
 219
 220 class SOP2 <dag outs, dag ins, string asm, list<dag> pattern> :
 221     InstSI <outs, ins, asm, pattern> {
 222
 223   let mayLoad = 0;
 224   let mayStore = 0;
 225   let hasSideEffects = 0;
 226   let SALU = 1;
 227   let SOP2 = 1;
 228
 229   let UseNamedOperandTable = 1;
 230 }
 231
 232 class SOPC <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 233   InstSI<outs, ins, asm, pattern>, SOPCe <op> {
 234
 235   let DisableEncoding = "$dst";
 236   let mayLoad = 0;
 237   let mayStore = 0;
 238   let hasSideEffects = 0;
 239   let SALU = 1;
 240   let SOPC = 1;
 241
 242   let UseNamedOperandTable = 1;
 243 }
 244
 245 class SOPK <dag outs, dag ins, string asm, list<dag> pattern> :
 246    InstSI <outs, ins , asm, pattern> {
 247
 248   let mayLoad = 0;
 249   let mayStore = 0;
 250   let hasSideEffects = 0;
 251   let SALU = 1;
 252   let SOPK = 1;
 253
 254   let UseNamedOperandTable = 1;
 255 }
 256
 257 class SOPP <bits<7> op, dag ins, string asm, list<dag> pattern = []> :
 258                 InstSI <(outs), ins, asm, pattern >, SOPPe <op> {
 259
 260   let mayLoad = 0;
 261   let mayStore = 0;
 262   let hasSideEffects = 0;
 263   let isCodeGenOnly = 0;
 264   let SALU = 1;
 265   let SOPP = 1;
 266
 267   let UseNamedOperandTable = 1;
 268 }
 269
 270 } // let SchedRW = [WriteSALU]
 271
 272 class SMRD <dag outs, dag ins, string asm, list<dag> pattern> :
 273     InstSI<outs, ins, asm, pattern> {
 274
 275   let LGKM_CNT = 1;
 276   let SMRD = 1;
 277   let mayStore = 0;
 278   let mayLoad = 1;
 279   let hasSideEffects = 0;
 280   let UseNamedOperandTable = 1;
 281   let SchedRW = [WriteSMEM];
 282 }
 283
 284 //===----------------------------------------------------------------------===//
 285 // Vector ALU operations
 286 //===----------------------------------------------------------------------===//
 287
 288 class VOP1e <bits<8> op> : Enc32 {
 289
 290   bits<8> VDST;
 291   bits<9> SRC0;
 292
 293   let Inst{8-0} = SRC0;
 294   let Inst{16-9} = op;
 295   let Inst{24-17} = VDST;
 296   let Inst{31-25} = 0x3f; //encoding
 297 }
 298
 299 class VOP2e <bits<6> op> : Enc32 {
 300
 301   bits<8> VDST;
 302   bits<9> SRC0;
 303   bits<8> VSRC1;
 304
 305   let Inst{8-0} = SRC0;
 306   let Inst{16-9} = VSRC1;
 307   let Inst{24-17} = VDST;
 308   let Inst{30-25} = op;
 309   let Inst{31} = 0x0; //encoding
 310 }
 311
 312 class VOP3e <bits<9> op> : Enc64 {
 313
 314   bits<8> dst;
 315   bits<2> src0_modifiers;
 316   bits<9> src0;
 317   bits<2> src1_modifiers;
 318   bits<9> src1;
 319   bits<2> src2_modifiers;
 320   bits<9> src2;
 321   bits<1> clamp;
 322   bits<2> omod;
 323
 324   let Inst{7-0} = dst;
 325   let Inst{8} = src0_modifiers{1};
 326   let Inst{9} = src1_modifiers{1};
 327   let Inst{10} = src2_modifiers{1};
 328   let Inst{11} = clamp;
 329   let Inst{25-17} = op;
 330   let Inst{31-26} = 0x34; //encoding
 331   let Inst{40-32} = src0;
 332   let Inst{49-41} = src1;
 333   let Inst{58-50} = src2;
 334   let Inst{60-59} = omod;
 335   let Inst{61} = src0_modifiers{0};
 336   let Inst{62} = src1_modifiers{0};
 337   let Inst{63} = src2_modifiers{0};
 338 }
 339
 340 class VOP3be <bits<9> op> : Enc64 {
 341
 342   bits<8> vdst;
 343   bits<2> src0_modifiers;
 344   bits<9> src0;
 345   bits<2> src1_modifiers;
 346   bits<9> src1;
 347   bits<2> src2_modifiers;
 348   bits<9> src2;
 349   bits<7> sdst;
 350   bits<2> omod;
 351
 352   let Inst{7-0} = vdst;
 353   let Inst{14-8} = sdst;
 354   let Inst{25-17} = op;
 355   let Inst{31-26} = 0x34; //encoding
 356   let Inst{40-32} = src0;
 357   let Inst{49-41} = src1;
 358   let Inst{58-50} = src2;
 359   let Inst{60-59} = omod;
 360   let Inst{61} = src0_modifiers{0};
 361   let Inst{62} = src1_modifiers{0};
 362   let Inst{63} = src2_modifiers{0};
 363 }
 364
 365 class VOPCe <bits<8> op> : Enc32 {
 366
 367   bits<9> SRC0;
 368   bits<8> VSRC1;
 369
 370   let Inst{8-0} = SRC0;
 371   let Inst{16-9} = VSRC1;
 372   let Inst{24-17} = op;
 373   let Inst{31-25} = 0x3e;
 374 }
 375
 376 class VINTRPe <bits<2> op> : Enc32 {
 377
 378   bits<8> VDST;
 379   bits<8> VSRC;
 380   bits<2> ATTRCHAN;
 381   bits<6> ATTR;
 382
 383   let Inst{7-0} = VSRC;
 384   let Inst{9-8} = ATTRCHAN;
 385   let Inst{15-10} = ATTR;
 386   let Inst{17-16} = op;
 387   let Inst{25-18} = VDST;
 388   let Inst{31-26} = 0x32; // encoding
 389 }
 390
 391 class DSe <bits<8> op> : Enc64 {
 392
 393   bits<8> vdst;
 394   bits<1> gds;
 395   bits<8> addr;
 396   bits<8> data0;
 397   bits<8> data1;
 398   bits<8> offset0;
 399   bits<8> offset1;
 400
 401   let Inst{7-0} = offset0;
 402   let Inst{15-8} = offset1;
 403   let Inst{17} = gds;
 404   let Inst{25-18} = op;
 405   let Inst{31-26} = 0x36; //encoding
 406   let Inst{39-32} = addr;
 407   let Inst{47-40} = data0;
 408   let Inst{55-48} = data1;
 409   let Inst{63-56} = vdst;
 410 }
 411
 412 class MUBUFe <bits<7> op> : Enc64 {
 413
 414   bits<12> offset;
 415   bits<1> offen;
 416   bits<1> idxen;
 417   bits<1> glc;
 418   bits<1> addr64;
 419   bits<1> lds;
 420   bits<8> vaddr;
 421   bits<8> vdata;
 422   bits<7> srsrc;
 423   bits<1> slc;
 424   bits<1> tfe;
 425   bits<8> soffset;
 426
 427   let Inst{11-0} = offset;
 428   let Inst{12} = offen;
 429   let Inst{13} = idxen;
 430   let Inst{14} = glc;
 431   let Inst{15} = addr64;
 432   let Inst{16} = lds;
 433   let Inst{24-18} = op;
 434   let Inst{31-26} = 0x38; //encoding
 435   let Inst{39-32} = vaddr;
 436   let Inst{47-40} = vdata;
 437   let Inst{52-48} = srsrc{6-2};
 438   let Inst{54} = slc;
 439   let Inst{55} = tfe;
 440   let Inst{63-56} = soffset;
 441 }
 442
 443 class MTBUFe <bits<3> op> : Enc64 {
 444
 445   bits<8> VDATA;
 446   bits<12> OFFSET;
 447   bits<1> OFFEN;
 448   bits<1> IDXEN;
 449   bits<1> GLC;
 450   bits<1> ADDR64;
 451   bits<4> DFMT;
 452   bits<3> NFMT;
 453   bits<8> VADDR;
 454   bits<7> SRSRC;
 455   bits<1> SLC;
 456   bits<1> TFE;
 457   bits<8> SOFFSET;
 458
 459   let Inst{11-0} = OFFSET;
 460   let Inst{12} = OFFEN;
 461   let Inst{13} = IDXEN;
 462   let Inst{14} = GLC;
 463   let Inst{15} = ADDR64;
 464   let Inst{18-16} = op;
 465   let Inst{22-19} = DFMT;
 466   let Inst{25-23} = NFMT;
 467   let Inst{31-26} = 0x3a; //encoding
 468   let Inst{39-32} = VADDR;
 469   let Inst{47-40} = VDATA;
 470   let Inst{52-48} = SRSRC{6-2};
 471   let Inst{54} = SLC;
 472   let Inst{55} = TFE;
 473   let Inst{63-56} = SOFFSET;
 474 }
 475
 476 class MIMGe <bits<7> op> : Enc64 {
 477
 478   bits<8> VDATA;
 479   bits<4> DMASK;
 480   bits<1> UNORM;
 481   bits<1> GLC;
 482   bits<1> DA;
 483   bits<1> R128;
 484   bits<1> TFE;
 485   bits<1> LWE;
 486   bits<1> SLC;
 487   bits<8> VADDR;
 488   bits<7> SRSRC;
 489   bits<7> SSAMP;
 490
 491   let Inst{11-8} = DMASK;
 492   let Inst{12} = UNORM;
 493   let Inst{13} = GLC;
 494   let Inst{14} = DA;
 495   let Inst{15} = R128;
 496   let Inst{16} = TFE;
 497   let Inst{17} = LWE;
 498   let Inst{24-18} = op;
 499   let Inst{25} = SLC;
 500   let Inst{31-26} = 0x3c;
 501   let Inst{39-32} = VADDR;
 502   let Inst{47-40} = VDATA;
 503   let Inst{52-48} = SRSRC{6-2};
 504   let Inst{57-53} = SSAMP{6-2};
 505 }
 506
 507 class FLATe<bits<7> op> : Enc64 {
 508   bits<8> addr;
 509   bits<8> data;
 510   bits<8> vdst;
 511   bits<1> slc;
 512   bits<1> glc;
 513   bits<1> tfe;
 514
 515   // 15-0 is reserved.
 516   let Inst{16} = glc;
 517   let Inst{17} = slc;
 518   let Inst{24-18} = op;
 519   let Inst{31-26} = 0x37; // Encoding.
 520   let Inst{39-32} = addr;
 521   let Inst{47-40} = data;
 522   // 54-48 is reserved.
 523   let Inst{55} = tfe;
 524   let Inst{63-56} = vdst;
 525 }
 526
 527 class EXPe : Enc64 {
 528   bits<4> EN;
 529   bits<6> TGT;
 530   bits<1> COMPR;
 531   bits<1> DONE;
 532   bits<1> VM;
 533   bits<8> VSRC0;
 534   bits<8> VSRC1;
 535   bits<8> VSRC2;
 536   bits<8> VSRC3;
 537
 538   let Inst{3-0} = EN;
 539   let Inst{9-4} = TGT;
 540   let Inst{10} = COMPR;
 541   let Inst{11} = DONE;
 542   let Inst{12} = VM;
 543   let Inst{31-26} = 0x3e;
 544   let Inst{39-32} = VSRC0;
 545   let Inst{47-40} = VSRC1;
 546   let Inst{55-48} = VSRC2;
 547   let Inst{63-56} = VSRC3;
 548 }
 549
 550 let Uses = [EXEC] in {
 551
 552 class VOP1 <bits<8> op, dag outs, dag ins, string asm, list<dag> pattern> :
 553     VOP1Common <outs, ins, asm, pattern>,
 554     VOP1e<op>;
 555
 556 class VOP2 <bits<6> op, dag outs, dag ins, string asm, list<dag> pattern> :
 557     VOP2Common <outs, ins, asm, pattern>, VOP2e<op>;
 558
 559 class VOPC <bits<8> op, dag ins, string asm, list<dag> pattern> :
 560     VOPCCommon <ins, asm, pattern>, VOPCe <op>;
 561
 562 class VINTRPCommon <dag outs, dag ins, string asm, list<dag> pattern> :
 563     InstSI <outs, ins, asm, pattern> {
 564   let mayLoad = 1;
 565   let mayStore = 0;
 566   let hasSideEffects = 0;
 567 }
 568
 569 } // End Uses = [EXEC]
 570
 571 //===----------------------------------------------------------------------===//
 572 // Vector I/O operations
 573 //===----------------------------------------------------------------------===//
 574
 575 let Uses = [EXEC] in {
 576
 577 class DS <dag outs, dag ins, string asm, list<dag> pattern> :
 578     InstSI <outs, ins, asm, pattern> {
 579
 580   let LGKM_CNT = 1;
 581   let DS = 1;
 582   let UseNamedOperandTable = 1;
 583   let DisableEncoding = "$m0";
 584   let SchedRW = [WriteLDS];
 585 }
 586
 587 class MUBUF <dag outs, dag ins, string asm, list<dag> pattern> :
 588     InstSI<outs, ins, asm, pattern> {
 589
 590   let VM_CNT = 1;
 591   let EXP_CNT = 1;
 592   let MUBUF = 1;
 593
 594   let hasSideEffects = 0;
 595   let UseNamedOperandTable = 1;
 596   let SchedRW = [WriteVMEM];
 597 }
 598
 599 class MTBUF <dag outs, dag ins, string asm, list<dag> pattern> :
 600     InstSI<outs, ins, asm, pattern> {
 601
 602   let VM_CNT = 1;
 603   let EXP_CNT = 1;
 604   let MTBUF = 1;
 605
 606   let hasSideEffects = 0;
 607   let UseNamedOperandTable = 1;
 608   let SchedRW = [WriteVMEM];
 609 }
 610
 611 class FLAT <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 612     InstSI<outs, ins, asm, pattern>, FLATe <op> {
 613   let FLAT = 1;
 614   // Internally, FLAT instruction are executed as both an LDS and a
 615   // Buffer instruction; so, they increment both VM_CNT and LGKM_CNT
 616   // and are not considered done until both have been decremented.
 617   let VM_CNT = 1;
 618   let LGKM_CNT = 1;
 619
 620   let Uses = [EXEC, FLAT_SCR]; // M0
 621
 622   let UseNamedOperandTable = 1;
 623   let hasSideEffects = 0;
 624 }
 625
 626 class MIMG <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 627     InstSI <outs, ins, asm, pattern>, MIMGe <op> {
 628
 629   let VM_CNT = 1;
 630   let EXP_CNT = 1;
 631   let MIMG = 1;
 632
 633   let hasSideEffects = 0; // XXX ????
 634 }
 635
 636
 637 } // End Uses = [EXEC]