contrib/llvm/lib/Target/AMDGPU/SOPInstructions.td

   1 //===-- SOPInstructions.td - SOP Instruction Defintions -------------------===//
   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 def GPRIdxModeMatchClass : AsmOperandClass {
  11   let Name = "GPRIdxMode";
  12   let PredicateMethod = "isGPRIdxMode";
  13   let RenderMethod = "addImmOperands";
  14 }
  15
  16 def GPRIdxMode : Operand<i32> {
  17   let PrintMethod = "printVGPRIndexMode";
  18   let ParserMatchClass = GPRIdxModeMatchClass;
  19   let OperandType = "OPERAND_IMMEDIATE";
  20 }
  21
  22 class SOP_Pseudo<string opName, dag outs, dag ins, string asmOps,
  23                   list<dag> pattern=[]> :
  24     InstSI<outs, ins, "", pattern>,
  25     SIMCInstr<opName, SIEncodingFamily.NONE> {
  26
  27   let isPseudo = 1;
  28   let isCodeGenOnly = 1;
  29   let SubtargetPredicate = isGCN;
  30
  31   string Mnemonic = opName;
  32   string AsmOperands = asmOps;
  33
  34   bits<1> has_sdst = 0;
  35 }
  36
  37 //===----------------------------------------------------------------------===//
  38 // SOP1 Instructions
  39 //===----------------------------------------------------------------------===//
  40
  41 class SOP1_Pseudo <string opName, dag outs, dag ins,
  42                    string asmOps, list<dag> pattern=[]> :
  43   SOP_Pseudo<opName, outs, ins, asmOps, pattern> {
  44
  45   let mayLoad = 0;
  46   let mayStore = 0;
  47   let hasSideEffects = 0;
  48   let SALU = 1;
  49   let SOP1 = 1;
  50   let SchedRW = [WriteSALU];
  51   let Size = 4;
  52   let UseNamedOperandTable = 1;
  53
  54   bits<1> has_src0 = 1;
  55   bits<1> has_sdst = 1;
  56 }
  57
  58 class SOP1_Real<bits<8> op, SOP1_Pseudo ps> :
  59   InstSI <ps.OutOperandList, ps.InOperandList,
  60           ps.Mnemonic # " " # ps.AsmOperands, []>,
  61   Enc32 {
  62
  63   let isPseudo = 0;
  64   let isCodeGenOnly = 0;
  65   let Size = 4;
  66
  67   // copy relevant pseudo op flags
  68   let SubtargetPredicate = ps.SubtargetPredicate;
  69   let AsmMatchConverter  = ps.AsmMatchConverter;
  70
  71   // encoding
  72   bits<7> sdst;
  73   bits<8> src0;
  74
  75   let Inst{7-0} = !if(ps.has_src0, src0, ?);
  76   let Inst{15-8} = op;
  77   let Inst{22-16} = !if(ps.has_sdst, sdst, ?);
  78   let Inst{31-23} = 0x17d; //encoding;
  79 }
  80
  81 class SOP1_32 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
  82   opName, (outs SReg_32:$sdst), (ins SSrc_b32:$src0),
  83   "$sdst, $src0", pattern
  84 >;
  85
  86 // 32-bit input, no output.
  87 class SOP1_0_32 <string opName, list<dag> pattern = []> : SOP1_Pseudo <
  88   opName, (outs), (ins SSrc_b32:$src0),
  89   "$src0", pattern> {
  90   let has_sdst = 0;
  91 }
  92
  93 class SOP1_0_32R <string opName, list<dag> pattern = []> : SOP1_Pseudo <
  94   opName, (outs), (ins SReg_32:$src0),
  95   "$src0", pattern> {
  96   let has_sdst = 0;
  97 }
  98
  99 class SOP1_64 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
 100   opName, (outs SReg_64:$sdst), (ins SSrc_b64:$src0),
 101   "$sdst, $src0", pattern
 102 >;
 103
 104 // 64-bit input, 32-bit output.
 105 class SOP1_32_64 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
 106   opName, (outs SReg_32:$sdst), (ins SSrc_b64:$src0),
 107   "$sdst, $src0", pattern
 108 >;
 109
 110 // 32-bit input, 64-bit output.
 111 class SOP1_64_32 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
 112   opName, (outs SReg_64:$sdst), (ins SSrc_b32:$src0),
 113   "$sdst, $src0", pattern
 114 >;
 115
 116 // no input, 64-bit output.
 117 class SOP1_64_0 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
 118   opName, (outs SReg_64:$sdst), (ins), "$sdst", pattern> {
 119   let has_src0 = 0;
 120 }
 121
 122 // 64-bit input, no output
 123 class SOP1_1 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
 124   opName, (outs), (ins SReg_64:$src0), "$src0", pattern> {
 125   let has_sdst = 0;
 126 }
 127
 128
 129 let isMoveImm = 1 in {
 130   let isReMaterializable = 1, isAsCheapAsAMove = 1 in {
 131     def S_MOV_B32 : SOP1_32 <"s_mov_b32">;
 132     def S_MOV_B64 : SOP1_64 <"s_mov_b64">;
 133   } // End isRematerializeable = 1
 134
 135   let Uses = [SCC] in {
 136     def S_CMOV_B32 : SOP1_32 <"s_cmov_b32">;
 137     def S_CMOV_B64 : SOP1_64 <"s_cmov_b64">;
 138   } // End Uses = [SCC]
 139 } // End isMoveImm = 1
 140
 141 let Defs = [SCC] in {
 142   def S_NOT_B32 : SOP1_32 <"s_not_b32",
 143     [(set i32:$sdst, (not i32:$src0))]
 144   >;
 145
 146   def S_NOT_B64 : SOP1_64 <"s_not_b64",
 147     [(set i64:$sdst, (not i64:$src0))]
 148   >;
 149   def S_WQM_B32 : SOP1_32 <"s_wqm_b32">;
 150   def S_WQM_B64 : SOP1_64 <"s_wqm_b64",
 151     [(set i1:$sdst, (int_amdgcn_wqm_vote i1:$src0))]
 152   >;
 153 } // End Defs = [SCC]
 154
 155
 156 def S_BREV_B32 : SOP1_32 <"s_brev_b32",
 157   [(set i32:$sdst, (bitreverse i32:$src0))]
 158 >;
 159 def S_BREV_B64 : SOP1_64 <"s_brev_b64">;
 160
 161 let Defs = [SCC] in {
 162 def S_BCNT0_I32_B32 : SOP1_32 <"s_bcnt0_i32_b32">;
 163 def S_BCNT0_I32_B64 : SOP1_32_64 <"s_bcnt0_i32_b64">;
 164 def S_BCNT1_I32_B32 : SOP1_32 <"s_bcnt1_i32_b32",
 165   [(set i32:$sdst, (ctpop i32:$src0))]
 166 >;
 167 def S_BCNT1_I32_B64 : SOP1_32_64 <"s_bcnt1_i32_b64">;
 168 } // End Defs = [SCC]
 169
 170 def S_FF0_I32_B32 : SOP1_32 <"s_ff0_i32_b32">;
 171 def S_FF0_I32_B64 : SOP1_32_64 <"s_ff0_i32_b64">;
 172 def S_FF1_I32_B64 : SOP1_32_64 <"s_ff1_i32_b64">;
 173
 174 def S_FF1_I32_B32 : SOP1_32 <"s_ff1_i32_b32",
 175   [(set i32:$sdst, (AMDGPUffbl_b32 i32:$src0))]
 176 >;
 177
 178 def S_FLBIT_I32_B32 : SOP1_32 <"s_flbit_i32_b32",
 179   [(set i32:$sdst, (AMDGPUffbh_u32 i32:$src0))]
 180 >;
 181
 182 def S_FLBIT_I32_B64 : SOP1_32_64 <"s_flbit_i32_b64">;
 183 def S_FLBIT_I32 : SOP1_32 <"s_flbit_i32",
 184   [(set i32:$sdst, (AMDGPUffbh_i32 i32:$src0))]
 185 >;
 186 def S_FLBIT_I32_I64 : SOP1_32_64 <"s_flbit_i32_i64">;
 187 def S_SEXT_I32_I8 : SOP1_32 <"s_sext_i32_i8",
 188   [(set i32:$sdst, (sext_inreg i32:$src0, i8))]
 189 >;
 190 def S_SEXT_I32_I16 : SOP1_32 <"s_sext_i32_i16",
 191   [(set i32:$sdst, (sext_inreg i32:$src0, i16))]
 192 >;
 193
 194 def S_BITSET0_B32 : SOP1_32    <"s_bitset0_b32">;
 195 def S_BITSET0_B64 : SOP1_64_32 <"s_bitset0_b64">;
 196 def S_BITSET1_B32 : SOP1_32    <"s_bitset1_b32">;
 197 def S_BITSET1_B64 : SOP1_64_32 <"s_bitset1_b64">;
 198 def S_GETPC_B64 : SOP1_64_0  <"s_getpc_b64",
 199   [(set i64:$sdst, (int_amdgcn_s_getpc))]
 200 >;
 201
 202 let isTerminator = 1, isBarrier = 1, SchedRW = [WriteBranch] in {
 203
 204 let isBranch = 1, isIndirectBranch = 1 in {
 205 def S_SETPC_B64 : SOP1_1  <"s_setpc_b64">;
 206 } // End isBranch = 1, isIndirectBranch = 1
 207
 208 let isReturn = 1 in {
 209 // Define variant marked as return rather than branch.
 210 def S_SETPC_B64_return : SOP1_1<"", [(AMDGPUret_flag i64:$src0)]>;
 211 }
 212 } // End isTerminator = 1, isBarrier = 1
 213
 214 let isCall = 1 in {
 215 def S_SWAPPC_B64 : SOP1_64 <"s_swappc_b64"
 216 >;
 217 }
 218
 219 def S_RFE_B64 : SOP1_1  <"s_rfe_b64">;
 220
 221 let hasSideEffects = 1, Uses = [EXEC], Defs = [EXEC, SCC] in {
 222
 223 def S_AND_SAVEEXEC_B64 : SOP1_64 <"s_and_saveexec_b64">;
 224 def S_OR_SAVEEXEC_B64 : SOP1_64 <"s_or_saveexec_b64">;
 225 def S_XOR_SAVEEXEC_B64 : SOP1_64 <"s_xor_saveexec_b64">;
 226 def S_ANDN2_SAVEEXEC_B64 : SOP1_64 <"s_andn2_saveexec_b64">;
 227 def S_ORN2_SAVEEXEC_B64 : SOP1_64 <"s_orn2_saveexec_b64">;
 228 def S_NAND_SAVEEXEC_B64 : SOP1_64 <"s_nand_saveexec_b64">;
 229 def S_NOR_SAVEEXEC_B64 : SOP1_64 <"s_nor_saveexec_b64">;
 230 def S_XNOR_SAVEEXEC_B64 : SOP1_64 <"s_xnor_saveexec_b64">;
 231
 232 } // End hasSideEffects = 1, Uses = [EXEC], Defs = [EXEC, SCC]
 233
 234 def S_QUADMASK_B32 : SOP1_32 <"s_quadmask_b32">;
 235 def S_QUADMASK_B64 : SOP1_64 <"s_quadmask_b64">;
 236
 237 let Uses = [M0] in {
 238 def S_MOVRELS_B32 : SOP1_32 <"s_movrels_b32">;
 239 def S_MOVRELS_B64 : SOP1_64 <"s_movrels_b64">;
 240 def S_MOVRELD_B32 : SOP1_32 <"s_movreld_b32">;
 241 def S_MOVRELD_B64 : SOP1_64 <"s_movreld_b64">;
 242 } // End Uses = [M0]
 243
 244 def S_CBRANCH_JOIN : SOP1_0_32R <"s_cbranch_join">;
 245 def S_MOV_REGRD_B32 : SOP1_32 <"s_mov_regrd_b32">;
 246 let Defs = [SCC] in {
 247 def S_ABS_I32 : SOP1_32 <"s_abs_i32">;
 248 } // End Defs = [SCC]
 249 def S_MOV_FED_B32 : SOP1_32 <"s_mov_fed_b32">;
 250
 251 let SubtargetPredicate = HasVGPRIndexMode in {
 252 def S_SET_GPR_IDX_IDX : SOP1_0_32<"s_set_gpr_idx_idx"> {
 253   let Uses = [M0];
 254   let Defs = [M0];
 255 }
 256 }
 257
 258 let SubtargetPredicate = isGFX9 in {
 259   let hasSideEffects = 1, Defs = [EXEC, SCC], Uses = [EXEC] in {
 260     def S_ANDN1_SAVEEXEC_B64 : SOP1_64<"s_andn1_saveexec_b64">;
 261     def S_ORN1_SAVEEXEC_B64  : SOP1_64<"s_orn1_saveexec_b64">;
 262     def S_ANDN1_WREXEC_B64   : SOP1_64<"s_andn1_wrexec_b64">;
 263     def S_ANDN2_WREXEC_B64   : SOP1_64<"s_andn2_wrexec_b64">;
 264   } // End hasSideEffects = 1, Defs = [EXEC, SCC], Uses = [EXEC]
 265
 266   def S_BITREPLICATE_B64_B32 : SOP1_64_32<"s_bitreplicate_b64_b32">;
 267 } // End SubtargetPredicate = isGFX9
 268
 269 //===----------------------------------------------------------------------===//
 270 // SOP2 Instructions
 271 //===----------------------------------------------------------------------===//
 272
 273 class SOP2_Pseudo<string opName, dag outs, dag ins,
 274                   string asmOps, list<dag> pattern=[]> :
 275   SOP_Pseudo<opName, outs, ins, asmOps, pattern> {
 276
 277   let mayLoad = 0;
 278   let mayStore = 0;
 279   let hasSideEffects = 0;
 280   let SALU = 1;
 281   let SOP2 = 1;
 282   let SchedRW = [WriteSALU];
 283   let UseNamedOperandTable = 1;
 284
 285   let has_sdst = 1;
 286
 287   // Pseudo instructions have no encodings, but adding this field here allows
 288   // us to do:
 289   // let sdst = xxx in {
 290   // for multiclasses that include both real and pseudo instructions.
 291   // field bits<7> sdst = 0;
 292   // let Size = 4; // Do we need size here?
 293 }
 294
 295 class SOP2_Real<bits<7> op, SOP_Pseudo ps> :
 296   InstSI <ps.OutOperandList, ps.InOperandList,
 297           ps.Mnemonic # " " # ps.AsmOperands, []>,
 298   Enc32 {
 299   let isPseudo = 0;
 300   let isCodeGenOnly = 0;
 301
 302   // copy relevant pseudo op flags
 303   let SubtargetPredicate = ps.SubtargetPredicate;
 304   let AsmMatchConverter  = ps.AsmMatchConverter;
 305
 306   // encoding
 307   bits<7> sdst;
 308   bits<8> src0;
 309   bits<8> src1;
 310
 311   let Inst{7-0}   = src0;
 312   let Inst{15-8}  = src1;
 313   let Inst{22-16} = !if(ps.has_sdst, sdst, ?);
 314   let Inst{29-23} = op;
 315   let Inst{31-30} = 0x2; // encoding
 316 }
 317
 318
 319 class SOP2_32 <string opName, list<dag> pattern=[]> : SOP2_Pseudo <
 320   opName, (outs SReg_32:$sdst), (ins SSrc_b32:$src0, SSrc_b32:$src1),
 321   "$sdst, $src0, $src1", pattern
 322 >;
 323
 324 class SOP2_64 <string opName, list<dag> pattern=[]> : SOP2_Pseudo <
 325   opName, (outs SReg_64:$sdst), (ins SSrc_b64:$src0, SSrc_b64:$src1),
 326   "$sdst, $src0, $src1", pattern
 327 >;
 328
 329 class SOP2_64_32 <string opName, list<dag> pattern=[]> : SOP2_Pseudo <
 330   opName, (outs SReg_64:$sdst), (ins SSrc_b64:$src0, SSrc_b32:$src1),
 331   "$sdst, $src0, $src1", pattern
 332 >;
 333
 334 class SOP2_64_32_32 <string opName, list<dag> pattern=[]> : SOP2_Pseudo <
 335   opName, (outs SReg_64:$sdst), (ins SSrc_b32:$src0, SSrc_b32:$src1),
 336   "$sdst, $src0, $src1", pattern
 337 >;
 338
 339 class UniformUnaryFrag<SDPatternOperator Op> : PatFrag <
 340   (ops node:$src0),
 341   (Op $src0),
 342   [{ return !N->isDivergent(); }]
 343 >;
 344
 345 class UniformBinFrag<SDPatternOperator Op> : PatFrag <
 346   (ops node:$src0, node:$src1),
 347   (Op $src0, $src1),
 348   [{ return !N->isDivergent(); }]
 349 >;
 350
 351 let Defs = [SCC] in { // Carry out goes to SCC
 352 let isCommutable = 1 in {
 353 def S_ADD_U32 : SOP2_32 <"s_add_u32">;
 354 def S_ADD_I32 : SOP2_32 <"s_add_i32",
 355   [(set i32:$sdst, (UniformBinFrag<add> SSrc_b32:$src0, SSrc_b32:$src1))]
 356 >;
 357 } // End isCommutable = 1
 358
 359 def S_SUB_U32 : SOP2_32 <"s_sub_u32">;
 360 def S_SUB_I32 : SOP2_32 <"s_sub_i32",
 361   [(set i32:$sdst, (UniformBinFrag<sub> SSrc_b32:$src0, SSrc_b32:$src1))]
 362 >;
 363
 364 let Uses = [SCC] in { // Carry in comes from SCC
 365 let isCommutable = 1 in {
 366 def S_ADDC_U32 : SOP2_32 <"s_addc_u32",
 367   [(set i32:$sdst, (UniformBinFrag<adde> (i32 SSrc_b32:$src0), (i32 SSrc_b32:$src1)))]>;
 368 } // End isCommutable = 1
 369
 370 def S_SUBB_U32 : SOP2_32 <"s_subb_u32",
 371   [(set i32:$sdst, (UniformBinFrag<sube> (i32 SSrc_b32:$src0), (i32 SSrc_b32:$src1)))]>;
 372 } // End Uses = [SCC]
 373
 374
 375 let isCommutable = 1 in {
 376 def S_MIN_I32 : SOP2_32 <"s_min_i32",
 377   [(set i32:$sdst, (UniformBinFrag<smin> i32:$src0, i32:$src1))]
 378 >;
 379 def S_MIN_U32 : SOP2_32 <"s_min_u32",
 380   [(set i32:$sdst, (UniformBinFrag<umin> i32:$src0, i32:$src1))]
 381 >;
 382 def S_MAX_I32 : SOP2_32 <"s_max_i32",
 383   [(set i32:$sdst, (UniformBinFrag<smax> i32:$src0, i32:$src1))]
 384 >;
 385 def S_MAX_U32 : SOP2_32 <"s_max_u32",
 386   [(set i32:$sdst, (UniformBinFrag<umax> i32:$src0, i32:$src1))]
 387 >;
 388 } // End isCommutable = 1
 389 } // End Defs = [SCC]
 390
 391
 392 let Uses = [SCC] in {
 393   def S_CSELECT_B32 : SOP2_32 <"s_cselect_b32">;
 394   def S_CSELECT_B64 : SOP2_64 <"s_cselect_b64">;
 395 } // End Uses = [SCC]
 396
 397 let Defs = [SCC] in {
 398 let isCommutable = 1 in {
 399 def S_AND_B32 : SOP2_32 <"s_and_b32",
 400   [(set i32:$sdst, (UniformBinFrag<and> i32:$src0, i32:$src1))]
 401 >;
 402
 403 def S_AND_B64 : SOP2_64 <"s_and_b64",
 404   [(set i64:$sdst, (UniformBinFrag<and> i64:$src0, i64:$src1))]
 405 >;
 406
 407 def S_OR_B32 : SOP2_32 <"s_or_b32",
 408   [(set i32:$sdst, (UniformBinFrag<or> i32:$src0, i32:$src1))]
 409 >;
 410
 411 def S_OR_B64 : SOP2_64 <"s_or_b64",
 412   [(set i64:$sdst, (UniformBinFrag<or> i64:$src0, i64:$src1))]
 413 >;
 414
 415 def S_XOR_B32 : SOP2_32 <"s_xor_b32",
 416   [(set i32:$sdst, (UniformBinFrag<xor> i32:$src0, i32:$src1))]
 417 >;
 418
 419 def S_XOR_B64 : SOP2_64 <"s_xor_b64",
 420   [(set i64:$sdst, (UniformBinFrag<xor> i64:$src0, i64:$src1))]
 421 >;
 422
 423 def S_XNOR_B32 : SOP2_32 <"s_xnor_b32",
 424   [(set i32:$sdst, (not (xor_oneuse i32:$src0, i32:$src1)))]
 425 >;
 426
 427 def S_XNOR_B64 : SOP2_64 <"s_xnor_b64",
 428   [(set i64:$sdst, (not (xor_oneuse i64:$src0, i64:$src1)))]
 429 >;
 430
 431 def S_NAND_B32 : SOP2_32 <"s_nand_b32",
 432   [(set i32:$sdst, (not (and_oneuse i32:$src0, i32:$src1)))]
 433 >;
 434
 435 def S_NAND_B64 : SOP2_64 <"s_nand_b64",
 436   [(set i64:$sdst, (not (and_oneuse i64:$src0, i64:$src1)))]
 437 >;
 438
 439 def S_NOR_B32 : SOP2_32 <"s_nor_b32",
 440   [(set i32:$sdst, (not (or_oneuse i32:$src0, i32:$src1)))]
 441 >;
 442
 443 def S_NOR_B64 : SOP2_64 <"s_nor_b64",
 444   [(set i64:$sdst, (not (or_oneuse i64:$src0, i64:$src1)))]
 445 >;
 446 } // End isCommutable = 1
 447
 448 def S_ANDN2_B32 : SOP2_32 <"s_andn2_b32",
 449   [(set i32:$sdst, (UniformBinFrag<and> i32:$src0, (UniformUnaryFrag<not> i32:$src1)))]
 450 >;
 451
 452 def S_ANDN2_B64 : SOP2_64 <"s_andn2_b64",
 453   [(set i64:$sdst, (UniformBinFrag<and> i64:$src0, (UniformUnaryFrag<not> i64:$src1)))]
 454 >;
 455
 456 def S_ORN2_B32 : SOP2_32 <"s_orn2_b32",
 457   [(set i32:$sdst, (UniformBinFrag<or> i32:$src0, (UniformUnaryFrag<not> i32:$src1)))]
 458 >;
 459
 460 def S_ORN2_B64 : SOP2_64 <"s_orn2_b64",
 461   [(set i64:$sdst, (UniformBinFrag<or> i64:$src0, (UniformUnaryFrag<not> i64:$src1)))]
 462 >;
 463 } // End Defs = [SCC]
 464
 465 // Use added complexity so these patterns are preferred to the VALU patterns.
 466 let AddedComplexity = 1 in {
 467
 468 let Defs = [SCC] in {
 469 // TODO: b64 versions require VOP3 change since v_lshlrev_b64 is VOP3
 470 def S_LSHL_B32 : SOP2_32 <"s_lshl_b32",
 471   [(set i32:$sdst, (UniformBinFrag<shl> i32:$src0, i32:$src1))]
 472 >;
 473 def S_LSHL_B64 : SOP2_64_32 <"s_lshl_b64",
 474   [(set i64:$sdst, (UniformBinFrag<shl> i64:$src0, i32:$src1))]
 475 >;
 476 def S_LSHR_B32 : SOP2_32 <"s_lshr_b32",
 477   [(set i32:$sdst, (UniformBinFrag<srl> i32:$src0, i32:$src1))]
 478 >;
 479 def S_LSHR_B64 : SOP2_64_32 <"s_lshr_b64",
 480   [(set i64:$sdst, (UniformBinFrag<srl> i64:$src0, i32:$src1))]
 481 >;
 482 def S_ASHR_I32 : SOP2_32 <"s_ashr_i32",
 483   [(set i32:$sdst, (UniformBinFrag<sra> i32:$src0, i32:$src1))]
 484 >;
 485 def S_ASHR_I64 : SOP2_64_32 <"s_ashr_i64",
 486   [(set i64:$sdst, (UniformBinFrag<sra> i64:$src0, i32:$src1))]
 487 >;
 488 } // End Defs = [SCC]
 489
 490 def S_BFM_B32 : SOP2_32 <"s_bfm_b32",
 491   [(set i32:$sdst, (UniformBinFrag<AMDGPUbfm> i32:$src0, i32:$src1))]>;
 492 def S_BFM_B64 : SOP2_64_32_32 <"s_bfm_b64">;
 493
 494 // TODO: S_MUL_I32 require V_MUL_LO_I32 from VOP3 change
 495 def S_MUL_I32 : SOP2_32 <"s_mul_i32",
 496   [(set i32:$sdst, (mul i32:$src0, i32:$src1))]> {
 497   let isCommutable = 1;
 498 }
 499
 500 } // End AddedComplexity = 1
 501
 502 let Defs = [SCC] in {
 503 def S_BFE_U32 : SOP2_32 <"s_bfe_u32">;
 504 def S_BFE_I32 : SOP2_32 <"s_bfe_i32">;
 505 def S_BFE_U64 : SOP2_64_32 <"s_bfe_u64">;
 506 def S_BFE_I64 : SOP2_64_32 <"s_bfe_i64">;
 507 } // End Defs = [SCC]
 508
 509 def S_CBRANCH_G_FORK : SOP2_Pseudo <
 510   "s_cbranch_g_fork", (outs),
 511   (ins SCSrc_b64:$src0, SCSrc_b64:$src1),
 512   "$src0, $src1"
 513 > {
 514   let has_sdst = 0;
 515 }
 516
 517 let Defs = [SCC] in {
 518 def S_ABSDIFF_I32 : SOP2_32 <"s_absdiff_i32">;
 519 } // End Defs = [SCC]
 520
 521 let SubtargetPredicate = isVI in {
 522   def S_RFE_RESTORE_B64 : SOP2_Pseudo <
 523     "s_rfe_restore_b64", (outs),
 524     (ins SSrc_b64:$src0, SSrc_b32:$src1),
 525     "$src0, $src1"
 526   > {
 527     let hasSideEffects = 1;
 528     let has_sdst = 0;
 529   }
 530 }
 531
 532 let SubtargetPredicate = isGFX9 in {
 533   def S_PACK_LL_B32_B16 : SOP2_32<"s_pack_ll_b32_b16">;
 534   def S_PACK_LH_B32_B16 : SOP2_32<"s_pack_lh_b32_b16">;
 535   def S_PACK_HH_B32_B16 : SOP2_32<"s_pack_hh_b32_b16">;
 536
 537   let Defs = [SCC] in {
 538     def S_LSHL1_ADD_U32 : SOP2_32<"s_lshl1_add_u32">;
 539     def S_LSHL2_ADD_U32 : SOP2_32<"s_lshl2_add_u32">;
 540     def S_LSHL3_ADD_U32 : SOP2_32<"s_lshl3_add_u32">;
 541     def S_LSHL4_ADD_U32 : SOP2_32<"s_lshl4_add_u32">;
 542   } // End Defs = [SCC]
 543
 544   def S_MUL_HI_U32 : SOP2_32<"s_mul_hi_u32">;
 545   def S_MUL_HI_I32 : SOP2_32<"s_mul_hi_i32">;
 546 }
 547
 548 //===----------------------------------------------------------------------===//
 549 // SOPK Instructions
 550 //===----------------------------------------------------------------------===//
 551
 552 class SOPK_Pseudo <string opName, dag outs, dag ins,
 553                    string asmOps, list<dag> pattern=[]> :
 554   InstSI <outs, ins, "", pattern>,
 555   SIMCInstr<opName, SIEncodingFamily.NONE> {
 556   let isPseudo = 1;
 557   let isCodeGenOnly = 1;
 558   let SubtargetPredicate = isGCN;
 559   let mayLoad = 0;
 560   let mayStore = 0;
 561   let hasSideEffects = 0;
 562   let SALU = 1;
 563   let SOPK = 1;
 564   let SchedRW = [WriteSALU];
 565   let UseNamedOperandTable = 1;
 566   string Mnemonic = opName;
 567   string AsmOperands = asmOps;
 568
 569   bits<1> has_sdst = 1;
 570 }
 571
 572 class SOPK_Real<bits<5> op, SOPK_Pseudo ps> :
 573   InstSI <ps.OutOperandList, ps.InOperandList,
 574           ps.Mnemonic # " " # ps.AsmOperands, []> {
 575   let isPseudo = 0;
 576   let isCodeGenOnly = 0;
 577
 578   // copy relevant pseudo op flags
 579   let SubtargetPredicate = ps.SubtargetPredicate;
 580   let AsmMatchConverter  = ps.AsmMatchConverter;
 581   let DisableEncoding    = ps.DisableEncoding;
 582   let Constraints        = ps.Constraints;
 583
 584   // encoding
 585   bits<7>  sdst;
 586   bits<16> simm16;
 587   bits<32> imm;
 588 }
 589
 590 class SOPK_Real32<bits<5> op, SOPK_Pseudo ps> :
 591   SOPK_Real <op, ps>,
 592   Enc32 {
 593   let Inst{15-0}  = simm16;
 594   let Inst{22-16} = !if(ps.has_sdst, sdst, ?);
 595   let Inst{27-23} = op;
 596   let Inst{31-28} = 0xb; //encoding
 597 }
 598
 599 class SOPK_Real64<bits<5> op, SOPK_Pseudo ps> :
 600   SOPK_Real<op, ps>,
 601   Enc64 {
 602   let Inst{15-0}  = simm16;
 603   let Inst{22-16} = !if(ps.has_sdst, sdst, ?);
 604   let Inst{27-23} = op;
 605   let Inst{31-28} = 0xb; //encoding
 606   let Inst{63-32} = imm;
 607 }
 608
 609 class SOPKInstTable <bit is_sopk, string cmpOp = ""> {
 610   bit IsSOPK = is_sopk;
 611   string BaseCmpOp = cmpOp;
 612 }
 613
 614 class SOPK_32 <string opName, list<dag> pattern=[]> : SOPK_Pseudo <
 615   opName,
 616   (outs SReg_32:$sdst),
 617   (ins s16imm:$simm16),
 618   "$sdst, $simm16",
 619   pattern>;
 620
 621 class SOPK_SCC <string opName, string base_op, bit isSignExt> : SOPK_Pseudo <
 622   opName,
 623   (outs),
 624   !if(isSignExt,
 625       (ins SReg_32:$sdst, s16imm:$simm16),
 626       (ins SReg_32:$sdst, u16imm:$simm16)),
 627   "$sdst, $simm16", []>,
 628   SOPKInstTable<1, base_op>{
 629   let Defs = [SCC];
 630 }
 631
 632 class SOPK_32TIE <string opName, list<dag> pattern=[]> : SOPK_Pseudo <
 633   opName,
 634   (outs SReg_32:$sdst),
 635   (ins SReg_32:$src0, s16imm:$simm16),
 636   "$sdst, $simm16",
 637   pattern
 638 >;
 639
 640 let isReMaterializable = 1, isMoveImm = 1 in {
 641 def S_MOVK_I32 : SOPK_32 <"s_movk_i32">;
 642 } // End isReMaterializable = 1
 643 let Uses = [SCC] in {
 644 def S_CMOVK_I32 : SOPK_32 <"s_cmovk_i32">;
 645 }
 646
 647 let isCompare = 1 in {
 648
 649 // This instruction is disabled for now until we can figure out how to teach
 650 // the instruction selector to correctly use the  S_CMP* vs V_CMP*
 651 // instructions.
 652 //
 653 // When this instruction is enabled the code generator sometimes produces this
 654 // invalid sequence:
 655 //
 656 // SCC = S_CMPK_EQ_I32 SGPR0, imm
 657 // VCC = COPY SCC
 658 // VGPR0 = V_CNDMASK VCC, VGPR0, VGPR1
 659 //
 660 // def S_CMPK_EQ_I32 : SOPK_SCC <"s_cmpk_eq_i32",
 661 //   [(set i1:$dst, (setcc i32:$src0, imm:$src1, SETEQ))]
 662 // >;
 663
 664 def S_CMPK_EQ_I32 : SOPK_SCC <"s_cmpk_eq_i32", "s_cmp_eq_i32", 1>;
 665 def S_CMPK_LG_I32 : SOPK_SCC <"s_cmpk_lg_i32", "s_cmp_lg_i32", 1>;
 666 def S_CMPK_GT_I32 : SOPK_SCC <"s_cmpk_gt_i32", "s_cmp_gt_i32", 1>;
 667 def S_CMPK_GE_I32 : SOPK_SCC <"s_cmpk_ge_i32", "s_cmp_ge_i32", 1>;
 668 def S_CMPK_LT_I32 : SOPK_SCC <"s_cmpk_lt_i32", "s_cmp_lt_i32", 1>;
 669 def S_CMPK_LE_I32 : SOPK_SCC <"s_cmpk_le_i32", "s_cmp_le_i32", 1>;
 670
 671 let SOPKZext = 1 in {
 672 def S_CMPK_EQ_U32 : SOPK_SCC <"s_cmpk_eq_u32", "s_cmp_eq_u32", 0>;
 673 def S_CMPK_LG_U32 : SOPK_SCC <"s_cmpk_lg_u32", "s_cmp_lg_u32", 0>;
 674 def S_CMPK_GT_U32 : SOPK_SCC <"s_cmpk_gt_u32", "s_cmp_gt_u32", 0>;
 675 def S_CMPK_GE_U32 : SOPK_SCC <"s_cmpk_ge_u32", "s_cmp_ge_u32", 0>;
 676 def S_CMPK_LT_U32 : SOPK_SCC <"s_cmpk_lt_u32", "s_cmp_lt_u32", 0>;
 677 def S_CMPK_LE_U32 : SOPK_SCC <"s_cmpk_le_u32", "s_cmp_le_u32", 0>;
 678 } // End SOPKZext = 1
 679 } // End isCompare = 1
 680
 681 let Defs = [SCC], isCommutable = 1, DisableEncoding = "$src0",
 682     Constraints = "$sdst = $src0" in {
 683   def S_ADDK_I32 : SOPK_32TIE <"s_addk_i32">;
 684   def S_MULK_I32 : SOPK_32TIE <"s_mulk_i32">;
 685 }
 686
 687 def S_CBRANCH_I_FORK : SOPK_Pseudo <
 688   "s_cbranch_i_fork",
 689   (outs), (ins SReg_64:$sdst, s16imm:$simm16),
 690   "$sdst, $simm16"
 691 >;
 692
 693 let mayLoad = 1 in {
 694 def S_GETREG_B32 : SOPK_Pseudo <
 695   "s_getreg_b32",
 696   (outs SReg_32:$sdst), (ins hwreg:$simm16),
 697   "$sdst, $simm16"
 698 >;
 699 }
 700
 701 let hasSideEffects = 1 in {
 702
 703 def S_SETREG_B32 : SOPK_Pseudo <
 704   "s_setreg_b32",
 705   (outs), (ins SReg_32:$sdst, hwreg:$simm16),
 706   "$simm16, $sdst",
 707   [(AMDGPUsetreg i32:$sdst, (i16 timm:$simm16))]
 708 >;
 709
 710 // FIXME: Not on SI?
 711 //def S_GETREG_REGRD_B32 : SOPK_32 <sopk<0x14, 0x13>, "s_getreg_regrd_b32">;
 712
 713 def S_SETREG_IMM32_B32 : SOPK_Pseudo <
 714   "s_setreg_imm32_b32",
 715   (outs), (ins i32imm:$imm, hwreg:$simm16),
 716   "$simm16, $imm"> {
 717   let Size = 8; // Unlike every other SOPK instruction.
 718   let has_sdst = 0;
 719 }
 720
 721 } // End hasSideEffects = 1
 722
 723 let SubtargetPredicate = isGFX9 in {
 724   def S_CALL_B64 : SOPK_Pseudo<
 725       "s_call_b64",
 726       (outs SReg_64:$sdst),
 727       (ins s16imm:$simm16),
 728       "$sdst, $simm16"> {
 729     let isCall = 1;
 730   }
 731 }
 732
 733 //===----------------------------------------------------------------------===//
 734 // SOPC Instructions
 735 //===----------------------------------------------------------------------===//
 736
 737 class SOPCe <bits<7> op> : Enc32 {
 738   bits<8> src0;
 739   bits<8> src1;
 740
 741   let Inst{7-0} = src0;
 742   let Inst{15-8} = src1;
 743   let Inst{22-16} = op;
 744   let Inst{31-23} = 0x17e;
 745 }
 746
 747 class SOPC <bits<7> op, dag outs, dag ins, string asm,
 748             list<dag> pattern = []> :
 749   InstSI<outs, ins, asm, pattern>, SOPCe <op> {
 750   let mayLoad = 0;
 751   let mayStore = 0;
 752   let hasSideEffects = 0;
 753   let SALU = 1;
 754   let SOPC = 1;
 755   let isCodeGenOnly = 0;
 756   let Defs = [SCC];
 757   let SchedRW = [WriteSALU];
 758   let UseNamedOperandTable = 1;
 759   let SubtargetPredicate = isGCN;
 760 }
 761
 762 class SOPC_Base <bits<7> op, RegisterOperand rc0, RegisterOperand rc1,
 763                  string opName, list<dag> pattern = []> : SOPC <
 764   op, (outs), (ins rc0:$src0, rc1:$src1),
 765   opName#" $src0, $src1", pattern > {
 766   let Defs = [SCC];
 767 }
 768 class SOPC_Helper <bits<7> op, RegisterOperand rc, ValueType vt,
 769                     string opName, PatLeaf cond> : SOPC_Base <
 770   op, rc, rc, opName,
 771   [(set SCC, (si_setcc_uniform vt:$src0, vt:$src1, cond))] > {
 772 }
 773
 774 class SOPC_CMP_32<bits<7> op, string opName,
 775                   PatLeaf cond = COND_NULL, string revOp = opName>
 776   : SOPC_Helper<op, SSrc_b32, i32, opName, cond>,
 777     Commutable_REV<revOp, !eq(revOp, opName)>,
 778     SOPKInstTable<0, opName> {
 779   let isCompare = 1;
 780   let isCommutable = 1;
 781 }
 782
 783 class SOPC_CMP_64<bits<7> op, string opName,
 784                   PatLeaf cond = COND_NULL, string revOp = opName>
 785   : SOPC_Helper<op, SSrc_b64, i64, opName, cond>,
 786     Commutable_REV<revOp, !eq(revOp, opName)> {
 787   let isCompare = 1;
 788   let isCommutable = 1;
 789 }
 790
 791 class SOPC_32<bits<7> op, string opName, list<dag> pattern = []>
 792   : SOPC_Base<op, SSrc_b32, SSrc_b32, opName, pattern>;
 793
 794 class SOPC_64_32<bits<7> op, string opName, list<dag> pattern = []>
 795   : SOPC_Base<op, SSrc_b64, SSrc_b32, opName, pattern>;
 796
 797 def S_CMP_EQ_I32 : SOPC_CMP_32 <0x00, "s_cmp_eq_i32">;
 798 def S_CMP_LG_I32 : SOPC_CMP_32 <0x01, "s_cmp_lg_i32">;
 799 def S_CMP_GT_I32 : SOPC_CMP_32 <0x02, "s_cmp_gt_i32", COND_SGT>;
 800 def S_CMP_GE_I32 : SOPC_CMP_32 <0x03, "s_cmp_ge_i32", COND_SGE>;
 801 def S_CMP_LT_I32 : SOPC_CMP_32 <0x04, "s_cmp_lt_i32", COND_SLT, "s_cmp_gt_i32">;
 802 def S_CMP_LE_I32 : SOPC_CMP_32 <0x05, "s_cmp_le_i32", COND_SLE, "s_cmp_ge_i32">;
 803 def S_CMP_EQ_U32 : SOPC_CMP_32 <0x06, "s_cmp_eq_u32", COND_EQ>;
 804 def S_CMP_LG_U32 : SOPC_CMP_32 <0x07, "s_cmp_lg_u32", COND_NE>;
 805 def S_CMP_GT_U32 : SOPC_CMP_32 <0x08, "s_cmp_gt_u32", COND_UGT>;
 806 def S_CMP_GE_U32 : SOPC_CMP_32 <0x09, "s_cmp_ge_u32", COND_UGE>;
 807 def S_CMP_LT_U32 : SOPC_CMP_32 <0x0a, "s_cmp_lt_u32", COND_ULT, "s_cmp_gt_u32">;
 808 def S_CMP_LE_U32 : SOPC_CMP_32 <0x0b, "s_cmp_le_u32", COND_ULE, "s_cmp_ge_u32">;
 809
 810 def S_BITCMP0_B32 : SOPC_32 <0x0c, "s_bitcmp0_b32">;
 811 def S_BITCMP1_B32 : SOPC_32 <0x0d, "s_bitcmp1_b32">;
 812 def S_BITCMP0_B64 : SOPC_64_32 <0x0e, "s_bitcmp0_b64">;
 813 def S_BITCMP1_B64 : SOPC_64_32 <0x0f, "s_bitcmp1_b64">;
 814 def S_SETVSKIP : SOPC_32 <0x10, "s_setvskip">;
 815
 816 let SubtargetPredicate = isVI in {
 817 def S_CMP_EQ_U64 : SOPC_CMP_64 <0x12, "s_cmp_eq_u64", COND_EQ>;
 818 def S_CMP_LG_U64 : SOPC_CMP_64 <0x13, "s_cmp_lg_u64", COND_NE>;
 819 }
 820
 821 let SubtargetPredicate = HasVGPRIndexMode in {
 822 def S_SET_GPR_IDX_ON : SOPC <0x11,
 823   (outs),
 824   (ins SSrc_b32:$src0, GPRIdxMode:$src1),
 825   "s_set_gpr_idx_on $src0,$src1"> {
 826   let Defs = [M0]; // No scc def
 827   let Uses = [M0]; // Other bits of m0 unmodified.
 828   let hasSideEffects = 1; // Sets mode.gpr_idx_en
 829   let FixedSize = 1;
 830 }
 831 }
 832
 833 //===----------------------------------------------------------------------===//
 834 // SOPP Instructions
 835 //===----------------------------------------------------------------------===//
 836
 837 class SOPPe <bits<7> op> : Enc32 {
 838   bits <16> simm16;
 839
 840   let Inst{15-0} = simm16;
 841   let Inst{22-16} = op;
 842   let Inst{31-23} = 0x17f; // encoding
 843 }
 844
 845 class SOPP <bits<7> op, dag ins, string asm, list<dag> pattern = []> :
 846   InstSI <(outs), ins, asm, pattern >, SOPPe <op> {
 847
 848   let mayLoad = 0;
 849   let mayStore = 0;
 850   let hasSideEffects = 0;
 851   let SALU = 1;
 852   let SOPP = 1;
 853   let Size = 4;
 854   let SchedRW = [WriteSALU];
 855
 856   let UseNamedOperandTable = 1;
 857   let SubtargetPredicate = isGCN;
 858 }
 859
 860
 861 def S_NOP : SOPP <0x00000000, (ins i16imm:$simm16), "s_nop $simm16">;
 862
 863 let isTerminator = 1 in {
 864
 865 def S_ENDPGM : SOPP <0x00000001, (ins), "s_endpgm",
 866   [(AMDGPUendpgm)]> {
 867   let simm16 = 0;
 868   let isBarrier = 1;
 869   let isReturn = 1;
 870 }
 871
 872 let SubtargetPredicate = isVI in {
 873 def S_ENDPGM_SAVED : SOPP <0x0000001B, (ins), "s_endpgm_saved"> {
 874   let simm16 = 0;
 875   let isBarrier = 1;
 876   let isReturn = 1;
 877 }
 878 }
 879
 880 let SubtargetPredicate = isGFX9 in {
 881   let isBarrier = 1, isReturn = 1, simm16 = 0 in {
 882     def S_ENDPGM_ORDERED_PS_DONE :
 883       SOPP<0x01e, (ins), "s_endpgm_ordered_ps_done">;
 884   } // End isBarrier = 1, isReturn = 1, simm16 = 0
 885 } // End SubtargetPredicate = isGFX9
 886
 887 let isBranch = 1, SchedRW = [WriteBranch] in {
 888 def S_BRANCH : SOPP <
 889   0x00000002, (ins sopp_brtarget:$simm16), "s_branch $simm16",
 890   [(br bb:$simm16)]> {
 891   let isBarrier = 1;
 892 }
 893
 894 let Uses = [SCC] in {
 895 def S_CBRANCH_SCC0 : SOPP <
 896   0x00000004, (ins sopp_brtarget:$simm16),
 897   "s_cbranch_scc0 $simm16"
 898 >;
 899 def S_CBRANCH_SCC1 : SOPP <
 900   0x00000005, (ins sopp_brtarget:$simm16),
 901   "s_cbranch_scc1 $simm16"
 902 >;
 903 } // End Uses = [SCC]
 904
 905 let Uses = [VCC] in {
 906 def S_CBRANCH_VCCZ : SOPP <
 907   0x00000006, (ins sopp_brtarget:$simm16),
 908   "s_cbranch_vccz $simm16"
 909 >;
 910 def S_CBRANCH_VCCNZ : SOPP <
 911   0x00000007, (ins sopp_brtarget:$simm16),
 912   "s_cbranch_vccnz $simm16"
 913 >;
 914 } // End Uses = [VCC]
 915
 916 let Uses = [EXEC] in {
 917 def S_CBRANCH_EXECZ : SOPP <
 918   0x00000008, (ins sopp_brtarget:$simm16),
 919   "s_cbranch_execz $simm16"
 920 >;
 921 def S_CBRANCH_EXECNZ : SOPP <
 922   0x00000009, (ins sopp_brtarget:$simm16),
 923   "s_cbranch_execnz $simm16"
 924 >;
 925 } // End Uses = [EXEC]
 926
 927 def S_CBRANCH_CDBGSYS : SOPP <
 928   0x00000017, (ins sopp_brtarget:$simm16),
 929   "s_cbranch_cdbgsys $simm16"
 930 >;
 931
 932 def S_CBRANCH_CDBGSYS_AND_USER : SOPP <
 933   0x0000001A, (ins sopp_brtarget:$simm16),
 934   "s_cbranch_cdbgsys_and_user $simm16"
 935 >;
 936
 937 def S_CBRANCH_CDBGSYS_OR_USER : SOPP <
 938   0x00000019, (ins sopp_brtarget:$simm16),
 939   "s_cbranch_cdbgsys_or_user $simm16"
 940 >;
 941
 942 def S_CBRANCH_CDBGUSER : SOPP <
 943   0x00000018, (ins sopp_brtarget:$simm16),
 944   "s_cbranch_cdbguser $simm16"
 945 >;
 946
 947 } // End isBranch = 1
 948 } // End isTerminator = 1
 949
 950 let hasSideEffects = 1 in {
 951 def S_BARRIER : SOPP <0x0000000a, (ins), "s_barrier",
 952   [(int_amdgcn_s_barrier)]> {
 953   let SchedRW = [WriteBarrier];
 954   let simm16 = 0;
 955   let mayLoad = 1;
 956   let mayStore = 1;
 957   let isConvergent = 1;
 958 }
 959
 960 let SubtargetPredicate = isVI in {
 961 def S_WAKEUP : SOPP <0x00000003, (ins), "s_wakeup"> {
 962   let simm16 = 0;
 963   let mayLoad = 1;
 964   let mayStore = 1;
 965 }
 966 }
 967
 968 let mayLoad = 1, mayStore = 1, hasSideEffects = 1 in
 969 def S_WAITCNT : SOPP <0x0000000c, (ins WAIT_FLAG:$simm16), "s_waitcnt $simm16">;
 970 def S_SETHALT : SOPP <0x0000000d, (ins i16imm:$simm16), "s_sethalt $simm16">;
 971 def S_SETKILL : SOPP <0x0000000b, (ins i16imm:$simm16), "s_setkill $simm16">;
 972
 973 // On SI the documentation says sleep for approximately 64 * low 2
 974 // bits, consistent with the reported maximum of 448. On VI the
 975 // maximum reported is 960 cycles, so 960 / 64 = 15 max, so is the
 976 // maximum really 15 on VI?
 977 def S_SLEEP : SOPP <0x0000000e, (ins i32imm:$simm16),
 978   "s_sleep $simm16", [(int_amdgcn_s_sleep SIMM16bit:$simm16)]> {
 979   let hasSideEffects = 1;
 980   let mayLoad = 1;
 981   let mayStore = 1;
 982 }
 983
 984 def S_SETPRIO : SOPP <0x0000000f, (ins i16imm:$simm16), "s_setprio $simm16">;
 985
 986 let Uses = [EXEC, M0] in {
 987 // FIXME: Should this be mayLoad+mayStore?
 988 def S_SENDMSG : SOPP <0x00000010, (ins SendMsgImm:$simm16), "s_sendmsg $simm16",
 989   [(AMDGPUsendmsg (i32 imm:$simm16))]
 990 >;
 991
 992 def S_SENDMSGHALT : SOPP <0x00000011, (ins SendMsgImm:$simm16), "s_sendmsghalt $simm16",
 993   [(AMDGPUsendmsghalt (i32 imm:$simm16))]
 994 >;
 995 } // End Uses = [EXEC, M0]
 996
 997 def S_TRAP : SOPP <0x00000012, (ins i16imm:$simm16), "s_trap $simm16">;
 998 def S_ICACHE_INV : SOPP <0x00000013, (ins), "s_icache_inv"> {
 999   let simm16 = 0;
1000 }
1001 def S_INCPERFLEVEL : SOPP <0x00000014, (ins i32imm:$simm16), "s_incperflevel $simm16",
1002   [(int_amdgcn_s_incperflevel SIMM16bit:$simm16)]> {
1003   let hasSideEffects = 1;
1004   let mayLoad = 1;
1005   let mayStore = 1;
1006 }
1007 def S_DECPERFLEVEL : SOPP <0x00000015, (ins i32imm:$simm16), "s_decperflevel $simm16",
1008   [(int_amdgcn_s_decperflevel SIMM16bit:$simm16)]> {
1009   let hasSideEffects = 1;
1010   let mayLoad = 1;
1011   let mayStore = 1;
1012 }
1013 def S_TTRACEDATA : SOPP <0x00000016, (ins), "s_ttracedata"> {
1014   let simm16 = 0;
1015 }
1016
1017 let SubtargetPredicate = HasVGPRIndexMode in {
1018 def S_SET_GPR_IDX_OFF : SOPP<0x1c, (ins), "s_set_gpr_idx_off"> {
1019   let simm16 = 0;
1020 }
1021 }
1022 } // End hasSideEffects
1023
1024 let SubtargetPredicate = HasVGPRIndexMode in {
1025 def S_SET_GPR_IDX_MODE : SOPP<0x1d, (ins GPRIdxMode:$simm16),
1026   "s_set_gpr_idx_mode$simm16"> {
1027   let Defs = [M0];
1028 }
1029 }
1030
1031 //===----------------------------------------------------------------------===//
1032 // S_GETREG_B32 Intrinsic Pattern.
1033 //===----------------------------------------------------------------------===//
1034 def : GCNPat <
1035   (int_amdgcn_s_getreg imm:$simm16),
1036   (S_GETREG_B32 (as_i16imm $simm16))
1037 >;
1038
1039 //===----------------------------------------------------------------------===//
1040 // SOP1 Patterns
1041 //===----------------------------------------------------------------------===//
1042
1043 def : GCNPat <
1044   (i64 (ctpop i64:$src)),
1045     (i64 (REG_SEQUENCE SReg_64,
1046      (i32 (COPY_TO_REGCLASS (S_BCNT1_I32_B64 $src), SReg_32)), sub0,
1047      (S_MOV_B32 (i32 0)), sub1))
1048 >;
1049
1050 def : GCNPat <
1051   (i32 (smax i32:$x, (i32 (ineg i32:$x)))),
1052   (S_ABS_I32 $x)
1053 >;
1054
1055 def : GCNPat <
1056   (i16 imm:$imm),
1057   (S_MOV_B32 imm:$imm)
1058 >;
1059
1060 // Same as a 32-bit inreg
1061 def : GCNPat<
1062   (i32 (sext i16:$src)),
1063   (S_SEXT_I32_I16 $src)
1064 >;
1065
1066
1067 //===----------------------------------------------------------------------===//
1068 // SOP2 Patterns
1069 //===----------------------------------------------------------------------===//
1070
1071 // V_ADD_I32_e32/S_ADD_U32 produces carry in VCC/SCC. For the vector
1072 // case, the sgpr-copies pass will fix this to use the vector version.
1073 def : GCNPat <
1074   (i32 (addc i32:$src0, i32:$src1)),
1075   (S_ADD_U32 $src0, $src1)
1076 >;
1077
1078 // FIXME: We need to use COPY_TO_REGCLASS to work-around the fact that
1079 // REG_SEQUENCE patterns don't support instructions with multiple
1080 // outputs.
1081 def : GCNPat<
1082   (i64 (zext i16:$src)),
1083     (REG_SEQUENCE SReg_64,
1084       (i32 (COPY_TO_REGCLASS (S_AND_B32 $src, (S_MOV_B32 (i32 0xffff))), SGPR_32)), sub0,
1085       (S_MOV_B32 (i32 0)), sub1)
1086 >;
1087
1088 def : GCNPat <
1089   (i64 (sext i16:$src)),
1090     (REG_SEQUENCE SReg_64, (i32 (S_SEXT_I32_I16 $src)), sub0,
1091     (i32 (COPY_TO_REGCLASS (S_ASHR_I32 (i32 (S_SEXT_I32_I16 $src)), (S_MOV_B32 (i32 31))), SGPR_32)), sub1)
1092 >;
1093
1094 def : GCNPat<
1095   (i32 (zext i16:$src)),
1096   (S_AND_B32 (S_MOV_B32 (i32 0xffff)), $src)
1097 >;
1098
1099
1100
1101 //===----------------------------------------------------------------------===//
1102 // SOPP Patterns
1103 //===----------------------------------------------------------------------===//
1104
1105 def : GCNPat <
1106   (int_amdgcn_s_waitcnt i32:$simm16),
1107   (S_WAITCNT (as_i16imm $simm16))
1108 >;
1109
1110
1111 //===----------------------------------------------------------------------===//
1112 // Real target instructions, move this to the appropriate subtarget TD file
1113 //===----------------------------------------------------------------------===//
1114
1115 class Select_si<string opName> :
1116   SIMCInstr<opName, SIEncodingFamily.SI> {
1117   list<Predicate> AssemblerPredicates = [isSICI];
1118   string DecoderNamespace = "SICI";
1119 }
1120
1121 class SOP1_Real_si<bits<8> op, SOP1_Pseudo ps> :
1122   SOP1_Real<op, ps>,
1123   Select_si<ps.Mnemonic>;
1124
1125 class SOP2_Real_si<bits<7> op, SOP2_Pseudo ps> :
1126   SOP2_Real<op, ps>,
1127   Select_si<ps.Mnemonic>;
1128
1129 class SOPK_Real_si<bits<5> op, SOPK_Pseudo ps> :
1130   SOPK_Real32<op, ps>,
1131   Select_si<ps.Mnemonic>;
1132
1133 def S_MOV_B32_si           : SOP1_Real_si <0x03, S_MOV_B32>;
1134 def S_MOV_B64_si           : SOP1_Real_si <0x04, S_MOV_B64>;
1135 def S_CMOV_B32_si          : SOP1_Real_si <0x05, S_CMOV_B32>;
1136 def S_CMOV_B64_si          : SOP1_Real_si <0x06, S_CMOV_B64>;
1137 def S_NOT_B32_si           : SOP1_Real_si <0x07, S_NOT_B32>;
1138 def S_NOT_B64_si           : SOP1_Real_si <0x08, S_NOT_B64>;
1139 def S_WQM_B32_si           : SOP1_Real_si <0x09, S_WQM_B32>;
1140 def S_WQM_B64_si           : SOP1_Real_si <0x0a, S_WQM_B64>;
1141 def S_BREV_B32_si          : SOP1_Real_si <0x0b, S_BREV_B32>;
1142 def S_BREV_B64_si          : SOP1_Real_si <0x0c, S_BREV_B64>;
1143 def S_BCNT0_I32_B32_si     : SOP1_Real_si <0x0d, S_BCNT0_I32_B32>;
1144 def S_BCNT0_I32_B64_si     : SOP1_Real_si <0x0e, S_BCNT0_I32_B64>;
1145 def S_BCNT1_I32_B32_si     : SOP1_Real_si <0x0f, S_BCNT1_I32_B32>;
1146 def S_BCNT1_I32_B64_si     : SOP1_Real_si <0x10, S_BCNT1_I32_B64>;
1147 def S_FF0_I32_B32_si       : SOP1_Real_si <0x11, S_FF0_I32_B32>;
1148 def S_FF0_I32_B64_si       : SOP1_Real_si <0x12, S_FF0_I32_B64>;
1149 def S_FF1_I32_B32_si       : SOP1_Real_si <0x13, S_FF1_I32_B32>;
1150 def S_FF1_I32_B64_si       : SOP1_Real_si <0x14, S_FF1_I32_B64>;
1151 def S_FLBIT_I32_B32_si     : SOP1_Real_si <0x15, S_FLBIT_I32_B32>;
1152 def S_FLBIT_I32_B64_si     : SOP1_Real_si <0x16, S_FLBIT_I32_B64>;
1153 def S_FLBIT_I32_si         : SOP1_Real_si <0x17, S_FLBIT_I32>;
1154 def S_FLBIT_I32_I64_si     : SOP1_Real_si <0x18, S_FLBIT_I32_I64>;
1155 def S_SEXT_I32_I8_si       : SOP1_Real_si <0x19, S_SEXT_I32_I8>;
1156 def S_SEXT_I32_I16_si      : SOP1_Real_si <0x1a, S_SEXT_I32_I16>;
1157 def S_BITSET0_B32_si       : SOP1_Real_si <0x1b, S_BITSET0_B32>;
1158 def S_BITSET0_B64_si       : SOP1_Real_si <0x1c, S_BITSET0_B64>;
1159 def S_BITSET1_B32_si       : SOP1_Real_si <0x1d, S_BITSET1_B32>;
1160 def S_BITSET1_B64_si       : SOP1_Real_si <0x1e, S_BITSET1_B64>;
1161 def S_GETPC_B64_si         : SOP1_Real_si <0x1f, S_GETPC_B64>;
1162 def S_SETPC_B64_si         : SOP1_Real_si <0x20, S_SETPC_B64>;
1163 def S_SWAPPC_B64_si        : SOP1_Real_si <0x21, S_SWAPPC_B64>;
1164 def S_RFE_B64_si           : SOP1_Real_si <0x22, S_RFE_B64>;
1165 def S_AND_SAVEEXEC_B64_si  : SOP1_Real_si <0x24, S_AND_SAVEEXEC_B64>;
1166 def S_OR_SAVEEXEC_B64_si   : SOP1_Real_si <0x25, S_OR_SAVEEXEC_B64>;
1167 def S_XOR_SAVEEXEC_B64_si  : SOP1_Real_si <0x26, S_XOR_SAVEEXEC_B64>;
1168 def S_ANDN2_SAVEEXEC_B64_si: SOP1_Real_si <0x27, S_ANDN2_SAVEEXEC_B64>;
1169 def S_ORN2_SAVEEXEC_B64_si : SOP1_Real_si <0x28, S_ORN2_SAVEEXEC_B64>;
1170 def S_NAND_SAVEEXEC_B64_si : SOP1_Real_si <0x29, S_NAND_SAVEEXEC_B64>;
1171 def S_NOR_SAVEEXEC_B64_si  : SOP1_Real_si <0x2a, S_NOR_SAVEEXEC_B64>;
1172 def S_XNOR_SAVEEXEC_B64_si : SOP1_Real_si <0x2b, S_XNOR_SAVEEXEC_B64>;
1173 def S_QUADMASK_B32_si      : SOP1_Real_si <0x2c, S_QUADMASK_B32>;
1174 def S_QUADMASK_B64_si      : SOP1_Real_si <0x2d, S_QUADMASK_B64>;
1175 def S_MOVRELS_B32_si       : SOP1_Real_si <0x2e, S_MOVRELS_B32>;
1176 def S_MOVRELS_B64_si       : SOP1_Real_si <0x2f, S_MOVRELS_B64>;
1177 def S_MOVRELD_B32_si       : SOP1_Real_si <0x30, S_MOVRELD_B32>;
1178 def S_MOVRELD_B64_si       : SOP1_Real_si <0x31, S_MOVRELD_B64>;
1179 def S_CBRANCH_JOIN_si      : SOP1_Real_si <0x32, S_CBRANCH_JOIN>;
1180 def S_MOV_REGRD_B32_si     : SOP1_Real_si <0x33, S_MOV_REGRD_B32>;
1181 def S_ABS_I32_si           : SOP1_Real_si <0x34, S_ABS_I32>;
1182 def S_MOV_FED_B32_si       : SOP1_Real_si <0x35, S_MOV_FED_B32>;
1183
1184 def S_ADD_U32_si           : SOP2_Real_si <0x00, S_ADD_U32>;
1185 def S_ADD_I32_si           : SOP2_Real_si <0x02, S_ADD_I32>;
1186 def S_SUB_U32_si           : SOP2_Real_si <0x01, S_SUB_U32>;
1187 def S_SUB_I32_si           : SOP2_Real_si <0x03, S_SUB_I32>;
1188 def S_ADDC_U32_si          : SOP2_Real_si <0x04, S_ADDC_U32>;
1189 def S_SUBB_U32_si          : SOP2_Real_si <0x05, S_SUBB_U32>;
1190 def S_MIN_I32_si           : SOP2_Real_si <0x06, S_MIN_I32>;
1191 def S_MIN_U32_si           : SOP2_Real_si <0x07, S_MIN_U32>;
1192 def S_MAX_I32_si           : SOP2_Real_si <0x08, S_MAX_I32>;
1193 def S_MAX_U32_si           : SOP2_Real_si <0x09, S_MAX_U32>;
1194 def S_CSELECT_B32_si       : SOP2_Real_si <0x0a, S_CSELECT_B32>;
1195 def S_CSELECT_B64_si       : SOP2_Real_si <0x0b, S_CSELECT_B64>;
1196 def S_AND_B32_si           : SOP2_Real_si <0x0e, S_AND_B32>;
1197 def S_AND_B64_si           : SOP2_Real_si <0x0f, S_AND_B64>;
1198 def S_OR_B32_si            : SOP2_Real_si <0x10, S_OR_B32>;
1199 def S_OR_B64_si            : SOP2_Real_si <0x11, S_OR_B64>;
1200 def S_XOR_B32_si           : SOP2_Real_si <0x12, S_XOR_B32>;
1201 def S_XOR_B64_si           : SOP2_Real_si <0x13, S_XOR_B64>;
1202 def S_ANDN2_B32_si         : SOP2_Real_si <0x14, S_ANDN2_B32>;
1203 def S_ANDN2_B64_si         : SOP2_Real_si <0x15, S_ANDN2_B64>;
1204 def S_ORN2_B32_si          : SOP2_Real_si <0x16, S_ORN2_B32>;
1205 def S_ORN2_B64_si          : SOP2_Real_si <0x17, S_ORN2_B64>;
1206 def S_NAND_B32_si          : SOP2_Real_si <0x18, S_NAND_B32>;
1207 def S_NAND_B64_si          : SOP2_Real_si <0x19, S_NAND_B64>;
1208 def S_NOR_B32_si           : SOP2_Real_si <0x1a, S_NOR_B32>;
1209 def S_NOR_B64_si           : SOP2_Real_si <0x1b, S_NOR_B64>;
1210 def S_XNOR_B32_si          : SOP2_Real_si <0x1c, S_XNOR_B32>;
1211 def S_XNOR_B64_si          : SOP2_Real_si <0x1d, S_XNOR_B64>;
1212 def S_LSHL_B32_si          : SOP2_Real_si <0x1e, S_LSHL_B32>;
1213 def S_LSHL_B64_si          : SOP2_Real_si <0x1f, S_LSHL_B64>;
1214 def S_LSHR_B32_si          : SOP2_Real_si <0x20, S_LSHR_B32>;
1215 def S_LSHR_B64_si          : SOP2_Real_si <0x21, S_LSHR_B64>;
1216 def S_ASHR_I32_si          : SOP2_Real_si <0x22, S_ASHR_I32>;
1217 def S_ASHR_I64_si          : SOP2_Real_si <0x23, S_ASHR_I64>;
1218 def S_BFM_B32_si           : SOP2_Real_si <0x24, S_BFM_B32>;
1219 def S_BFM_B64_si           : SOP2_Real_si <0x25, S_BFM_B64>;
1220 def S_MUL_I32_si           : SOP2_Real_si <0x26, S_MUL_I32>;
1221 def S_BFE_U32_si           : SOP2_Real_si <0x27, S_BFE_U32>;
1222 def S_BFE_I32_si           : SOP2_Real_si <0x28, S_BFE_I32>;
1223 def S_BFE_U64_si           : SOP2_Real_si <0x29, S_BFE_U64>;
1224 def S_BFE_I64_si           : SOP2_Real_si <0x2a, S_BFE_I64>;
1225 def S_CBRANCH_G_FORK_si    : SOP2_Real_si <0x2b, S_CBRANCH_G_FORK>;
1226 def S_ABSDIFF_I32_si       : SOP2_Real_si <0x2c, S_ABSDIFF_I32>;
1227
1228 def S_MOVK_I32_si          : SOPK_Real_si <0x00, S_MOVK_I32>;
1229 def S_CMOVK_I32_si         : SOPK_Real_si <0x02, S_CMOVK_I32>;
1230 def S_CMPK_EQ_I32_si       : SOPK_Real_si <0x03, S_CMPK_EQ_I32>;
1231 def S_CMPK_LG_I32_si       : SOPK_Real_si <0x04, S_CMPK_LG_I32>;
1232 def S_CMPK_GT_I32_si       : SOPK_Real_si <0x05, S_CMPK_GT_I32>;
1233 def S_CMPK_GE_I32_si       : SOPK_Real_si <0x06, S_CMPK_GE_I32>;
1234 def S_CMPK_LT_I32_si       : SOPK_Real_si <0x07, S_CMPK_LT_I32>;
1235 def S_CMPK_LE_I32_si       : SOPK_Real_si <0x08, S_CMPK_LE_I32>;
1236 def S_CMPK_EQ_U32_si       : SOPK_Real_si <0x09, S_CMPK_EQ_U32>;
1237 def S_CMPK_LG_U32_si       : SOPK_Real_si <0x0a, S_CMPK_LG_U32>;
1238 def S_CMPK_GT_U32_si       : SOPK_Real_si <0x0b, S_CMPK_GT_U32>;
1239 def S_CMPK_GE_U32_si       : SOPK_Real_si <0x0c, S_CMPK_GE_U32>;
1240 def S_CMPK_LT_U32_si       : SOPK_Real_si <0x0d, S_CMPK_LT_U32>;
1241 def S_CMPK_LE_U32_si       : SOPK_Real_si <0x0e, S_CMPK_LE_U32>;
1242 def S_ADDK_I32_si          : SOPK_Real_si <0x0f, S_ADDK_I32>;
1243 def S_MULK_I32_si          : SOPK_Real_si <0x10, S_MULK_I32>;
1244 def S_CBRANCH_I_FORK_si    : SOPK_Real_si <0x11, S_CBRANCH_I_FORK>;
1245 def S_GETREG_B32_si        : SOPK_Real_si <0x12, S_GETREG_B32>;
1246 def S_SETREG_B32_si        : SOPK_Real_si <0x13, S_SETREG_B32>;
1247 //def S_GETREG_REGRD_B32_si  : SOPK_Real_si <0x14, S_GETREG_REGRD_B32>; // see pseudo for comments
1248 def S_SETREG_IMM32_B32_si  : SOPK_Real64<0x15, S_SETREG_IMM32_B32>,
1249                              Select_si<S_SETREG_IMM32_B32.Mnemonic>;
1250
1251
1252 class Select_vi<string opName> :
1253   SIMCInstr<opName, SIEncodingFamily.VI> {
1254   list<Predicate> AssemblerPredicates = [isVI];
1255   string DecoderNamespace = "VI";
1256 }
1257
1258 class SOP1_Real_vi<bits<8> op, SOP1_Pseudo ps> :
1259   SOP1_Real<op, ps>,
1260   Select_vi<ps.Mnemonic>;
1261
1262
1263 class SOP2_Real_vi<bits<7> op, SOP2_Pseudo ps> :
1264   SOP2_Real<op, ps>,
1265   Select_vi<ps.Mnemonic>;
1266
1267 class SOPK_Real_vi<bits<5> op, SOPK_Pseudo ps> :
1268   SOPK_Real32<op, ps>,
1269   Select_vi<ps.Mnemonic>;
1270
1271 def S_MOV_B32_vi           : SOP1_Real_vi <0x00, S_MOV_B32>;
1272 def S_MOV_B64_vi           : SOP1_Real_vi <0x01, S_MOV_B64>;
1273 def S_CMOV_B32_vi          : SOP1_Real_vi <0x02, S_CMOV_B32>;
1274 def S_CMOV_B64_vi          : SOP1_Real_vi <0x03, S_CMOV_B64>;
1275 def S_NOT_B32_vi           : SOP1_Real_vi <0x04, S_NOT_B32>;
1276 def S_NOT_B64_vi           : SOP1_Real_vi <0x05, S_NOT_B64>;
1277 def S_WQM_B32_vi           : SOP1_Real_vi <0x06, S_WQM_B32>;
1278 def S_WQM_B64_vi           : SOP1_Real_vi <0x07, S_WQM_B64>;
1279 def S_BREV_B32_vi          : SOP1_Real_vi <0x08, S_BREV_B32>;
1280 def S_BREV_B64_vi          : SOP1_Real_vi <0x09, S_BREV_B64>;
1281 def S_BCNT0_I32_B32_vi     : SOP1_Real_vi <0x0a, S_BCNT0_I32_B32>;
1282 def S_BCNT0_I32_B64_vi     : SOP1_Real_vi <0x0b, S_BCNT0_I32_B64>;
1283 def S_BCNT1_I32_B32_vi     : SOP1_Real_vi <0x0c, S_BCNT1_I32_B32>;
1284 def S_BCNT1_I32_B64_vi     : SOP1_Real_vi <0x0d, S_BCNT1_I32_B64>;
1285 def S_FF0_I32_B32_vi       : SOP1_Real_vi <0x0e, S_FF0_I32_B32>;
1286 def S_FF0_I32_B64_vi       : SOP1_Real_vi <0x0f, S_FF0_I32_B64>;
1287 def S_FF1_I32_B32_vi       : SOP1_Real_vi <0x10, S_FF1_I32_B32>;
1288 def S_FF1_I32_B64_vi       : SOP1_Real_vi <0x11, S_FF1_I32_B64>;
1289 def S_FLBIT_I32_B32_vi     : SOP1_Real_vi <0x12, S_FLBIT_I32_B32>;
1290 def S_FLBIT_I32_B64_vi     : SOP1_Real_vi <0x13, S_FLBIT_I32_B64>;
1291 def S_FLBIT_I32_vi         : SOP1_Real_vi <0x14, S_FLBIT_I32>;
1292 def S_FLBIT_I32_I64_vi     : SOP1_Real_vi <0x15, S_FLBIT_I32_I64>;
1293 def S_SEXT_I32_I8_vi       : SOP1_Real_vi <0x16, S_SEXT_I32_I8>;
1294 def S_SEXT_I32_I16_vi      : SOP1_Real_vi <0x17, S_SEXT_I32_I16>;
1295 def S_BITSET0_B32_vi       : SOP1_Real_vi <0x18, S_BITSET0_B32>;
1296 def S_BITSET0_B64_vi       : SOP1_Real_vi <0x19, S_BITSET0_B64>;
1297 def S_BITSET1_B32_vi       : SOP1_Real_vi <0x1a, S_BITSET1_B32>;
1298 def S_BITSET1_B64_vi       : SOP1_Real_vi <0x1b, S_BITSET1_B64>;
1299 def S_GETPC_B64_vi         : SOP1_Real_vi <0x1c, S_GETPC_B64>;
1300 def S_SETPC_B64_vi         : SOP1_Real_vi <0x1d, S_SETPC_B64>;
1301 def S_SWAPPC_B64_vi        : SOP1_Real_vi <0x1e, S_SWAPPC_B64>;
1302 def S_RFE_B64_vi           : SOP1_Real_vi <0x1f, S_RFE_B64>;
1303 def S_AND_SAVEEXEC_B64_vi  : SOP1_Real_vi <0x20, S_AND_SAVEEXEC_B64>;
1304 def S_OR_SAVEEXEC_B64_vi   : SOP1_Real_vi <0x21, S_OR_SAVEEXEC_B64>;
1305 def S_XOR_SAVEEXEC_B64_vi  : SOP1_Real_vi <0x22, S_XOR_SAVEEXEC_B64>;
1306 def S_ANDN2_SAVEEXEC_B64_vi: SOP1_Real_vi <0x23, S_ANDN2_SAVEEXEC_B64>;
1307 def S_ORN2_SAVEEXEC_B64_vi : SOP1_Real_vi <0x24, S_ORN2_SAVEEXEC_B64>;
1308 def S_NAND_SAVEEXEC_B64_vi : SOP1_Real_vi <0x25, S_NAND_SAVEEXEC_B64>;
1309 def S_NOR_SAVEEXEC_B64_vi  : SOP1_Real_vi <0x26, S_NOR_SAVEEXEC_B64>;
1310 def S_XNOR_SAVEEXEC_B64_vi : SOP1_Real_vi <0x27, S_XNOR_SAVEEXEC_B64>;
1311 def S_QUADMASK_B32_vi      : SOP1_Real_vi <0x28, S_QUADMASK_B32>;
1312 def S_QUADMASK_B64_vi      : SOP1_Real_vi <0x29, S_QUADMASK_B64>;
1313 def S_MOVRELS_B32_vi       : SOP1_Real_vi <0x2a, S_MOVRELS_B32>;
1314 def S_MOVRELS_B64_vi       : SOP1_Real_vi <0x2b, S_MOVRELS_B64>;
1315 def S_MOVRELD_B32_vi       : SOP1_Real_vi <0x2c, S_MOVRELD_B32>;
1316 def S_MOVRELD_B64_vi       : SOP1_Real_vi <0x2d, S_MOVRELD_B64>;
1317 def S_CBRANCH_JOIN_vi      : SOP1_Real_vi <0x2e, S_CBRANCH_JOIN>;
1318 def S_MOV_REGRD_B32_vi     : SOP1_Real_vi <0x2f, S_MOV_REGRD_B32>;
1319 def S_ABS_I32_vi           : SOP1_Real_vi <0x30, S_ABS_I32>;
1320 def S_MOV_FED_B32_vi       : SOP1_Real_vi <0x31, S_MOV_FED_B32>;
1321 def S_SET_GPR_IDX_IDX_vi   : SOP1_Real_vi <0x32, S_SET_GPR_IDX_IDX>;
1322
1323 def S_ADD_U32_vi           : SOP2_Real_vi <0x00, S_ADD_U32>;
1324 def S_ADD_I32_vi           : SOP2_Real_vi <0x02, S_ADD_I32>;
1325 def S_SUB_U32_vi           : SOP2_Real_vi <0x01, S_SUB_U32>;
1326 def S_SUB_I32_vi           : SOP2_Real_vi <0x03, S_SUB_I32>;
1327 def S_ADDC_U32_vi          : SOP2_Real_vi <0x04, S_ADDC_U32>;
1328 def S_SUBB_U32_vi          : SOP2_Real_vi <0x05, S_SUBB_U32>;
1329 def S_MIN_I32_vi           : SOP2_Real_vi <0x06, S_MIN_I32>;
1330 def S_MIN_U32_vi           : SOP2_Real_vi <0x07, S_MIN_U32>;
1331 def S_MAX_I32_vi           : SOP2_Real_vi <0x08, S_MAX_I32>;
1332 def S_MAX_U32_vi           : SOP2_Real_vi <0x09, S_MAX_U32>;
1333 def S_CSELECT_B32_vi       : SOP2_Real_vi <0x0a, S_CSELECT_B32>;
1334 def S_CSELECT_B64_vi       : SOP2_Real_vi <0x0b, S_CSELECT_B64>;
1335 def S_AND_B32_vi           : SOP2_Real_vi <0x0c, S_AND_B32>;
1336 def S_AND_B64_vi           : SOP2_Real_vi <0x0d, S_AND_B64>;
1337 def S_OR_B32_vi            : SOP2_Real_vi <0x0e, S_OR_B32>;
1338 def S_OR_B64_vi            : SOP2_Real_vi <0x0f, S_OR_B64>;
1339 def S_XOR_B32_vi           : SOP2_Real_vi <0x10, S_XOR_B32>;
1340 def S_XOR_B64_vi           : SOP2_Real_vi <0x11, S_XOR_B64>;
1341 def S_ANDN2_B32_vi         : SOP2_Real_vi <0x12, S_ANDN2_B32>;
1342 def S_ANDN2_B64_vi         : SOP2_Real_vi <0x13, S_ANDN2_B64>;
1343 def S_ORN2_B32_vi          : SOP2_Real_vi <0x14, S_ORN2_B32>;
1344 def S_ORN2_B64_vi          : SOP2_Real_vi <0x15, S_ORN2_B64>;
1345 def S_NAND_B32_vi          : SOP2_Real_vi <0x16, S_NAND_B32>;
1346 def S_NAND_B64_vi          : SOP2_Real_vi <0x17, S_NAND_B64>;
1347 def S_NOR_B32_vi           : SOP2_Real_vi <0x18, S_NOR_B32>;
1348 def S_NOR_B64_vi           : SOP2_Real_vi <0x19, S_NOR_B64>;
1349 def S_XNOR_B32_vi          : SOP2_Real_vi <0x1a, S_XNOR_B32>;
1350 def S_XNOR_B64_vi          : SOP2_Real_vi <0x1b, S_XNOR_B64>;
1351 def S_LSHL_B32_vi          : SOP2_Real_vi <0x1c, S_LSHL_B32>;
1352 def S_LSHL_B64_vi          : SOP2_Real_vi <0x1d, S_LSHL_B64>;
1353 def S_LSHR_B32_vi          : SOP2_Real_vi <0x1e, S_LSHR_B32>;
1354 def S_LSHR_B64_vi          : SOP2_Real_vi <0x1f, S_LSHR_B64>;
1355 def S_ASHR_I32_vi          : SOP2_Real_vi <0x20, S_ASHR_I32>;
1356 def S_ASHR_I64_vi          : SOP2_Real_vi <0x21, S_ASHR_I64>;
1357 def S_BFM_B32_vi           : SOP2_Real_vi <0x22, S_BFM_B32>;
1358 def S_BFM_B64_vi           : SOP2_Real_vi <0x23, S_BFM_B64>;
1359 def S_MUL_I32_vi           : SOP2_Real_vi <0x24, S_MUL_I32>;
1360 def S_BFE_U32_vi           : SOP2_Real_vi <0x25, S_BFE_U32>;
1361 def S_BFE_I32_vi           : SOP2_Real_vi <0x26, S_BFE_I32>;
1362 def S_BFE_U64_vi           : SOP2_Real_vi <0x27, S_BFE_U64>;
1363 def S_BFE_I64_vi           : SOP2_Real_vi <0x28, S_BFE_I64>;
1364 def S_CBRANCH_G_FORK_vi    : SOP2_Real_vi <0x29, S_CBRANCH_G_FORK>;
1365 def S_ABSDIFF_I32_vi       : SOP2_Real_vi <0x2a, S_ABSDIFF_I32>;
1366 def S_PACK_LL_B32_B16_vi   : SOP2_Real_vi <0x32, S_PACK_LL_B32_B16>;
1367 def S_PACK_LH_B32_B16_vi   : SOP2_Real_vi <0x33, S_PACK_LH_B32_B16>;
1368 def S_PACK_HH_B32_B16_vi   : SOP2_Real_vi <0x34, S_PACK_HH_B32_B16>;
1369 def S_RFE_RESTORE_B64_vi   : SOP2_Real_vi <0x2b, S_RFE_RESTORE_B64>;
1370
1371 def S_MOVK_I32_vi          : SOPK_Real_vi <0x00, S_MOVK_I32>;
1372 def S_CMOVK_I32_vi         : SOPK_Real_vi <0x01, S_CMOVK_I32>;
1373 def S_CMPK_EQ_I32_vi       : SOPK_Real_vi <0x02, S_CMPK_EQ_I32>;
1374 def S_CMPK_LG_I32_vi       : SOPK_Real_vi <0x03, S_CMPK_LG_I32>;
1375 def S_CMPK_GT_I32_vi       : SOPK_Real_vi <0x04, S_CMPK_GT_I32>;
1376 def S_CMPK_GE_I32_vi       : SOPK_Real_vi <0x05, S_CMPK_GE_I32>;
1377 def S_CMPK_LT_I32_vi       : SOPK_Real_vi <0x06, S_CMPK_LT_I32>;
1378 def S_CMPK_LE_I32_vi       : SOPK_Real_vi <0x07, S_CMPK_LE_I32>;
1379 def S_CMPK_EQ_U32_vi       : SOPK_Real_vi <0x08, S_CMPK_EQ_U32>;
1380 def S_CMPK_LG_U32_vi       : SOPK_Real_vi <0x09, S_CMPK_LG_U32>;
1381 def S_CMPK_GT_U32_vi       : SOPK_Real_vi <0x0A, S_CMPK_GT_U32>;
1382 def S_CMPK_GE_U32_vi       : SOPK_Real_vi <0x0B, S_CMPK_GE_U32>;
1383 def S_CMPK_LT_U32_vi       : SOPK_Real_vi <0x0C, S_CMPK_LT_U32>;
1384 def S_CMPK_LE_U32_vi       : SOPK_Real_vi <0x0D, S_CMPK_LE_U32>;
1385 def S_ADDK_I32_vi          : SOPK_Real_vi <0x0E, S_ADDK_I32>;
1386 def S_MULK_I32_vi          : SOPK_Real_vi <0x0F, S_MULK_I32>;
1387 def S_CBRANCH_I_FORK_vi    : SOPK_Real_vi <0x10, S_CBRANCH_I_FORK>;
1388 def S_GETREG_B32_vi        : SOPK_Real_vi <0x11, S_GETREG_B32>;
1389 def S_SETREG_B32_vi        : SOPK_Real_vi <0x12, S_SETREG_B32>;
1390 //def S_GETREG_REGRD_B32_vi  : SOPK_Real_vi <0x13, S_GETREG_REGRD_B32>; // see pseudo for comments
1391 def S_SETREG_IMM32_B32_vi  : SOPK_Real64<0x14, S_SETREG_IMM32_B32>,
1392                              Select_vi<S_SETREG_IMM32_B32.Mnemonic>;
1393
1394 def S_CALL_B64_vi          : SOPK_Real_vi <0x15, S_CALL_B64>;
1395
1396 //===----------------------------------------------------------------------===//
1397 // SOP1 - GFX9.
1398 //===----------------------------------------------------------------------===//
1399
1400 def S_ANDN1_SAVEEXEC_B64_vi   : SOP1_Real_vi<0x33, S_ANDN1_SAVEEXEC_B64>;
1401 def S_ORN1_SAVEEXEC_B64_vi    : SOP1_Real_vi<0x34, S_ORN1_SAVEEXEC_B64>;
1402 def S_ANDN1_WREXEC_B64_vi     : SOP1_Real_vi<0x35, S_ANDN1_WREXEC_B64>;
1403 def S_ANDN2_WREXEC_B64_vi     : SOP1_Real_vi<0x36, S_ANDN2_WREXEC_B64>;
1404 def S_BITREPLICATE_B64_B32_vi : SOP1_Real_vi<0x37, S_BITREPLICATE_B64_B32>;
1405
1406 //===----------------------------------------------------------------------===//
1407 // SOP2 - GFX9.
1408 //===----------------------------------------------------------------------===//
1409
1410 def S_LSHL1_ADD_U32_vi   : SOP2_Real_vi<0x2e, S_LSHL1_ADD_U32>;
1411 def S_LSHL2_ADD_U32_vi   : SOP2_Real_vi<0x2f, S_LSHL2_ADD_U32>;
1412 def S_LSHL3_ADD_U32_vi   : SOP2_Real_vi<0x30, S_LSHL3_ADD_U32>;
1413 def S_LSHL4_ADD_U32_vi   : SOP2_Real_vi<0x31, S_LSHL4_ADD_U32>;
1414 def S_MUL_HI_U32_vi      : SOP2_Real_vi<0x2c, S_MUL_HI_U32>;
1415 def S_MUL_HI_I32_vi      : SOP2_Real_vi<0x2d, S_MUL_HI_I32>;