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