lib/Target/R600/SIInstrInfo.td

   1 //===-- SIInstrInfo.td - SI Instruction Infos -------------*- 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 SIbuffer_store : SDNode<"AMDGPUISD::BUFFER_STORE",
  30                            SDTypeProfile<0, 3, [SDTCisPtrTy<1>, SDTCisInt<2>]>,
  31                            [SDNPHasChain, SDNPMayStore]>;
  32
  33 def IMM8bitDWORD : ImmLeaf <
  34   i32, [{
  35     return (Imm & ~0x3FC) == 0;
  36   }], SDNodeXForm<imm, [{
  37     return CurDAG->getTargetConstant(
  38       N->getZExtValue() >> 2, MVT::i32);
  39   }]>
  40 >;
  41
  42 def IMM12bit : ImmLeaf <
  43   i16,
  44   [{return isUInt<12>(Imm);}]
  45 >;
  46
  47 class InlineImm <ValueType vt> : PatLeaf <(vt imm), [{
  48   return ((const SITargetLowering &)TLI).analyzeImmediate(N) == 0;
  49 }]>;
  50
  51 //===----------------------------------------------------------------------===//
  52 // SI assembler operands
  53 //===----------------------------------------------------------------------===//
  54
  55 def SIOperand {
  56   int ZERO = 0x80;
  57   int VCC = 0x6A;
  58 }
  59
  60 include "SIInstrFormats.td"
  61
  62 //===----------------------------------------------------------------------===//
  63 //
  64 // SI Instruction multiclass helpers.
  65 //
  66 // Instructions with _32 take 32-bit operands.
  67 // Instructions with _64 take 64-bit operands.
  68 //
  69 // VOP_* instructions can use either a 32-bit or 64-bit encoding.  The 32-bit
  70 // encoding is the standard encoding, but instruction that make use of
  71 // any of the instruction modifiers must use the 64-bit encoding.
  72 //
  73 // Instructions with _e32 use the 32-bit encoding.
  74 // Instructions with _e64 use the 64-bit encoding.
  75 //
  76 //===----------------------------------------------------------------------===//
  77
  78 //===----------------------------------------------------------------------===//
  79 // Scalar classes
  80 //===----------------------------------------------------------------------===//
  81
  82 class SOP1_32 <bits<8> op, string opName, list<dag> pattern> : SOP1 <
  83   op, (outs SReg_32:$dst), (ins SSrc_32:$src0),
  84   opName#" $dst, $src0", pattern
  85 >;
  86
  87 class SOP1_64 <bits<8> op, string opName, list<dag> pattern> : SOP1 <
  88   op, (outs SReg_64:$dst), (ins SSrc_64:$src0),
  89   opName#" $dst, $src0", pattern
  90 >;
  91
  92 class SOP2_32 <bits<7> op, string opName, list<dag> pattern> : SOP2 <
  93   op, (outs SReg_32:$dst), (ins SSrc_32:$src0, SSrc_32:$src1),
  94   opName#" $dst, $src0, $src1", pattern
  95 >;
  96
  97 class SOP2_64 <bits<7> op, string opName, list<dag> pattern> : SOP2 <
  98   op, (outs SReg_64:$dst), (ins SSrc_64:$src0, SSrc_64:$src1),
  99   opName#" $dst, $src0, $src1", pattern
 100 >;
 101
 102 class SOPC_32 <bits<7> op, string opName, list<dag> pattern> : SOPC <
 103   op, (outs SCCReg:$dst), (ins SSrc_32:$src0, SSrc_32:$src1),
 104   opName#" $dst, $src0, $src1", pattern
 105 >;
 106
 107 class SOPC_64 <bits<7> op, string opName, list<dag> pattern> : SOPC <
 108   op, (outs SCCReg:$dst), (ins SSrc_64:$src0, SSrc_64:$src1),
 109   opName#" $dst, $src0, $src1", pattern
 110 >;
 111
 112 class SOPK_32 <bits<5> op, string opName, list<dag> pattern> : SOPK <
 113   op, (outs SReg_32:$dst), (ins i16imm:$src0),
 114   opName#" $dst, $src0", pattern
 115 >;
 116
 117 class SOPK_64 <bits<5> op, string opName, list<dag> pattern> : SOPK <
 118   op, (outs SReg_64:$dst), (ins i16imm:$src0),
 119   opName#" $dst, $src0", pattern
 120 >;
 121
 122 multiclass SMRD_Helper <bits<5> op, string asm, RegisterClass baseClass,
 123                         RegisterClass dstClass> {
 124   def _IMM : SMRD <
 125     op, 1, (outs dstClass:$dst),
 126     (ins baseClass:$sbase, i32imm:$offset),
 127     asm#" $dst, $sbase, $offset", []
 128   >;
 129
 130   def _SGPR : SMRD <
 131     op, 0, (outs dstClass:$dst),
 132     (ins baseClass:$sbase, SReg_32:$soff),
 133     asm#" $dst, $sbase, $soff", []
 134   >;
 135 }
 136
 137 //===----------------------------------------------------------------------===//
 138 // Vector ALU classes
 139 //===----------------------------------------------------------------------===//
 140
 141 class VOP <string opName> {
 142   string OpName = opName;
 143 }
 144
 145 class VOP2_REV <string revOp, bit isOrig> {
 146   string RevOp = revOp;
 147   bit IsOrig = isOrig;
 148 }
 149
 150 multiclass VOP1_Helper <bits<8> op, RegisterClass drc, RegisterClass src,
 151                         string opName, list<dag> pattern> {
 152
 153   def _e32 : VOP1 <
 154     op, (outs drc:$dst), (ins src:$src0),
 155     opName#"_e32 $dst, $src0", pattern
 156   >, VOP <opName>;
 157
 158   def _e64 : VOP3 <
 159     {1, 1, op{6}, op{5}, op{4}, op{3}, op{2}, op{1}, op{0}},
 160     (outs drc:$dst),
 161     (ins src:$src0,
 162          i32imm:$abs, i32imm:$clamp,
 163          i32imm:$omod, i32imm:$neg),
 164     opName#"_e64 $dst, $src0, $abs, $clamp, $omod, $neg", []
 165   >, VOP <opName> {
 166     let src1 = SIOperand.ZERO;
 167     let src2 = SIOperand.ZERO;
 168   }
 169 }
 170
 171 multiclass VOP1_32 <bits<8> op, string opName, list<dag> pattern>
 172   : VOP1_Helper <op, VReg_32, VSrc_32, opName, pattern>;
 173
 174 multiclass VOP1_64 <bits<8> op, string opName, list<dag> pattern>
 175   : VOP1_Helper <op, VReg_64, VSrc_64, opName, pattern>;
 176
 177 multiclass VOP2_Helper <bits<6> op, RegisterClass vrc, RegisterClass arc,
 178                         string opName, list<dag> pattern, string revOp> {
 179   def _e32 : VOP2 <
 180     op, (outs vrc:$dst), (ins arc:$src0, vrc:$src1),
 181     opName#"_e32 $dst, $src0, $src1", pattern
 182   >, VOP <opName>, VOP2_REV<revOp#"_e32", !eq(revOp, opName)>;
 183
 184   def _e64 : VOP3 <
 185     {1, 0, 0, op{5}, op{4}, op{3}, op{2}, op{1}, op{0}},
 186     (outs vrc:$dst),
 187     (ins arc:$src0, arc:$src1,
 188          i32imm:$abs, i32imm:$clamp,
 189          i32imm:$omod, i32imm:$neg),
 190     opName#"_e64 $dst, $src0, $src1, $abs, $clamp, $omod, $neg", []
 191   >, VOP <opName>, VOP2_REV<revOp#"_e64", !eq(revOp, opName)> {
 192     let src2 = SIOperand.ZERO;
 193   }
 194 }
 195
 196 multiclass VOP2_32 <bits<6> op, string opName, list<dag> pattern,
 197                     string revOp = opName>
 198   : VOP2_Helper <op, VReg_32, VSrc_32, opName, pattern, revOp>;
 199
 200 multiclass VOP2_64 <bits<6> op, string opName, list<dag> pattern,
 201                     string revOp = opName>
 202   : VOP2_Helper <op, VReg_64, VSrc_64, opName, pattern, revOp>;
 203
 204 multiclass VOP2b_32 <bits<6> op, string opName, list<dag> pattern,
 205                      string revOp = opName> {
 206
 207   def _e32 : VOP2 <
 208     op, (outs VReg_32:$dst), (ins VSrc_32:$src0, VReg_32:$src1),
 209     opName#"_e32 $dst, $src0, $src1", pattern
 210   >, VOP <opName>, VOP2_REV<revOp#"_e32", !eq(revOp, opName)>;
 211
 212   def _e64 : VOP3b <
 213     {1, 0, 0, op{5}, op{4}, op{3}, op{2}, op{1}, op{0}},
 214     (outs VReg_32:$dst),
 215     (ins VSrc_32:$src0, VSrc_32:$src1,
 216          i32imm:$abs, i32imm:$clamp,
 217          i32imm:$omod, i32imm:$neg),
 218     opName#"_e64 $dst, $src0, $src1, $abs, $clamp, $omod, $neg", []
 219   >, VOP <opName>, VOP2_REV<revOp#"_e64", !eq(revOp, opName)> {
 220     let src2 = SIOperand.ZERO;
 221     /* the VOP2 variant puts the carry out into VCC, the VOP3 variant
 222        can write it into any SGPR. We currently don't use the carry out,
 223        so for now hardcode it to VCC as well */
 224     let sdst = SIOperand.VCC;
 225   }
 226 }
 227
 228 multiclass VOPC_Helper <bits<8> op, RegisterClass vrc, RegisterClass arc,
 229                         string opName, ValueType vt, PatLeaf cond> {
 230
 231   def _e32 : VOPC <
 232     op, (ins arc:$src0, vrc:$src1),
 233     opName#"_e32 $dst, $src0, $src1", []
 234   >, VOP <opName>;
 235
 236   def _e64 : VOP3 <
 237     {0, op{7}, op{6}, op{5}, op{4}, op{3}, op{2}, op{1}, op{0}},
 238     (outs SReg_64:$dst),
 239     (ins arc:$src0, arc:$src1,
 240          InstFlag:$abs, InstFlag:$clamp,
 241          InstFlag:$omod, InstFlag:$neg),
 242     opName#"_e64 $dst, $src0, $src1, $abs, $clamp, $omod, $neg",
 243     !if(!eq(!cast<string>(cond), "COND_NULL"), []<dag>,
 244       [(set SReg_64:$dst, (i1 (setcc (vt arc:$src0), arc:$src1, cond)))]
 245     )
 246   >, VOP <opName> {
 247     let src2 = SIOperand.ZERO;
 248   }
 249 }
 250
 251 multiclass VOPC_32 <bits<8> op, string opName,
 252   ValueType vt = untyped, PatLeaf cond = COND_NULL>
 253   : VOPC_Helper <op, VReg_32, VSrc_32, opName, vt, cond>;
 254
 255 multiclass VOPC_64 <bits<8> op, string opName,
 256   ValueType vt = untyped, PatLeaf cond = COND_NULL>
 257   : VOPC_Helper <op, VReg_64, VSrc_64, opName, vt, cond>;
 258
 259 class VOP3_32 <bits<9> op, string opName, list<dag> pattern> : VOP3 <
 260   op, (outs VReg_32:$dst),
 261   (ins VSrc_32:$src0, VSrc_32:$src1, VSrc_32:$src2,
 262    InstFlag:$abs, InstFlag:$clamp, InstFlag:$omod, InstFlag:$neg),
 263   opName#" $dst, $src0, $src1, $src2, $abs, $clamp, $omod, $neg", pattern
 264 >, VOP <opName>;
 265
 266 class VOP3_64_Shift <bits <9> op, string opName, list<dag> pattern> : VOP3 <
 267   op, (outs VReg_64:$dst),
 268   (ins VSrc_64:$src0, VSrc_32:$src1),
 269   opName#" $dst, $src0, $src1", pattern
 270 >, VOP <opName> {
 271
 272   let src2 = SIOperand.ZERO;
 273   let abs = 0;
 274   let clamp = 0;
 275   let omod = 0;
 276   let neg = 0;
 277 }
 278
 279 class VOP3_64 <bits<9> op, string opName, list<dag> pattern> : VOP3 <
 280   op, (outs VReg_64:$dst),
 281   (ins VSrc_64:$src0, VSrc_64:$src1, VSrc_64:$src2,
 282    InstFlag:$abs, InstFlag:$clamp, InstFlag:$omod, InstFlag:$neg),
 283   opName#" $dst, $src0, $src1, $src2, $abs, $clamp, $omod, $neg", pattern
 284 >, VOP <opName>;
 285
 286 //===----------------------------------------------------------------------===//
 287 // Vector I/O classes
 288 //===----------------------------------------------------------------------===//
 289
 290 class MTBUF_Store_Helper <bits<3> op, string asm, RegisterClass regClass> : MTBUF <
 291   op,
 292   (outs),
 293   (ins regClass:$vdata, i16imm:$offset, i1imm:$offen, i1imm:$idxen, i1imm:$glc,
 294    i1imm:$addr64, i8imm:$dfmt, i8imm:$nfmt, VReg_32:$vaddr,
 295    SReg_128:$srsrc, i1imm:$slc, i1imm:$tfe, SSrc_32:$soffset),
 296   asm#" $vdata, $offset, $offen, $idxen, $glc, $addr64, $dfmt,"
 297      #" $nfmt, $vaddr, $srsrc, $slc, $tfe, $soffset",
 298   []> {
 299   let mayStore = 1;
 300   let mayLoad = 0;
 301 }
 302
 303 class MUBUF_Load_Helper <bits<7> op, string asm, RegisterClass regClass> : MUBUF <
 304   op,
 305   (outs regClass:$vdata),
 306   (ins i16imm:$offset, i1imm:$offen, i1imm:$idxen, i1imm:$glc, i1imm:$addr64,
 307        i1imm:$lds, VReg_32:$vaddr, SReg_128:$srsrc, i1imm:$slc,
 308        i1imm:$tfe, SSrc_32:$soffset),
 309   asm#" $vdata, $offset, $offen, $idxen, $glc, $addr64, "
 310      #"$lds, $vaddr, $srsrc, $slc, $tfe, $soffset",
 311   []> {
 312   let mayLoad = 1;
 313   let mayStore = 0;
 314 }
 315
 316 class MUBUF_Store_Helper <bits<7> op, string name, RegisterClass vdataClass,
 317                          ValueType VT> :
 318     MUBUF <op, (outs), (ins vdataClass:$vdata, SReg_128:$srsrc, VReg_64:$vaddr),
 319           name#" $vdata, $srsrc + $vaddr",
 320           [(SIbuffer_store (VT vdataClass:$vdata), (i128 SReg_128:$srsrc),
 321                                                     (i64 VReg_64:$vaddr))]> {
 322
 323   let mayLoad = 0;
 324   let mayStore = 1;
 325
 326   // Encoding
 327   let offset = 0;
 328   let offen = 0;
 329   let idxen = 0;
 330   let glc = 0;
 331   let addr64 = 1;
 332   let lds = 0;
 333   let slc = 0;
 334   let tfe = 0;
 335   let soffset = 128; // ZERO
 336 }
 337
 338 class MTBUF_Load_Helper <bits<3> op, string asm, RegisterClass regClass> : MTBUF <
 339   op,
 340   (outs regClass:$dst),
 341   (ins i16imm:$offset, i1imm:$offen, i1imm:$idxen, i1imm:$glc, i1imm:$addr64,
 342        i8imm:$dfmt, i8imm:$nfmt, VReg_32:$vaddr, SReg_128:$srsrc,
 343        i1imm:$slc, i1imm:$tfe, SSrc_32:$soffset),
 344   asm#" $dst, $offset, $offen, $idxen, $glc, $addr64, $dfmt,"
 345      #" $nfmt, $vaddr, $srsrc, $slc, $tfe, $soffset",
 346   []> {
 347   let mayLoad = 1;
 348   let mayStore = 0;
 349 }
 350
 351 class MIMG_NoSampler_Helper <bits<7> op, string asm> : MIMG <
 352   op,
 353   (outs VReg_128:$vdata),
 354   (ins i32imm:$dmask, i1imm:$unorm, i1imm:$glc, i1imm:$da, i1imm:$r128,
 355        i1imm:$tfe, i1imm:$lwe, i1imm:$slc, unknown:$vaddr,
 356        SReg_256:$srsrc),
 357   asm#" $vdata, $dmask, $unorm, $glc, $da, $r128,"
 358      #" $tfe, $lwe, $slc, $vaddr, $srsrc",
 359   []> {
 360   let SSAMP = 0;
 361   let mayLoad = 1;
 362   let mayStore = 0;
 363   let hasPostISelHook = 1;
 364 }
 365
 366 class MIMG_Sampler_Helper <bits<7> op, string asm> : MIMG <
 367   op,
 368   (outs VReg_128:$vdata),
 369   (ins i32imm:$dmask, i1imm:$unorm, i1imm:$glc, i1imm:$da, i1imm:$r128,
 370        i1imm:$tfe, i1imm:$lwe, i1imm:$slc, unknown:$vaddr,
 371        SReg_256:$srsrc, SReg_128:$ssamp),
 372   asm#" $vdata, $dmask, $unorm, $glc, $da, $r128,"
 373      #" $tfe, $lwe, $slc, $vaddr, $srsrc, $ssamp",
 374   []> {
 375   let mayLoad = 1;
 376   let mayStore = 0;
 377   let hasPostISelHook = 1;
 378 }
 379
 380 //===----------------------------------------------------------------------===//
 381 // Vector instruction mappings
 382 //===----------------------------------------------------------------------===//
 383
 384 // Maps an opcode in e32 form to its e64 equivalent
 385 def getVOPe64 : InstrMapping {
 386   let FilterClass = "VOP";
 387   let RowFields = ["OpName"];
 388   let ColFields = ["Size"];
 389   let KeyCol = ["4"];
 390   let ValueCols = [["8"]];
 391 }
 392
 393 // Maps an original opcode to its commuted version
 394 def getCommuteRev : InstrMapping {
 395   let FilterClass = "VOP2_REV";
 396   let RowFields = ["RevOp"];
 397   let ColFields = ["IsOrig"];
 398   let KeyCol = ["1"];
 399   let ValueCols = [["0"]];
 400 }
 401
 402 // Maps an commuted opcode to its original version
 403 def getCommuteOrig : InstrMapping {
 404   let FilterClass = "VOP2_REV";
 405   let RowFields = ["RevOp"];
 406   let ColFields = ["IsOrig"];
 407   let KeyCol = ["0"];
 408   let ValueCols = [["1"]];
 409 }
 410
 411 // Test if the supplied opcode is an MIMG instruction
 412 def isMIMG : InstrMapping {
 413   let FilterClass = "MIMG";
 414   let RowFields = ["Inst"];
 415   let ColFields = ["Size"];
 416   let KeyCol = ["8"];
 417   let ValueCols = [["8"]];
 418 }
 419
 420 include "SIInstructions.td"