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<1> VM_CNT = 0;
  74   field bits<1> EXP_CNT = 0;
  75   field bits<1> LGKM_CNT = 0;
  76
  77   let TSFlags{0} = VM_CNT;
  78   let TSFlags{1} = EXP_CNT;
  79   let TSFlags{2} = LGKM_CNT;
  80 }
  81
  82 class Enc32 <dag outs, dag ins, string asm, list<dag> pattern> :
  83     InstSI <outs, ins, asm, pattern> {
  84
  85   field bits<32> Inst;
  86   let Size = 4;
  87 }
  88
  89 class Enc64 <dag outs, dag ins, string asm, list<dag> pattern> :
  90     InstSI <outs, ins, asm, pattern> {
  91
  92   field bits<64> Inst;
  93   let Size = 8;
  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
 141   let EXP_CNT = 1;
 142 }
 143
 144 class MIMG <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 145     Enc64 <outs, ins, asm, pattern> {
 146
 147   bits<8> VDATA;
 148   bits<4> DMASK;
 149   bits<1> UNORM;
 150   bits<1> GLC;
 151   bits<1> DA;
 152   bits<1> R128;
 153   bits<1> TFE;
 154   bits<1> LWE;
 155   bits<1> SLC;
 156   bits<8> VADDR;
 157   bits<5> SRSRC;
 158   bits<5> SSAMP;
 159
 160   let Inst{11-8} = DMASK;
 161   let Inst{12} = UNORM;
 162   let Inst{13} = GLC;
 163   let Inst{14} = DA;
 164   let Inst{15} = R128;
 165   let Inst{16} = TFE;
 166   let Inst{17} = LWE;
 167   let Inst{24-18} = op;
 168   let Inst{25} = SLC;
 169   let Inst{31-26} = 0x3c;
 170   let Inst{39-32} = VADDR;
 171   let Inst{47-40} = VDATA;
 172   let Inst{52-48} = SRSRC;
 173   let Inst{57-53} = SSAMP;
 174
 175   let VM_CNT = 1;
 176   let EXP_CNT = 1;
 177 }
 178
 179 class MTBUF <bits<3> op, dag outs, dag ins, string asm, list<dag> pattern> :
 180     Enc64<outs, ins, asm, pattern> {
 181
 182   bits<8> VDATA;
 183   bits<12> OFFSET;
 184   bits<1> OFFEN;
 185   bits<1> IDXEN;
 186   bits<1> GLC;
 187   bits<1> ADDR64;
 188   bits<4> DFMT;
 189   bits<3> NFMT;
 190   bits<8> VADDR;
 191   bits<5> SRSRC;
 192   bits<1> SLC;
 193   bits<1> TFE;
 194   bits<8> SOFFSET;
 195
 196   let Inst{11-0} = OFFSET;
 197   let Inst{12} = OFFEN;
 198   let Inst{13} = IDXEN;
 199   let Inst{14} = GLC;
 200   let Inst{15} = ADDR64;
 201   let Inst{18-16} = op;
 202   let Inst{22-19} = DFMT;
 203   let Inst{25-23} = NFMT;
 204   let Inst{31-26} = 0x3a; //encoding
 205   let Inst{39-32} = VADDR;
 206   let Inst{47-40} = VDATA;
 207   let Inst{52-48} = SRSRC;
 208   let Inst{54} = SLC;
 209   let Inst{55} = TFE;
 210   let Inst{63-56} = SOFFSET;
 211
 212   let VM_CNT = 1;
 213   let EXP_CNT = 1;
 214
 215   let neverHasSideEffects = 1;
 216 }
 217
 218 class MUBUF <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 219     Enc64<outs, ins, asm, pattern> {
 220
 221   bits<8> VDATA;
 222   bits<12> OFFSET;
 223   bits<1> OFFEN;
 224   bits<1> IDXEN;
 225   bits<1> GLC;
 226   bits<1> ADDR64;
 227   bits<1> LDS;
 228   bits<8> VADDR;
 229   bits<5> SRSRC;
 230   bits<1> SLC;
 231   bits<1> TFE;
 232   bits<8> SOFFSET;
 233
 234   let Inst{11-0} = OFFSET;
 235   let Inst{12} = OFFEN;
 236   let Inst{13} = IDXEN;
 237   let Inst{14} = GLC;
 238   let Inst{15} = ADDR64;
 239   let Inst{16} = LDS;
 240   let Inst{24-18} = op;
 241   let Inst{31-26} = 0x38; //encoding
 242   let Inst{39-32} = VADDR;
 243   let Inst{47-40} = VDATA;
 244   let Inst{52-48} = SRSRC;
 245   let Inst{54} = SLC;
 246   let Inst{55} = TFE;
 247   let Inst{63-56} = SOFFSET;
 248
 249   let VM_CNT = 1;
 250   let EXP_CNT = 1;
 251
 252   let neverHasSideEffects = 1;
 253 }
 254
 255 } // End Uses = [EXEC]
 256
 257 class SMRD <bits<5> op, bits<1> imm, dag outs, dag ins, string asm,
 258             list<dag> pattern> : Enc32<outs, ins, asm, pattern> {
 259
 260   bits<7> SDST;
 261   bits<6> SBASE;
 262   bits<8> OFFSET;
 263
 264   let Inst{7-0} = OFFSET;
 265   let Inst{8} = imm;
 266   let Inst{14-9} = SBASE;
 267   let Inst{21-15} = SDST;
 268   let Inst{26-22} = op;
 269   let Inst{31-27} = 0x18; //encoding
 270
 271   let LGKM_CNT = 1;
 272 }
 273
 274 class SOP1 <bits<8> op, dag outs, dag ins, string asm, list<dag> pattern> :
 275     Enc32<outs, ins, asm, pattern> {
 276
 277   bits<7> SDST;
 278   bits<8> SSRC0;
 279
 280   let Inst{7-0} = SSRC0;
 281   let Inst{15-8} = op;
 282   let Inst{22-16} = SDST;
 283   let Inst{31-23} = 0x17d; //encoding;
 284
 285   let mayLoad = 0;
 286   let mayStore = 0;
 287   let hasSideEffects = 0;
 288 }
 289
 290 class SOP2 <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 291     Enc32 <outs, ins, asm, pattern> {
 292
 293   bits<7> SDST;
 294   bits<8> SSRC0;
 295   bits<8> SSRC1;
 296
 297   let Inst{7-0} = SSRC0;
 298   let Inst{15-8} = SSRC1;
 299   let Inst{22-16} = SDST;
 300   let Inst{29-23} = op;
 301   let Inst{31-30} = 0x2; // encoding
 302
 303   let mayLoad = 0;
 304   let mayStore = 0;
 305   let hasSideEffects = 0;
 306 }
 307
 308 class SOPC <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 309   Enc32<outs, ins, asm, pattern> {
 310
 311   bits<8> SSRC0;
 312   bits<8> SSRC1;
 313
 314   let Inst{7-0} = SSRC0;
 315   let Inst{15-8} = SSRC1;
 316   let Inst{22-16} = op;
 317   let Inst{31-23} = 0x17e;
 318
 319   let DisableEncoding = "$dst";
 320   let mayLoad = 0;
 321   let mayStore = 0;
 322   let hasSideEffects = 0;
 323 }
 324
 325 class SOPK <bits<5> op, dag outs, dag ins, string asm, list<dag> pattern> :
 326    Enc32 <outs, ins , asm, pattern> {
 327
 328   bits <7> SDST;
 329   bits <16> SIMM16;
 330
 331   let Inst{15-0} = SIMM16;
 332   let Inst{22-16} = SDST;
 333   let Inst{27-23} = op;
 334   let Inst{31-28} = 0xb; //encoding
 335
 336   let mayLoad = 0;
 337   let mayStore = 0;
 338   let hasSideEffects = 0;
 339 }
 340
 341 class SOPP <bits<7> op, dag ins, string asm, list<dag> pattern> : Enc32 <
 342   (outs),
 343   ins,
 344   asm,
 345   pattern > {
 346
 347   bits <16> SIMM16;
 348
 349   let Inst{15-0} = SIMM16;
 350   let Inst{22-16} = op;
 351   let Inst{31-23} = 0x17f; // encoding
 352
 353   let mayLoad = 0;
 354   let mayStore = 0;
 355   let hasSideEffects = 0;
 356 }
 357
 358 let Uses = [EXEC] in {
 359
 360 class VINTRP <bits <2> op, dag outs, dag ins, string asm, list<dag> pattern> :
 361     Enc32 <outs, ins, asm, pattern> {
 362
 363   bits<8> VDST;
 364   bits<8> VSRC;
 365   bits<2> ATTRCHAN;
 366   bits<6> ATTR;
 367
 368   let Inst{7-0} = VSRC;
 369   let Inst{9-8} = ATTRCHAN;
 370   let Inst{15-10} = ATTR;
 371   let Inst{17-16} = op;
 372   let Inst{25-18} = VDST;
 373   let Inst{31-26} = 0x32; // encoding
 374
 375   let neverHasSideEffects = 1;
 376   let mayLoad = 1;
 377   let mayStore = 0;
 378 }
 379
 380 class VOP1 <bits<8> op, dag outs, dag ins, string asm, list<dag> pattern> :
 381     Enc32 <outs, ins, asm, pattern> {
 382
 383   bits<8> VDST;
 384   bits<9> SRC0;
 385
 386   let Inst{8-0} = SRC0;
 387   let Inst{16-9} = op;
 388   let Inst{24-17} = VDST;
 389   let Inst{31-25} = 0x3f; //encoding
 390
 391   let mayLoad = 0;
 392   let mayStore = 0;
 393   let hasSideEffects = 0;
 394 }
 395
 396 class VOP2 <bits<6> op, dag outs, dag ins, string asm, list<dag> pattern> :
 397     Enc32 <outs, ins, asm, pattern> {
 398
 399   bits<8> VDST;
 400   bits<9> SRC0;
 401   bits<8> VSRC1;
 402
 403   let Inst{8-0} = SRC0;
 404   let Inst{16-9} = VSRC1;
 405   let Inst{24-17} = VDST;
 406   let Inst{30-25} = op;
 407   let Inst{31} = 0x0; //encoding
 408
 409   let mayLoad = 0;
 410   let mayStore = 0;
 411   let hasSideEffects = 0;
 412 }
 413
 414 class VOP3 <bits<9> op, dag outs, dag ins, string asm, list<dag> pattern> :
 415     Enc64 <outs, ins, asm, pattern> {
 416
 417   bits<8> VDST;
 418   bits<9> SRC0;
 419   bits<9> SRC1;
 420   bits<9> SRC2;
 421   bits<3> ABS;
 422   bits<1> CLAMP;
 423   bits<2> OMOD;
 424   bits<3> NEG;
 425
 426   let Inst{7-0} = VDST;
 427   let Inst{10-8} = ABS;
 428   let Inst{11} = CLAMP;
 429   let Inst{25-17} = op;
 430   let Inst{31-26} = 0x34; //encoding
 431   let Inst{40-32} = SRC0;
 432   let Inst{49-41} = SRC1;
 433   let Inst{58-50} = SRC2;
 434   let Inst{60-59} = OMOD;
 435   let Inst{63-61} = NEG;
 436
 437   let mayLoad = 0;
 438   let mayStore = 0;
 439   let hasSideEffects = 0;
 440 }
 441
 442 class VOP3b <bits<9> op, dag outs, dag ins, string asm, list<dag> pattern> :
 443     Enc64 <outs, ins, asm, pattern> {
 444
 445   bits<8> VDST;
 446   bits<9> SRC0;
 447   bits<9> SRC1;
 448   bits<9> SRC2;
 449   bits<7> SDST;
 450   bits<2> OMOD;
 451   bits<3> NEG;
 452
 453   let Inst{7-0} = VDST;
 454   let Inst{14-8} = SDST;
 455   let Inst{25-17} = op;
 456   let Inst{31-26} = 0x34; //encoding
 457   let Inst{40-32} = SRC0;
 458   let Inst{49-41} = SRC1;
 459   let Inst{58-50} = SRC2;
 460   let Inst{60-59} = OMOD;
 461   let Inst{63-61} = NEG;
 462
 463   let mayLoad = 0;
 464   let mayStore = 0;
 465   let hasSideEffects = 0;
 466 }
 467
 468 class VOPC <bits<8> op, dag ins, string asm, list<dag> pattern> :
 469     Enc32 <(outs VCCReg:$dst), ins, asm, pattern> {
 470
 471   bits<9> SRC0;
 472   bits<8> VSRC1;
 473
 474   let Inst{8-0} = SRC0;
 475   let Inst{16-9} = VSRC1;
 476   let Inst{24-17} = op;
 477   let Inst{31-25} = 0x3e;
 478
 479   let DisableEncoding = "$dst";
 480   let mayLoad = 0;
 481   let mayStore = 0;
 482   let hasSideEffects = 0;
 483 }
 484
 485 } // End Uses = [EXEC]
 486
 487 include "SIInstrFormats.td"
 488 include "SIInstructions.td"