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