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 // Execpt for the NONE field, this must be kept in sync with the SISubtarget enum
  11 // in AMDGPUMCInstLower.h
  12 def SISubtarget {
  13   int NONE = -1;
  14   int SI = 0;
  15 }
  16
  17 //===----------------------------------------------------------------------===//
  18 // SI DAG Nodes
  19 //===----------------------------------------------------------------------===//
  20
  21 def SIload_constant : SDNode<"AMDGPUISD::LOAD_CONSTANT",
  22   SDTypeProfile<1, 2, [SDTCisVT<0, f32>, SDTCisVT<1, v4i32>, SDTCisVT<2, i32>]>,
  23                       [SDNPMayLoad, SDNPMemOperand]
  24 >;
  25
  26 def SItbuffer_store : SDNode<"AMDGPUISD::TBUFFER_STORE_FORMAT",
  27   SDTypeProfile<0, 13,
  28     [SDTCisVT<0, v4i32>,   // rsrc(SGPR)
  29      SDTCisVT<1, iAny>,   // vdata(VGPR)
  30      SDTCisVT<2, i32>,    // num_channels(imm)
  31      SDTCisVT<3, i32>,    // vaddr(VGPR)
  32      SDTCisVT<4, i32>,    // soffset(SGPR)
  33      SDTCisVT<5, i32>,    // inst_offset(imm)
  34      SDTCisVT<6, i32>,    // dfmt(imm)
  35      SDTCisVT<7, i32>,    // nfmt(imm)
  36      SDTCisVT<8, i32>,    // offen(imm)
  37      SDTCisVT<9, i32>,    // idxen(imm)
  38      SDTCisVT<10, i32>,   // glc(imm)
  39      SDTCisVT<11, i32>,   // slc(imm)
  40      SDTCisVT<12, i32>    // tfe(imm)
  41     ]>,
  42   [SDNPMayStore, SDNPMemOperand, SDNPHasChain]
  43 >;
  44
  45 def SIload_input : SDNode<"AMDGPUISD::LOAD_INPUT",
  46   SDTypeProfile<1, 3, [SDTCisVT<0, v4f32>, SDTCisVT<1, v4i32>, SDTCisVT<2, i16>,
  47                        SDTCisVT<3, i32>]>
  48 >;
  49
  50 class SDSample<string opcode> : SDNode <opcode,
  51   SDTypeProfile<1, 4, [SDTCisVT<0, v4f32>, SDTCisVT<2, v32i8>,
  52                        SDTCisVT<3, v4i32>, SDTCisVT<4, i32>]>
  53 >;
  54
  55 def SIsample : SDSample<"AMDGPUISD::SAMPLE">;
  56 def SIsampleb : SDSample<"AMDGPUISD::SAMPLEB">;
  57 def SIsampled : SDSample<"AMDGPUISD::SAMPLED">;
  58 def SIsamplel : SDSample<"AMDGPUISD::SAMPLEL">;
  59
  60 // Transformation function, extract the lower 32bit of a 64bit immediate
  61 def LO32 : SDNodeXForm<imm, [{
  62   return CurDAG->getTargetConstant(N->getZExtValue() & 0xffffffff, MVT::i32);
  63 }]>;
  64
  65 def LO32f : SDNodeXForm<fpimm, [{
  66   APInt V = N->getValueAPF().bitcastToAPInt().trunc(32);
  67   return CurDAG->getTargetConstantFP(APFloat(APFloat::IEEEsingle, V), MVT::f32);
  68 }]>;
  69
  70 // Transformation function, extract the upper 32bit of a 64bit immediate
  71 def HI32 : SDNodeXForm<imm, [{
  72   return CurDAG->getTargetConstant(N->getZExtValue() >> 32, MVT::i32);
  73 }]>;
  74
  75 def HI32f : SDNodeXForm<fpimm, [{
  76   APInt V = N->getValueAPF().bitcastToAPInt().lshr(32).trunc(32);
  77   return CurDAG->getTargetConstantFP(APFloat(APFloat::IEEEsingle, V), MVT::f32);
  78 }]>;
  79
  80 def IMM8bitDWORD : PatLeaf <(imm),
  81   [{return (N->getZExtValue() & ~0x3FC) == 0;}]
  82 >;
  83
  84 def as_dword_i32imm : SDNodeXForm<imm, [{
  85   return CurDAG->getTargetConstant(N->getZExtValue() >> 2, MVT::i32);
  86 }]>;
  87
  88 def as_i1imm : SDNodeXForm<imm, [{
  89   return CurDAG->getTargetConstant(N->getZExtValue(), MVT::i1);
  90 }]>;
  91
  92 def as_i8imm : SDNodeXForm<imm, [{
  93   return CurDAG->getTargetConstant(N->getZExtValue(), MVT::i8);
  94 }]>;
  95
  96 def as_i16imm : SDNodeXForm<imm, [{
  97   return CurDAG->getTargetConstant(N->getSExtValue(), MVT::i16);
  98 }]>;
  99
 100 def as_i32imm: SDNodeXForm<imm, [{
 101   return CurDAG->getTargetConstant(N->getSExtValue(), MVT::i32);
 102 }]>;
 103
 104 def IMM8bit : PatLeaf <(imm),
 105   [{return isUInt<8>(N->getZExtValue());}]
 106 >;
 107
 108 def IMM12bit : PatLeaf <(imm),
 109   [{return isUInt<12>(N->getZExtValue());}]
 110 >;
 111
 112 def IMM16bit : PatLeaf <(imm),
 113   [{return isUInt<16>(N->getZExtValue());}]
 114 >;
 115
 116 def IMM32bit : PatLeaf <(imm),
 117   [{return isUInt<32>(N->getZExtValue());}]
 118 >;
 119
 120 def mubuf_vaddr_offset : PatFrag<
 121   (ops node:$ptr, node:$offset, node:$imm_offset),
 122   (add (add node:$ptr, node:$offset), node:$imm_offset)
 123 >;
 124
 125 class InlineImm <ValueType vt> : PatLeaf <(vt imm), [{
 126   return isInlineImmediate(N);
 127 }]>;
 128
 129 class SGPRImm <dag frag> : PatLeaf<frag, [{
 130   if (TM.getSubtarget<AMDGPUSubtarget>().getGeneration() <
 131       AMDGPUSubtarget::SOUTHERN_ISLANDS) {
 132     return false;
 133   }
 134   const SIRegisterInfo *SIRI =
 135                        static_cast<const SIRegisterInfo*>(TM.getRegisterInfo());
 136   for (SDNode::use_iterator U = N->use_begin(), E = SDNode::use_end();
 137                                                 U != E; ++U) {
 138     if (SIRI->isSGPRClass(getOperandRegClass(*U, U.getOperandNo()))) {
 139       return true;
 140     }
 141   }
 142   return false;
 143 }]>;
 144
 145 def FRAMEri32 : Operand<iPTR> {
 146   let MIOperandInfo = (ops i32:$ptr, i32imm:$index);
 147 }
 148
 149 //===----------------------------------------------------------------------===//
 150 // SI assembler operands
 151 //===----------------------------------------------------------------------===//
 152
 153 def SIOperand {
 154   int ZERO = 0x80;
 155   int VCC = 0x6A;
 156 }
 157
 158 include "SIInstrFormats.td"
 159
 160 //===----------------------------------------------------------------------===//
 161 //
 162 // SI Instruction multiclass helpers.
 163 //
 164 // Instructions with _32 take 32-bit operands.
 165 // Instructions with _64 take 64-bit operands.
 166 //
 167 // VOP_* instructions can use either a 32-bit or 64-bit encoding.  The 32-bit
 168 // encoding is the standard encoding, but instruction that make use of
 169 // any of the instruction modifiers must use the 64-bit encoding.
 170 //
 171 // Instructions with _e32 use the 32-bit encoding.
 172 // Instructions with _e64 use the 64-bit encoding.
 173 //
 174 //===----------------------------------------------------------------------===//
 175
 176 //===----------------------------------------------------------------------===//
 177 // Scalar classes
 178 //===----------------------------------------------------------------------===//
 179
 180 class SOP1_32 <bits<8> op, string opName, list<dag> pattern> : SOP1 <
 181   op, (outs SReg_32:$dst), (ins SSrc_32:$src0),
 182   opName#" $dst, $src0", pattern
 183 >;
 184
 185 class SOP1_64 <bits<8> op, string opName, list<dag> pattern> : SOP1 <
 186   op, (outs SReg_64:$dst), (ins SSrc_64:$src0),
 187   opName#" $dst, $src0", pattern
 188 >;
 189
 190 // 64-bit input, 32-bit output.
 191 class SOP1_32_64 <bits<8> op, string opName, list<dag> pattern> : SOP1 <
 192   op, (outs SReg_32:$dst), (ins SSrc_64:$src0),
 193   opName#" $dst, $src0", pattern
 194 >;
 195
 196 class SOP2_32 <bits<7> op, string opName, list<dag> pattern> : SOP2 <
 197   op, (outs SReg_32:$dst), (ins SSrc_32:$src0, SSrc_32:$src1),
 198   opName#" $dst, $src0, $src1", pattern
 199 >;
 200
 201 class SOP2_64 <bits<7> op, string opName, list<dag> pattern> : SOP2 <
 202   op, (outs SReg_64:$dst), (ins SSrc_64:$src0, SSrc_64:$src1),
 203   opName#" $dst, $src0, $src1", pattern
 204 >;
 205
 206 class SOP2_SHIFT_64 <bits<7> op, string opName, list<dag> pattern> : SOP2 <
 207   op, (outs SReg_64:$dst), (ins SSrc_64:$src0, SSrc_32:$src1),
 208   opName#" $dst, $src0, $src1", pattern
 209 >;
 210
 211
 212 class SOPC_Helper <bits<7> op, RegisterClass rc, ValueType vt,
 213                     string opName, PatLeaf cond> : SOPC <
 214   op, (outs SCCReg:$dst), (ins rc:$src0, rc:$src1),
 215   opName#" $dst, $src0, $src1", []>;
 216
 217 class SOPC_32<bits<7> op, string opName, PatLeaf cond = COND_NULL>
 218   : SOPC_Helper<op, SSrc_32, i32, opName, cond>;
 219
 220 class SOPC_64<bits<7> op, string opName, PatLeaf cond = COND_NULL>
 221   : SOPC_Helper<op, SSrc_64, i64, opName, cond>;
 222
 223 class SOPK_32 <bits<5> op, string opName, list<dag> pattern> : SOPK <
 224   op, (outs SReg_32:$dst), (ins i16imm:$src0),
 225   opName#" $dst, $src0", pattern
 226 >;
 227
 228 class SOPK_64 <bits<5> op, string opName, list<dag> pattern> : SOPK <
 229   op, (outs SReg_64:$dst), (ins i16imm:$src0),
 230   opName#" $dst, $src0", pattern
 231 >;
 232
 233 multiclass SMRD_Helper <bits<5> op, string asm, RegisterClass baseClass,
 234                         RegisterClass dstClass> {
 235   def _IMM : SMRD <
 236     op, 1, (outs dstClass:$dst),
 237     (ins baseClass:$sbase, u32imm:$offset),
 238     asm#" $dst, $sbase, $offset", []
 239   >;
 240
 241   def _SGPR : SMRD <
 242     op, 0, (outs dstClass:$dst),
 243     (ins baseClass:$sbase, SReg_32:$soff),
 244     asm#" $dst, $sbase, $soff", []
 245   >;
 246 }
 247
 248 //===----------------------------------------------------------------------===//
 249 // Vector ALU classes
 250 //===----------------------------------------------------------------------===//
 251
 252 class VOP <string opName> {
 253   string OpName = opName;
 254 }
 255
 256 class VOP2_REV <string revOp, bit isOrig> {
 257   string RevOp = revOp;
 258   bit IsOrig = isOrig;
 259 }
 260
 261 class SIMCInstr <string pseudo, int subtarget> {
 262   string PseudoInstr = pseudo;
 263   int Subtarget = subtarget;
 264 }
 265
 266 multiclass VOP3_m <bits<9> op, dag outs, dag ins, string asm, list<dag> pattern,
 267                    string opName> {
 268
 269   def "" : InstSI <outs, ins, "", pattern>, VOP <opName>,
 270            SIMCInstr<OpName, SISubtarget.NONE> {
 271     let isPseudo = 1;
 272   }
 273
 274   def _si : VOP3 <op, outs, ins, asm, []>, SIMCInstr<opName, SISubtarget.SI>;
 275
 276 }
 277
 278 // This must always be right before the operand being input modified.
 279 def InputMods : OperandWithDefaultOps <i32, (ops (i32 0))> {
 280   let PrintMethod = "printOperandAndMods";
 281 }
 282
 283 multiclass VOP1_Helper <bits<8> op, RegisterClass drc, RegisterClass src,
 284                         string opName, list<dag> pattern> {
 285
 286   def _e32 : VOP1 <
 287     op, (outs drc:$dst), (ins src:$src0),
 288     opName#"_e32 $dst, $src0", pattern
 289   >, VOP <opName>;
 290
 291   def _e64 : VOP3 <
 292     {1, 1, op{6}, op{5}, op{4}, op{3}, op{2}, op{1}, op{0}},
 293     (outs drc:$dst),
 294     (ins InputMods:$src0_modifiers, src:$src0, i32imm:$clamp, i32imm:$omod),
 295     opName#"_e64 $dst, $src0_modifiers, $clamp, $omod", []
 296   >, VOP <opName> {
 297     let src1 = SIOperand.ZERO;
 298     let src2 = SIOperand.ZERO;
 299   }
 300 }
 301
 302 multiclass VOP1_32 <bits<8> op, string opName, list<dag> pattern>
 303   : VOP1_Helper <op, VReg_32, VSrc_32, opName, pattern>;
 304
 305 multiclass VOP1_64 <bits<8> op, string opName, list<dag> pattern>
 306   : VOP1_Helper <op, VReg_64, VSrc_64, opName, pattern>;
 307
 308 multiclass VOP1_32_64 <bits<8> op, string opName, list<dag> pattern>
 309   : VOP1_Helper <op, VReg_32, VSrc_64, opName, pattern>;
 310
 311 multiclass VOP1_64_32 <bits<8> op, string opName, list<dag> pattern>
 312   : VOP1_Helper <op, VReg_64, VSrc_32, opName, pattern>;
 313
 314 multiclass VOP2_Helper <bits<6> op, RegisterClass vrc, RegisterClass arc,
 315                         string opName, list<dag> pattern, string revOp> {
 316   def _e32 : VOP2 <
 317     op, (outs vrc:$dst), (ins arc:$src0, vrc:$src1),
 318     opName#"_e32 $dst, $src0, $src1", pattern
 319   >, VOP <opName>, VOP2_REV<revOp#"_e32", !eq(revOp, opName)>;
 320
 321   def _e64 : VOP3 <
 322     {1, 0, 0, op{5}, op{4}, op{3}, op{2}, op{1}, op{0}},
 323     (outs vrc:$dst),
 324     (ins InputMods:$src0_modifiers, arc:$src0,
 325          InputMods:$src1_modifiers, arc:$src1,
 326          i32imm:$clamp, i32imm:$omod),
 327     opName#"_e64 $dst, $src0_modifiers, $src1_modifiers, $clamp, $omod", []
 328   >, VOP <opName>, VOP2_REV<revOp#"_e64", !eq(revOp, opName)> {
 329     let src2 = SIOperand.ZERO;
 330   }
 331 }
 332
 333 multiclass VOP2_32 <bits<6> op, string opName, list<dag> pattern,
 334                     string revOp = opName>
 335   : VOP2_Helper <op, VReg_32, VSrc_32, opName, pattern, revOp>;
 336
 337 multiclass VOP2_64 <bits<6> op, string opName, list<dag> pattern,
 338                     string revOp = opName>
 339   : VOP2_Helper <op, VReg_64, VSrc_64, opName, pattern, revOp>;
 340
 341 multiclass VOP2b_32 <bits<6> op, string opName, list<dag> pattern,
 342                      RegisterClass src0_rc, string revOp = opName> {
 343
 344   def _e32 : VOP2 <
 345     op, (outs VReg_32:$dst), (ins src0_rc:$src0, VReg_32:$src1),
 346     opName#"_e32 $dst, $src0, $src1", pattern
 347   >, VOP <opName>, VOP2_REV<revOp#"_e32", !eq(revOp, opName)>;
 348
 349   def _e64 : VOP3b <
 350     {1, 0, 0, op{5}, op{4}, op{3}, op{2}, op{1}, op{0}},
 351     (outs VReg_32:$dst),
 352     (ins InputMods: $src0_modifiers, VSrc_32:$src0,
 353          InputMods:$src1_modifiers, VSrc_32:$src1,
 354          i32imm:$clamp, i32imm:$omod),
 355     opName#"_e64 $dst, $src0_modifiers, $src1_modifiers, $clamp, $omod", []
 356   >, VOP <opName>, VOP2_REV<revOp#"_e64", !eq(revOp, opName)> {
 357     let src2 = SIOperand.ZERO;
 358     /* the VOP2 variant puts the carry out into VCC, the VOP3 variant
 359        can write it into any SGPR. We currently don't use the carry out,
 360        so for now hardcode it to VCC as well */
 361     let sdst = SIOperand.VCC;
 362   }
 363 }
 364
 365 multiclass VOPC_Helper <bits<8> op, RegisterClass vrc, RegisterClass arc,
 366                         string opName, ValueType vt, PatLeaf cond> {
 367
 368   def _e32 : VOPC <
 369     op, (ins arc:$src0, vrc:$src1),
 370     opName#"_e32 $dst, $src0, $src1", []
 371   >, VOP <opName>;
 372
 373   def _e64 : VOP3 <
 374     {0, op{7}, op{6}, op{5}, op{4}, op{3}, op{2}, op{1}, op{0}},
 375     (outs SReg_64:$dst),
 376     (ins InputMods:$src0_modifiers, arc:$src0,
 377          InputMods:$src1_modifiers, arc:$src1,
 378          InstFlag:$clamp, InstFlag:$omod),
 379     opName#"_e64 $dst, $src0_modifiers, $src1_modifiers, $clamp, $omod",
 380     !if(!eq(!cast<string>(cond), "COND_NULL"), []<dag>,
 381       [(set SReg_64:$dst, (i1 (setcc (vt arc:$src0), arc:$src1, cond)))]
 382     )
 383   >, VOP <opName> {
 384     let src2 = SIOperand.ZERO;
 385     let src2_modifiers = 0;
 386   }
 387 }
 388
 389 multiclass VOPC_32 <bits<8> op, string opName,
 390   ValueType vt = untyped, PatLeaf cond = COND_NULL>
 391   : VOPC_Helper <op, VReg_32, VSrc_32, opName, vt, cond>;
 392
 393 multiclass VOPC_64 <bits<8> op, string opName,
 394   ValueType vt = untyped, PatLeaf cond = COND_NULL>
 395   : VOPC_Helper <op, VReg_64, VSrc_64, opName, vt, cond>;
 396
 397 multiclass VOP3_32 <bits<9> op, string opName, list<dag> pattern> : VOP3_m <
 398   op, (outs VReg_32:$dst),
 399   (ins InputMods: $src0_modifiers, VSrc_32:$src0, InputMods:$src1_modifiers,
 400    VSrc_32:$src1, InputMods:$src2_modifiers, VSrc_32:$src2,
 401    InstFlag:$clamp, InstFlag:$omod),
 402   opName#" $dst, $src0_modifiers, $src1, $src2, $clamp, $omod", pattern, opName
 403 >;
 404
 405 class VOP3_64_32 <bits <9> op, string opName, list<dag> pattern> : VOP3 <
 406   op, (outs VReg_64:$dst),
 407   (ins VSrc_64:$src0, VSrc_32:$src1),
 408   opName#" $dst, $src0, $src1", pattern
 409 >, VOP <opName> {
 410
 411   let src2 = SIOperand.ZERO;
 412   let src0_modifiers = 0;
 413   let clamp = 0;
 414   let omod = 0;
 415 }
 416
 417 class VOP3_64 <bits<9> op, string opName, list<dag> pattern> : VOP3 <
 418   op, (outs VReg_64:$dst),
 419   (ins VSrc_64:$src0, VSrc_64:$src1, VSrc_64:$src2,
 420    InstFlag:$abs, InstFlag:$clamp, InstFlag:$omod, InstFlag:$neg),
 421   opName#" $dst, $src0, $src1, $src2, $abs, $clamp, $omod, $neg", pattern
 422 >, VOP <opName>;
 423
 424 //===----------------------------------------------------------------------===//
 425 // Vector I/O classes
 426 //===----------------------------------------------------------------------===//
 427
 428 class DS_1A <bits<8> op, dag outs, dag ins, string asm, list<dag> pat> :
 429     DS <op, outs, ins, asm, pat> {
 430   bits<16> offset;
 431
 432   // Single load interpret the 2 i8imm operands as a single i16 offset.
 433   let offset0 = offset{7-0};
 434   let offset1 = offset{15-8};
 435 }
 436
 437 class DS_Load_Helper <bits<8> op, string asm, RegisterClass regClass> : DS_1A <
 438   op,
 439   (outs regClass:$vdst),
 440   (ins i1imm:$gds, VReg_32:$addr, u16imm:$offset),
 441   asm#" $vdst, $addr, $offset, [M0]",
 442   []> {
 443   let data0 = 0;
 444   let data1 = 0;
 445   let mayLoad = 1;
 446   let mayStore = 0;
 447 }
 448
 449 class DS_Load2_Helper <bits<8> op, string asm, RegisterClass regClass> : DS <
 450   op,
 451   (outs regClass:$vdst),
 452   (ins i1imm:$gds, VReg_32:$addr, u8imm:$offset0, u8imm:$offset1),
 453   asm#" $gds, $vdst, $addr, $offset0, $offset1, [M0]",
 454   []> {
 455   let data0 = 0;
 456   let data1 = 0;
 457   let mayLoad = 1;
 458   let mayStore = 0;
 459 }
 460
 461 class DS_Store_Helper <bits<8> op, string asm, RegisterClass regClass> : DS_1A <
 462   op,
 463   (outs),
 464   (ins i1imm:$gds, VReg_32:$addr, regClass:$data0, u16imm:$offset),
 465   asm#" $addr, $data0, $offset [M0]",
 466   []> {
 467   let data1 = 0;
 468   let mayStore = 1;
 469   let mayLoad = 0;
 470   let vdst = 0;
 471 }
 472
 473 class DS_Store2_Helper <bits<8> op, string asm, RegisterClass regClass> : DS_1A <
 474   op,
 475   (outs),
 476   (ins i1imm:$gds, VReg_32:$addr, regClass:$data0, u8imm:$offset0, u8imm:$offset1),
 477   asm#" $addr, $data0, $data1, $offset0, $offset1 [M0]",
 478   []> {
 479   let mayStore = 1;
 480   let mayLoad = 0;
 481   let vdst = 0;
 482 }
 483
 484 // 1 address, 1 data.
 485 class DS_1A1D_RET <bits<8> op, string asm, RegisterClass rc> : DS_1A <
 486   op,
 487   (outs rc:$vdst),
 488   (ins i1imm:$gds, VReg_32:$addr, rc:$data0, u16imm:$offset),
 489   asm#" $vdst, $addr, $data0, $offset, [M0]",
 490   []> {
 491
 492   let data1 = 0;
 493   let mayStore = 1;
 494   let mayLoad = 1;
 495 }
 496
 497 // 1 address, 2 data.
 498 class DS_1A2D_RET <bits<8> op, string asm, RegisterClass rc> : DS_1A <
 499   op,
 500   (outs rc:$vdst),
 501   (ins i1imm:$gds, VReg_32:$addr, rc:$data0, rc:$data1, u16imm:$offset),
 502   asm#" $vdst, $addr, $data0, $data1, $offset, [M0]",
 503   []> {
 504   let mayStore = 1;
 505   let mayLoad = 1;
 506 }
 507
 508 // 1 address, 2 data.
 509 class DS_1A2D_NORET <bits<8> op, string asm, RegisterClass rc> : DS_1A <
 510   op,
 511   (outs),
 512   (ins i1imm:$gds, VReg_32:$addr, rc:$data0, rc:$data1, u16imm:$offset),
 513   asm#" $addr, $data0, $data1, $offset, [M0]",
 514   []> {
 515   let mayStore = 1;
 516   let mayLoad = 1;
 517 }
 518
 519 // 1 address, 1 data.
 520 class DS_1A1D_NORET <bits<8> op, string asm, RegisterClass rc> : DS_1A <
 521   op,
 522   (outs),
 523   (ins i1imm:$gds, VReg_32:$addr, rc:$data0, u16imm:$offset),
 524   asm#" $addr, $data0, $offset, [M0]",
 525   []> {
 526
 527   let data1 = 0;
 528   let mayStore = 1;
 529   let mayLoad = 1;
 530 }
 531
 532 class MTBUF_Store_Helper <bits<3> op, string asm, RegisterClass regClass> : MTBUF <
 533   op,
 534   (outs),
 535   (ins regClass:$vdata, u16imm:$offset, i1imm:$offen, i1imm:$idxen, i1imm:$glc,
 536    i1imm:$addr64, i8imm:$dfmt, i8imm:$nfmt, VReg_32:$vaddr,
 537    SReg_128:$srsrc, i1imm:$slc, i1imm:$tfe, SSrc_32:$soffset),
 538   asm#" $vdata, $offset, $offen, $idxen, $glc, $addr64, $dfmt,"
 539      #" $nfmt, $vaddr, $srsrc, $slc, $tfe, $soffset",
 540   []> {
 541   let mayStore = 1;
 542   let mayLoad = 0;
 543 }
 544
 545 multiclass MUBUF_Load_Helper <bits<7> op, string asm, RegisterClass regClass> {
 546
 547   let lds = 0, mayLoad = 1 in {
 548
 549     let addr64 = 0 in {
 550
 551       let offen = 0, idxen = 0 in {
 552         def _OFFSET : MUBUF <op, (outs regClass:$vdata),
 553                              (ins SReg_128:$srsrc, VReg_32:$vaddr,
 554                              u16imm:$offset, SSrc_32:$soffset, i1imm:$glc,
 555                              i1imm:$slc, i1imm:$tfe),
 556                              asm#" $vdata, $srsrc + $offset + $soffset, glc=$glc, slc=$slc, tfe=$tfe", []>;
 557       }
 558
 559       let offen = 1, idxen = 0, offset = 0 in {
 560         def _OFFEN  : MUBUF <op, (outs regClass:$vdata),
 561                              (ins SReg_128:$srsrc, VReg_32:$vaddr,
 562                              SSrc_32:$soffset, i1imm:$glc, i1imm:$slc,
 563                              i1imm:$tfe),
 564                              asm#" $vdata, $srsrc + $vaddr + $soffset, glc=$glc, slc=$slc, tfe=$tfe", []>;
 565       }
 566
 567       let offen = 0, idxen = 1 in {
 568         def _IDXEN  : MUBUF <op, (outs regClass:$vdata),
 569                              (ins SReg_128:$srsrc, VReg_32:$vaddr,
 570                              u16imm:$offset, SSrc_32:$soffset, i1imm:$glc,
 571                              i1imm:$slc, i1imm:$tfe),
 572                              asm#" $vdata, $srsrc[$vaddr] + $offset + $soffset, glc=$glc, slc=$slc, tfe=$tfe", []>;
 573       }
 574
 575       let offen = 1, idxen = 1 in {
 576         def _BOTHEN : MUBUF <op, (outs regClass:$vdata),
 577                              (ins SReg_128:$srsrc, VReg_64:$vaddr,
 578                              SSrc_32:$soffset, i1imm:$glc,
 579                              i1imm:$slc, i1imm:$tfe),
 580                              asm#" $vdata, $srsrc[$vaddr[0]] + $vaddr[1] + $soffset, glc=$glc, slc=$slc, tfe=$tfe", []>;
 581       }
 582     }
 583
 584     let offen = 0, idxen = 0, addr64 = 1, glc = 0, slc = 0, tfe = 0, soffset = 128 /* ZERO */ in {
 585       def _ADDR64 : MUBUF <op, (outs regClass:$vdata),
 586                            (ins SReg_128:$srsrc, VReg_64:$vaddr, u16imm:$offset),
 587                            asm#" $vdata, $srsrc + $vaddr + $offset", []>;
 588     }
 589   }
 590 }
 591
 592 class MUBUF_Store_Helper <bits<7> op, string name, RegisterClass vdataClass> :
 593     MUBUF <op, (outs), (ins vdataClass:$vdata, SReg_128:$srsrc, VReg_64:$vaddr,
 594                             u16imm:$offset),
 595           name#" $vdata, $srsrc + $vaddr + $offset",
 596          []> {
 597
 598   let mayLoad = 0;
 599   let mayStore = 1;
 600
 601   // Encoding
 602   let offen = 0;
 603   let idxen = 0;
 604   let glc = 0;
 605   let addr64 = 1;
 606   let lds = 0;
 607   let slc = 0;
 608   let tfe = 0;
 609   let soffset = 128; // ZERO
 610 }
 611
 612 class MTBUF_Load_Helper <bits<3> op, string asm, RegisterClass regClass> : MTBUF <
 613   op,
 614   (outs regClass:$dst),
 615   (ins u16imm:$offset, i1imm:$offen, i1imm:$idxen, i1imm:$glc, i1imm:$addr64,
 616        i8imm:$dfmt, i8imm:$nfmt, VReg_32:$vaddr, SReg_128:$srsrc,
 617        i1imm:$slc, i1imm:$tfe, SSrc_32:$soffset),
 618   asm#" $dst, $offset, $offen, $idxen, $glc, $addr64, $dfmt,"
 619      #" $nfmt, $vaddr, $srsrc, $slc, $tfe, $soffset",
 620   []> {
 621   let mayLoad = 1;
 622   let mayStore = 0;
 623 }
 624
 625 class MIMG_Mask <string op, int channels> {
 626   string Op = op;
 627   int Channels = channels;
 628 }
 629
 630 class MIMG_NoSampler_Helper <bits<7> op, string asm,
 631                              RegisterClass dst_rc,
 632                              RegisterClass src_rc> : MIMG <
 633   op,
 634   (outs dst_rc:$vdata),
 635   (ins i32imm:$dmask, i1imm:$unorm, i1imm:$glc, i1imm:$da, i1imm:$r128,
 636        i1imm:$tfe, i1imm:$lwe, i1imm:$slc, src_rc:$vaddr,
 637        SReg_256:$srsrc),
 638   asm#" $vdata, $dmask, $unorm, $glc, $da, $r128,"
 639      #" $tfe, $lwe, $slc, $vaddr, $srsrc",
 640   []> {
 641   let SSAMP = 0;
 642   let mayLoad = 1;
 643   let mayStore = 0;
 644   let hasPostISelHook = 1;
 645 }
 646
 647 multiclass MIMG_NoSampler_Src_Helper <bits<7> op, string asm,
 648                                       RegisterClass dst_rc,
 649                                       int channels> {
 650   def _V1 : MIMG_NoSampler_Helper <op, asm, dst_rc, VReg_32>,
 651             MIMG_Mask<asm#"_V1", channels>;
 652   def _V2 : MIMG_NoSampler_Helper <op, asm, dst_rc, VReg_64>,
 653             MIMG_Mask<asm#"_V2", channels>;
 654   def _V4 : MIMG_NoSampler_Helper <op, asm, dst_rc, VReg_128>,
 655             MIMG_Mask<asm#"_V4", channels>;
 656 }
 657
 658 multiclass MIMG_NoSampler <bits<7> op, string asm> {
 659   defm _V1 : MIMG_NoSampler_Src_Helper <op, asm, VReg_32, 1>;
 660   defm _V2 : MIMG_NoSampler_Src_Helper <op, asm, VReg_64, 2>;
 661   defm _V3 : MIMG_NoSampler_Src_Helper <op, asm, VReg_96, 3>;
 662   defm _V4 : MIMG_NoSampler_Src_Helper <op, asm, VReg_128, 4>;
 663 }
 664
 665 class MIMG_Sampler_Helper <bits<7> op, string asm,
 666                            RegisterClass dst_rc,
 667                            RegisterClass src_rc> : MIMG <
 668   op,
 669   (outs dst_rc:$vdata),
 670   (ins i32imm:$dmask, i1imm:$unorm, i1imm:$glc, i1imm:$da, i1imm:$r128,
 671        i1imm:$tfe, i1imm:$lwe, i1imm:$slc, src_rc:$vaddr,
 672        SReg_256:$srsrc, SReg_128:$ssamp),
 673   asm#" $vdata, $dmask, $unorm, $glc, $da, $r128,"
 674      #" $tfe, $lwe, $slc, $vaddr, $srsrc, $ssamp",
 675   []> {
 676   let mayLoad = 1;
 677   let mayStore = 0;
 678   let hasPostISelHook = 1;
 679 }
 680
 681 multiclass MIMG_Sampler_Src_Helper <bits<7> op, string asm,
 682                                     RegisterClass dst_rc,
 683                                     int channels> {
 684   def _V1 : MIMG_Sampler_Helper <op, asm, dst_rc, VReg_32>,
 685             MIMG_Mask<asm#"_V1", channels>;
 686   def _V2 : MIMG_Sampler_Helper <op, asm, dst_rc, VReg_64>,
 687             MIMG_Mask<asm#"_V2", channels>;
 688   def _V4 : MIMG_Sampler_Helper <op, asm, dst_rc, VReg_128>,
 689             MIMG_Mask<asm#"_V4", channels>;
 690   def _V8 : MIMG_Sampler_Helper <op, asm, dst_rc, VReg_256>,
 691             MIMG_Mask<asm#"_V8", channels>;
 692   def _V16 : MIMG_Sampler_Helper <op, asm, dst_rc, VReg_512>,
 693             MIMG_Mask<asm#"_V16", channels>;
 694 }
 695
 696 multiclass MIMG_Sampler <bits<7> op, string asm> {
 697   defm _V1 : MIMG_Sampler_Src_Helper<op, asm, VReg_32, 1>;
 698   defm _V2 : MIMG_Sampler_Src_Helper<op, asm, VReg_64, 2>;
 699   defm _V3 : MIMG_Sampler_Src_Helper<op, asm, VReg_96, 3>;
 700   defm _V4 : MIMG_Sampler_Src_Helper<op, asm, VReg_128, 4>;
 701 }
 702
 703 //===----------------------------------------------------------------------===//
 704 // Vector instruction mappings
 705 //===----------------------------------------------------------------------===//
 706
 707 // Maps an opcode in e32 form to its e64 equivalent
 708 def getVOPe64 : InstrMapping {
 709   let FilterClass = "VOP";
 710   let RowFields = ["OpName"];
 711   let ColFields = ["Size"];
 712   let KeyCol = ["4"];
 713   let ValueCols = [["8"]];
 714 }
 715
 716 // Maps an original opcode to its commuted version
 717 def getCommuteRev : InstrMapping {
 718   let FilterClass = "VOP2_REV";
 719   let RowFields = ["RevOp"];
 720   let ColFields = ["IsOrig"];
 721   let KeyCol = ["1"];
 722   let ValueCols = [["0"]];
 723 }
 724
 725 def getMaskedMIMGOp : InstrMapping {
 726   let FilterClass = "MIMG_Mask";
 727   let RowFields = ["Op"];
 728   let ColFields = ["Channels"];
 729   let KeyCol = ["4"];
 730   let ValueCols = [["1"], ["2"], ["3"] ];
 731 }
 732
 733 // Maps an commuted opcode to its original version
 734 def getCommuteOrig : InstrMapping {
 735   let FilterClass = "VOP2_REV";
 736   let RowFields = ["RevOp"];
 737   let ColFields = ["IsOrig"];
 738   let KeyCol = ["0"];
 739   let ValueCols = [["1"]];
 740 }
 741
 742 def isDS : InstrMapping {
 743   let FilterClass = "DS";
 744   let RowFields = ["Inst"];
 745   let ColFields = ["Size"];
 746   let KeyCol = ["8"];
 747   let ValueCols = [["8"]];
 748 }
 749
 750 def getMCOpcode : InstrMapping {
 751   let FilterClass = "SIMCInstr";
 752   let RowFields = ["PseudoInstr"];
 753   let ColFields = ["Subtarget"];
 754   let KeyCol = [!cast<string>(SISubtarget.NONE)];
 755   let ValueCols = [[!cast<string>(SISubtarget.SI)]];
 756 }
 757
 758 include "SIInstructions.td"