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