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

   1 //===-- SOPInstructions.td - SOP Instruction Defintions -------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 def GPRIdxModeMatchClass : AsmOperandClass {
  10   let Name = "GPRIdxMode";
  11   let PredicateMethod = "isGPRIdxMode";
  12   let ParserMethod = "parseGPRIdxMode";
  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
  30   string Mnemonic = opName;
  31   string AsmOperands = asmOps;
  32
  33   bits<1> has_sdst = 0;
  34 }
  35
  36 //===----------------------------------------------------------------------===//
  37 // SOP1 Instructions
  38 //===----------------------------------------------------------------------===//
  39
  40 class SOP1_Pseudo <string opName, dag outs, dag ins,
  41                    string asmOps, list<dag> pattern=[]> :
  42   SOP_Pseudo<opName, outs, ins, asmOps, pattern> {
  43
  44   let mayLoad = 0;
  45   let mayStore = 0;
  46   let hasSideEffects = 0;
  47   let SALU = 1;
  48   let SOP1 = 1;
  49   let SchedRW = [WriteSALU];
  50   let Size = 4;
  51   let UseNamedOperandTable = 1;
  52
  53   bits<1> has_src0 = 1;
  54   bits<1> has_sdst = 1;
  55 }
  56
  57 class SOP1_Real<bits<8> op, SOP1_Pseudo ps> :
  58   InstSI <ps.OutOperandList, ps.InOperandList,
  59           ps.Mnemonic # " " # ps.AsmOperands, []>,
  60   Enc32 {
  61
  62   let isPseudo = 0;
  63   let isCodeGenOnly = 0;
  64   let Size = 4;
  65
  66   // copy relevant pseudo op flags
  67   let SubtargetPredicate = ps.SubtargetPredicate;
  68   let AsmMatchConverter  = ps.AsmMatchConverter;
  69
  70   // encoding
  71   bits<7> sdst;
  72   bits<8> src0;
  73
  74   let Inst{7-0} = !if(ps.has_src0, src0, ?);
  75   let Inst{15-8} = op;
  76   let Inst{22-16} = !if(ps.has_sdst, sdst, ?);
  77   let Inst{31-23} = 0x17d; //encoding;
  78 }
  79
  80 class SOP1_32 <string opName, list<dag> pattern=[], bit tied_in = 0> : SOP1_Pseudo <
  81   opName, (outs SReg_32:$sdst),
  82   !if(tied_in, (ins SSrc_b32:$src0, SReg_32:$sdst_in),
  83                (ins SSrc_b32:$src0)),
  84   "$sdst, $src0", pattern> {
  85   let Constraints = !if(tied_in, "$sdst = $sdst_in", "");
  86 }
  87
  88 // 32-bit input, no output.
  89 class SOP1_0_32 <string opName, list<dag> pattern = []> : SOP1_Pseudo <
  90   opName, (outs), (ins SSrc_b32:$src0),
  91   "$src0", pattern> {
  92   let has_sdst = 0;
  93 }
  94
  95 class SOP1_0_32R <string opName, list<dag> pattern = []> : SOP1_Pseudo <
  96   opName, (outs), (ins SReg_32:$src0),
  97   "$src0", pattern> {
  98   let has_sdst = 0;
  99 }
 100
 101 class SOP1_64 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
 102   opName, (outs SReg_64:$sdst), (ins SSrc_b64:$src0),
 103   "$sdst, $src0", pattern
 104 >;
 105
 106 // 64-bit input, 32-bit output.
 107 class SOP1_32_64 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
 108   opName, (outs SReg_32:$sdst), (ins SSrc_b64:$src0),
 109   "$sdst, $src0", pattern
 110 >;
 111
 112 // 32-bit input, 64-bit output.
 113 class SOP1_64_32 <string opName, list<dag> pattern=[], bit tied_in = 0> : SOP1_Pseudo <
 114   opName, (outs SReg_64:$sdst),
 115   !if(tied_in, (ins SSrc_b32:$src0, SReg_64:$sdst_in),
 116                (ins SSrc_b32:$src0)),
 117   "$sdst, $src0", pattern> {
 118   let Constraints = !if(tied_in, "$sdst = $sdst_in", "");
 119 }
 120
 121 // no input, 64-bit output.
 122 class SOP1_64_0 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
 123   opName, (outs SReg_64:$sdst), (ins), "$sdst", pattern> {
 124   let has_src0 = 0;
 125 }
 126
 127 // 64-bit input, no output
 128 class SOP1_1 <string opName, RegisterClass rc = SReg_64, list<dag> pattern=[]> : SOP1_Pseudo <
 129   opName, (outs), (ins rc:$src0), "$src0", pattern> {
 130   let has_sdst = 0;
 131 }
 132
 133
 134 let isMoveImm = 1 in {
 135   let isReMaterializable = 1, isAsCheapAsAMove = 1 in {
 136     def S_MOV_B32 : SOP1_32 <"s_mov_b32">;
 137     def S_MOV_B64 : SOP1_64 <"s_mov_b64">;
 138   } // End isRematerializeable = 1
 139
 140   let Uses = [SCC] in {
 141     def S_CMOV_B32 : SOP1_32 <"s_cmov_b32">;
 142     def S_CMOV_B64 : SOP1_64 <"s_cmov_b64">;
 143   } // End Uses = [SCC]
 144 } // End isMoveImm = 1
 145
 146 let Defs = [SCC] in {
 147   def S_NOT_B32 : SOP1_32 <"s_not_b32",
 148     [(set i32:$sdst, (not i32:$src0))]
 149   >;
 150
 151   def S_NOT_B64 : SOP1_64 <"s_not_b64",
 152     [(set i64:$sdst, (not i64:$src0))]
 153   >;
 154   def S_WQM_B32 : SOP1_32 <"s_wqm_b32">;
 155   def S_WQM_B64 : SOP1_64 <"s_wqm_b64">;
 156 } // End Defs = [SCC]
 157
 158
 159 let WaveSizePredicate = isWave32 in {
 160 def : GCNPat <
 161   (int_amdgcn_wqm_vote i1:$src0),
 162   (S_WQM_B32 $src0)
 163 >;
 164 }
 165
 166 let WaveSizePredicate = isWave64 in {
 167 def : GCNPat <
 168   (int_amdgcn_wqm_vote i1:$src0),
 169   (S_WQM_B64 $src0)
 170 >;
 171 }
 172
 173 def S_BREV_B32 : SOP1_32 <"s_brev_b32",
 174   [(set i32:$sdst, (bitreverse i32:$src0))]
 175 >;
 176 def S_BREV_B64 : SOP1_64 <"s_brev_b64">;
 177
 178 let Defs = [SCC] in {
 179 def S_BCNT0_I32_B32 : SOP1_32 <"s_bcnt0_i32_b32">;
 180 def S_BCNT0_I32_B64 : SOP1_32_64 <"s_bcnt0_i32_b64">;
 181 def S_BCNT1_I32_B32 : SOP1_32 <"s_bcnt1_i32_b32",
 182   [(set i32:$sdst, (ctpop i32:$src0))]
 183 >;
 184 def S_BCNT1_I32_B64 : SOP1_32_64 <"s_bcnt1_i32_b64">;
 185 } // End Defs = [SCC]
 186
 187 def S_FF0_I32_B32 : SOP1_32 <"s_ff0_i32_b32">;
 188 def S_FF0_I32_B64 : SOP1_32_64 <"s_ff0_i32_b64">;
 189 def S_FF1_I32_B64 : SOP1_32_64 <"s_ff1_i32_b64">;
 190
 191 def S_FF1_I32_B32 : SOP1_32 <"s_ff1_i32_b32",
 192   [(set i32:$sdst, (AMDGPUffbl_b32 i32:$src0))]
 193 >;
 194
 195 def S_FLBIT_I32_B32 : SOP1_32 <"s_flbit_i32_b32",
 196   [(set i32:$sdst, (AMDGPUffbh_u32 i32:$src0))]
 197 >;
 198
 199 def S_FLBIT_I32_B64 : SOP1_32_64 <"s_flbit_i32_b64">;
 200 def S_FLBIT_I32 : SOP1_32 <"s_flbit_i32",
 201   [(set i32:$sdst, (AMDGPUffbh_i32 i32:$src0))]
 202 >;
 203 def S_FLBIT_I32_I64 : SOP1_32_64 <"s_flbit_i32_i64">;
 204 def S_SEXT_I32_I8 : SOP1_32 <"s_sext_i32_i8",
 205   [(set i32:$sdst, (sext_inreg i32:$src0, i8))]
 206 >;
 207 def S_SEXT_I32_I16 : SOP1_32 <"s_sext_i32_i16",
 208   [(set i32:$sdst, (sext_inreg i32:$src0, i16))]
 209 >;
 210
 211 def S_BITSET0_B32 : SOP1_32    <"s_bitset0_b32", [], 1>;
 212 def S_BITSET0_B64 : SOP1_64_32 <"s_bitset0_b64", [], 1>;
 213 def S_BITSET1_B32 : SOP1_32    <"s_bitset1_b32", [], 1>;
 214 def S_BITSET1_B64 : SOP1_64_32 <"s_bitset1_b64", [], 1>;
 215 def S_GETPC_B64 : SOP1_64_0  <"s_getpc_b64",
 216   [(set i64:$sdst, (int_amdgcn_s_getpc))]
 217 >;
 218
 219 let isTerminator = 1, isBarrier = 1, SchedRW = [WriteBranch] in {
 220
 221 let isBranch = 1, isIndirectBranch = 1 in {
 222 def S_SETPC_B64 : SOP1_1  <"s_setpc_b64">;
 223 } // End isBranch = 1, isIndirectBranch = 1
 224
 225 let isReturn = 1 in {
 226 // Define variant marked as return rather than branch.
 227 def S_SETPC_B64_return : SOP1_1<"", CCR_SGPR_64, [(AMDGPUret_flag i64:$src0)]>;
 228 }
 229 } // End isTerminator = 1, isBarrier = 1
 230
 231 let isCall = 1 in {
 232 def S_SWAPPC_B64 : SOP1_64 <"s_swappc_b64"
 233 >;
 234 }
 235
 236 def S_RFE_B64 : SOP1_1  <"s_rfe_b64">;
 237
 238 let hasSideEffects = 1, Uses = [EXEC], Defs = [EXEC, SCC] in {
 239
 240 def S_AND_SAVEEXEC_B64 : SOP1_64 <"s_and_saveexec_b64">;
 241 def S_OR_SAVEEXEC_B64 : SOP1_64 <"s_or_saveexec_b64">;
 242 def S_XOR_SAVEEXEC_B64 : SOP1_64 <"s_xor_saveexec_b64">;
 243 def S_ANDN2_SAVEEXEC_B64 : SOP1_64 <"s_andn2_saveexec_b64">;
 244 def S_ORN2_SAVEEXEC_B64 : SOP1_64 <"s_orn2_saveexec_b64">;
 245 def S_NAND_SAVEEXEC_B64 : SOP1_64 <"s_nand_saveexec_b64">;
 246 def S_NOR_SAVEEXEC_B64 : SOP1_64 <"s_nor_saveexec_b64">;
 247 def S_XNOR_SAVEEXEC_B64 : SOP1_64 <"s_xnor_saveexec_b64">;
 248
 249 } // End hasSideEffects = 1, Uses = [EXEC], Defs = [EXEC, SCC]
 250
 251 def S_QUADMASK_B32 : SOP1_32 <"s_quadmask_b32">;
 252 def S_QUADMASK_B64 : SOP1_64 <"s_quadmask_b64">;
 253
 254 let Uses = [M0] in {
 255 def S_MOVRELS_B32 : SOP1_32 <"s_movrels_b32">;
 256 def S_MOVRELS_B64 : SOP1_64 <"s_movrels_b64">;
 257 def S_MOVRELD_B32 : SOP1_32 <"s_movreld_b32">;
 258 def S_MOVRELD_B64 : SOP1_64 <"s_movreld_b64">;
 259 } // End Uses = [M0]
 260
 261 let SubtargetPredicate = isGFX6GFX7GFX8GFX9 in {
 262 def S_CBRANCH_JOIN : SOP1_0_32R <"s_cbranch_join">;
 263 def S_MOV_REGRD_B32 : SOP1_32 <"s_mov_regrd_b32">;
 264 } // End SubtargetPredicate = isGFX6GFX7GFX8GFX9
 265
 266 let Defs = [SCC] in {
 267 def S_ABS_I32 : SOP1_32 <"s_abs_i32">;
 268 } // End Defs = [SCC]
 269 def S_MOV_FED_B32 : SOP1_32 <"s_mov_fed_b32">;
 270
 271 let SubtargetPredicate = HasVGPRIndexMode in {
 272 def S_SET_GPR_IDX_IDX : SOP1_0_32<"s_set_gpr_idx_idx"> {
 273   let Uses = [M0];
 274   let Defs = [M0];
 275 }
 276 }
 277
 278 let SubtargetPredicate = isGFX9Plus in {
 279   let hasSideEffects = 1, Defs = [EXEC, SCC], Uses = [EXEC] in {
 280     def S_ANDN1_SAVEEXEC_B64 : SOP1_64<"s_andn1_saveexec_b64">;
 281     def S_ORN1_SAVEEXEC_B64  : SOP1_64<"s_orn1_saveexec_b64">;
 282     def S_ANDN1_WREXEC_B64   : SOP1_64<"s_andn1_wrexec_b64">;
 283     def S_ANDN2_WREXEC_B64   : SOP1_64<"s_andn2_wrexec_b64">;
 284   } // End hasSideEffects = 1, Defs = [EXEC, SCC], Uses = [EXEC]
 285
 286   def S_BITREPLICATE_B64_B32 : SOP1_64_32<"s_bitreplicate_b64_b32">;
 287 } // End SubtargetPredicate = isGFX9Plus
 288
 289 let SubtargetPredicate = isGFX10Plus in {
 290   let hasSideEffects = 1, Defs = [EXEC, SCC], Uses = [EXEC] in {
 291     def S_AND_SAVEEXEC_B32   : SOP1_32<"s_and_saveexec_b32">;
 292     def S_OR_SAVEEXEC_B32    : SOP1_32<"s_or_saveexec_b32">;
 293     def S_XOR_SAVEEXEC_B32   : SOP1_32<"s_xor_saveexec_b32">;
 294     def S_ANDN2_SAVEEXEC_B32 : SOP1_32<"s_andn2_saveexec_b32">;
 295     def S_ORN2_SAVEEXEC_B32  : SOP1_32<"s_orn2_saveexec_b32">;
 296     def S_NAND_SAVEEXEC_B32  : SOP1_32<"s_nand_saveexec_b32">;
 297     def S_NOR_SAVEEXEC_B32   : SOP1_32<"s_nor_saveexec_b32">;
 298     def S_XNOR_SAVEEXEC_B32  : SOP1_32<"s_xnor_saveexec_b32">;
 299     def S_ANDN1_SAVEEXEC_B32 : SOP1_32<"s_andn1_saveexec_b32">;
 300     def S_ORN1_SAVEEXEC_B32  : SOP1_32<"s_orn1_saveexec_b32">;
 301     def S_ANDN1_WREXEC_B32   : SOP1_32<"s_andn1_wrexec_b32">;
 302     def S_ANDN2_WREXEC_B32   : SOP1_32<"s_andn2_wrexec_b32">;
 303   } // End hasSideEffects = 1, Defs = [EXEC, SCC], Uses = [EXEC]
 304
 305   let Uses = [M0] in {
 306     def S_MOVRELSD_2_B32 : SOP1_32<"s_movrelsd_2_b32">;
 307   } // End Uses = [M0]
 308 } // End SubtargetPredicate = isGFX10Plus
 309
 310 //===----------------------------------------------------------------------===//
 311 // SOP2 Instructions
 312 //===----------------------------------------------------------------------===//
 313
 314 class SOP2_Pseudo<string opName, dag outs, dag ins,
 315                   string asmOps, list<dag> pattern=[]> :
 316   SOP_Pseudo<opName, outs, ins, asmOps, pattern> {
 317
 318   let mayLoad = 0;
 319   let mayStore = 0;
 320   let hasSideEffects = 0;
 321   let SALU = 1;
 322   let SOP2 = 1;
 323   let SchedRW = [WriteSALU];
 324   let UseNamedOperandTable = 1;
 325
 326   let has_sdst = 1;
 327
 328   // Pseudo instructions have no encodings, but adding this field here allows
 329   // us to do:
 330   // let sdst = xxx in {
 331   // for multiclasses that include both real and pseudo instructions.
 332   // field bits<7> sdst = 0;
 333   // let Size = 4; // Do we need size here?
 334 }
 335
 336 class SOP2_Real<bits<7> op, SOP_Pseudo ps> :
 337   InstSI <ps.OutOperandList, ps.InOperandList,
 338           ps.Mnemonic # " " # ps.AsmOperands, []>,
 339   Enc32 {
 340   let isPseudo = 0;
 341   let isCodeGenOnly = 0;
 342
 343   // copy relevant pseudo op flags
 344   let SubtargetPredicate = ps.SubtargetPredicate;
 345   let AsmMatchConverter  = ps.AsmMatchConverter;
 346   let UseNamedOperandTable = ps.UseNamedOperandTable;
 347   let TSFlags = ps.TSFlags;
 348
 349   // encoding
 350   bits<7> sdst;
 351   bits<8> src0;
 352   bits<8> src1;
 353
 354   let Inst{7-0}   = src0;
 355   let Inst{15-8}  = src1;
 356   let Inst{22-16} = !if(ps.has_sdst, sdst, ?);
 357   let Inst{29-23} = op;
 358   let Inst{31-30} = 0x2; // encoding
 359 }
 360
 361
 362 class SOP2_32 <string opName, list<dag> pattern=[]> : SOP2_Pseudo <
 363   opName, (outs SReg_32:$sdst), (ins SSrc_b32:$src0, SSrc_b32:$src1),
 364   "$sdst, $src0, $src1", pattern
 365 >;
 366
 367 class SOP2_64 <string opName, list<dag> pattern=[]> : SOP2_Pseudo <
 368   opName, (outs SReg_64:$sdst), (ins SSrc_b64:$src0, SSrc_b64:$src1),
 369   "$sdst, $src0, $src1", pattern
 370 >;
 371
 372 class SOP2_64_32 <string opName, list<dag> pattern=[]> : SOP2_Pseudo <
 373   opName, (outs SReg_64:$sdst), (ins SSrc_b64:$src0, SSrc_b32:$src1),
 374   "$sdst, $src0, $src1", pattern
 375 >;
 376
 377 class SOP2_64_32_32 <string opName, list<dag> pattern=[]> : SOP2_Pseudo <
 378   opName, (outs SReg_64:$sdst), (ins SSrc_b32:$src0, SSrc_b32:$src1),
 379   "$sdst, $src0, $src1", pattern
 380 >;
 381
 382 class UniformUnaryFrag<SDPatternOperator Op> : PatFrag <
 383   (ops node:$src0),
 384   (Op $src0),
 385   [{ return !N->isDivergent(); }]
 386 >;
 387
 388 class UniformBinFrag<SDPatternOperator Op> : PatFrag <
 389   (ops node:$src0, node:$src1),
 390   (Op $src0, $src1),
 391   [{ return !N->isDivergent(); }]
 392 >;
 393
 394 let Defs = [SCC] in { // Carry out goes to SCC
 395 let isCommutable = 1 in {
 396 def S_ADD_U32 : SOP2_32 <"s_add_u32">;
 397 def S_ADD_I32 : SOP2_32 <"s_add_i32",
 398   [(set i32:$sdst, (UniformBinFrag<add> SSrc_b32:$src0, SSrc_b32:$src1))]
 399 >;
 400 } // End isCommutable = 1
 401
 402 def S_SUB_U32 : SOP2_32 <"s_sub_u32">;
 403 def S_SUB_I32 : SOP2_32 <"s_sub_i32",
 404   [(set i32:$sdst, (UniformBinFrag<sub> SSrc_b32:$src0, SSrc_b32:$src1))]
 405 >;
 406
 407 let Uses = [SCC] in { // Carry in comes from SCC
 408 let isCommutable = 1 in {
 409 def S_ADDC_U32 : SOP2_32 <"s_addc_u32",
 410   [(set i32:$sdst, (UniformBinFrag<adde> (i32 SSrc_b32:$src0), (i32 SSrc_b32:$src1)))]>;
 411 } // End isCommutable = 1
 412
 413 def S_SUBB_U32 : SOP2_32 <"s_subb_u32",
 414   [(set i32:$sdst, (UniformBinFrag<sube> (i32 SSrc_b32:$src0), (i32 SSrc_b32:$src1)))]>;
 415 } // End Uses = [SCC]
 416
 417
 418 let isCommutable = 1 in {
 419 def S_MIN_I32 : SOP2_32 <"s_min_i32",
 420   [(set i32:$sdst, (UniformBinFrag<smin> i32:$src0, i32:$src1))]
 421 >;
 422 def S_MIN_U32 : SOP2_32 <"s_min_u32",
 423   [(set i32:$sdst, (UniformBinFrag<umin> i32:$src0, i32:$src1))]
 424 >;
 425 def S_MAX_I32 : SOP2_32 <"s_max_i32",
 426   [(set i32:$sdst, (UniformBinFrag<smax> i32:$src0, i32:$src1))]
 427 >;
 428 def S_MAX_U32 : SOP2_32 <"s_max_u32",
 429   [(set i32:$sdst, (UniformBinFrag<umax> i32:$src0, i32:$src1))]
 430 >;
 431 } // End isCommutable = 1
 432 } // End Defs = [SCC]
 433
 434
 435 let Uses = [SCC] in {
 436   def S_CSELECT_B32 : SOP2_32 <"s_cselect_b32">;
 437   def S_CSELECT_B64 : SOP2_64 <"s_cselect_b64">;
 438 } // End Uses = [SCC]
 439
 440 let Defs = [SCC] in {
 441 let isCommutable = 1 in {
 442 def S_AND_B32 : SOP2_32 <"s_and_b32",
 443   [(set i32:$sdst, (UniformBinFrag<and> i32:$src0, i32:$src1))]
 444 >;
 445
 446 def S_AND_B64 : SOP2_64 <"s_and_b64",
 447   [(set i64:$sdst, (UniformBinFrag<and> i64:$src0, i64:$src1))]
 448 >;
 449
 450 def S_OR_B32 : SOP2_32 <"s_or_b32",
 451   [(set i32:$sdst, (UniformBinFrag<or> i32:$src0, i32:$src1))]
 452 >;
 453
 454 def S_OR_B64 : SOP2_64 <"s_or_b64",
 455   [(set i64:$sdst, (UniformBinFrag<or> i64:$src0, i64:$src1))]
 456 >;
 457
 458 def S_XOR_B32 : SOP2_32 <"s_xor_b32",
 459   [(set i32:$sdst, (UniformBinFrag<xor> i32:$src0, i32:$src1))]
 460 >;
 461
 462 def S_XOR_B64 : SOP2_64 <"s_xor_b64",
 463   [(set i64:$sdst, (UniformBinFrag<xor> i64:$src0, i64:$src1))]
 464 >;
 465
 466 def S_XNOR_B32 : SOP2_32 <"s_xnor_b32",
 467   [(set i32:$sdst, (not (xor_oneuse i32:$src0, i32:$src1)))]
 468 >;
 469
 470 def S_XNOR_B64 : SOP2_64 <"s_xnor_b64",
 471   [(set i64:$sdst, (not (xor_oneuse i64:$src0, i64:$src1)))]
 472 >;
 473
 474 def S_NAND_B32 : SOP2_32 <"s_nand_b32",
 475   [(set i32:$sdst, (not (and_oneuse i32:$src0, i32:$src1)))]
 476 >;
 477
 478 def S_NAND_B64 : SOP2_64 <"s_nand_b64",
 479   [(set i64:$sdst, (not (and_oneuse i64:$src0, i64:$src1)))]
 480 >;
 481
 482 def S_NOR_B32 : SOP2_32 <"s_nor_b32",
 483   [(set i32:$sdst, (not (or_oneuse i32:$src0, i32:$src1)))]
 484 >;
 485
 486 def S_NOR_B64 : SOP2_64 <"s_nor_b64",
 487   [(set i64:$sdst, (not (or_oneuse i64:$src0, i64:$src1)))]
 488 >;
 489 } // End isCommutable = 1
 490
 491 def S_ANDN2_B32 : SOP2_32 <"s_andn2_b32",
 492   [(set i32:$sdst, (UniformBinFrag<and> i32:$src0, (UniformUnaryFrag<not> i32:$src1)))]
 493 >;
 494
 495 def S_ANDN2_B64 : SOP2_64 <"s_andn2_b64",
 496   [(set i64:$sdst, (UniformBinFrag<and> i64:$src0, (UniformUnaryFrag<not> i64:$src1)))]
 497 >;
 498
 499 def S_ORN2_B32 : SOP2_32 <"s_orn2_b32",
 500   [(set i32:$sdst, (UniformBinFrag<or> i32:$src0, (UniformUnaryFrag<not> i32:$src1)))]
 501 >;
 502
 503 def S_ORN2_B64 : SOP2_64 <"s_orn2_b64",
 504   [(set i64:$sdst, (UniformBinFrag<or> i64:$src0, (UniformUnaryFrag<not> i64:$src1)))]
 505 >;
 506 } // End Defs = [SCC]
 507
 508 // Use added complexity so these patterns are preferred to the VALU patterns.
 509 let AddedComplexity = 1 in {
 510
 511 let Defs = [SCC] in {
 512 // TODO: b64 versions require VOP3 change since v_lshlrev_b64 is VOP3
 513 def S_LSHL_B32 : SOP2_32 <"s_lshl_b32",
 514   [(set SReg_32:$sdst, (shl (i32 SSrc_b32:$src0), (i32 SSrc_b32:$src1)))]
 515 >;
 516 def S_LSHL_B64 : SOP2_64_32 <"s_lshl_b64",
 517   [(set SReg_64:$sdst, (shl (i64 SSrc_b64:$src0), (i32 SSrc_b32:$src1)))]
 518 >;
 519 def S_LSHR_B32 : SOP2_32 <"s_lshr_b32",
 520   [(set SReg_32:$sdst, (srl (i32 SSrc_b32:$src0), (i32 SSrc_b32:$src1)))]
 521 >;
 522 def S_LSHR_B64 : SOP2_64_32 <"s_lshr_b64",
 523   [(set SReg_64:$sdst, (srl (i64 SSrc_b64:$src0), (i32 SSrc_b32:$src1)))]
 524 >;
 525 def S_ASHR_I32 : SOP2_32 <"s_ashr_i32",
 526   [(set SReg_32:$sdst, (sra (i32 SSrc_b32:$src0), (i32 SSrc_b32:$src1)))]
 527 >;
 528 def S_ASHR_I64 : SOP2_64_32 <"s_ashr_i64",
 529   [(set SReg_64:$sdst, (sra (i64 SSrc_b64:$src0), (i32 SSrc_b32:$src1)))]
 530 >;
 531 } // End Defs = [SCC]
 532
 533 def S_BFM_B32 : SOP2_32 <"s_bfm_b32",
 534   [(set i32:$sdst, (UniformBinFrag<AMDGPUbfm> i32:$src0, i32:$src1))]>;
 535 def S_BFM_B64 : SOP2_64_32_32 <"s_bfm_b64">;
 536
 537 // TODO: S_MUL_I32 require V_MUL_LO_I32 from VOP3 change
 538 def S_MUL_I32 : SOP2_32 <"s_mul_i32",
 539   [(set i32:$sdst, (mul i32:$src0, i32:$src1))]> {
 540   let isCommutable = 1;
 541 }
 542
 543 } // End AddedComplexity = 1
 544
 545 let Defs = [SCC] in {
 546 def S_BFE_U32 : SOP2_32 <"s_bfe_u32">;
 547 def S_BFE_I32 : SOP2_32 <"s_bfe_i32">;
 548 def S_BFE_U64 : SOP2_64_32 <"s_bfe_u64">;
 549 def S_BFE_I64 : SOP2_64_32 <"s_bfe_i64">;
 550 } // End Defs = [SCC]
 551
 552 def S_CBRANCH_G_FORK : SOP2_Pseudo <
 553   "s_cbranch_g_fork", (outs),
 554   (ins SCSrc_b64:$src0, SCSrc_b64:$src1),
 555   "$src0, $src1"
 556 > {
 557   let has_sdst = 0;
 558   let SubtargetPredicate = isGFX6GFX7GFX8GFX9;
 559 }
 560
 561 let Defs = [SCC] in {
 562 def S_ABSDIFF_I32 : SOP2_32 <"s_absdiff_i32">;
 563 } // End Defs = [SCC]
 564
 565 let SubtargetPredicate = isGFX8GFX9 in {
 566   def S_RFE_RESTORE_B64 : SOP2_Pseudo <
 567     "s_rfe_restore_b64", (outs),
 568     (ins SSrc_b64:$src0, SSrc_b32:$src1),
 569     "$src0, $src1"
 570   > {
 571     let hasSideEffects = 1;
 572     let has_sdst = 0;
 573   }
 574 }
 575
 576 let SubtargetPredicate = isGFX9Plus in {
 577   def S_PACK_LL_B32_B16 : SOP2_32<"s_pack_ll_b32_b16">;
 578   def S_PACK_LH_B32_B16 : SOP2_32<"s_pack_lh_b32_b16">;
 579   def S_PACK_HH_B32_B16 : SOP2_32<"s_pack_hh_b32_b16">;
 580
 581   let Defs = [SCC] in {
 582     def S_LSHL1_ADD_U32 : SOP2_32<"s_lshl1_add_u32">;
 583     def S_LSHL2_ADD_U32 : SOP2_32<"s_lshl2_add_u32">;
 584     def S_LSHL3_ADD_U32 : SOP2_32<"s_lshl3_add_u32">;
 585     def S_LSHL4_ADD_U32 : SOP2_32<"s_lshl4_add_u32">;
 586   } // End Defs = [SCC]
 587
 588   def S_MUL_HI_U32 : SOP2_32<"s_mul_hi_u32">;
 589   def S_MUL_HI_I32 : SOP2_32<"s_mul_hi_i32">;
 590 } // End SubtargetPredicate = isGFX9Plus
 591
 592 //===----------------------------------------------------------------------===//
 593 // SOPK Instructions
 594 //===----------------------------------------------------------------------===//
 595
 596 class SOPK_Pseudo <string opName, dag outs, dag ins,
 597                    string asmOps, list<dag> pattern=[]> :
 598   InstSI <outs, ins, "", pattern>,
 599   SIMCInstr<opName, SIEncodingFamily.NONE> {
 600   let isPseudo = 1;
 601   let isCodeGenOnly = 1;
 602   let mayLoad = 0;
 603   let mayStore = 0;
 604   let hasSideEffects = 0;
 605   let SALU = 1;
 606   let SOPK = 1;
 607   let SchedRW = [WriteSALU];
 608   let UseNamedOperandTable = 1;
 609   string Mnemonic = opName;
 610   string AsmOperands = asmOps;
 611
 612   bits<1> has_sdst = 1;
 613 }
 614
 615 class SOPK_Real<bits<5> op, SOPK_Pseudo ps> :
 616   InstSI <ps.OutOperandList, ps.InOperandList,
 617           ps.Mnemonic # " " # ps.AsmOperands, []> {
 618   let isPseudo = 0;
 619   let isCodeGenOnly = 0;
 620
 621   // copy relevant pseudo op flags
 622   let SubtargetPredicate = ps.SubtargetPredicate;
 623   let AsmMatchConverter  = ps.AsmMatchConverter;
 624   let DisableEncoding    = ps.DisableEncoding;
 625   let Constraints        = ps.Constraints;
 626
 627   // encoding
 628   bits<7>  sdst;
 629   bits<16> simm16;
 630   bits<32> imm;
 631 }
 632
 633 class SOPK_Real32<bits<5> op, SOPK_Pseudo ps> :
 634   SOPK_Real <op, ps>,
 635   Enc32 {
 636   let Inst{15-0}  = simm16;
 637   let Inst{22-16} = !if(ps.has_sdst, sdst, ?);
 638   let Inst{27-23} = op;
 639   let Inst{31-28} = 0xb; //encoding
 640 }
 641
 642 class SOPK_Real64<bits<5> op, SOPK_Pseudo ps> :
 643   SOPK_Real<op, ps>,
 644   Enc64 {
 645   let Inst{15-0}  = simm16;
 646   let Inst{22-16} = !if(ps.has_sdst, sdst, ?);
 647   let Inst{27-23} = op;
 648   let Inst{31-28} = 0xb; //encoding
 649   let Inst{63-32} = imm;
 650 }
 651
 652 class SOPKInstTable <bit is_sopk, string cmpOp = ""> {
 653   bit IsSOPK = is_sopk;
 654   string BaseCmpOp = cmpOp;
 655 }
 656
 657 class SOPK_32 <string opName, list<dag> pattern=[]> : SOPK_Pseudo <
 658   opName,
 659   (outs SReg_32:$sdst),
 660   (ins s16imm:$simm16),
 661   "$sdst, $simm16",
 662   pattern>;
 663
 664 class SOPK_32_BR <string opName, list<dag> pattern=[]> : SOPK_Pseudo <
 665   opName,
 666   (outs),
 667   (ins sopp_brtarget:$simm16, SReg_32:$sdst),
 668   "$sdst, $simm16",
 669   pattern> {
 670   let Defs = [EXEC];
 671   let Uses = [EXEC];
 672   let isBranch = 1;
 673   let isTerminator = 1;
 674   let SchedRW = [WriteBranch];
 675 }
 676
 677 class SOPK_SCC <string opName, string base_op, bit isSignExt> : SOPK_Pseudo <
 678   opName,
 679   (outs),
 680   !if(isSignExt,
 681       (ins SReg_32:$sdst, s16imm:$simm16),
 682       (ins SReg_32:$sdst, u16imm:$simm16)),
 683   "$sdst, $simm16", []>,
 684   SOPKInstTable<1, base_op>{
 685   let Defs = [SCC];
 686 }
 687
 688 class SOPK_32TIE <string opName, list<dag> pattern=[]> : SOPK_Pseudo <
 689   opName,
 690   (outs SReg_32:$sdst),
 691   (ins SReg_32:$src0, s16imm:$simm16),
 692   "$sdst, $simm16",
 693   pattern
 694 >;
 695
 696 let isReMaterializable = 1, isMoveImm = 1 in {
 697 def S_MOVK_I32 : SOPK_32 <"s_movk_i32">;
 698 } // End isReMaterializable = 1
 699 let Uses = [SCC] in {
 700 def S_CMOVK_I32 : SOPK_32 <"s_cmovk_i32">;
 701 }
 702
 703 let isCompare = 1 in {
 704
 705 // This instruction is disabled for now until we can figure out how to teach
 706 // the instruction selector to correctly use the  S_CMP* vs V_CMP*
 707 // instructions.
 708 //
 709 // When this instruction is enabled the code generator sometimes produces this
 710 // invalid sequence:
 711 //
 712 // SCC = S_CMPK_EQ_I32 SGPR0, imm
 713 // VCC = COPY SCC
 714 // VGPR0 = V_CNDMASK VCC, VGPR0, VGPR1
 715 //
 716 // def S_CMPK_EQ_I32 : SOPK_SCC <"s_cmpk_eq_i32",
 717 //   [(set i1:$dst, (setcc i32:$src0, imm:$src1, SETEQ))]
 718 // >;
 719
 720 def S_CMPK_EQ_I32 : SOPK_SCC <"s_cmpk_eq_i32", "s_cmp_eq_i32", 1>;
 721 def S_CMPK_LG_I32 : SOPK_SCC <"s_cmpk_lg_i32", "s_cmp_lg_i32", 1>;
 722 def S_CMPK_GT_I32 : SOPK_SCC <"s_cmpk_gt_i32", "s_cmp_gt_i32", 1>;
 723 def S_CMPK_GE_I32 : SOPK_SCC <"s_cmpk_ge_i32", "s_cmp_ge_i32", 1>;
 724 def S_CMPK_LT_I32 : SOPK_SCC <"s_cmpk_lt_i32", "s_cmp_lt_i32", 1>;
 725 def S_CMPK_LE_I32 : SOPK_SCC <"s_cmpk_le_i32", "s_cmp_le_i32", 1>;
 726
 727 let SOPKZext = 1 in {
 728 def S_CMPK_EQ_U32 : SOPK_SCC <"s_cmpk_eq_u32", "s_cmp_eq_u32", 0>;
 729 def S_CMPK_LG_U32 : SOPK_SCC <"s_cmpk_lg_u32", "s_cmp_lg_u32", 0>;
 730 def S_CMPK_GT_U32 : SOPK_SCC <"s_cmpk_gt_u32", "s_cmp_gt_u32", 0>;
 731 def S_CMPK_GE_U32 : SOPK_SCC <"s_cmpk_ge_u32", "s_cmp_ge_u32", 0>;
 732 def S_CMPK_LT_U32 : SOPK_SCC <"s_cmpk_lt_u32", "s_cmp_lt_u32", 0>;
 733 def S_CMPK_LE_U32 : SOPK_SCC <"s_cmpk_le_u32", "s_cmp_le_u32", 0>;
 734 } // End SOPKZext = 1
 735 } // End isCompare = 1
 736
 737 let Defs = [SCC], isCommutable = 1, DisableEncoding = "$src0",
 738     Constraints = "$sdst = $src0" in {
 739   def S_ADDK_I32 : SOPK_32TIE <"s_addk_i32">;
 740   def S_MULK_I32 : SOPK_32TIE <"s_mulk_i32">;
 741 }
 742
 743 let SubtargetPredicate = isGFX6GFX7GFX8GFX9 in
 744 def S_CBRANCH_I_FORK : SOPK_Pseudo <
 745   "s_cbranch_i_fork",
 746   (outs), (ins SReg_64:$sdst, sopp_brtarget:$simm16),
 747   "$sdst, $simm16"
 748 >;
 749
 750 let mayLoad = 1 in {
 751 def S_GETREG_B32 : SOPK_Pseudo <
 752   "s_getreg_b32",
 753   (outs SReg_32:$sdst), (ins hwreg:$simm16),
 754   "$sdst, $simm16"
 755 >;
 756 }
 757
 758 let hasSideEffects = 1 in {
 759
 760 def S_SETREG_B32 : SOPK_Pseudo <
 761   "s_setreg_b32",
 762   (outs), (ins SReg_32:$sdst, hwreg:$simm16),
 763   "$simm16, $sdst",
 764   [(AMDGPUsetreg i32:$sdst, (i16 timm:$simm16))]
 765 >;
 766
 767 // FIXME: Not on SI?
 768 //def S_GETREG_REGRD_B32 : SOPK_32 <sopk<0x14, 0x13>, "s_getreg_regrd_b32">;
 769
 770 def S_SETREG_IMM32_B32 : SOPK_Pseudo <
 771   "s_setreg_imm32_b32",
 772   (outs), (ins i32imm:$imm, hwreg:$simm16),
 773   "$simm16, $imm"> {
 774   let Size = 8; // Unlike every other SOPK instruction.
 775   let has_sdst = 0;
 776 }
 777
 778 } // End hasSideEffects = 1
 779
 780 class SOPK_WAITCNT<string opName, list<dag> pat=[]> :
 781     SOPK_Pseudo<
 782         opName,
 783         (outs),
 784         (ins SReg_32:$sdst, s16imm:$simm16),
 785         "$sdst, $simm16",
 786         pat> {
 787   let hasSideEffects = 1;
 788   let mayLoad = 1;
 789   let mayStore = 1;
 790   let has_sdst = 1; // First source takes place of sdst in encoding
 791 }
 792
 793 let SubtargetPredicate = isGFX9Plus in {
 794   def S_CALL_B64 : SOPK_Pseudo<
 795       "s_call_b64",
 796       (outs SReg_64:$sdst),
 797       (ins sopp_brtarget:$simm16),
 798       "$sdst, $simm16"> {
 799     let isCall = 1;
 800   }
 801 } // End SubtargetPredicate = isGFX9Plus
 802
 803 let SubtargetPredicate = isGFX10Plus in {
 804   def S_VERSION : SOPK_Pseudo<
 805       "s_version",
 806       (outs),
 807       (ins s16imm:$simm16),
 808       "$simm16"> {
 809     let has_sdst = 0;
 810   }
 811
 812   def S_SUBVECTOR_LOOP_BEGIN : SOPK_32_BR<"s_subvector_loop_begin">;
 813   def S_SUBVECTOR_LOOP_END   : SOPK_32_BR<"s_subvector_loop_end">;
 814
 815   def S_WAITCNT_VSCNT   : SOPK_WAITCNT<"s_waitcnt_vscnt">;
 816   def S_WAITCNT_VMCNT   : SOPK_WAITCNT<"s_waitcnt_vmcnt">;
 817   def S_WAITCNT_EXPCNT  : SOPK_WAITCNT<"s_waitcnt_expcnt">;
 818   def S_WAITCNT_LGKMCNT : SOPK_WAITCNT<"s_waitcnt_lgkmcnt">;
 819 } // End SubtargetPredicate = isGFX10Plus
 820
 821 //===----------------------------------------------------------------------===//
 822 // SOPC Instructions
 823 //===----------------------------------------------------------------------===//
 824
 825 class SOPCe <bits<7> op> : Enc32 {
 826   bits<8> src0;
 827   bits<8> src1;
 828
 829   let Inst{7-0} = src0;
 830   let Inst{15-8} = src1;
 831   let Inst{22-16} = op;
 832   let Inst{31-23} = 0x17e;
 833 }
 834
 835 class SOPC <bits<7> op, dag outs, dag ins, string asm,
 836             list<dag> pattern = []> :
 837   InstSI<outs, ins, asm, pattern>, SOPCe <op> {
 838   let mayLoad = 0;
 839   let mayStore = 0;
 840   let hasSideEffects = 0;
 841   let SALU = 1;
 842   let SOPC = 1;
 843   let isCodeGenOnly = 0;
 844   let Defs = [SCC];
 845   let SchedRW = [WriteSALU];
 846   let UseNamedOperandTable = 1;
 847 }
 848
 849 class SOPC_Base <bits<7> op, RegisterOperand rc0, RegisterOperand rc1,
 850                  string opName, list<dag> pattern = []> : SOPC <
 851   op, (outs), (ins rc0:$src0, rc1:$src1),
 852   opName#" $src0, $src1", pattern > {
 853   let Defs = [SCC];
 854 }
 855 class SOPC_Helper <bits<7> op, RegisterOperand rc, ValueType vt,
 856                     string opName, PatLeaf cond> : SOPC_Base <
 857   op, rc, rc, opName,
 858   [(set SCC, (si_setcc_uniform vt:$src0, vt:$src1, cond))] > {
 859 }
 860
 861 class SOPC_CMP_32<bits<7> op, string opName,
 862                   PatLeaf cond = COND_NULL, string revOp = opName>
 863   : SOPC_Helper<op, SSrc_b32, i32, opName, cond>,
 864     Commutable_REV<revOp, !eq(revOp, opName)>,
 865     SOPKInstTable<0, opName> {
 866   let isCompare = 1;
 867   let isCommutable = 1;
 868 }
 869
 870 class SOPC_CMP_64<bits<7> op, string opName,
 871                   PatLeaf cond = COND_NULL, string revOp = opName>
 872   : SOPC_Helper<op, SSrc_b64, i64, opName, cond>,
 873     Commutable_REV<revOp, !eq(revOp, opName)> {
 874   let isCompare = 1;
 875   let isCommutable = 1;
 876 }
 877
 878 class SOPC_32<bits<7> op, string opName, list<dag> pattern = []>
 879   : SOPC_Base<op, SSrc_b32, SSrc_b32, opName, pattern>;
 880
 881 class SOPC_64_32<bits<7> op, string opName, list<dag> pattern = []>
 882   : SOPC_Base<op, SSrc_b64, SSrc_b32, opName, pattern>;
 883
 884 def S_CMP_EQ_I32 : SOPC_CMP_32 <0x00, "s_cmp_eq_i32">;
 885 def S_CMP_LG_I32 : SOPC_CMP_32 <0x01, "s_cmp_lg_i32">;
 886 def S_CMP_GT_I32 : SOPC_CMP_32 <0x02, "s_cmp_gt_i32", COND_SGT>;
 887 def S_CMP_GE_I32 : SOPC_CMP_32 <0x03, "s_cmp_ge_i32", COND_SGE>;
 888 def S_CMP_LT_I32 : SOPC_CMP_32 <0x04, "s_cmp_lt_i32", COND_SLT, "s_cmp_gt_i32">;
 889 def S_CMP_LE_I32 : SOPC_CMP_32 <0x05, "s_cmp_le_i32", COND_SLE, "s_cmp_ge_i32">;
 890 def S_CMP_EQ_U32 : SOPC_CMP_32 <0x06, "s_cmp_eq_u32", COND_EQ>;
 891 def S_CMP_LG_U32 : SOPC_CMP_32 <0x07, "s_cmp_lg_u32", COND_NE>;
 892 def S_CMP_GT_U32 : SOPC_CMP_32 <0x08, "s_cmp_gt_u32", COND_UGT>;
 893 def S_CMP_GE_U32 : SOPC_CMP_32 <0x09, "s_cmp_ge_u32", COND_UGE>;
 894 def S_CMP_LT_U32 : SOPC_CMP_32 <0x0a, "s_cmp_lt_u32", COND_ULT, "s_cmp_gt_u32">;
 895 def S_CMP_LE_U32 : SOPC_CMP_32 <0x0b, "s_cmp_le_u32", COND_ULE, "s_cmp_ge_u32">;
 896
 897 def S_BITCMP0_B32 : SOPC_32 <0x0c, "s_bitcmp0_b32">;
 898 def S_BITCMP1_B32 : SOPC_32 <0x0d, "s_bitcmp1_b32">;
 899 def S_BITCMP0_B64 : SOPC_64_32 <0x0e, "s_bitcmp0_b64">;
 900 def S_BITCMP1_B64 : SOPC_64_32 <0x0f, "s_bitcmp1_b64">;
 901 let SubtargetPredicate = isGFX6GFX7GFX8GFX9 in
 902 def S_SETVSKIP : SOPC_32 <0x10, "s_setvskip">;
 903
 904 let SubtargetPredicate = isGFX8Plus in {
 905 def S_CMP_EQ_U64 : SOPC_CMP_64 <0x12, "s_cmp_eq_u64", COND_EQ>;
 906 def S_CMP_LG_U64 : SOPC_CMP_64 <0x13, "s_cmp_lg_u64", COND_NE>;
 907 } // End SubtargetPredicate = isGFX8Plus
 908
 909 let SubtargetPredicate = HasVGPRIndexMode in {
 910 def S_SET_GPR_IDX_ON : SOPC <0x11,
 911   (outs),
 912   (ins SSrc_b32:$src0, GPRIdxMode:$src1),
 913   "s_set_gpr_idx_on $src0,$src1"> {
 914   let Defs = [M0]; // No scc def
 915   let Uses = [M0]; // Other bits of m0 unmodified.
 916   let hasSideEffects = 1; // Sets mode.gpr_idx_en
 917   let FixedSize = 1;
 918 }
 919 }
 920
 921 //===----------------------------------------------------------------------===//
 922 // SOPP Instructions
 923 //===----------------------------------------------------------------------===//
 924
 925 class Base_SOPP <string asm> {
 926   string AsmString = asm;
 927 }
 928
 929 class SOPPe <bits<7> op> : Enc32 {
 930   bits <16> simm16;
 931
 932   let Inst{15-0} = simm16;
 933   let Inst{22-16} = op;
 934   let Inst{31-23} = 0x17f; // encoding
 935 }
 936
 937 class SOPP <bits<7> op, dag ins, string asm, list<dag> pattern = []> :
 938   InstSI <(outs), ins, asm, pattern >, SOPPe <op>, Base_SOPP <asm> {
 939
 940   let mayLoad = 0;
 941   let mayStore = 0;
 942   let hasSideEffects = 0;
 943   let SALU = 1;
 944   let SOPP = 1;
 945   let Size = 4;
 946   let SchedRW = [WriteSALU];
 947
 948   let UseNamedOperandTable = 1;
 949 }
 950
 951 def S_NOP : SOPP <0x00000000, (ins i16imm:$simm16), "s_nop $simm16">;
 952
 953 class SOPP_w_nop_e <bits<7> op> : Enc64 {
 954   bits <16> simm16;
 955
 956   let Inst{15-0} = simm16;
 957   let Inst{22-16} = op;
 958   let Inst{31-23} = 0x17f; // encoding
 959   let Inst{47-32} = 0x0;
 960   let Inst{54-48} = S_NOP.Inst{22-16}; // opcode
 961   let Inst{63-55} = S_NOP.Inst{31-23}; // encoding
 962 }
 963
 964 class SOPP_w_nop <bits<7> op, dag ins, string asm, list<dag> pattern = []> :
 965   InstSI <(outs), ins, asm, pattern >, SOPP_w_nop_e <op>, Base_SOPP <asm> {
 966
 967   let mayLoad = 0;
 968   let mayStore = 0;
 969   let hasSideEffects = 0;
 970   let SALU = 1;
 971   let SOPP = 1;
 972   let Size = 8;
 973   let SchedRW = [WriteSALU];
 974
 975   let UseNamedOperandTable = 1;
 976 }
 977
 978 multiclass SOPP_With_Relaxation <bits<7> op, dag ins, string asm, list<dag> pattern = []> {
 979   def "" : SOPP <op, ins, asm, pattern>;
 980   def _pad_s_nop : SOPP_w_nop <op, ins, asm, pattern>;
 981 }
 982
 983 let isTerminator = 1 in {
 984
 985 def S_ENDPGM : SOPP <0x00000001, (ins EndpgmImm:$simm16), "s_endpgm$simm16"> {
 986   let isBarrier = 1;
 987   let isReturn = 1;
 988 }
 989
 990 def S_ENDPGM_SAVED : SOPP <0x0000001B, (ins), "s_endpgm_saved"> {
 991   let SubtargetPredicate = isGFX8Plus;
 992   let simm16 = 0;
 993   let isBarrier = 1;
 994   let isReturn = 1;
 995 }
 996
 997 let SubtargetPredicate = isGFX9Plus in {
 998   let isBarrier = 1, isReturn = 1, simm16 = 0 in {
 999     def S_ENDPGM_ORDERED_PS_DONE :
1000       SOPP<0x01e, (ins), "s_endpgm_ordered_ps_done">;
1001   } // End isBarrier = 1, isReturn = 1, simm16 = 0
1002 } // End SubtargetPredicate = isGFX9Plus
1003
1004 let SubtargetPredicate = isGFX10Plus in {
1005   let isBarrier = 1, isReturn = 1, simm16 = 0 in {
1006     def S_CODE_END :
1007       SOPP<0x01f, (ins), "s_code_end">;
1008   } // End isBarrier = 1, isReturn = 1, simm16 = 0
1009 } // End SubtargetPredicate = isGFX10Plus
1010
1011 let isBranch = 1, SchedRW = [WriteBranch] in {
1012 let isBarrier = 1 in {
1013 defm S_BRANCH : SOPP_With_Relaxation <
1014   0x00000002, (ins sopp_brtarget:$simm16), "s_branch $simm16",
1015   [(br bb:$simm16)]>;
1016 }
1017
1018 let Uses = [SCC] in {
1019 defm S_CBRANCH_SCC0 : SOPP_With_Relaxation <
1020   0x00000004, (ins sopp_brtarget:$simm16),
1021   "s_cbranch_scc0 $simm16"
1022 >;
1023 defm S_CBRANCH_SCC1 : SOPP_With_Relaxation <
1024   0x00000005, (ins sopp_brtarget:$simm16),
1025   "s_cbranch_scc1 $simm16"
1026 >;
1027 } // End Uses = [SCC]
1028
1029 let Uses = [VCC] in {
1030 defm S_CBRANCH_VCCZ : SOPP_With_Relaxation <
1031   0x00000006, (ins sopp_brtarget:$simm16),
1032   "s_cbranch_vccz $simm16"
1033 >;
1034 defm S_CBRANCH_VCCNZ : SOPP_With_Relaxation <
1035   0x00000007, (ins sopp_brtarget:$simm16),
1036   "s_cbranch_vccnz $simm16"
1037 >;
1038 } // End Uses = [VCC]
1039
1040 let Uses = [EXEC] in {
1041 defm S_CBRANCH_EXECZ : SOPP_With_Relaxation <
1042   0x00000008, (ins sopp_brtarget:$simm16),
1043   "s_cbranch_execz $simm16"
1044 >;
1045 defm S_CBRANCH_EXECNZ : SOPP_With_Relaxation <
1046   0x00000009, (ins sopp_brtarget:$simm16),
1047   "s_cbranch_execnz $simm16"
1048 >;
1049 } // End Uses = [EXEC]
1050
1051 defm S_CBRANCH_CDBGSYS : SOPP_With_Relaxation <
1052   0x00000017, (ins sopp_brtarget:$simm16),
1053   "s_cbranch_cdbgsys $simm16"
1054 >;
1055
1056 defm S_CBRANCH_CDBGSYS_AND_USER : SOPP_With_Relaxation <
1057   0x0000001A, (ins sopp_brtarget:$simm16),
1058   "s_cbranch_cdbgsys_and_user $simm16"
1059 >;
1060
1061 defm S_CBRANCH_CDBGSYS_OR_USER : SOPP_With_Relaxation <
1062   0x00000019, (ins sopp_brtarget:$simm16),
1063   "s_cbranch_cdbgsys_or_user $simm16"
1064 >;
1065
1066 defm S_CBRANCH_CDBGUSER : SOPP_With_Relaxation <
1067   0x00000018, (ins sopp_brtarget:$simm16),
1068   "s_cbranch_cdbguser $simm16"
1069 >;
1070
1071 } // End isBranch = 1
1072 } // End isTerminator = 1
1073
1074 let hasSideEffects = 1 in {
1075 def S_BARRIER : SOPP <0x0000000a, (ins), "s_barrier",
1076   [(int_amdgcn_s_barrier)]> {
1077   let SchedRW = [WriteBarrier];
1078   let simm16 = 0;
1079   let mayLoad = 1;
1080   let mayStore = 1;
1081   let isConvergent = 1;
1082 }
1083
1084 def S_WAKEUP : SOPP <0x00000003, (ins), "s_wakeup"> {
1085   let SubtargetPredicate = isGFX8Plus;
1086   let simm16 = 0;
1087   let mayLoad = 1;
1088   let mayStore = 1;
1089 }
1090
1091 let mayLoad = 1, mayStore = 1, hasSideEffects = 1 in
1092 def S_WAITCNT : SOPP <0x0000000c, (ins WAIT_FLAG:$simm16), "s_waitcnt $simm16",
1093     [(int_amdgcn_s_waitcnt UIMM16bit:$simm16)]>;
1094 def S_SETHALT : SOPP <0x0000000d, (ins i16imm:$simm16), "s_sethalt $simm16">;
1095 def S_SETKILL : SOPP <0x0000000b, (ins i16imm:$simm16), "s_setkill $simm16">;
1096
1097 // On SI the documentation says sleep for approximately 64 * low 2
1098 // bits, consistent with the reported maximum of 448. On VI the
1099 // maximum reported is 960 cycles, so 960 / 64 = 15 max, so is the
1100 // maximum really 15 on VI?
1101 def S_SLEEP : SOPP <0x0000000e, (ins i32imm:$simm16),
1102   "s_sleep $simm16", [(int_amdgcn_s_sleep SIMM16bit:$simm16)]> {
1103   let hasSideEffects = 1;
1104   let mayLoad = 1;
1105   let mayStore = 1;
1106 }
1107
1108 def S_SETPRIO : SOPP <0x0000000f, (ins i16imm:$simm16), "s_setprio $simm16">;
1109
1110 let Uses = [EXEC, M0] in {
1111 // FIXME: Should this be mayLoad+mayStore?
1112 def S_SENDMSG : SOPP <0x00000010, (ins SendMsgImm:$simm16), "s_sendmsg $simm16",
1113   [(AMDGPUsendmsg (i32 imm:$simm16))]
1114 >;
1115
1116 def S_SENDMSGHALT : SOPP <0x00000011, (ins SendMsgImm:$simm16), "s_sendmsghalt $simm16",
1117   [(AMDGPUsendmsghalt (i32 imm:$simm16))]
1118 >;
1119 } // End Uses = [EXEC, M0]
1120
1121 def S_TRAP : SOPP <0x00000012, (ins i16imm:$simm16), "s_trap $simm16"> {
1122   let isTrap = 1;
1123 }
1124
1125 def S_ICACHE_INV : SOPP <0x00000013, (ins), "s_icache_inv"> {
1126   let simm16 = 0;
1127 }
1128 def S_INCPERFLEVEL : SOPP <0x00000014, (ins i32imm:$simm16), "s_incperflevel $simm16",
1129   [(int_amdgcn_s_incperflevel SIMM16bit:$simm16)]> {
1130   let hasSideEffects = 1;
1131   let mayLoad = 1;
1132   let mayStore = 1;
1133 }
1134 def S_DECPERFLEVEL : SOPP <0x00000015, (ins i32imm:$simm16), "s_decperflevel $simm16",
1135   [(int_amdgcn_s_decperflevel SIMM16bit:$simm16)]> {
1136   let hasSideEffects = 1;
1137   let mayLoad = 1;
1138   let mayStore = 1;
1139 }
1140 def S_TTRACEDATA : SOPP <0x00000016, (ins), "s_ttracedata"> {
1141   let simm16 = 0;
1142 }
1143
1144 let SubtargetPredicate = HasVGPRIndexMode in {
1145 def S_SET_GPR_IDX_OFF : SOPP<0x1c, (ins), "s_set_gpr_idx_off"> {
1146   let simm16 = 0;
1147 }
1148 }
1149 } // End hasSideEffects
1150
1151 let SubtargetPredicate = HasVGPRIndexMode in {
1152 def S_SET_GPR_IDX_MODE : SOPP<0x1d, (ins GPRIdxMode:$simm16),
1153   "s_set_gpr_idx_mode$simm16"> {
1154   let Defs = [M0];
1155 }
1156 }
1157
1158 let SubtargetPredicate = isGFX10Plus in {
1159   def S_INST_PREFETCH :
1160     SOPP<0x020, (ins s16imm:$simm16), "s_inst_prefetch $simm16">;
1161   def S_CLAUSE :
1162     SOPP<0x021, (ins s16imm:$simm16), "s_clause $simm16">;
1163   def S_WAITCNT_IDLE :
1164     SOPP <0x022, (ins), "s_wait_idle"> {
1165       let simm16 = 0;
1166     }
1167   def S_WAITCNT_DEPCTR :
1168     SOPP <0x023, (ins s16imm:$simm16), "s_waitcnt_depctr $simm16">;
1169   def S_ROUND_MODE :
1170     SOPP<0x024, (ins s16imm:$simm16), "s_round_mode $simm16">;
1171   def S_DENORM_MODE :
1172     SOPP<0x025, (ins s16imm:$simm16), "s_denorm_mode $simm16">;
1173   def S_TTRACEDATA_IMM :
1174     SOPP<0x028, (ins s16imm:$simm16), "s_ttracedata_imm $simm16">;
1175 } // End SubtargetPredicate = isGFX10Plus
1176
1177 //===----------------------------------------------------------------------===//
1178 // S_GETREG_B32 Intrinsic Pattern.
1179 //===----------------------------------------------------------------------===//
1180 def : GCNPat <
1181   (int_amdgcn_s_getreg imm:$simm16),
1182   (S_GETREG_B32 (as_i16imm $simm16))
1183 >;
1184
1185 //===----------------------------------------------------------------------===//
1186 // SOP1 Patterns
1187 //===----------------------------------------------------------------------===//
1188
1189 def : GCNPat <
1190   (AMDGPUendpgm),
1191     (S_ENDPGM (i16 0))
1192 >;
1193
1194 def : GCNPat <
1195   (i64 (ctpop i64:$src)),
1196     (i64 (REG_SEQUENCE SReg_64,
1197      (i32 (COPY_TO_REGCLASS (S_BCNT1_I32_B64 $src), SReg_32)), sub0,
1198      (S_MOV_B32 (i32 0)), sub1))
1199 >;
1200
1201 def : GCNPat <
1202   (i32 (smax i32:$x, (i32 (ineg i32:$x)))),
1203   (S_ABS_I32 $x)
1204 >;
1205
1206 def : GCNPat <
1207   (i16 imm:$imm),
1208   (S_MOV_B32 imm:$imm)
1209 >;
1210
1211 // Same as a 32-bit inreg
1212 def : GCNPat<
1213   (i32 (sext i16:$src)),
1214   (S_SEXT_I32_I16 $src)
1215 >;
1216
1217
1218 //===----------------------------------------------------------------------===//
1219 // SOP2 Patterns
1220 //===----------------------------------------------------------------------===//
1221
1222 // V_ADD_I32_e32/S_ADD_U32 produces carry in VCC/SCC. For the vector
1223 // case, the sgpr-copies pass will fix this to use the vector version.
1224 def : GCNPat <
1225   (i32 (addc i32:$src0, i32:$src1)),
1226   (S_ADD_U32 $src0, $src1)
1227 >;
1228
1229 // FIXME: We need to use COPY_TO_REGCLASS to work-around the fact that
1230 // REG_SEQUENCE patterns don't support instructions with multiple
1231 // outputs.
1232 def : GCNPat<
1233   (i64 (zext i16:$src)),
1234     (REG_SEQUENCE SReg_64,
1235       (i32 (COPY_TO_REGCLASS (S_AND_B32 $src, (S_MOV_B32 (i32 0xffff))), SGPR_32)), sub0,
1236       (S_MOV_B32 (i32 0)), sub1)
1237 >;
1238
1239 def : GCNPat <
1240   (i64 (sext i16:$src)),
1241     (REG_SEQUENCE SReg_64, (i32 (S_SEXT_I32_I16 $src)), sub0,
1242     (i32 (COPY_TO_REGCLASS (S_ASHR_I32 (i32 (S_SEXT_I32_I16 $src)), (S_MOV_B32 (i32 31))), SGPR_32)), sub1)
1243 >;
1244
1245 def : GCNPat<
1246   (i32 (zext i16:$src)),
1247   (S_AND_B32 (S_MOV_B32 (i32 0xffff)), $src)
1248 >;
1249
1250
1251 //===----------------------------------------------------------------------===//
1252 // Target-specific instruction encodings.
1253 //===----------------------------------------------------------------------===//
1254
1255 //===----------------------------------------------------------------------===//
1256 // SOP1 - GFX10.
1257 //===----------------------------------------------------------------------===//
1258
1259 class Select_gfx10<string opName> : SIMCInstr<opName, SIEncodingFamily.GFX10> {
1260   Predicate AssemblerPredicate = isGFX10Plus;
1261   string DecoderNamespace      = "GFX10";
1262 }
1263
1264 multiclass SOP1_Real_gfx10<bits<8> op> {
1265   def _gfx10 : SOP1_Real<op, !cast<SOP1_Pseudo>(NAME)>,
1266                Select_gfx10<!cast<SOP1_Pseudo>(NAME).Mnemonic>;
1267 }
1268
1269 defm S_ANDN1_SAVEEXEC_B64   : SOP1_Real_gfx10<0x037>;
1270 defm S_ORN1_SAVEEXEC_B64    : SOP1_Real_gfx10<0x038>;
1271 defm S_ANDN1_WREXEC_B64     : SOP1_Real_gfx10<0x039>;
1272 defm S_ANDN2_WREXEC_B64     : SOP1_Real_gfx10<0x03a>;
1273 defm S_BITREPLICATE_B64_B32 : SOP1_Real_gfx10<0x03b>;
1274 defm S_AND_SAVEEXEC_B32     : SOP1_Real_gfx10<0x03c>;
1275 defm S_OR_SAVEEXEC_B32      : SOP1_Real_gfx10<0x03d>;
1276 defm S_XOR_SAVEEXEC_B32     : SOP1_Real_gfx10<0x03e>;
1277 defm S_ANDN2_SAVEEXEC_B32   : SOP1_Real_gfx10<0x03f>;
1278 defm S_ORN2_SAVEEXEC_B32    : SOP1_Real_gfx10<0x040>;
1279 defm S_NAND_SAVEEXEC_B32    : SOP1_Real_gfx10<0x041>;
1280 defm S_NOR_SAVEEXEC_B32     : SOP1_Real_gfx10<0x042>;
1281 defm S_XNOR_SAVEEXEC_B32    : SOP1_Real_gfx10<0x043>;
1282 defm S_ANDN1_SAVEEXEC_B32   : SOP1_Real_gfx10<0x044>;
1283 defm S_ORN1_SAVEEXEC_B32    : SOP1_Real_gfx10<0x045>;
1284 defm S_ANDN1_WREXEC_B32     : SOP1_Real_gfx10<0x046>;
1285 defm S_ANDN2_WREXEC_B32     : SOP1_Real_gfx10<0x047>;
1286 defm S_MOVRELSD_2_B32       : SOP1_Real_gfx10<0x049>;
1287
1288 //===----------------------------------------------------------------------===//
1289 // SOP1 - GFX6, GFX7.
1290 //===----------------------------------------------------------------------===//
1291
1292 class Select_gfx6_gfx7<string opName> : SIMCInstr<opName, SIEncodingFamily.SI> {
1293   Predicate AssemblerPredicate = isGFX6GFX7;
1294   string DecoderNamespace      = "GFX6GFX7";
1295 }
1296
1297 multiclass SOP1_Real_gfx6_gfx7<bits<8> op> {
1298   def _gfx6_gfx7 : SOP1_Real<op, !cast<SOP1_Pseudo>(NAME)>,
1299                    Select_gfx6_gfx7<!cast<SOP1_Pseudo>(NAME).Mnemonic>;
1300 }
1301
1302 multiclass SOP1_Real_gfx6_gfx7_gfx10<bits<8> op> :
1303   SOP1_Real_gfx6_gfx7<op>, SOP1_Real_gfx10<op>;
1304
1305 defm S_CBRANCH_JOIN  : SOP1_Real_gfx6_gfx7<0x032>;
1306 defm S_MOV_REGRD_B32 : SOP1_Real_gfx6_gfx7<0x033>;
1307
1308 defm S_MOV_B32            : SOP1_Real_gfx6_gfx7_gfx10<0x003>;
1309 defm S_MOV_B64            : SOP1_Real_gfx6_gfx7_gfx10<0x004>;
1310 defm S_CMOV_B32           : SOP1_Real_gfx6_gfx7_gfx10<0x005>;
1311 defm S_CMOV_B64           : SOP1_Real_gfx6_gfx7_gfx10<0x006>;
1312 defm S_NOT_B32            : SOP1_Real_gfx6_gfx7_gfx10<0x007>;
1313 defm S_NOT_B64            : SOP1_Real_gfx6_gfx7_gfx10<0x008>;
1314 defm S_WQM_B32            : SOP1_Real_gfx6_gfx7_gfx10<0x009>;
1315 defm S_WQM_B64            : SOP1_Real_gfx6_gfx7_gfx10<0x00a>;
1316 defm S_BREV_B32           : SOP1_Real_gfx6_gfx7_gfx10<0x00b>;
1317 defm S_BREV_B64           : SOP1_Real_gfx6_gfx7_gfx10<0x00c>;
1318 defm S_BCNT0_I32_B32      : SOP1_Real_gfx6_gfx7_gfx10<0x00d>;
1319 defm S_BCNT0_I32_B64      : SOP1_Real_gfx6_gfx7_gfx10<0x00e>;
1320 defm S_BCNT1_I32_B32      : SOP1_Real_gfx6_gfx7_gfx10<0x00f>;
1321 defm S_BCNT1_I32_B64      : SOP1_Real_gfx6_gfx7_gfx10<0x010>;
1322 defm S_FF0_I32_B32        : SOP1_Real_gfx6_gfx7_gfx10<0x011>;
1323 defm S_FF0_I32_B64        : SOP1_Real_gfx6_gfx7_gfx10<0x012>;
1324 defm S_FF1_I32_B32        : SOP1_Real_gfx6_gfx7_gfx10<0x013>;
1325 defm S_FF1_I32_B64        : SOP1_Real_gfx6_gfx7_gfx10<0x014>;
1326 defm S_FLBIT_I32_B32      : SOP1_Real_gfx6_gfx7_gfx10<0x015>;
1327 defm S_FLBIT_I32_B64      : SOP1_Real_gfx6_gfx7_gfx10<0x016>;
1328 defm S_FLBIT_I32          : SOP1_Real_gfx6_gfx7_gfx10<0x017>;
1329 defm S_FLBIT_I32_I64      : SOP1_Real_gfx6_gfx7_gfx10<0x018>;
1330 defm S_SEXT_I32_I8        : SOP1_Real_gfx6_gfx7_gfx10<0x019>;
1331 defm S_SEXT_I32_I16       : SOP1_Real_gfx6_gfx7_gfx10<0x01a>;
1332 defm S_BITSET0_B32        : SOP1_Real_gfx6_gfx7_gfx10<0x01b>;
1333 defm S_BITSET0_B64        : SOP1_Real_gfx6_gfx7_gfx10<0x01c>;
1334 defm S_BITSET1_B32        : SOP1_Real_gfx6_gfx7_gfx10<0x01d>;
1335 defm S_BITSET1_B64        : SOP1_Real_gfx6_gfx7_gfx10<0x01e>;
1336 defm S_GETPC_B64          : SOP1_Real_gfx6_gfx7_gfx10<0x01f>;
1337 defm S_SETPC_B64          : SOP1_Real_gfx6_gfx7_gfx10<0x020>;
1338 defm S_SWAPPC_B64         : SOP1_Real_gfx6_gfx7_gfx10<0x021>;
1339 defm S_RFE_B64            : SOP1_Real_gfx6_gfx7_gfx10<0x022>;
1340 defm S_AND_SAVEEXEC_B64   : SOP1_Real_gfx6_gfx7_gfx10<0x024>;
1341 defm S_OR_SAVEEXEC_B64    : SOP1_Real_gfx6_gfx7_gfx10<0x025>;
1342 defm S_XOR_SAVEEXEC_B64   : SOP1_Real_gfx6_gfx7_gfx10<0x026>;
1343 defm S_ANDN2_SAVEEXEC_B64 : SOP1_Real_gfx6_gfx7_gfx10<0x027>;
1344 defm S_ORN2_SAVEEXEC_B64  : SOP1_Real_gfx6_gfx7_gfx10<0x028>;
1345 defm S_NAND_SAVEEXEC_B64  : SOP1_Real_gfx6_gfx7_gfx10<0x029>;
1346 defm S_NOR_SAVEEXEC_B64   : SOP1_Real_gfx6_gfx7_gfx10<0x02a>;
1347 defm S_XNOR_SAVEEXEC_B64  : SOP1_Real_gfx6_gfx7_gfx10<0x02b>;
1348 defm S_QUADMASK_B32       : SOP1_Real_gfx6_gfx7_gfx10<0x02c>;
1349 defm S_QUADMASK_B64       : SOP1_Real_gfx6_gfx7_gfx10<0x02d>;
1350 defm S_MOVRELS_B32        : SOP1_Real_gfx6_gfx7_gfx10<0x02e>;
1351 defm S_MOVRELS_B64        : SOP1_Real_gfx6_gfx7_gfx10<0x02f>;
1352 defm S_MOVRELD_B32        : SOP1_Real_gfx6_gfx7_gfx10<0x030>;
1353 defm S_MOVRELD_B64        : SOP1_Real_gfx6_gfx7_gfx10<0x031>;
1354 defm S_ABS_I32            : SOP1_Real_gfx6_gfx7_gfx10<0x034>;
1355 defm S_MOV_FED_B32        : SOP1_Real_gfx6_gfx7_gfx10<0x035>;
1356
1357 //===----------------------------------------------------------------------===//
1358 // SOP2 - GFX10.
1359 //===----------------------------------------------------------------------===//
1360
1361 multiclass SOP2_Real_gfx10<bits<7> op> {
1362   def _gfx10 : SOP2_Real<op, !cast<SOP2_Pseudo>(NAME)>,
1363                Select_gfx10<!cast<SOP2_Pseudo>(NAME).Mnemonic>;
1364 }
1365
1366 defm S_LSHL1_ADD_U32   : SOP2_Real_gfx10<0x02e>;
1367 defm S_LSHL2_ADD_U32   : SOP2_Real_gfx10<0x02f>;
1368 defm S_LSHL3_ADD_U32   : SOP2_Real_gfx10<0x030>;
1369 defm S_LSHL4_ADD_U32   : SOP2_Real_gfx10<0x031>;
1370 defm S_PACK_LL_B32_B16 : SOP2_Real_gfx10<0x032>;
1371 defm S_PACK_LH_B32_B16 : SOP2_Real_gfx10<0x033>;
1372 defm S_PACK_HH_B32_B16 : SOP2_Real_gfx10<0x034>;
1373 defm S_MUL_HI_U32      : SOP2_Real_gfx10<0x035>;
1374 defm S_MUL_HI_I32      : SOP2_Real_gfx10<0x036>;
1375
1376 //===----------------------------------------------------------------------===//
1377 // SOP2 - GFX6, GFX7.
1378 //===----------------------------------------------------------------------===//
1379
1380 multiclass SOP2_Real_gfx6_gfx7<bits<7> op> {
1381   def _gfx6_gfx7 : SOP2_Real<op, !cast<SOP_Pseudo>(NAME)>,
1382                    Select_gfx6_gfx7<!cast<SOP_Pseudo>(NAME).Mnemonic>;
1383 }
1384
1385 multiclass SOP2_Real_gfx6_gfx7_gfx10<bits<7> op> :
1386   SOP2_Real_gfx6_gfx7<op>, SOP2_Real_gfx10<op>;
1387
1388 defm S_CBRANCH_G_FORK : SOP2_Real_gfx6_gfx7<0x02b>;
1389
1390 defm S_ADD_U32     : SOP2_Real_gfx6_gfx7_gfx10<0x000>;
1391 defm S_SUB_U32     : SOP2_Real_gfx6_gfx7_gfx10<0x001>;
1392 defm S_ADD_I32     : SOP2_Real_gfx6_gfx7_gfx10<0x002>;
1393 defm S_SUB_I32     : SOP2_Real_gfx6_gfx7_gfx10<0x003>;
1394 defm S_ADDC_U32    : SOP2_Real_gfx6_gfx7_gfx10<0x004>;
1395 defm S_SUBB_U32    : SOP2_Real_gfx6_gfx7_gfx10<0x005>;
1396 defm S_MIN_I32     : SOP2_Real_gfx6_gfx7_gfx10<0x006>;
1397 defm S_MIN_U32     : SOP2_Real_gfx6_gfx7_gfx10<0x007>;
1398 defm S_MAX_I32     : SOP2_Real_gfx6_gfx7_gfx10<0x008>;
1399 defm S_MAX_U32     : SOP2_Real_gfx6_gfx7_gfx10<0x009>;
1400 defm S_CSELECT_B32 : SOP2_Real_gfx6_gfx7_gfx10<0x00a>;
1401 defm S_CSELECT_B64 : SOP2_Real_gfx6_gfx7_gfx10<0x00b>;
1402 defm S_AND_B32     : SOP2_Real_gfx6_gfx7_gfx10<0x00e>;
1403 defm S_AND_B64     : SOP2_Real_gfx6_gfx7_gfx10<0x00f>;
1404 defm S_OR_B32      : SOP2_Real_gfx6_gfx7_gfx10<0x010>;
1405 defm S_OR_B64      : SOP2_Real_gfx6_gfx7_gfx10<0x011>;
1406 defm S_XOR_B32     : SOP2_Real_gfx6_gfx7_gfx10<0x012>;
1407 defm S_XOR_B64     : SOP2_Real_gfx6_gfx7_gfx10<0x013>;
1408 defm S_ANDN2_B32   : SOP2_Real_gfx6_gfx7_gfx10<0x014>;
1409 defm S_ANDN2_B64   : SOP2_Real_gfx6_gfx7_gfx10<0x015>;
1410 defm S_ORN2_B32    : SOP2_Real_gfx6_gfx7_gfx10<0x016>;
1411 defm S_ORN2_B64    : SOP2_Real_gfx6_gfx7_gfx10<0x017>;
1412 defm S_NAND_B32    : SOP2_Real_gfx6_gfx7_gfx10<0x018>;
1413 defm S_NAND_B64    : SOP2_Real_gfx6_gfx7_gfx10<0x019>;
1414 defm S_NOR_B32     : SOP2_Real_gfx6_gfx7_gfx10<0x01a>;
1415 defm S_NOR_B64     : SOP2_Real_gfx6_gfx7_gfx10<0x01b>;
1416 defm S_XNOR_B32    : SOP2_Real_gfx6_gfx7_gfx10<0x01c>;
1417 defm S_XNOR_B64    : SOP2_Real_gfx6_gfx7_gfx10<0x01d>;
1418 defm S_LSHL_B32    : SOP2_Real_gfx6_gfx7_gfx10<0x01e>;
1419 defm S_LSHL_B64    : SOP2_Real_gfx6_gfx7_gfx10<0x01f>;
1420 defm S_LSHR_B32    : SOP2_Real_gfx6_gfx7_gfx10<0x020>;
1421 defm S_LSHR_B64    : SOP2_Real_gfx6_gfx7_gfx10<0x021>;
1422 defm S_ASHR_I32    : SOP2_Real_gfx6_gfx7_gfx10<0x022>;
1423 defm S_ASHR_I64    : SOP2_Real_gfx6_gfx7_gfx10<0x023>;
1424 defm S_BFM_B32     : SOP2_Real_gfx6_gfx7_gfx10<0x024>;
1425 defm S_BFM_B64     : SOP2_Real_gfx6_gfx7_gfx10<0x025>;
1426 defm S_MUL_I32     : SOP2_Real_gfx6_gfx7_gfx10<0x026>;
1427 defm S_BFE_U32     : SOP2_Real_gfx6_gfx7_gfx10<0x027>;
1428 defm S_BFE_I32     : SOP2_Real_gfx6_gfx7_gfx10<0x028>;
1429 defm S_BFE_U64     : SOP2_Real_gfx6_gfx7_gfx10<0x029>;
1430 defm S_BFE_I64     : SOP2_Real_gfx6_gfx7_gfx10<0x02a>;
1431 defm S_ABSDIFF_I32 : SOP2_Real_gfx6_gfx7_gfx10<0x02c>;
1432
1433 //===----------------------------------------------------------------------===//
1434 // SOPK - GFX10.
1435 //===----------------------------------------------------------------------===//
1436
1437 multiclass SOPK_Real32_gfx10<bits<5> op> {
1438   def _gfx10 : SOPK_Real32<op, !cast<SOPK_Pseudo>(NAME)>,
1439                Select_gfx10<!cast<SOPK_Pseudo>(NAME).Mnemonic>;
1440 }
1441
1442 multiclass SOPK_Real64_gfx10<bits<5> op> {
1443   def _gfx10 : SOPK_Real64<op, !cast<SOPK_Pseudo>(NAME)>,
1444                Select_gfx10<!cast<SOPK_Pseudo>(NAME).Mnemonic>;
1445 }
1446
1447 defm S_VERSION              : SOPK_Real32_gfx10<0x001>;
1448 defm S_CALL_B64             : SOPK_Real32_gfx10<0x016>;
1449 defm S_WAITCNT_VSCNT        : SOPK_Real32_gfx10<0x017>;
1450 defm S_WAITCNT_VMCNT        : SOPK_Real32_gfx10<0x018>;
1451 defm S_WAITCNT_EXPCNT       : SOPK_Real32_gfx10<0x019>;
1452 defm S_WAITCNT_LGKMCNT      : SOPK_Real32_gfx10<0x01a>;
1453 defm S_SUBVECTOR_LOOP_BEGIN : SOPK_Real32_gfx10<0x01b>;
1454 defm S_SUBVECTOR_LOOP_END   : SOPK_Real32_gfx10<0x01c>;
1455
1456 //===----------------------------------------------------------------------===//
1457 // SOPK - GFX6, GFX7.
1458 //===----------------------------------------------------------------------===//
1459
1460 multiclass SOPK_Real32_gfx6_gfx7<bits<5> op> {
1461   def _gfx6_gfx7 : SOPK_Real32<op, !cast<SOPK_Pseudo>(NAME)>,
1462                    Select_gfx6_gfx7<!cast<SOPK_Pseudo>(NAME).Mnemonic>;
1463 }
1464
1465 multiclass SOPK_Real64_gfx6_gfx7<bits<5> op> {
1466   def _gfx6_gfx7 : SOPK_Real64<op, !cast<SOPK_Pseudo>(NAME)>,
1467                    Select_gfx6_gfx7<!cast<SOPK_Pseudo>(NAME).Mnemonic>;
1468 }
1469
1470 multiclass SOPK_Real32_gfx6_gfx7_gfx10<bits<5> op> :
1471   SOPK_Real32_gfx6_gfx7<op>, SOPK_Real32_gfx10<op>;
1472
1473 multiclass SOPK_Real64_gfx6_gfx7_gfx10<bits<5> op> :
1474   SOPK_Real64_gfx6_gfx7<op>, SOPK_Real64_gfx10<op>;
1475
1476 defm S_CBRANCH_I_FORK : SOPK_Real32_gfx6_gfx7<0x011>;
1477
1478 defm S_MOVK_I32         : SOPK_Real32_gfx6_gfx7_gfx10<0x000>;
1479 defm S_CMOVK_I32        : SOPK_Real32_gfx6_gfx7_gfx10<0x002>;
1480 defm S_CMPK_EQ_I32      : SOPK_Real32_gfx6_gfx7_gfx10<0x003>;
1481 defm S_CMPK_LG_I32      : SOPK_Real32_gfx6_gfx7_gfx10<0x004>;
1482 defm S_CMPK_GT_I32      : SOPK_Real32_gfx6_gfx7_gfx10<0x005>;
1483 defm S_CMPK_GE_I32      : SOPK_Real32_gfx6_gfx7_gfx10<0x006>;
1484 defm S_CMPK_LT_I32      : SOPK_Real32_gfx6_gfx7_gfx10<0x007>;
1485 defm S_CMPK_LE_I32      : SOPK_Real32_gfx6_gfx7_gfx10<0x008>;
1486 defm S_CMPK_EQ_U32      : SOPK_Real32_gfx6_gfx7_gfx10<0x009>;
1487 defm S_CMPK_LG_U32      : SOPK_Real32_gfx6_gfx7_gfx10<0x00a>;
1488 defm S_CMPK_GT_U32      : SOPK_Real32_gfx6_gfx7_gfx10<0x00b>;
1489 defm S_CMPK_GE_U32      : SOPK_Real32_gfx6_gfx7_gfx10<0x00c>;
1490 defm S_CMPK_LT_U32      : SOPK_Real32_gfx6_gfx7_gfx10<0x00d>;
1491 defm S_CMPK_LE_U32      : SOPK_Real32_gfx6_gfx7_gfx10<0x00e>;
1492 defm S_ADDK_I32         : SOPK_Real32_gfx6_gfx7_gfx10<0x00f>;
1493 defm S_MULK_I32         : SOPK_Real32_gfx6_gfx7_gfx10<0x010>;
1494 defm S_GETREG_B32       : SOPK_Real32_gfx6_gfx7_gfx10<0x012>;
1495 defm S_SETREG_B32       : SOPK_Real32_gfx6_gfx7_gfx10<0x013>;
1496 defm S_SETREG_IMM32_B32 : SOPK_Real64_gfx6_gfx7_gfx10<0x015>;
1497
1498 //===----------------------------------------------------------------------===//
1499 // GFX8, GFX9 (VI).
1500 //===----------------------------------------------------------------------===//
1501
1502 class Select_vi<string opName> :
1503   SIMCInstr<opName, SIEncodingFamily.VI> {
1504   list<Predicate> AssemblerPredicates = [isGFX8GFX9];
1505   string DecoderNamespace = "GFX8";
1506 }
1507
1508 class SOP1_Real_vi<bits<8> op, SOP1_Pseudo ps> :
1509   SOP1_Real<op, ps>,
1510   Select_vi<ps.Mnemonic>;
1511
1512
1513 class SOP2_Real_vi<bits<7> op, SOP2_Pseudo ps> :
1514   SOP2_Real<op, ps>,
1515   Select_vi<ps.Mnemonic>;
1516
1517 class SOPK_Real_vi<bits<5> op, SOPK_Pseudo ps> :
1518   SOPK_Real32<op, ps>,
1519   Select_vi<ps.Mnemonic>;
1520
1521 def S_MOV_B32_vi           : SOP1_Real_vi <0x00, S_MOV_B32>;
1522 def S_MOV_B64_vi           : SOP1_Real_vi <0x01, S_MOV_B64>;
1523 def S_CMOV_B32_vi          : SOP1_Real_vi <0x02, S_CMOV_B32>;
1524 def S_CMOV_B64_vi          : SOP1_Real_vi <0x03, S_CMOV_B64>;
1525 def S_NOT_B32_vi           : SOP1_Real_vi <0x04, S_NOT_B32>;
1526 def S_NOT_B64_vi           : SOP1_Real_vi <0x05, S_NOT_B64>;
1527 def S_WQM_B32_vi           : SOP1_Real_vi <0x06, S_WQM_B32>;
1528 def S_WQM_B64_vi           : SOP1_Real_vi <0x07, S_WQM_B64>;
1529 def S_BREV_B32_vi          : SOP1_Real_vi <0x08, S_BREV_B32>;
1530 def S_BREV_B64_vi          : SOP1_Real_vi <0x09, S_BREV_B64>;
1531 def S_BCNT0_I32_B32_vi     : SOP1_Real_vi <0x0a, S_BCNT0_I32_B32>;
1532 def S_BCNT0_I32_B64_vi     : SOP1_Real_vi <0x0b, S_BCNT0_I32_B64>;
1533 def S_BCNT1_I32_B32_vi     : SOP1_Real_vi <0x0c, S_BCNT1_I32_B32>;
1534 def S_BCNT1_I32_B64_vi     : SOP1_Real_vi <0x0d, S_BCNT1_I32_B64>;
1535 def S_FF0_I32_B32_vi       : SOP1_Real_vi <0x0e, S_FF0_I32_B32>;
1536 def S_FF0_I32_B64_vi       : SOP1_Real_vi <0x0f, S_FF0_I32_B64>;
1537 def S_FF1_I32_B32_vi       : SOP1_Real_vi <0x10, S_FF1_I32_B32>;
1538 def S_FF1_I32_B64_vi       : SOP1_Real_vi <0x11, S_FF1_I32_B64>;
1539 def S_FLBIT_I32_B32_vi     : SOP1_Real_vi <0x12, S_FLBIT_I32_B32>;
1540 def S_FLBIT_I32_B64_vi     : SOP1_Real_vi <0x13, S_FLBIT_I32_B64>;
1541 def S_FLBIT_I32_vi         : SOP1_Real_vi <0x14, S_FLBIT_I32>;
1542 def S_FLBIT_I32_I64_vi     : SOP1_Real_vi <0x15, S_FLBIT_I32_I64>;
1543 def S_SEXT_I32_I8_vi       : SOP1_Real_vi <0x16, S_SEXT_I32_I8>;
1544 def S_SEXT_I32_I16_vi      : SOP1_Real_vi <0x17, S_SEXT_I32_I16>;
1545 def S_BITSET0_B32_vi       : SOP1_Real_vi <0x18, S_BITSET0_B32>;
1546 def S_BITSET0_B64_vi       : SOP1_Real_vi <0x19, S_BITSET0_B64>;
1547 def S_BITSET1_B32_vi       : SOP1_Real_vi <0x1a, S_BITSET1_B32>;
1548 def S_BITSET1_B64_vi       : SOP1_Real_vi <0x1b, S_BITSET1_B64>;
1549 def S_GETPC_B64_vi         : SOP1_Real_vi <0x1c, S_GETPC_B64>;
1550 def S_SETPC_B64_vi         : SOP1_Real_vi <0x1d, S_SETPC_B64>;
1551 def S_SWAPPC_B64_vi        : SOP1_Real_vi <0x1e, S_SWAPPC_B64>;
1552 def S_RFE_B64_vi           : SOP1_Real_vi <0x1f, S_RFE_B64>;
1553 def S_AND_SAVEEXEC_B64_vi  : SOP1_Real_vi <0x20, S_AND_SAVEEXEC_B64>;
1554 def S_OR_SAVEEXEC_B64_vi   : SOP1_Real_vi <0x21, S_OR_SAVEEXEC_B64>;
1555 def S_XOR_SAVEEXEC_B64_vi  : SOP1_Real_vi <0x22, S_XOR_SAVEEXEC_B64>;
1556 def S_ANDN2_SAVEEXEC_B64_vi: SOP1_Real_vi <0x23, S_ANDN2_SAVEEXEC_B64>;
1557 def S_ORN2_SAVEEXEC_B64_vi : SOP1_Real_vi <0x24, S_ORN2_SAVEEXEC_B64>;
1558 def S_NAND_SAVEEXEC_B64_vi : SOP1_Real_vi <0x25, S_NAND_SAVEEXEC_B64>;
1559 def S_NOR_SAVEEXEC_B64_vi  : SOP1_Real_vi <0x26, S_NOR_SAVEEXEC_B64>;
1560 def S_XNOR_SAVEEXEC_B64_vi : SOP1_Real_vi <0x27, S_XNOR_SAVEEXEC_B64>;
1561 def S_QUADMASK_B32_vi      : SOP1_Real_vi <0x28, S_QUADMASK_B32>;
1562 def S_QUADMASK_B64_vi      : SOP1_Real_vi <0x29, S_QUADMASK_B64>;
1563 def S_MOVRELS_B32_vi       : SOP1_Real_vi <0x2a, S_MOVRELS_B32>;
1564 def S_MOVRELS_B64_vi       : SOP1_Real_vi <0x2b, S_MOVRELS_B64>;
1565 def S_MOVRELD_B32_vi       : SOP1_Real_vi <0x2c, S_MOVRELD_B32>;
1566 def S_MOVRELD_B64_vi       : SOP1_Real_vi <0x2d, S_MOVRELD_B64>;
1567 def S_CBRANCH_JOIN_vi      : SOP1_Real_vi <0x2e, S_CBRANCH_JOIN>;
1568 def S_MOV_REGRD_B32_vi     : SOP1_Real_vi <0x2f, S_MOV_REGRD_B32>;
1569 def S_ABS_I32_vi           : SOP1_Real_vi <0x30, S_ABS_I32>;
1570 def S_MOV_FED_B32_vi       : SOP1_Real_vi <0x31, S_MOV_FED_B32>;
1571 def S_SET_GPR_IDX_IDX_vi   : SOP1_Real_vi <0x32, S_SET_GPR_IDX_IDX>;
1572
1573 def S_ADD_U32_vi           : SOP2_Real_vi <0x00, S_ADD_U32>;
1574 def S_ADD_I32_vi           : SOP2_Real_vi <0x02, S_ADD_I32>;
1575 def S_SUB_U32_vi           : SOP2_Real_vi <0x01, S_SUB_U32>;
1576 def S_SUB_I32_vi           : SOP2_Real_vi <0x03, S_SUB_I32>;
1577 def S_ADDC_U32_vi          : SOP2_Real_vi <0x04, S_ADDC_U32>;
1578 def S_SUBB_U32_vi          : SOP2_Real_vi <0x05, S_SUBB_U32>;
1579 def S_MIN_I32_vi           : SOP2_Real_vi <0x06, S_MIN_I32>;
1580 def S_MIN_U32_vi           : SOP2_Real_vi <0x07, S_MIN_U32>;
1581 def S_MAX_I32_vi           : SOP2_Real_vi <0x08, S_MAX_I32>;
1582 def S_MAX_U32_vi           : SOP2_Real_vi <0x09, S_MAX_U32>;
1583 def S_CSELECT_B32_vi       : SOP2_Real_vi <0x0a, S_CSELECT_B32>;
1584 def S_CSELECT_B64_vi       : SOP2_Real_vi <0x0b, S_CSELECT_B64>;
1585 def S_AND_B32_vi           : SOP2_Real_vi <0x0c, S_AND_B32>;
1586 def S_AND_B64_vi           : SOP2_Real_vi <0x0d, S_AND_B64>;
1587 def S_OR_B32_vi            : SOP2_Real_vi <0x0e, S_OR_B32>;
1588 def S_OR_B64_vi            : SOP2_Real_vi <0x0f, S_OR_B64>;
1589 def S_XOR_B32_vi           : SOP2_Real_vi <0x10, S_XOR_B32>;
1590 def S_XOR_B64_vi           : SOP2_Real_vi <0x11, S_XOR_B64>;
1591 def S_ANDN2_B32_vi         : SOP2_Real_vi <0x12, S_ANDN2_B32>;
1592 def S_ANDN2_B64_vi         : SOP2_Real_vi <0x13, S_ANDN2_B64>;
1593 def S_ORN2_B32_vi          : SOP2_Real_vi <0x14, S_ORN2_B32>;
1594 def S_ORN2_B64_vi          : SOP2_Real_vi <0x15, S_ORN2_B64>;
1595 def S_NAND_B32_vi          : SOP2_Real_vi <0x16, S_NAND_B32>;
1596 def S_NAND_B64_vi          : SOP2_Real_vi <0x17, S_NAND_B64>;
1597 def S_NOR_B32_vi           : SOP2_Real_vi <0x18, S_NOR_B32>;
1598 def S_NOR_B64_vi           : SOP2_Real_vi <0x19, S_NOR_B64>;
1599 def S_XNOR_B32_vi          : SOP2_Real_vi <0x1a, S_XNOR_B32>;
1600 def S_XNOR_B64_vi          : SOP2_Real_vi <0x1b, S_XNOR_B64>;
1601 def S_LSHL_B32_vi          : SOP2_Real_vi <0x1c, S_LSHL_B32>;
1602 def S_LSHL_B64_vi          : SOP2_Real_vi <0x1d, S_LSHL_B64>;
1603 def S_LSHR_B32_vi          : SOP2_Real_vi <0x1e, S_LSHR_B32>;
1604 def S_LSHR_B64_vi          : SOP2_Real_vi <0x1f, S_LSHR_B64>;
1605 def S_ASHR_I32_vi          : SOP2_Real_vi <0x20, S_ASHR_I32>;
1606 def S_ASHR_I64_vi          : SOP2_Real_vi <0x21, S_ASHR_I64>;
1607 def S_BFM_B32_vi           : SOP2_Real_vi <0x22, S_BFM_B32>;
1608 def S_BFM_B64_vi           : SOP2_Real_vi <0x23, S_BFM_B64>;
1609 def S_MUL_I32_vi           : SOP2_Real_vi <0x24, S_MUL_I32>;
1610 def S_BFE_U32_vi           : SOP2_Real_vi <0x25, S_BFE_U32>;
1611 def S_BFE_I32_vi           : SOP2_Real_vi <0x26, S_BFE_I32>;
1612 def S_BFE_U64_vi           : SOP2_Real_vi <0x27, S_BFE_U64>;
1613 def S_BFE_I64_vi           : SOP2_Real_vi <0x28, S_BFE_I64>;
1614 def S_CBRANCH_G_FORK_vi    : SOP2_Real_vi <0x29, S_CBRANCH_G_FORK>;
1615 def S_ABSDIFF_I32_vi       : SOP2_Real_vi <0x2a, S_ABSDIFF_I32>;
1616 def S_PACK_LL_B32_B16_vi   : SOP2_Real_vi <0x32, S_PACK_LL_B32_B16>;
1617 def S_PACK_LH_B32_B16_vi   : SOP2_Real_vi <0x33, S_PACK_LH_B32_B16>;
1618 def S_PACK_HH_B32_B16_vi   : SOP2_Real_vi <0x34, S_PACK_HH_B32_B16>;
1619 def S_RFE_RESTORE_B64_vi   : SOP2_Real_vi <0x2b, S_RFE_RESTORE_B64>;
1620
1621 def S_MOVK_I32_vi          : SOPK_Real_vi <0x00, S_MOVK_I32>;
1622 def S_CMOVK_I32_vi         : SOPK_Real_vi <0x01, S_CMOVK_I32>;
1623 def S_CMPK_EQ_I32_vi       : SOPK_Real_vi <0x02, S_CMPK_EQ_I32>;
1624 def S_CMPK_LG_I32_vi       : SOPK_Real_vi <0x03, S_CMPK_LG_I32>;
1625 def S_CMPK_GT_I32_vi       : SOPK_Real_vi <0x04, S_CMPK_GT_I32>;
1626 def S_CMPK_GE_I32_vi       : SOPK_Real_vi <0x05, S_CMPK_GE_I32>;
1627 def S_CMPK_LT_I32_vi       : SOPK_Real_vi <0x06, S_CMPK_LT_I32>;
1628 def S_CMPK_LE_I32_vi       : SOPK_Real_vi <0x07, S_CMPK_LE_I32>;
1629 def S_CMPK_EQ_U32_vi       : SOPK_Real_vi <0x08, S_CMPK_EQ_U32>;
1630 def S_CMPK_LG_U32_vi       : SOPK_Real_vi <0x09, S_CMPK_LG_U32>;
1631 def S_CMPK_GT_U32_vi       : SOPK_Real_vi <0x0A, S_CMPK_GT_U32>;
1632 def S_CMPK_GE_U32_vi       : SOPK_Real_vi <0x0B, S_CMPK_GE_U32>;
1633 def S_CMPK_LT_U32_vi       : SOPK_Real_vi <0x0C, S_CMPK_LT_U32>;
1634 def S_CMPK_LE_U32_vi       : SOPK_Real_vi <0x0D, S_CMPK_LE_U32>;
1635 def S_ADDK_I32_vi          : SOPK_Real_vi <0x0E, S_ADDK_I32>;
1636 def S_MULK_I32_vi          : SOPK_Real_vi <0x0F, S_MULK_I32>;
1637 def S_CBRANCH_I_FORK_vi    : SOPK_Real_vi <0x10, S_CBRANCH_I_FORK>;
1638 def S_GETREG_B32_vi        : SOPK_Real_vi <0x11, S_GETREG_B32>;
1639 def S_SETREG_B32_vi        : SOPK_Real_vi <0x12, S_SETREG_B32>;
1640 //def S_GETREG_REGRD_B32_vi  : SOPK_Real_vi <0x13, S_GETREG_REGRD_B32>; // see pseudo for comments
1641 def S_SETREG_IMM32_B32_vi  : SOPK_Real64<0x14, S_SETREG_IMM32_B32>,
1642                              Select_vi<S_SETREG_IMM32_B32.Mnemonic>;
1643
1644 def S_CALL_B64_vi          : SOPK_Real_vi <0x15, S_CALL_B64>;
1645
1646 //===----------------------------------------------------------------------===//
1647 // SOP1 - GFX9.
1648 //===----------------------------------------------------------------------===//
1649
1650 def S_ANDN1_SAVEEXEC_B64_vi   : SOP1_Real_vi<0x33, S_ANDN1_SAVEEXEC_B64>;
1651 def S_ORN1_SAVEEXEC_B64_vi    : SOP1_Real_vi<0x34, S_ORN1_SAVEEXEC_B64>;
1652 def S_ANDN1_WREXEC_B64_vi     : SOP1_Real_vi<0x35, S_ANDN1_WREXEC_B64>;
1653 def S_ANDN2_WREXEC_B64_vi     : SOP1_Real_vi<0x36, S_ANDN2_WREXEC_B64>;
1654 def S_BITREPLICATE_B64_B32_vi : SOP1_Real_vi<0x37, S_BITREPLICATE_B64_B32>;
1655
1656 //===----------------------------------------------------------------------===//
1657 // SOP2 - GFX9.
1658 //===----------------------------------------------------------------------===//
1659
1660 def S_LSHL1_ADD_U32_vi   : SOP2_Real_vi<0x2e, S_LSHL1_ADD_U32>;
1661 def S_LSHL2_ADD_U32_vi   : SOP2_Real_vi<0x2f, S_LSHL2_ADD_U32>;
1662 def S_LSHL3_ADD_U32_vi   : SOP2_Real_vi<0x30, S_LSHL3_ADD_U32>;
1663 def S_LSHL4_ADD_U32_vi   : SOP2_Real_vi<0x31, S_LSHL4_ADD_U32>;
1664 def S_MUL_HI_U32_vi      : SOP2_Real_vi<0x2c, S_MUL_HI_U32>;
1665 def S_MUL_HI_I32_vi      : SOP2_Real_vi<0x2d, S_MUL_HI_I32>;