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