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