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 Nodes
  12 //===----------------------------------------------------------------------===//
  13
  14 // SMRD takes a 64bit memory address and can only add an 32bit offset
  15 def SIadd64bit32bit : SDNode<"ISD::ADD",
  16   SDTypeProfile<1, 2, [SDTCisSameAs<0, 1>, SDTCisVT<0, i64>, SDTCisVT<2, i32>]>
  17 >;
  18
  19 // Transformation function, extract the lower 32bit of a 64bit immediate
  20 def LO32 : SDNodeXForm<imm, [{
  21   return CurDAG->getTargetConstant(N->getZExtValue() & 0xffffffff, MVT::i32);
  22 }]>;
  23
  24 // Transformation function, extract the upper 32bit of a 64bit immediate
  25 def HI32 : SDNodeXForm<imm, [{
  26   return CurDAG->getTargetConstant(N->getZExtValue() >> 32, MVT::i32);
  27 }]>;
  28
  29 def IMM8bitDWORD : ImmLeaf <
  30   i32, [{
  31     return (Imm & ~0x3FC) == 0;
  32   }], SDNodeXForm<imm, [{
  33     return CurDAG->getTargetConstant(
  34       N->getZExtValue() >> 2, MVT::i32);
  35   }]>
  36 >;
  37
  38 def IMM12bit : ImmLeaf <
  39   i16,
  40   [{return isUInt<12>(Imm);}]
  41 >;
  42
  43 class InstSI <dag outs, dag ins, string asm, list<dag> pattern> :
  44     AMDGPUInst<outs, ins, asm, pattern> {
  45
  46   field bits<1> VM_CNT = 0;
  47   field bits<1> EXP_CNT = 0;
  48   field bits<1> LGKM_CNT = 0;
  49
  50   let TSFlags{0} = VM_CNT;
  51   let TSFlags{1} = EXP_CNT;
  52   let TSFlags{2} = LGKM_CNT;
  53 }
  54
  55 class Enc32 <dag outs, dag ins, string asm, list<dag> pattern> :
  56     InstSI <outs, ins, asm, pattern> {
  57
  58   field bits<32> Inst;
  59   let Size = 4;
  60 }
  61
  62 class Enc64 <dag outs, dag ins, string asm, list<dag> pattern> :
  63     InstSI <outs, ins, asm, pattern> {
  64
  65   field bits<64> Inst;
  66   let Size = 8;
  67 }
  68
  69 class SIOperand <ValueType vt, dag opInfo>: Operand <vt> {
  70   let EncoderMethod = "encodeOperand";
  71   let MIOperandInfo = opInfo;
  72 }
  73
  74 class GPR4Align <RegisterClass rc> : Operand <vAny> {
  75   let EncoderMethod = "GPR4AlignEncode";
  76   let MIOperandInfo = (ops rc:$reg);
  77 }
  78
  79 class GPR2Align <RegisterClass rc> : Operand <iPTR> {
  80   let EncoderMethod = "GPR2AlignEncode";
  81   let MIOperandInfo = (ops rc:$reg);
  82 }
  83
  84 let Uses = [EXEC] in {
  85
  86 def EXP : Enc64<
  87   (outs),
  88   (ins i32imm:$en, i32imm:$tgt, i32imm:$compr, i32imm:$done, i32imm:$vm,
  89        VReg_32:$src0, VReg_32:$src1, VReg_32:$src2, VReg_32:$src3),
  90   "EXP $en, $tgt, $compr, $done, $vm, $src0, $src1, $src2, $src3",
  91   [] > {
  92
  93   bits<4> EN;
  94   bits<6> TGT;
  95   bits<1> COMPR;
  96   bits<1> DONE;
  97   bits<1> VM;
  98   bits<8> VSRC0;
  99   bits<8> VSRC1;
 100   bits<8> VSRC2;
 101   bits<8> VSRC3;
 102
 103   let Inst{3-0} = EN;
 104   let Inst{9-4} = TGT;
 105   let Inst{10} = COMPR;
 106   let Inst{11} = DONE;
 107   let Inst{12} = VM;
 108   let Inst{31-26} = 0x3e;
 109   let Inst{39-32} = VSRC0;
 110   let Inst{47-40} = VSRC1;
 111   let Inst{55-48} = VSRC2;
 112   let Inst{63-56} = VSRC3;
 113
 114   let EXP_CNT = 1;
 115 }
 116
 117 class MIMG <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 118     Enc64 <outs, ins, asm, pattern> {
 119
 120   bits<8> VDATA;
 121   bits<4> DMASK;
 122   bits<1> UNORM;
 123   bits<1> GLC;
 124   bits<1> DA;
 125   bits<1> R128;
 126   bits<1> TFE;
 127   bits<1> LWE;
 128   bits<1> SLC;
 129   bits<8> VADDR;
 130   bits<5> SRSRC;
 131   bits<5> SSAMP;
 132
 133   let Inst{11-8} = DMASK;
 134   let Inst{12} = UNORM;
 135   let Inst{13} = GLC;
 136   let Inst{14} = DA;
 137   let Inst{15} = R128;
 138   let Inst{16} = TFE;
 139   let Inst{17} = LWE;
 140   let Inst{24-18} = op;
 141   let Inst{25} = SLC;
 142   let Inst{31-26} = 0x3c;
 143   let Inst{39-32} = VADDR;
 144   let Inst{47-40} = VDATA;
 145   let Inst{52-48} = SRSRC;
 146   let Inst{57-53} = SSAMP;
 147
 148   let VM_CNT = 1;
 149   let EXP_CNT = 1;
 150 }
 151
 152 class MTBUF <bits<3> op, dag outs, dag ins, string asm, list<dag> pattern> :
 153     Enc64<outs, ins, asm, pattern> {
 154
 155   bits<8> VDATA;
 156   bits<12> OFFSET;
 157   bits<1> OFFEN;
 158   bits<1> IDXEN;
 159   bits<1> GLC;
 160   bits<1> ADDR64;
 161   bits<4> DFMT;
 162   bits<3> NFMT;
 163   bits<8> VADDR;
 164   bits<5> SRSRC;
 165   bits<1> SLC;
 166   bits<1> TFE;
 167   bits<8> SOFFSET;
 168
 169   let Inst{11-0} = OFFSET;
 170   let Inst{12} = OFFEN;
 171   let Inst{13} = IDXEN;
 172   let Inst{14} = GLC;
 173   let Inst{15} = ADDR64;
 174   let Inst{18-16} = op;
 175   let Inst{22-19} = DFMT;
 176   let Inst{25-23} = NFMT;
 177   let Inst{31-26} = 0x3a; //encoding
 178   let Inst{39-32} = VADDR;
 179   let Inst{47-40} = VDATA;
 180   let Inst{52-48} = SRSRC;
 181   let Inst{54} = SLC;
 182   let Inst{55} = TFE;
 183   let Inst{63-56} = SOFFSET;
 184
 185   let VM_CNT = 1;
 186   let EXP_CNT = 1;
 187
 188   let neverHasSideEffects = 1;
 189 }
 190
 191 class MUBUF <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 192     Enc64<outs, ins, asm, pattern> {
 193
 194   bits<8> VDATA;
 195   bits<12> OFFSET;
 196   bits<1> OFFEN;
 197   bits<1> IDXEN;
 198   bits<1> GLC;
 199   bits<1> ADDR64;
 200   bits<1> LDS;
 201   bits<8> VADDR;
 202   bits<5> SRSRC;
 203   bits<1> SLC;
 204   bits<1> TFE;
 205   bits<8> SOFFSET;
 206
 207   let Inst{11-0} = OFFSET;
 208   let Inst{12} = OFFEN;
 209   let Inst{13} = IDXEN;
 210   let Inst{14} = GLC;
 211   let Inst{15} = ADDR64;
 212   let Inst{16} = LDS;
 213   let Inst{24-18} = op;
 214   let Inst{31-26} = 0x38; //encoding
 215   let Inst{39-32} = VADDR;
 216   let Inst{47-40} = VDATA;
 217   let Inst{52-48} = SRSRC;
 218   let Inst{54} = SLC;
 219   let Inst{55} = TFE;
 220   let Inst{63-56} = SOFFSET;
 221
 222   let VM_CNT = 1;
 223   let EXP_CNT = 1;
 224
 225   let neverHasSideEffects = 1;
 226 }
 227
 228 } // End Uses = [EXEC]
 229
 230 class SMRD <bits<5> op, bits<1> imm, dag outs, dag ins, string asm,
 231             list<dag> pattern> : Enc32<outs, ins, asm, pattern> {
 232
 233   bits<7> SDST;
 234   bits<6> SBASE;
 235   bits<8> OFFSET;
 236
 237   let Inst{7-0} = OFFSET;
 238   let Inst{8} = imm;
 239   let Inst{14-9} = SBASE;
 240   let Inst{21-15} = SDST;
 241   let Inst{26-22} = op;
 242   let Inst{31-27} = 0x18; //encoding
 243
 244   let LGKM_CNT = 1;
 245 }
 246
 247 class SOP1 <bits<8> op, dag outs, dag ins, string asm, list<dag> pattern> :
 248     Enc32<outs, ins, asm, pattern> {
 249
 250   bits<7> SDST;
 251   bits<8> SSRC0;
 252
 253   let Inst{7-0} = SSRC0;
 254   let Inst{15-8} = op;
 255   let Inst{22-16} = SDST;
 256   let Inst{31-23} = 0x17d; //encoding;
 257
 258   let mayLoad = 0;
 259   let mayStore = 0;
 260   let hasSideEffects = 0;
 261 }
 262
 263 class SOP2 <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 264     Enc32 <outs, ins, asm, pattern> {
 265
 266   bits<7> SDST;
 267   bits<8> SSRC0;
 268   bits<8> SSRC1;
 269
 270   let Inst{7-0} = SSRC0;
 271   let Inst{15-8} = SSRC1;
 272   let Inst{22-16} = SDST;
 273   let Inst{29-23} = op;
 274   let Inst{31-30} = 0x2; // encoding
 275
 276   let mayLoad = 0;
 277   let mayStore = 0;
 278   let hasSideEffects = 0;
 279 }
 280
 281 class SOPC <bits<7> op, dag outs, dag ins, string asm, list<dag> pattern> :
 282   Enc32<outs, ins, asm, pattern> {
 283
 284   bits<8> SSRC0;
 285   bits<8> SSRC1;
 286
 287   let Inst{7-0} = SSRC0;
 288   let Inst{15-8} = SSRC1;
 289   let Inst{22-16} = op;
 290   let Inst{31-23} = 0x17e;
 291
 292   let DisableEncoding = "$dst";
 293   let mayLoad = 0;
 294   let mayStore = 0;
 295   let hasSideEffects = 0;
 296 }
 297
 298 class SOPK <bits<5> op, dag outs, dag ins, string asm, list<dag> pattern> :
 299    Enc32 <outs, ins , asm, pattern> {
 300
 301   bits <7> SDST;
 302   bits <16> SIMM16;
 303
 304   let Inst{15-0} = SIMM16;
 305   let Inst{22-16} = SDST;
 306   let Inst{27-23} = op;
 307   let Inst{31-28} = 0xb; //encoding
 308
 309   let mayLoad = 0;
 310   let mayStore = 0;
 311   let hasSideEffects = 0;
 312 }
 313
 314 class SOPP <bits<7> op, dag ins, string asm, list<dag> pattern> : Enc32 <
 315   (outs),
 316   ins,
 317   asm,
 318   pattern > {
 319
 320   bits <16> SIMM16;
 321
 322   let Inst{15-0} = SIMM16;
 323   let Inst{22-16} = op;
 324   let Inst{31-23} = 0x17f; // encoding
 325
 326   let mayLoad = 0;
 327   let mayStore = 0;
 328   let hasSideEffects = 0;
 329 }
 330
 331 let Uses = [EXEC] in {
 332
 333 class VINTRP <bits <2> op, dag outs, dag ins, string asm, list<dag> pattern> :
 334     Enc32 <outs, ins, asm, pattern> {
 335
 336   bits<8> VDST;
 337   bits<8> VSRC;
 338   bits<2> ATTRCHAN;
 339   bits<6> ATTR;
 340
 341   let Inst{7-0} = VSRC;
 342   let Inst{9-8} = ATTRCHAN;
 343   let Inst{15-10} = ATTR;
 344   let Inst{17-16} = op;
 345   let Inst{25-18} = VDST;
 346   let Inst{31-26} = 0x32; // encoding
 347
 348   let neverHasSideEffects = 1;
 349   let mayLoad = 1;
 350   let mayStore = 0;
 351 }
 352
 353 class VOP1 <bits<8> op, dag outs, dag ins, string asm, list<dag> pattern> :
 354     Enc32 <outs, ins, asm, pattern> {
 355
 356   bits<8> VDST;
 357   bits<9> SRC0;
 358
 359   let Inst{8-0} = SRC0;
 360   let Inst{16-9} = op;
 361   let Inst{24-17} = VDST;
 362   let Inst{31-25} = 0x3f; //encoding
 363
 364   let mayLoad = 0;
 365   let mayStore = 0;
 366   let hasSideEffects = 0;
 367 }
 368
 369 class VOP2 <bits<6> op, dag outs, dag ins, string asm, list<dag> pattern> :
 370     Enc32 <outs, ins, asm, pattern> {
 371
 372   bits<8> VDST;
 373   bits<9> SRC0;
 374   bits<8> VSRC1;
 375
 376   let Inst{8-0} = SRC0;
 377   let Inst{16-9} = VSRC1;
 378   let Inst{24-17} = VDST;
 379   let Inst{30-25} = op;
 380   let Inst{31} = 0x0; //encoding
 381
 382   let mayLoad = 0;
 383   let mayStore = 0;
 384   let hasSideEffects = 0;
 385 }
 386
 387 class VOP3 <bits<9> op, dag outs, dag ins, string asm, list<dag> pattern> :
 388     Enc64 <outs, ins, asm, pattern> {
 389
 390   bits<8> VDST;
 391   bits<9> SRC0;
 392   bits<9> SRC1;
 393   bits<9> SRC2;
 394   bits<3> ABS;
 395   bits<1> CLAMP;
 396   bits<2> OMOD;
 397   bits<3> NEG;
 398
 399   let Inst{7-0} = VDST;
 400   let Inst{10-8} = ABS;
 401   let Inst{11} = CLAMP;
 402   let Inst{25-17} = op;
 403   let Inst{31-26} = 0x34; //encoding
 404   let Inst{40-32} = SRC0;
 405   let Inst{49-41} = SRC1;
 406   let Inst{58-50} = SRC2;
 407   let Inst{60-59} = OMOD;
 408   let Inst{63-61} = NEG;
 409
 410   let mayLoad = 0;
 411   let mayStore = 0;
 412   let hasSideEffects = 0;
 413 }
 414
 415 class VOP3b <bits<9> op, dag outs, dag ins, string asm, list<dag> pattern> :
 416     Enc64 <outs, ins, asm, pattern> {
 417
 418   bits<8> VDST;
 419   bits<9> SRC0;
 420   bits<9> SRC1;
 421   bits<9> SRC2;
 422   bits<7> SDST;
 423   bits<2> OMOD;
 424   bits<3> NEG;
 425
 426   let Inst{7-0} = VDST;
 427   let Inst{14-8} = SDST;
 428   let Inst{25-17} = op;
 429   let Inst{31-26} = 0x34; //encoding
 430   let Inst{40-32} = SRC0;
 431   let Inst{49-41} = SRC1;
 432   let Inst{58-50} = SRC2;
 433   let Inst{60-59} = OMOD;
 434   let Inst{63-61} = NEG;
 435
 436   let mayLoad = 0;
 437   let mayStore = 0;
 438   let hasSideEffects = 0;
 439 }
 440
 441 class VOPC <bits<8> op, dag ins, string asm, list<dag> pattern> :
 442     Enc32 <(outs VCCReg:$dst), ins, asm, pattern> {
 443
 444   bits<9> SRC0;
 445   bits<8> VSRC1;
 446
 447   let Inst{8-0} = SRC0;
 448   let Inst{16-9} = VSRC1;
 449   let Inst{24-17} = op;
 450   let Inst{31-25} = 0x3e;
 451
 452   let DisableEncoding = "$dst";
 453   let mayLoad = 0;
 454   let mayStore = 0;
 455   let hasSideEffects = 0;
 456 }
 457
 458 } // End Uses = [EXEC]
 459
 460 include "SIInstrFormats.td"
 461 include "SIInstructions.td"