lib/Target/R600/SIInstrInfo.td

   1 //===-- SIInstrInfo.td - SI Instruction Encodings ---------*- tablegen -*--===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 //===----------------------------------------------------------------------===//
  11 // SI DAG Profiles
  12 //===----------------------------------------------------------------------===//
  13 def SDTVCCBinaryOp : SDTypeProfile<1, 2, [
  14   SDTCisInt<0>, SDTCisInt<1>, SDTCisSameAs<1, 2>
  15 ]>;
  16
  17 //===----------------------------------------------------------------------===//
  18 // SI DAG Nodes
  19 //===----------------------------------------------------------------------===//
  20
  21 // and operation on 64-bit wide vcc
  22 def SIsreg1_and : SDNode<"SIISD::VCC_AND", SDTVCCBinaryOp,
  23   [SDNPCommutative, SDNPAssociative]
  24 >;
  25
  26 // Special bitcast node for sharing VCC register between VALU and SALU
  27 def SIsreg1_bitcast : SDNode<"SIISD::VCC_BITCAST",
  28   SDTypeProfile<1, 1, [SDTCisInt<0>, SDTCisInt<1>]>
  29 >;
  30
  31 // and operation on 64-bit wide vcc
  32 def SIvcc_and : SDNode<"SIISD::VCC_AND", SDTVCCBinaryOp,
  33   [SDNPCommutative, SDNPAssociative]
  34 >;
  35
  36 // Special bitcast node for sharing VCC register between VALU and SALU
  37 def SIvcc_bitcast : SDNode<"SIISD::VCC_BITCAST",
  38   SDTypeProfile<1, 1, [SDTCisInt<0>, SDTCisInt<1>]>
  39 >;
  40
  41 // Transformation function, extract the lower 32bit of a 64bit immediate
  42 def LO32 : SDNodeXForm<imm, [{
  43   return CurDAG->getTargetConstant(N->getZExtValue() & 0xffffffff, MVT::i32);
  44 }]>;
  45
  46 // Transformation function, extract the upper 32bit of a 64bit immediate
  47 def HI32 : SDNodeXForm<imm, [{
  48   return CurDAG->getTargetConstant(N->getZExtValue() >> 32, MVT::i32);
  49 }]>;
  50
  51 class InstSI <dag outs, dag ins, string asm, list<dag> pattern> :
  52     AMDGPUInst<outs, ins, asm, pattern> {
  53
  54   field bits<4> EncodingType = 0;
  55   field bits<1> VM_CNT = 0;
  56   field bits<1> EXP_CNT = 0;
  57   field bits<1> LGKM_CNT = 0;
  58
  59   let TSFlags{3-0} = EncodingType;
  60   let TSFlags{4} = VM_CNT;
  61   let TSFlags{5} = EXP_CNT;
  62   let TSFlags{6} = LGKM_CNT;
  63 }
  64
  65 class Enc32 <dag outs, dag ins, string asm, list<dag> pattern> :
  66     InstSI <outs, ins, asm, pattern> {
  67
  68   field bits<32> Inst;
  69 }
  70
  71 class Enc64 <dag outs, dag ins, string asm, list<dag> pattern> :
  72     InstSI <outs, ins, asm, pattern> {
  73
  74   field bits<64> Inst;
  75 }
  76
  77 class SIOperand <ValueType vt, dag opInfo>: Operand <vt> {
  78   let EncoderMethod = "encodeOperand";
  79   let MIOperandInfo = opInfo;
  80 }
  81
  82 def IMM16bit : ImmLeaf <
  83   i16,
  84   [{return isInt<16>(Imm);}]
  85 >;
  86
  87 def IMM8bit : ImmLeaf <
  88   i32,
  89   [{return (int32_t)Imm >= 0 && (int32_t)Imm <= 0xff;}]
  90 >;
  91
  92 def IMM12bit : ImmLeaf <
  93   i16,
  94   [{return (int16_t)Imm >= 0 && (int16_t)Imm <= 0xfff;}]
  95 >;
  96
  97 def IMM32bitIn64bit : ImmLeaf <
  98   i64,
  99   [{return isInt<32>(Imm);}]
 100 >;
 101
 102 class GPR4Align <RegisterClass rc> : Operand <vAny> {
 103   let EncoderMethod = "GPR4AlignEncode";
 104   let MIOperandInfo = (ops rc:$reg);
 105 }
 106
 107 class GPR2Align <RegisterClass rc, ValueType vt> : Operand <vt> {
 108   let EncoderMethod = "GPR2AlignEncode";
 109   let MIOperandInfo = (ops rc:$reg);
 110 }
 111
 112 def SMRDmemrr : Operand<iPTR> {
 113   let MIOperandInfo = (ops SReg_64, SReg_32);
 114   let EncoderMethod = "GPR2AlignEncode";
 115 }
 116
 117 def SMRDmemri : Operand<iPTR> {
 118   let MIOperandInfo = (ops SReg_64, i32imm);
 119   let EncoderMethod = "SMRDmemriEncode";
 120 }
 121
 122 def ADDR_Reg     : ComplexPattern<i64, 2, "SelectADDRReg", [], []>;
 123 def ADDR_Offset8 : ComplexPattern<i64, 2, "SelectADDR8BitOffset", [], []>;
 124
 125 let Uses = [EXEC] in {
 126
 127 def EXP : Enc64<
 128   (outs),
 129   (ins i32imm:$en, i32imm:$tgt, i32imm:$compr, i32imm:$done, i32imm:$vm,
 130        VReg_32:$src0, VReg_32:$src1, VReg_32:$src2, VReg_32:$src3),
 131   "EXP $en, $tgt, $compr, $done, $vm, $src0, $src1, $src2, $src3",
 132   [] > {
 133
 134   bits<4> EN;
 135   bits<6> TGT;
 136   bits<1> COMPR;
 137   bits<1> DONE;
 138   bits<1> VM;
 139   bits<8> VSRC0;
 140   bits<8> VSRC1;
 141   bits<8> VSRC2;
 142   bits<8> VSRC3;
 143
 144   let Inst{3-0} = EN;
 145   let Inst{9-4} = TGT;
 146   let Inst{10} = COMPR;
 147   let Inst{11} = DONE;
 148   let Inst{12} = VM;
 149   let Inst{31-26} = 0x3e;
 150   let Inst{39-32} = VSRC0;
 151   let Inst{47-40} = VSRC1;
 152   let Inst{55-48} = VSRC2;
 153   let Inst{63-56} = VSRC3;
 154   let EncodingType = 0; //SIInstrEncodingType::EXP
 155
 156   let EXP_CNT = 1;
 157 }
 158
 159 class MIMG <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 160     Enc64 <outs, ins, asm, pattern> {
 161
 162   bits<8> VDATA;
 163   bits<4> DMASK;
 164   bits<1> UNORM;
 165   bits<1> GLC;
 166   bits<1> DA;
 167   bits<1> R128;
 168   bits<1> TFE;
 169   bits<1> LWE;
 170   bits<1> SLC;
 171   bits<8> VADDR;
 172   bits<5> SRSRC;
 173   bits<5> SSAMP;
 174
 175   let Inst{11-8} = DMASK;
 176   let Inst{12} = UNORM;
 177   let Inst{13} = GLC;
 178   let Inst{14} = DA;
 179   let Inst{15} = R128;
 180   let Inst{16} = TFE;
 181   let Inst{17} = LWE;
 182   let Inst{24-18} = op;
 183   let Inst{25} = SLC;
 184   let Inst{31-26} = 0x3c;
 185   let Inst{39-32} = VADDR;
 186   let Inst{47-40} = VDATA;
 187   let Inst{52-48} = SRSRC;
 188   let Inst{57-53} = SSAMP;
 189   let EncodingType = 2; //SIInstrEncodingType::MIMG
 190
 191   let VM_CNT = 1;
 192   let EXP_CNT = 1;
 193 }
 194
 195 class MTBUF <bits<3> op, dag outs, dag ins, string asm, list<dag> pattern> :
 196     Enc64<outs, ins, asm, pattern> {
 197
 198   bits<8> VDATA;
 199   bits<12> OFFSET;
 200   bits<1> OFFEN;
 201   bits<1> IDXEN;
 202   bits<1> GLC;
 203   bits<1> ADDR64;
 204   bits<4> DFMT;
 205   bits<3> NFMT;
 206   bits<8> VADDR;
 207   bits<5> SRSRC;
 208   bits<1> SLC;
 209   bits<1> TFE;
 210   bits<8> SOFFSET;
 211
 212   let Inst{11-0} = OFFSET;
 213   let Inst{12} = OFFEN;
 214   let Inst{13} = IDXEN;
 215   let Inst{14} = GLC;
 216   let Inst{15} = ADDR64;
 217   let Inst{18-16} = op;
 218   let Inst{22-19} = DFMT;
 219   let Inst{25-23} = NFMT;
 220   let Inst{31-26} = 0x3a; //encoding
 221   let Inst{39-32} = VADDR;
 222   let Inst{47-40} = VDATA;
 223   let Inst{52-48} = SRSRC;
 224   let Inst{54} = SLC;
 225   let Inst{55} = TFE;
 226   let Inst{63-56} = SOFFSET;
 227   let EncodingType = 3; //SIInstrEncodingType::MTBUF
 228
 229   let VM_CNT = 1;
 230   let EXP_CNT = 1;
 231
 232   let neverHasSideEffects = 1;
 233 }
 234
 235 class MUBUF <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 236     Enc64<outs, ins, asm, pattern> {
 237
 238   bits<8> VDATA;
 239   bits<12> OFFSET;
 240   bits<1> OFFEN;
 241   bits<1> IDXEN;
 242   bits<1> GLC;
 243   bits<1> ADDR64;
 244   bits<1> LDS;
 245   bits<8> VADDR;
 246   bits<5> SRSRC;
 247   bits<1> SLC;
 248   bits<1> TFE;
 249   bits<8> SOFFSET;
 250
 251   let Inst{11-0} = OFFSET;
 252   let Inst{12} = OFFEN;
 253   let Inst{13} = IDXEN;
 254   let Inst{14} = GLC;
 255   let Inst{15} = ADDR64;
 256   let Inst{16} = LDS;
 257   let Inst{24-18} = op;
 258   let Inst{31-26} = 0x38; //encoding
 259   let Inst{39-32} = VADDR;
 260   let Inst{47-40} = VDATA;
 261   let Inst{52-48} = SRSRC;
 262   let Inst{54} = SLC;
 263   let Inst{55} = TFE;
 264   let Inst{63-56} = SOFFSET;
 265   let EncodingType = 4; //SIInstrEncodingType::MUBUF
 266
 267   let VM_CNT = 1;
 268   let EXP_CNT = 1;
 269
 270   let neverHasSideEffects = 1;
 271 }
 272
 273 } // End Uses = [EXEC]
 274
 275 class SMRD <bits<5> op, dag outs, dag ins, string asm, list<dag> pattern> :
 276     Enc32<outs, ins, asm, pattern> {
 277
 278   bits<7> SDST;
 279   bits<15> PTR;
 280   bits<8> OFFSET = PTR{7-0};
 281   bits<1> IMM    = PTR{8};
 282   bits<6> SBASE  = PTR{14-9};
 283
 284   let Inst{7-0} = OFFSET;
 285   let Inst{8} = IMM;
 286   let Inst{14-9} = SBASE;
 287   let Inst{21-15} = SDST;
 288   let Inst{26-22} = op;
 289   let Inst{31-27} = 0x18; //encoding
 290   let EncodingType = 5; //SIInstrEncodingType::SMRD
 291
 292   let LGKM_CNT = 1;
 293 }
 294
 295 class SOP1 <bits<8> op, dag outs, dag ins, string asm, list<dag> pattern> :
 296     Enc32<outs, ins, asm, pattern> {
 297
 298   bits<7> SDST;
 299   bits<8> SSRC0;
 300
 301   let Inst{7-0} = SSRC0;
 302   let Inst{15-8} = op;
 303   let Inst{22-16} = SDST;
 304   let Inst{31-23} = 0x17d; //encoding;
 305   let EncodingType = 6; //SIInstrEncodingType::SOP1
 306
 307   let mayLoad = 0;
 308   let mayStore = 0;
 309   let hasSideEffects = 0;
 310 }
 311
 312 class SOP2 <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 313     Enc32 <outs, ins, asm, pattern> {
 314
 315   bits<7> SDST;
 316   bits<8> SSRC0;
 317   bits<8> SSRC1;
 318
 319   let Inst{7-0} = SSRC0;
 320   let Inst{15-8} = SSRC1;
 321   let Inst{22-16} = SDST;
 322   let Inst{29-23} = op;
 323   let Inst{31-30} = 0x2; // encoding
 324   let EncodingType = 7; // SIInstrEncodingType::SOP2
 325
 326   let mayLoad = 0;
 327   let mayStore = 0;
 328   let hasSideEffects = 0;
 329 }
 330
 331 class SOPC <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 332   Enc32<outs, ins, asm, pattern> {
 333
 334   bits<8> SSRC0;
 335   bits<8> SSRC1;
 336
 337   let Inst{7-0} = SSRC0;
 338   let Inst{15-8} = SSRC1;
 339   let Inst{22-16} = op;
 340   let Inst{31-23} = 0x17e;
 341   let EncodingType = 8; // SIInstrEncodingType::SOPC
 342
 343   let DisableEncoding = "$dst";
 344   let mayLoad = 0;
 345   let mayStore = 0;
 346   let hasSideEffects = 0;
 347 }
 348
 349 class SOPK <bits<5> op, dag outs, dag ins, string asm, list<dag> pattern> :
 350    Enc32 <outs, ins , asm, pattern> {
 351
 352   bits <7> SDST;
 353   bits <16> SIMM16;
 354
 355   let Inst{15-0} = SIMM16;
 356   let Inst{22-16} = SDST;
 357   let Inst{27-23} = op;
 358   let Inst{31-28} = 0xb; //encoding
 359   let EncodingType = 9; // SIInstrEncodingType::SOPK
 360
 361   let mayLoad = 0;
 362   let mayStore = 0;
 363   let hasSideEffects = 0;
 364 }
 365
 366 class SOPP <bits<7> op, dag ins, string asm, list<dag> pattern> : Enc32 <
 367   (outs),
 368   ins,
 369   asm,
 370   pattern > {
 371
 372   bits <16> SIMM16;
 373
 374   let Inst{15-0} = SIMM16;
 375   let Inst{22-16} = op;
 376   let Inst{31-23} = 0x17f; // encoding
 377   let EncodingType = 10; // SIInstrEncodingType::SOPP
 378
 379   let mayLoad = 0;
 380   let mayStore = 0;
 381   let hasSideEffects = 0;
 382 }
 383
 384 let Uses = [EXEC] in {
 385
 386 class VINTRP <bits <2> op, dag outs, dag ins, string asm, list<dag> pattern> :
 387     Enc32 <outs, ins, asm, pattern> {
 388
 389   bits<8> VDST;
 390   bits<8> VSRC;
 391   bits<2> ATTRCHAN;
 392   bits<6> ATTR;
 393
 394   let Inst{7-0} = VSRC;
 395   let Inst{9-8} = ATTRCHAN;
 396   let Inst{15-10} = ATTR;
 397   let Inst{17-16} = op;
 398   let Inst{25-18} = VDST;
 399   let Inst{31-26} = 0x32; // encoding
 400   let EncodingType = 11; // SIInstrEncodingType::VINTRP
 401
 402   let neverHasSideEffects = 1;
 403   let mayLoad = 1;
 404   let mayStore = 0;
 405 }
 406
 407 class VOP1 <bits<8> op, dag outs, dag ins, string asm, list<dag> pattern> :
 408     Enc32 <outs, ins, asm, pattern> {
 409
 410   bits<8> VDST;
 411   bits<9> SRC0;
 412
 413   let Inst{8-0} = SRC0;
 414   let Inst{16-9} = op;
 415   let Inst{24-17} = VDST;
 416   let Inst{31-25} = 0x3f; //encoding
 417
 418   let EncodingType = 12; // SIInstrEncodingType::VOP1
 419   let PostEncoderMethod = "VOPPostEncode";
 420
 421   let mayLoad = 0;
 422   let mayStore = 0;
 423   let hasSideEffects = 0;
 424 }
 425
 426 class VOP2 <bits<6> op, dag outs, dag ins, string asm, list<dag> pattern> :
 427     Enc32 <outs, ins, asm, pattern> {
 428
 429   bits<8> VDST;
 430   bits<9> SRC0;
 431   bits<8> VSRC1;
 432
 433   let Inst{8-0} = SRC0;
 434   let Inst{16-9} = VSRC1;
 435   let Inst{24-17} = VDST;
 436   let Inst{30-25} = op;
 437   let Inst{31} = 0x0; //encoding
 438
 439   let EncodingType = 13; // SIInstrEncodingType::VOP2
 440   let PostEncoderMethod = "VOPPostEncode";
 441
 442   let mayLoad = 0;
 443   let mayStore = 0;
 444   let hasSideEffects = 0;
 445 }
 446
 447 class VOP3 <bits<9> op, dag outs, dag ins, string asm, list<dag> pattern> :
 448     Enc64 <outs, ins, asm, pattern> {
 449
 450   bits<8> VDST;
 451   bits<9> SRC0;
 452   bits<9> SRC1;
 453   bits<9> SRC2;
 454   bits<3> ABS;
 455   bits<1> CLAMP;
 456   bits<2> OMOD;
 457   bits<3> NEG;
 458
 459   let Inst{7-0} = VDST;
 460   let Inst{10-8} = ABS;
 461   let Inst{11} = CLAMP;
 462   let Inst{25-17} = op;
 463   let Inst{31-26} = 0x34; //encoding
 464   let Inst{40-32} = SRC0;
 465   let Inst{49-41} = SRC1;
 466   let Inst{58-50} = SRC2;
 467   let Inst{60-59} = OMOD;
 468   let Inst{63-61} = NEG;
 469
 470   let EncodingType = 14; // SIInstrEncodingType::VOP3
 471   let PostEncoderMethod = "VOPPostEncode";
 472
 473   let mayLoad = 0;
 474   let mayStore = 0;
 475   let hasSideEffects = 0;
 476 }
 477
 478 class VOP3b <bits<9> op, dag outs, dag ins, string asm, list<dag> pattern> :
 479     Enc64 <outs, ins, asm, pattern> {
 480
 481   bits<8> VDST;
 482   bits<9> SRC0;
 483   bits<9> SRC1;
 484   bits<9> SRC2;
 485   bits<7> SDST;
 486   bits<2> OMOD;
 487   bits<3> NEG;
 488
 489   let Inst{7-0} = VDST;
 490   let Inst{14-8} = SDST;
 491   let Inst{25-17} = op;
 492   let Inst{31-26} = 0x34; //encoding
 493   let Inst{40-32} = SRC0;
 494   let Inst{49-41} = SRC1;
 495   let Inst{58-50} = SRC2;
 496   let Inst{60-59} = OMOD;
 497   let Inst{63-61} = NEG;
 498
 499   let EncodingType = 14; // SIInstrEncodingType::VOP3
 500   let PostEncoderMethod = "VOPPostEncode";
 501
 502   let mayLoad = 0;
 503   let mayStore = 0;
 504   let hasSideEffects = 0;
 505 }
 506
 507 class VOPC <bits<8> op, dag ins, string asm, list<dag> pattern> :
 508     Enc32 <(outs VCCReg:$dst), ins, asm, pattern> {
 509
 510   bits<9> SRC0;
 511   bits<8> VSRC1;
 512
 513   let Inst{8-0} = SRC0;
 514   let Inst{16-9} = VSRC1;
 515   let Inst{24-17} = op;
 516   let Inst{31-25} = 0x3e;
 517
 518   let EncodingType = 15; //SIInstrEncodingType::VOPC
 519   let PostEncoderMethod = "VOPPostEncode";
 520   let DisableEncoding = "$dst";
 521   let mayLoad = 0;
 522   let mayStore = 0;
 523   let hasSideEffects = 0;
 524 }
 525
 526 } // End Uses = [EXEC]
 527
 528 class MIMG_Load_Helper <bits<7> op, string asm> : MIMG <
 529   op,
 530   (outs VReg_128:$vdata),
 531   (ins i32imm:$dmask, i1imm:$unorm, i1imm:$glc, i1imm:$da, i1imm:$r128,
 532        i1imm:$tfe, i1imm:$lwe, i1imm:$slc, VReg_32:$vaddr,
 533        GPR4Align<SReg_256>:$srsrc, GPR4Align<SReg_128>:$ssamp),
 534   asm,
 535   []> {
 536   let mayLoad = 1;
 537   let mayStore = 0;
 538 }
 539
 540 class MUBUF_Load_Helper <bits<7> op, string asm, RegisterClass regClass> : MUBUF <
 541   op,
 542   (outs regClass:$dst),
 543   (ins i16imm:$offset, i1imm:$offen, i1imm:$idxen, i1imm:$glc, i1imm:$addr64,
 544        i1imm:$lds, VReg_32:$vaddr, GPR4Align<SReg_128>:$srsrc, i1imm:$slc,
 545        i1imm:$tfe, SReg_32:$soffset),
 546   asm,
 547   []> {
 548   let mayLoad = 1;
 549   let mayStore = 0;
 550 }
 551
 552 class MTBUF_Load_Helper <bits<3> op, string asm, RegisterClass regClass> : MTBUF <
 553   op,
 554   (outs regClass:$dst),
 555   (ins i16imm:$offset, i1imm:$offen, i1imm:$idxen, i1imm:$glc, i1imm:$addr64,
 556        i8imm:$dfmt, i8imm:$nfmt, VReg_32:$vaddr, GPR4Align<SReg_128>:$srsrc,
 557        i1imm:$slc, i1imm:$tfe, SReg_32:$soffset),
 558   asm,
 559   []> {
 560   let mayLoad = 1;
 561   let mayStore = 0;
 562 }
 563
 564 class MTBUF_Store_Helper <bits<3> op, string asm, RegisterClass regClass> : MTBUF <
 565   op,
 566   (outs),
 567   (ins regClass:$vdata, i16imm:$offset, i1imm:$offen, i1imm:$idxen, i1imm:$glc,
 568    i1imm:$addr64, i8imm:$dfmt, i8imm:$nfmt, VReg_32:$vaddr,
 569    GPR4Align<SReg_128>:$srsrc, i1imm:$slc, i1imm:$tfe, SReg_32:$soffset),
 570   asm,
 571   []> {
 572   let mayStore = 1;
 573   let mayLoad = 0;
 574 }
 575
 576 multiclass SMRD_Helper <bits<5> op, string asm, RegisterClass dstClass,
 577                         ValueType vt> {
 578   def _IMM : SMRD <
 579               op,
 580               (outs dstClass:$dst),
 581               (ins SMRDmemri:$src0),
 582               asm,
 583               [(set (vt dstClass:$dst), (constant_load ADDR_Offset8:$src0))]
 584   >;
 585
 586   def _SGPR : SMRD <
 587               op,
 588               (outs dstClass:$dst),
 589               (ins SMRDmemrr:$src0),
 590               asm,
 591               [(set (vt dstClass:$dst), (constant_load ADDR_Reg:$src0))]
 592   >;
 593 }
 594
 595 multiclass SMRD_32 <bits<5> op, string asm, RegisterClass dstClass> {
 596   defm _F32 : SMRD_Helper <op, asm, dstClass, f32>;
 597   defm _I32 : SMRD_Helper <op, asm, dstClass, i32>;
 598 }
 599
 600 include "SIInstrFormats.td"
 601 include "SIInstructions.td"