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 dstClass> {
 119   def _IMM : SMRD <
 120     op, 1, (outs dstClass:$dst),
 121     (ins SReg_64:$sbase, i32imm:$offset),
 122     asm#" $dst, $sbase, $offset", []
 123   >;
 124
 125   def _SGPR : SMRD <
 126     op, 0, (outs dstClass:$dst),
 127     (ins SReg_64:$sbase, SReg_32:$soff),
 128     asm#" $dst, $sbase, $soff", []
 129   >;
 130 }
 131
 132 //===----------------------------------------------------------------------===//
 133 // Vector ALU classes
 134 //===----------------------------------------------------------------------===//
 135
 136 class VOP <string opName> {
 137   string OpName = opName;
 138 }
 139
 140 multiclass VOP1_Helper <bits<8> op, RegisterClass drc, RegisterClass src,
 141                         string opName, list<dag> pattern> {
 142
 143   def _e32 : VOP1 <
 144     op, (outs drc:$dst), (ins src:$src0),
 145     opName#"_e32 $dst, $src0", pattern
 146   >, VOP <opName>;
 147
 148   def _e64 : VOP3 <
 149     {1, 1, op{6}, op{5}, op{4}, op{3}, op{2}, op{1}, op{0}},
 150     (outs drc:$dst),
 151     (ins src:$src0,
 152          i32imm:$abs, i32imm:$clamp,
 153          i32imm:$omod, i32imm:$neg),
 154     opName#"_e64 $dst, $src0, $abs, $clamp, $omod, $neg", []
 155   >, VOP <opName> {
 156     let SRC1 = SIOperand.ZERO;
 157     let SRC2 = SIOperand.ZERO;
 158   }
 159 }
 160
 161 multiclass VOP1_32 <bits<8> op, string opName, list<dag> pattern>
 162   : VOP1_Helper <op, VReg_32, VSrc_32, opName, pattern>;
 163
 164 multiclass VOP1_64 <bits<8> op, string opName, list<dag> pattern>
 165   : VOP1_Helper <op, VReg_64, VSrc_64, opName, pattern>;
 166
 167 multiclass VOP2_Helper <bits<6> op, RegisterClass vrc, RegisterClass arc,
 168                         string opName, list<dag> pattern> {
 169   def _e32 : VOP2 <
 170     op, (outs vrc:$dst), (ins arc:$src0, vrc:$src1),
 171     opName#"_e32 $dst, $src0, $src1", pattern
 172   >, VOP <opName>;
 173
 174   def _e64 : VOP3 <
 175     {1, 0, 0, op{5}, op{4}, op{3}, op{2}, op{1}, op{0}},
 176     (outs vrc:$dst),
 177     (ins arc:$src0, arc:$src1,
 178          i32imm:$abs, i32imm:$clamp,
 179          i32imm:$omod, i32imm:$neg),
 180     opName#"_e64 $dst, $src0, $src1, $abs, $clamp, $omod, $neg", []
 181   >, VOP <opName> {
 182     let SRC2 = SIOperand.ZERO;
 183   }
 184 }
 185
 186 multiclass VOP2_32 <bits<6> op, string opName, list<dag> pattern>
 187   : VOP2_Helper <op, VReg_32, VSrc_32, opName, pattern>;
 188
 189 multiclass VOP2_64 <bits<6> op, string opName, list<dag> pattern>
 190   : VOP2_Helper <op, VReg_64, VSrc_64, opName, pattern>;
 191
 192 multiclass VOP2b_32 <bits<6> op, string opName, list<dag> pattern> {
 193
 194   def _e32 : VOP2 <
 195     op, (outs VReg_32:$dst), (ins VSrc_32:$src0, VReg_32:$src1),
 196     opName#"_e32 $dst, $src0, $src1", pattern
 197   >, VOP <opName>;
 198
 199   def _e64 : VOP3b <
 200     {1, 0, 0, op{5}, op{4}, op{3}, op{2}, op{1}, op{0}},
 201     (outs VReg_32:$dst),
 202     (ins VSrc_32:$src0, VSrc_32:$src1,
 203          i32imm:$abs, i32imm:$clamp,
 204          i32imm:$omod, i32imm:$neg),
 205     opName#"_e64 $dst, $src0, $src1, $abs, $clamp, $omod, $neg", []
 206   >, VOP <opName> {
 207     let SRC2 = SIOperand.ZERO;
 208     /* the VOP2 variant puts the carry out into VCC, the VOP3 variant
 209        can write it into any SGPR. We currently don't use the carry out,
 210        so for now hardcode it to VCC as well */
 211     let SDST = SIOperand.VCC;
 212   }
 213 }
 214
 215 multiclass VOPC_Helper <bits<8> op, RegisterClass vrc, RegisterClass arc,
 216                         string opName, ValueType vt, PatLeaf cond> {
 217
 218   def _e32 : VOPC <
 219     op, (ins arc:$src0, vrc:$src1),
 220     opName#"_e32 $dst, $src0, $src1", []
 221   >, VOP <opName>;
 222
 223   def _e64 : VOP3 <
 224     {0, op{7}, op{6}, op{5}, op{4}, op{3}, op{2}, op{1}, op{0}},
 225     (outs SReg_64:$dst),
 226     (ins arc:$src0, arc:$src1,
 227          InstFlag:$abs, InstFlag:$clamp,
 228          InstFlag:$omod, InstFlag:$neg),
 229     opName#"_e64 $dst, $src0, $src1, $abs, $clamp, $omod, $neg",
 230     !if(!eq(!cast<string>(cond), "COND_NULL"), []<dag>,
 231       [(set SReg_64:$dst, (i1 (setcc (vt arc:$src0), arc:$src1, cond)))]
 232     )
 233   >, VOP <opName> {
 234     let SRC2 = SIOperand.ZERO;
 235   }
 236 }
 237
 238 multiclass VOPC_32 <bits<8> op, string opName,
 239   ValueType vt = untyped, PatLeaf cond = COND_NULL>
 240   : VOPC_Helper <op, VReg_32, VSrc_32, opName, vt, cond>;
 241
 242 multiclass VOPC_64 <bits<8> op, string opName,
 243   ValueType vt = untyped, PatLeaf cond = COND_NULL>
 244   : VOPC_Helper <op, VReg_64, VSrc_64, opName, vt, cond>;
 245
 246 class VOP3_32 <bits<9> op, string opName, list<dag> pattern> : VOP3 <
 247   op, (outs VReg_32:$dst),
 248   (ins VSrc_32:$src0, VSrc_32:$src1, VSrc_32:$src2,
 249    i32imm:$abs, i32imm:$clamp, i32imm:$omod, i32imm:$neg),
 250   opName#" $dst, $src0, $src1, $src2, $abs, $clamp, $omod, $neg", pattern
 251 >, VOP <opName>;
 252
 253 class VOP3_64 <bits<9> op, string opName, list<dag> pattern> : VOP3 <
 254   op, (outs VReg_64:$dst),
 255   (ins VSrc_64:$src0, VSrc_64:$src1, VSrc_64:$src2,
 256    i32imm:$abs, i32imm:$clamp, i32imm:$omod, i32imm:$neg),
 257   opName#" $dst, $src0, $src1, $src2, $abs, $clamp, $omod, $neg", pattern
 258 >, VOP <opName>;
 259
 260 //===----------------------------------------------------------------------===//
 261 // Vector I/O classes
 262 //===----------------------------------------------------------------------===//
 263
 264 class MTBUF_Store_Helper <bits<3> op, string asm, RegisterClass regClass> : MTBUF <
 265   op,
 266   (outs),
 267   (ins regClass:$vdata, i16imm:$offset, i1imm:$offen, i1imm:$idxen, i1imm:$glc,
 268    i1imm:$addr64, i8imm:$dfmt, i8imm:$nfmt, VReg_32:$vaddr,
 269    SReg_128:$srsrc, i1imm:$slc, i1imm:$tfe, SSrc_32:$soffset),
 270   asm#" $vdata, $offset, $offen, $idxen, $glc, $addr64, $dfmt,"
 271      #" $nfmt, $vaddr, $srsrc, $slc, $tfe, $soffset",
 272   []> {
 273   let mayStore = 1;
 274   let mayLoad = 0;
 275 }
 276
 277 class MUBUF_Load_Helper <bits<7> op, string asm, RegisterClass regClass> : MUBUF <
 278   op,
 279   (outs regClass:$dst),
 280   (ins i16imm:$offset, i1imm:$offen, i1imm:$idxen, i1imm:$glc, i1imm:$addr64,
 281        i1imm:$lds, VReg_32:$vaddr, SReg_128:$srsrc, i1imm:$slc,
 282        i1imm:$tfe, SSrc_32:$soffset),
 283   asm#" $dst, $offset, $offen, $idxen, $glc, $addr64, "
 284      #"$lds, $vaddr, $srsrc, $slc, $tfe, $soffset",
 285   []> {
 286   let mayLoad = 1;
 287   let mayStore = 0;
 288 }
 289
 290 class MTBUF_Load_Helper <bits<3> op, string asm, RegisterClass regClass> : MTBUF <
 291   op,
 292   (outs regClass:$dst),
 293   (ins i16imm:$offset, i1imm:$offen, i1imm:$idxen, i1imm:$glc, i1imm:$addr64,
 294        i8imm:$dfmt, i8imm:$nfmt, VReg_32:$vaddr, SReg_128:$srsrc,
 295        i1imm:$slc, i1imm:$tfe, SSrc_32:$soffset),
 296   asm#" $dst, $offset, $offen, $idxen, $glc, $addr64, $dfmt,"
 297      #" $nfmt, $vaddr, $srsrc, $slc, $tfe, $soffset",
 298   []> {
 299   let mayLoad = 1;
 300   let mayStore = 0;
 301 }
 302
 303 class MIMG_Load_Helper <bits<7> op, string asm> : MIMG <
 304   op,
 305   (outs VReg_128:$vdata),
 306   (ins i32imm:$dmask, i1imm:$unorm, i1imm:$glc, i1imm:$da, i1imm:$r128,
 307        i1imm:$tfe, i1imm:$lwe, i1imm:$slc, VReg_32:$vaddr,
 308        SReg_256:$srsrc, SReg_128:$ssamp),
 309   asm#" $vdata, $dmask, $unorm, $glc, $da, $r128,"
 310      #" $tfe, $lwe, $slc, $vaddr, $srsrc, $ssamp",
 311   []> {
 312   let mayLoad = 1;
 313   let mayStore = 0;
 314 }
 315
 316 //===----------------------------------------------------------------------===//
 317 // Vector instruction mappings
 318 //===----------------------------------------------------------------------===//
 319
 320 // Maps an opcode in e32 form to its e64 equivalent
 321 def getVOPe64 : InstrMapping {
 322   let FilterClass = "VOP";
 323   let RowFields = ["OpName"];
 324   let ColFields = ["Size"];
 325   let KeyCol = ["4"];
 326   let ValueCols = [["8"]];
 327 }
 328
 329 include "SIInstructions.td"