1 //===-- SOPInstructions.td - SOP Instruction Defintions -------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 def GPRIdxModeMatchClass : AsmOperandClass {
11 let Name = "GPRIdxMode";
12 let PredicateMethod = "isGPRIdxMode";
13 let RenderMethod = "addImmOperands";
16 def GPRIdxMode : Operand<i32> {
17 let PrintMethod = "printVGPRIndexMode";
18 let ParserMatchClass = GPRIdxModeMatchClass;
19 let OperandType = "OPERAND_IMMEDIATE";
22 class SOP_Pseudo<string opName, dag outs, dag ins, string asmOps,
23 list<dag> pattern=[]> :
24 InstSI<outs, ins, "", pattern>,
25 SIMCInstr<opName, SIEncodingFamily.NONE> {
28 let isCodeGenOnly = 1;
29 let SubtargetPredicate = isGCN;
31 string Mnemonic = opName;
32 string AsmOperands = asmOps;
37 //===----------------------------------------------------------------------===//
39 //===----------------------------------------------------------------------===//
41 class SOP1_Pseudo <string opName, dag outs, dag ins,
42 string asmOps, list<dag> pattern=[]> :
43 SOP_Pseudo<opName, outs, ins, asmOps, pattern> {
47 let hasSideEffects = 0;
50 let SchedRW = [WriteSALU];
52 let UseNamedOperandTable = 1;
58 class SOP1_Real<bits<8> op, SOP1_Pseudo ps> :
59 InstSI <ps.OutOperandList, ps.InOperandList,
60 ps.Mnemonic # " " # ps.AsmOperands, []>,
64 let isCodeGenOnly = 0;
67 // copy relevant pseudo op flags
68 let SubtargetPredicate = ps.SubtargetPredicate;
69 let AsmMatchConverter = ps.AsmMatchConverter;
75 let Inst{7-0} = !if(ps.has_src0, src0, ?);
77 let Inst{22-16} = !if(ps.has_sdst, sdst, ?);
78 let Inst{31-23} = 0x17d; //encoding;
81 class SOP1_32 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
82 opName, (outs SReg_32:$sdst), (ins SSrc_b32:$src0),
83 "$sdst, $src0", pattern
86 // 32-bit input, no output.
87 class SOP1_0_32 <string opName, list<dag> pattern = []> : SOP1_Pseudo <
88 opName, (outs), (ins SSrc_b32:$src0),
93 class SOP1_0_32R <string opName, list<dag> pattern = []> : SOP1_Pseudo <
94 opName, (outs), (ins SReg_32:$src0),
99 class SOP1_64 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
100 opName, (outs SReg_64:$sdst), (ins SSrc_b64:$src0),
101 "$sdst, $src0", pattern
104 // 64-bit input, 32-bit output.
105 class SOP1_32_64 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
106 opName, (outs SReg_32:$sdst), (ins SSrc_b64:$src0),
107 "$sdst, $src0", pattern
110 // 32-bit input, 64-bit output.
111 class SOP1_64_32 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
112 opName, (outs SReg_64:$sdst), (ins SSrc_b32:$src0),
113 "$sdst, $src0", pattern
116 // no input, 64-bit output.
117 class SOP1_64_0 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
118 opName, (outs SReg_64:$sdst), (ins), "$sdst", pattern> {
122 // 64-bit input, no output
123 class SOP1_1 <string opName, list<dag> pattern=[]> : SOP1_Pseudo <
124 opName, (outs), (ins SReg_64:$src0), "$src0", pattern> {
129 let isMoveImm = 1 in {
130 let isReMaterializable = 1, isAsCheapAsAMove = 1 in {
131 def S_MOV_B32 : SOP1_32 <"s_mov_b32">;
132 def S_MOV_B64 : SOP1_64 <"s_mov_b64">;
133 } // End isRematerializeable = 1
135 let Uses = [SCC] in {
136 def S_CMOV_B32 : SOP1_32 <"s_cmov_b32">;
137 def S_CMOV_B64 : SOP1_64 <"s_cmov_b64">;
138 } // End Uses = [SCC]
139 } // End isMoveImm = 1
141 let Defs = [SCC] in {
142 def S_NOT_B32 : SOP1_32 <"s_not_b32",
143 [(set i32:$sdst, (not i32:$src0))]
146 def S_NOT_B64 : SOP1_64 <"s_not_b64",
147 [(set i64:$sdst, (not i64:$src0))]
149 def S_WQM_B32 : SOP1_32 <"s_wqm_b32">;
150 def S_WQM_B64 : SOP1_64 <"s_wqm_b64",
151 [(set i1:$sdst, (int_amdgcn_wqm_vote i1:$src0))]
153 } // End Defs = [SCC]
156 def S_BREV_B32 : SOP1_32 <"s_brev_b32",
157 [(set i32:$sdst, (bitreverse i32:$src0))]
159 def S_BREV_B64 : SOP1_64 <"s_brev_b64">;
161 let Defs = [SCC] in {
162 def S_BCNT0_I32_B32 : SOP1_32 <"s_bcnt0_i32_b32">;
163 def S_BCNT0_I32_B64 : SOP1_32_64 <"s_bcnt0_i32_b64">;
164 def S_BCNT1_I32_B32 : SOP1_32 <"s_bcnt1_i32_b32",
165 [(set i32:$sdst, (ctpop i32:$src0))]
167 def S_BCNT1_I32_B64 : SOP1_32_64 <"s_bcnt1_i32_b64">;
168 } // End Defs = [SCC]
170 def S_FF0_I32_B32 : SOP1_32 <"s_ff0_i32_b32">;
171 def S_FF0_I32_B64 : SOP1_32_64 <"s_ff0_i32_b64">;
172 def S_FF1_I32_B64 : SOP1_32_64 <"s_ff1_i32_b64">;
174 def S_FF1_I32_B32 : SOP1_32 <"s_ff1_i32_b32",
175 [(set i32:$sdst, (AMDGPUffbl_b32 i32:$src0))]
178 def S_FLBIT_I32_B32 : SOP1_32 <"s_flbit_i32_b32",
179 [(set i32:$sdst, (AMDGPUffbh_u32 i32:$src0))]
182 def S_FLBIT_I32_B64 : SOP1_32_64 <"s_flbit_i32_b64">;
183 def S_FLBIT_I32 : SOP1_32 <"s_flbit_i32",
184 [(set i32:$sdst, (AMDGPUffbh_i32 i32:$src0))]
186 def S_FLBIT_I32_I64 : SOP1_32_64 <"s_flbit_i32_i64">;
187 def S_SEXT_I32_I8 : SOP1_32 <"s_sext_i32_i8",
188 [(set i32:$sdst, (sext_inreg i32:$src0, i8))]
190 def S_SEXT_I32_I16 : SOP1_32 <"s_sext_i32_i16",
191 [(set i32:$sdst, (sext_inreg i32:$src0, i16))]
194 def S_BITSET0_B32 : SOP1_32 <"s_bitset0_b32">;
195 def S_BITSET0_B64 : SOP1_64_32 <"s_bitset0_b64">;
196 def S_BITSET1_B32 : SOP1_32 <"s_bitset1_b32">;
197 def S_BITSET1_B64 : SOP1_64_32 <"s_bitset1_b64">;
198 def S_GETPC_B64 : SOP1_64_0 <"s_getpc_b64",
199 [(set i64:$sdst, (int_amdgcn_s_getpc))]
202 let isTerminator = 1, isBarrier = 1, SchedRW = [WriteBranch] in {
204 let isBranch = 1, isIndirectBranch = 1 in {
205 def S_SETPC_B64 : SOP1_1 <"s_setpc_b64">;
206 } // End isBranch = 1, isIndirectBranch = 1
208 let isReturn = 1 in {
209 // Define variant marked as return rather than branch.
210 def S_SETPC_B64_return : SOP1_1<"", [(AMDGPUret_flag i64:$src0)]>;
212 } // End isTerminator = 1, isBarrier = 1
215 def S_SWAPPC_B64 : SOP1_64 <"s_swappc_b64"
219 def S_RFE_B64 : SOP1_1 <"s_rfe_b64">;
221 let hasSideEffects = 1, Uses = [EXEC], Defs = [EXEC, SCC] in {
223 def S_AND_SAVEEXEC_B64 : SOP1_64 <"s_and_saveexec_b64">;
224 def S_OR_SAVEEXEC_B64 : SOP1_64 <"s_or_saveexec_b64">;
225 def S_XOR_SAVEEXEC_B64 : SOP1_64 <"s_xor_saveexec_b64">;
226 def S_ANDN2_SAVEEXEC_B64 : SOP1_64 <"s_andn2_saveexec_b64">;
227 def S_ORN2_SAVEEXEC_B64 : SOP1_64 <"s_orn2_saveexec_b64">;
228 def S_NAND_SAVEEXEC_B64 : SOP1_64 <"s_nand_saveexec_b64">;
229 def S_NOR_SAVEEXEC_B64 : SOP1_64 <"s_nor_saveexec_b64">;
230 def S_XNOR_SAVEEXEC_B64 : SOP1_64 <"s_xnor_saveexec_b64">;
232 } // End hasSideEffects = 1, Uses = [EXEC], Defs = [EXEC, SCC]
234 def S_QUADMASK_B32 : SOP1_32 <"s_quadmask_b32">;
235 def S_QUADMASK_B64 : SOP1_64 <"s_quadmask_b64">;
238 def S_MOVRELS_B32 : SOP1_32 <"s_movrels_b32">;
239 def S_MOVRELS_B64 : SOP1_64 <"s_movrels_b64">;
240 def S_MOVRELD_B32 : SOP1_32 <"s_movreld_b32">;
241 def S_MOVRELD_B64 : SOP1_64 <"s_movreld_b64">;
244 def S_CBRANCH_JOIN : SOP1_0_32R <"s_cbranch_join">;
245 def S_MOV_REGRD_B32 : SOP1_32 <"s_mov_regrd_b32">;
246 let Defs = [SCC] in {
247 def S_ABS_I32 : SOP1_32 <"s_abs_i32">;
248 } // End Defs = [SCC]
249 def S_MOV_FED_B32 : SOP1_32 <"s_mov_fed_b32">;
251 let SubtargetPredicate = HasVGPRIndexMode in {
252 def S_SET_GPR_IDX_IDX : SOP1_0_32<"s_set_gpr_idx_idx"> {
258 let SubtargetPredicate = isGFX9 in {
259 let hasSideEffects = 1, Defs = [EXEC, SCC], Uses = [EXEC] in {
260 def S_ANDN1_SAVEEXEC_B64 : SOP1_64<"s_andn1_saveexec_b64">;
261 def S_ORN1_SAVEEXEC_B64 : SOP1_64<"s_orn1_saveexec_b64">;
262 def S_ANDN1_WREXEC_B64 : SOP1_64<"s_andn1_wrexec_b64">;
263 def S_ANDN2_WREXEC_B64 : SOP1_64<"s_andn2_wrexec_b64">;
264 } // End hasSideEffects = 1, Defs = [EXEC, SCC], Uses = [EXEC]
266 def S_BITREPLICATE_B64_B32 : SOP1_64_32<"s_bitreplicate_b64_b32">;
267 } // End SubtargetPredicate = isGFX9
269 //===----------------------------------------------------------------------===//
271 //===----------------------------------------------------------------------===//
273 class SOP2_Pseudo<string opName, dag outs, dag ins,
274 string asmOps, list<dag> pattern=[]> :
275 SOP_Pseudo<opName, outs, ins, asmOps, pattern> {
279 let hasSideEffects = 0;
282 let SchedRW = [WriteSALU];
283 let UseNamedOperandTable = 1;
287 // Pseudo instructions have no encodings, but adding this field here allows
289 // let sdst = xxx in {
290 // for multiclasses that include both real and pseudo instructions.
291 // field bits<7> sdst = 0;
292 // let Size = 4; // Do we need size here?
295 class SOP2_Real<bits<7> op, SOP_Pseudo ps> :
296 InstSI <ps.OutOperandList, ps.InOperandList,
297 ps.Mnemonic # " " # ps.AsmOperands, []>,
300 let isCodeGenOnly = 0;
302 // copy relevant pseudo op flags
303 let SubtargetPredicate = ps.SubtargetPredicate;
304 let AsmMatchConverter = ps.AsmMatchConverter;
311 let Inst{7-0} = src0;
312 let Inst{15-8} = src1;
313 let Inst{22-16} = !if(ps.has_sdst, sdst, ?);
314 let Inst{29-23} = op;
315 let Inst{31-30} = 0x2; // encoding
319 class SOP2_32 <string opName, list<dag> pattern=[]> : SOP2_Pseudo <
320 opName, (outs SReg_32:$sdst), (ins SSrc_b32:$src0, SSrc_b32:$src1),
321 "$sdst, $src0, $src1", pattern
324 class SOP2_64 <string opName, list<dag> pattern=[]> : SOP2_Pseudo <
325 opName, (outs SReg_64:$sdst), (ins SSrc_b64:$src0, SSrc_b64:$src1),
326 "$sdst, $src0, $src1", pattern
329 class SOP2_64_32 <string opName, list<dag> pattern=[]> : SOP2_Pseudo <
330 opName, (outs SReg_64:$sdst), (ins SSrc_b64:$src0, SSrc_b32:$src1),
331 "$sdst, $src0, $src1", pattern
334 class SOP2_64_32_32 <string opName, list<dag> pattern=[]> : SOP2_Pseudo <
335 opName, (outs SReg_64:$sdst), (ins SSrc_b32:$src0, SSrc_b32:$src1),
336 "$sdst, $src0, $src1", pattern
339 let Defs = [SCC] in { // Carry out goes to SCC
340 let isCommutable = 1 in {
341 def S_ADD_U32 : SOP2_32 <"s_add_u32">;
342 def S_ADD_I32 : SOP2_32 <"s_add_i32",
343 [(set i32:$sdst, (add SSrc_b32:$src0, SSrc_b32:$src1))]
345 } // End isCommutable = 1
347 def S_SUB_U32 : SOP2_32 <"s_sub_u32">;
348 def S_SUB_I32 : SOP2_32 <"s_sub_i32",
349 [(set i32:$sdst, (sub SSrc_b32:$src0, SSrc_b32:$src1))]
352 let Uses = [SCC] in { // Carry in comes from SCC
353 let isCommutable = 1 in {
354 def S_ADDC_U32 : SOP2_32 <"s_addc_u32",
355 [(set i32:$sdst, (adde (i32 SSrc_b32:$src0), (i32 SSrc_b32:$src1)))]>;
356 } // End isCommutable = 1
358 def S_SUBB_U32 : SOP2_32 <"s_subb_u32",
359 [(set i32:$sdst, (sube (i32 SSrc_b32:$src0), (i32 SSrc_b32:$src1)))]>;
360 } // End Uses = [SCC]
363 let isCommutable = 1 in {
364 def S_MIN_I32 : SOP2_32 <"s_min_i32",
365 [(set i32:$sdst, (smin i32:$src0, i32:$src1))]
367 def S_MIN_U32 : SOP2_32 <"s_min_u32",
368 [(set i32:$sdst, (umin i32:$src0, i32:$src1))]
370 def S_MAX_I32 : SOP2_32 <"s_max_i32",
371 [(set i32:$sdst, (smax i32:$src0, i32:$src1))]
373 def S_MAX_U32 : SOP2_32 <"s_max_u32",
374 [(set i32:$sdst, (umax i32:$src0, i32:$src1))]
376 } // End isCommutable = 1
377 } // End Defs = [SCC]
380 let Uses = [SCC] in {
381 def S_CSELECT_B32 : SOP2_32 <"s_cselect_b32">;
382 def S_CSELECT_B64 : SOP2_64 <"s_cselect_b64">;
383 } // End Uses = [SCC]
385 let Defs = [SCC] in {
386 let isCommutable = 1 in {
387 def S_AND_B32 : SOP2_32 <"s_and_b32",
388 [(set i32:$sdst, (and i32:$src0, i32:$src1))]
391 def S_AND_B64 : SOP2_64 <"s_and_b64",
392 [(set i64:$sdst, (and i64:$src0, i64:$src1))]
395 def S_OR_B32 : SOP2_32 <"s_or_b32",
396 [(set i32:$sdst, (or i32:$src0, i32:$src1))]
399 def S_OR_B64 : SOP2_64 <"s_or_b64",
400 [(set i64:$sdst, (or i64:$src0, i64:$src1))]
403 def S_XOR_B32 : SOP2_32 <"s_xor_b32",
404 [(set i32:$sdst, (xor i32:$src0, i32:$src1))]
407 def S_XOR_B64 : SOP2_64 <"s_xor_b64",
408 [(set i64:$sdst, (xor i64:$src0, i64:$src1))]
411 def S_XNOR_B32 : SOP2_32 <"s_xnor_b32",
412 [(set i32:$sdst, (not (xor_oneuse i32:$src0, i32:$src1)))]
415 def S_XNOR_B64 : SOP2_64 <"s_xnor_b64",
416 [(set i64:$sdst, (not (xor_oneuse i64:$src0, i64:$src1)))]
418 } // End isCommutable = 1
420 def S_ANDN2_B32 : SOP2_32 <"s_andn2_b32">;
421 def S_ANDN2_B64 : SOP2_64 <"s_andn2_b64">;
422 def S_ORN2_B32 : SOP2_32 <"s_orn2_b32">;
423 def S_ORN2_B64 : SOP2_64 <"s_orn2_b64">;
424 def S_NAND_B32 : SOP2_32 <"s_nand_b32">;
425 def S_NAND_B64 : SOP2_64 <"s_nand_b64">;
426 def S_NOR_B32 : SOP2_32 <"s_nor_b32">;
427 def S_NOR_B64 : SOP2_64 <"s_nor_b64">;
428 } // End Defs = [SCC]
430 // Use added complexity so these patterns are preferred to the VALU patterns.
431 let AddedComplexity = 1 in {
433 let Defs = [SCC] in {
434 def S_LSHL_B32 : SOP2_32 <"s_lshl_b32",
435 [(set i32:$sdst, (shl i32:$src0, i32:$src1))]
437 def S_LSHL_B64 : SOP2_64_32 <"s_lshl_b64",
438 [(set i64:$sdst, (shl i64:$src0, i32:$src1))]
440 def S_LSHR_B32 : SOP2_32 <"s_lshr_b32",
441 [(set i32:$sdst, (srl i32:$src0, i32:$src1))]
443 def S_LSHR_B64 : SOP2_64_32 <"s_lshr_b64",
444 [(set i64:$sdst, (srl i64:$src0, i32:$src1))]
446 def S_ASHR_I32 : SOP2_32 <"s_ashr_i32",
447 [(set i32:$sdst, (sra i32:$src0, i32:$src1))]
449 def S_ASHR_I64 : SOP2_64_32 <"s_ashr_i64",
450 [(set i64:$sdst, (sra i64:$src0, i32:$src1))]
452 } // End Defs = [SCC]
454 def S_BFM_B32 : SOP2_32 <"s_bfm_b32",
455 [(set i32:$sdst, (AMDGPUbfm i32:$src0, i32:$src1))]>;
456 def S_BFM_B64 : SOP2_64_32_32 <"s_bfm_b64">;
457 def S_MUL_I32 : SOP2_32 <"s_mul_i32",
458 [(set i32:$sdst, (mul i32:$src0, i32:$src1))]> {
459 let isCommutable = 1;
462 } // End AddedComplexity = 1
464 let Defs = [SCC] in {
465 def S_BFE_U32 : SOP2_32 <"s_bfe_u32">;
466 def S_BFE_I32 : SOP2_32 <"s_bfe_i32">;
467 def S_BFE_U64 : SOP2_64_32 <"s_bfe_u64">;
468 def S_BFE_I64 : SOP2_64_32 <"s_bfe_i64">;
469 } // End Defs = [SCC]
471 def S_CBRANCH_G_FORK : SOP2_Pseudo <
472 "s_cbranch_g_fork", (outs),
473 (ins SCSrc_b64:$src0, SCSrc_b64:$src1),
479 let Defs = [SCC] in {
480 def S_ABSDIFF_I32 : SOP2_32 <"s_absdiff_i32">;
481 } // End Defs = [SCC]
483 let SubtargetPredicate = isVI in {
484 def S_RFE_RESTORE_B64 : SOP2_Pseudo <
485 "s_rfe_restore_b64", (outs),
486 (ins SSrc_b64:$src0, SSrc_b32:$src1),
489 let hasSideEffects = 1;
494 let SubtargetPredicate = isGFX9 in {
495 def S_PACK_LL_B32_B16 : SOP2_32<"s_pack_ll_b32_b16">;
496 def S_PACK_LH_B32_B16 : SOP2_32<"s_pack_lh_b32_b16">;
497 def S_PACK_HH_B32_B16 : SOP2_32<"s_pack_hh_b32_b16">;
499 let Defs = [SCC] in {
500 def S_LSHL1_ADD_U32 : SOP2_32<"s_lshl1_add_u32">;
501 def S_LSHL2_ADD_U32 : SOP2_32<"s_lshl2_add_u32">;
502 def S_LSHL3_ADD_U32 : SOP2_32<"s_lshl3_add_u32">;
503 def S_LSHL4_ADD_U32 : SOP2_32<"s_lshl4_add_u32">;
504 } // End Defs = [SCC]
506 def S_MUL_HI_U32 : SOP2_32<"s_mul_hi_u32">;
507 def S_MUL_HI_I32 : SOP2_32<"s_mul_hi_i32">;
510 //===----------------------------------------------------------------------===//
512 //===----------------------------------------------------------------------===//
514 class SOPK_Pseudo <string opName, dag outs, dag ins,
515 string asmOps, list<dag> pattern=[]> :
516 InstSI <outs, ins, "", pattern>,
517 SIMCInstr<opName, SIEncodingFamily.NONE> {
519 let isCodeGenOnly = 1;
520 let SubtargetPredicate = isGCN;
523 let hasSideEffects = 0;
526 let SchedRW = [WriteSALU];
527 let UseNamedOperandTable = 1;
528 string Mnemonic = opName;
529 string AsmOperands = asmOps;
531 bits<1> has_sdst = 1;
534 class SOPK_Real<bits<5> op, SOPK_Pseudo ps> :
535 InstSI <ps.OutOperandList, ps.InOperandList,
536 ps.Mnemonic # " " # ps.AsmOperands, []> {
538 let isCodeGenOnly = 0;
540 // copy relevant pseudo op flags
541 let SubtargetPredicate = ps.SubtargetPredicate;
542 let AsmMatchConverter = ps.AsmMatchConverter;
543 let DisableEncoding = ps.DisableEncoding;
544 let Constraints = ps.Constraints;
552 class SOPK_Real32<bits<5> op, SOPK_Pseudo ps> :
555 let Inst{15-0} = simm16;
556 let Inst{22-16} = !if(ps.has_sdst, sdst, ?);
557 let Inst{27-23} = op;
558 let Inst{31-28} = 0xb; //encoding
561 class SOPK_Real64<bits<5> op, SOPK_Pseudo ps> :
564 let Inst{15-0} = simm16;
565 let Inst{22-16} = !if(ps.has_sdst, sdst, ?);
566 let Inst{27-23} = op;
567 let Inst{31-28} = 0xb; //encoding
568 let Inst{63-32} = imm;
571 class SOPKInstTable <bit is_sopk, string cmpOp = ""> {
572 bit IsSOPK = is_sopk;
573 string BaseCmpOp = cmpOp;
576 class SOPK_32 <string opName, list<dag> pattern=[]> : SOPK_Pseudo <
578 (outs SReg_32:$sdst),
579 (ins s16imm:$simm16),
583 class SOPK_SCC <string opName, string base_op, bit isSignExt> : SOPK_Pseudo <
587 (ins SReg_32:$sdst, s16imm:$simm16),
588 (ins SReg_32:$sdst, u16imm:$simm16)),
589 "$sdst, $simm16", []>,
590 SOPKInstTable<1, base_op>{
594 class SOPK_32TIE <string opName, list<dag> pattern=[]> : SOPK_Pseudo <
596 (outs SReg_32:$sdst),
597 (ins SReg_32:$src0, s16imm:$simm16),
602 let isReMaterializable = 1, isMoveImm = 1 in {
603 def S_MOVK_I32 : SOPK_32 <"s_movk_i32">;
604 } // End isReMaterializable = 1
605 let Uses = [SCC] in {
606 def S_CMOVK_I32 : SOPK_32 <"s_cmovk_i32">;
609 let isCompare = 1 in {
611 // This instruction is disabled for now until we can figure out how to teach
612 // the instruction selector to correctly use the S_CMP* vs V_CMP*
615 // When this instruction is enabled the code generator sometimes produces this
618 // SCC = S_CMPK_EQ_I32 SGPR0, imm
620 // VGPR0 = V_CNDMASK VCC, VGPR0, VGPR1
622 // def S_CMPK_EQ_I32 : SOPK_SCC <"s_cmpk_eq_i32",
623 // [(set i1:$dst, (setcc i32:$src0, imm:$src1, SETEQ))]
626 def S_CMPK_EQ_I32 : SOPK_SCC <"s_cmpk_eq_i32", "s_cmp_eq_i32", 1>;
627 def S_CMPK_LG_I32 : SOPK_SCC <"s_cmpk_lg_i32", "s_cmp_lg_i32", 1>;
628 def S_CMPK_GT_I32 : SOPK_SCC <"s_cmpk_gt_i32", "s_cmp_gt_i32", 1>;
629 def S_CMPK_GE_I32 : SOPK_SCC <"s_cmpk_ge_i32", "s_cmp_ge_i32", 1>;
630 def S_CMPK_LT_I32 : SOPK_SCC <"s_cmpk_lt_i32", "s_cmp_lt_i32", 1>;
631 def S_CMPK_LE_I32 : SOPK_SCC <"s_cmpk_le_i32", "s_cmp_le_i32", 1>;
633 let SOPKZext = 1 in {
634 def S_CMPK_EQ_U32 : SOPK_SCC <"s_cmpk_eq_u32", "s_cmp_eq_u32", 0>;
635 def S_CMPK_LG_U32 : SOPK_SCC <"s_cmpk_lg_u32", "s_cmp_lg_u32", 0>;
636 def S_CMPK_GT_U32 : SOPK_SCC <"s_cmpk_gt_u32", "s_cmp_gt_u32", 0>;
637 def S_CMPK_GE_U32 : SOPK_SCC <"s_cmpk_ge_u32", "s_cmp_ge_u32", 0>;
638 def S_CMPK_LT_U32 : SOPK_SCC <"s_cmpk_lt_u32", "s_cmp_lt_u32", 0>;
639 def S_CMPK_LE_U32 : SOPK_SCC <"s_cmpk_le_u32", "s_cmp_le_u32", 0>;
640 } // End SOPKZext = 1
641 } // End isCompare = 1
643 let Defs = [SCC], isCommutable = 1, DisableEncoding = "$src0",
644 Constraints = "$sdst = $src0" in {
645 def S_ADDK_I32 : SOPK_32TIE <"s_addk_i32">;
646 def S_MULK_I32 : SOPK_32TIE <"s_mulk_i32">;
649 def S_CBRANCH_I_FORK : SOPK_Pseudo <
651 (outs), (ins SReg_64:$sdst, s16imm:$simm16),
656 def S_GETREG_B32 : SOPK_Pseudo <
658 (outs SReg_32:$sdst), (ins hwreg:$simm16),
663 let hasSideEffects = 1 in {
665 def S_SETREG_B32 : SOPK_Pseudo <
667 (outs), (ins SReg_32:$sdst, hwreg:$simm16),
669 [(AMDGPUsetreg i32:$sdst, (i16 timm:$simm16))]
673 //def S_GETREG_REGRD_B32 : SOPK_32 <sopk<0x14, 0x13>, "s_getreg_regrd_b32">;
675 def S_SETREG_IMM32_B32 : SOPK_Pseudo <
676 "s_setreg_imm32_b32",
677 (outs), (ins i32imm:$imm, hwreg:$simm16),
679 let Size = 8; // Unlike every other SOPK instruction.
683 } // End hasSideEffects = 1
685 let SubtargetPredicate = isGFX9 in {
686 def S_CALL_B64 : SOPK_Pseudo<
688 (outs SReg_64:$sdst),
689 (ins s16imm:$simm16),
695 //===----------------------------------------------------------------------===//
697 //===----------------------------------------------------------------------===//
699 class SOPCe <bits<7> op> : Enc32 {
703 let Inst{7-0} = src0;
704 let Inst{15-8} = src1;
705 let Inst{22-16} = op;
706 let Inst{31-23} = 0x17e;
709 class SOPC <bits<7> op, dag outs, dag ins, string asm,
710 list<dag> pattern = []> :
711 InstSI<outs, ins, asm, pattern>, SOPCe <op> {
714 let hasSideEffects = 0;
717 let isCodeGenOnly = 0;
719 let SchedRW = [WriteSALU];
720 let UseNamedOperandTable = 1;
721 let SubtargetPredicate = isGCN;
724 class SOPC_Base <bits<7> op, RegisterOperand rc0, RegisterOperand rc1,
725 string opName, list<dag> pattern = []> : SOPC <
726 op, (outs), (ins rc0:$src0, rc1:$src1),
727 opName#" $src0, $src1", pattern > {
730 class SOPC_Helper <bits<7> op, RegisterOperand rc, ValueType vt,
731 string opName, PatLeaf cond> : SOPC_Base <
733 [(set SCC, (si_setcc_uniform vt:$src0, vt:$src1, cond))] > {
736 class SOPC_CMP_32<bits<7> op, string opName,
737 PatLeaf cond = COND_NULL, string revOp = opName>
738 : SOPC_Helper<op, SSrc_b32, i32, opName, cond>,
739 Commutable_REV<revOp, !eq(revOp, opName)>,
740 SOPKInstTable<0, opName> {
742 let isCommutable = 1;
745 class SOPC_CMP_64<bits<7> op, string opName,
746 PatLeaf cond = COND_NULL, string revOp = opName>
747 : SOPC_Helper<op, SSrc_b64, i64, opName, cond>,
748 Commutable_REV<revOp, !eq(revOp, opName)> {
750 let isCommutable = 1;
753 class SOPC_32<bits<7> op, string opName, list<dag> pattern = []>
754 : SOPC_Base<op, SSrc_b32, SSrc_b32, opName, pattern>;
756 class SOPC_64_32<bits<7> op, string opName, list<dag> pattern = []>
757 : SOPC_Base<op, SSrc_b64, SSrc_b32, opName, pattern>;
759 def S_CMP_EQ_I32 : SOPC_CMP_32 <0x00, "s_cmp_eq_i32">;
760 def S_CMP_LG_I32 : SOPC_CMP_32 <0x01, "s_cmp_lg_i32">;
761 def S_CMP_GT_I32 : SOPC_CMP_32 <0x02, "s_cmp_gt_i32", COND_SGT>;
762 def S_CMP_GE_I32 : SOPC_CMP_32 <0x03, "s_cmp_ge_i32", COND_SGE>;
763 def S_CMP_LT_I32 : SOPC_CMP_32 <0x04, "s_cmp_lt_i32", COND_SLT, "s_cmp_gt_i32">;
764 def S_CMP_LE_I32 : SOPC_CMP_32 <0x05, "s_cmp_le_i32", COND_SLE, "s_cmp_ge_i32">;
765 def S_CMP_EQ_U32 : SOPC_CMP_32 <0x06, "s_cmp_eq_u32", COND_EQ>;
766 def S_CMP_LG_U32 : SOPC_CMP_32 <0x07, "s_cmp_lg_u32", COND_NE>;
767 def S_CMP_GT_U32 : SOPC_CMP_32 <0x08, "s_cmp_gt_u32", COND_UGT>;
768 def S_CMP_GE_U32 : SOPC_CMP_32 <0x09, "s_cmp_ge_u32", COND_UGE>;
769 def S_CMP_LT_U32 : SOPC_CMP_32 <0x0a, "s_cmp_lt_u32", COND_ULT, "s_cmp_gt_u32">;
770 def S_CMP_LE_U32 : SOPC_CMP_32 <0x0b, "s_cmp_le_u32", COND_ULE, "s_cmp_ge_u32">;
772 def S_BITCMP0_B32 : SOPC_32 <0x0c, "s_bitcmp0_b32">;
773 def S_BITCMP1_B32 : SOPC_32 <0x0d, "s_bitcmp1_b32">;
774 def S_BITCMP0_B64 : SOPC_64_32 <0x0e, "s_bitcmp0_b64">;
775 def S_BITCMP1_B64 : SOPC_64_32 <0x0f, "s_bitcmp1_b64">;
776 def S_SETVSKIP : SOPC_32 <0x10, "s_setvskip">;
778 let SubtargetPredicate = isVI in {
779 def S_CMP_EQ_U64 : SOPC_CMP_64 <0x12, "s_cmp_eq_u64", COND_EQ>;
780 def S_CMP_LG_U64 : SOPC_CMP_64 <0x13, "s_cmp_lg_u64", COND_NE>;
783 let SubtargetPredicate = HasVGPRIndexMode in {
784 def S_SET_GPR_IDX_ON : SOPC <0x11,
786 (ins SSrc_b32:$src0, GPRIdxMode:$src1),
787 "s_set_gpr_idx_on $src0,$src1"> {
788 let Defs = [M0]; // No scc def
789 let Uses = [M0]; // Other bits of m0 unmodified.
790 let hasSideEffects = 1; // Sets mode.gpr_idx_en
795 //===----------------------------------------------------------------------===//
797 //===----------------------------------------------------------------------===//
799 class SOPPe <bits<7> op> : Enc32 {
802 let Inst{15-0} = simm16;
803 let Inst{22-16} = op;
804 let Inst{31-23} = 0x17f; // encoding
807 class SOPP <bits<7> op, dag ins, string asm, list<dag> pattern = []> :
808 InstSI <(outs), ins, asm, pattern >, SOPPe <op> {
812 let hasSideEffects = 0;
816 let SchedRW = [WriteSALU];
818 let UseNamedOperandTable = 1;
819 let SubtargetPredicate = isGCN;
823 def S_NOP : SOPP <0x00000000, (ins i16imm:$simm16), "s_nop $simm16">;
825 let isTerminator = 1 in {
827 def S_ENDPGM : SOPP <0x00000001, (ins), "s_endpgm",
834 let SubtargetPredicate = isVI in {
835 def S_ENDPGM_SAVED : SOPP <0x0000001B, (ins), "s_endpgm_saved"> {
842 let SubtargetPredicate = isGFX9 in {
843 let isBarrier = 1, isReturn = 1, simm16 = 0 in {
844 def S_ENDPGM_ORDERED_PS_DONE :
845 SOPP<0x01e, (ins), "s_endpgm_ordered_ps_done">;
846 } // End isBarrier = 1, isReturn = 1, simm16 = 0
847 } // End SubtargetPredicate = isGFX9
849 let isBranch = 1, SchedRW = [WriteBranch] in {
850 def S_BRANCH : SOPP <
851 0x00000002, (ins sopp_brtarget:$simm16), "s_branch $simm16",
856 let Uses = [SCC] in {
857 def S_CBRANCH_SCC0 : SOPP <
858 0x00000004, (ins sopp_brtarget:$simm16),
859 "s_cbranch_scc0 $simm16"
861 def S_CBRANCH_SCC1 : SOPP <
862 0x00000005, (ins sopp_brtarget:$simm16),
863 "s_cbranch_scc1 $simm16"
865 } // End Uses = [SCC]
867 let Uses = [VCC] in {
868 def S_CBRANCH_VCCZ : SOPP <
869 0x00000006, (ins sopp_brtarget:$simm16),
870 "s_cbranch_vccz $simm16"
872 def S_CBRANCH_VCCNZ : SOPP <
873 0x00000007, (ins sopp_brtarget:$simm16),
874 "s_cbranch_vccnz $simm16"
876 } // End Uses = [VCC]
878 let Uses = [EXEC] in {
879 def S_CBRANCH_EXECZ : SOPP <
880 0x00000008, (ins sopp_brtarget:$simm16),
881 "s_cbranch_execz $simm16"
883 def S_CBRANCH_EXECNZ : SOPP <
884 0x00000009, (ins sopp_brtarget:$simm16),
885 "s_cbranch_execnz $simm16"
887 } // End Uses = [EXEC]
889 def S_CBRANCH_CDBGSYS : SOPP <
890 0x00000017, (ins sopp_brtarget:$simm16),
891 "s_cbranch_cdbgsys $simm16"
894 def S_CBRANCH_CDBGSYS_AND_USER : SOPP <
895 0x0000001A, (ins sopp_brtarget:$simm16),
896 "s_cbranch_cdbgsys_and_user $simm16"
899 def S_CBRANCH_CDBGSYS_OR_USER : SOPP <
900 0x00000019, (ins sopp_brtarget:$simm16),
901 "s_cbranch_cdbgsys_or_user $simm16"
904 def S_CBRANCH_CDBGUSER : SOPP <
905 0x00000018, (ins sopp_brtarget:$simm16),
906 "s_cbranch_cdbguser $simm16"
909 } // End isBranch = 1
910 } // End isTerminator = 1
912 let hasSideEffects = 1 in {
913 def S_BARRIER : SOPP <0x0000000a, (ins), "s_barrier",
914 [(int_amdgcn_s_barrier)]> {
915 let SchedRW = [WriteBarrier];
919 let isConvergent = 1;
922 let SubtargetPredicate = isVI in {
923 def S_WAKEUP : SOPP <0x00000003, (ins), "s_wakeup"> {
930 let mayLoad = 1, mayStore = 1, hasSideEffects = 1 in
931 def S_WAITCNT : SOPP <0x0000000c, (ins WAIT_FLAG:$simm16), "s_waitcnt $simm16">;
932 def S_SETHALT : SOPP <0x0000000d, (ins i16imm:$simm16), "s_sethalt $simm16">;
933 def S_SETKILL : SOPP <0x0000000b, (ins i16imm:$simm16), "s_setkill $simm16">;
935 // On SI the documentation says sleep for approximately 64 * low 2
936 // bits, consistent with the reported maximum of 448. On VI the
937 // maximum reported is 960 cycles, so 960 / 64 = 15 max, so is the
938 // maximum really 15 on VI?
939 def S_SLEEP : SOPP <0x0000000e, (ins i32imm:$simm16),
940 "s_sleep $simm16", [(int_amdgcn_s_sleep SIMM16bit:$simm16)]> {
941 let hasSideEffects = 1;
946 def S_SETPRIO : SOPP <0x0000000f, (ins i16imm:$simm16), "s_setprio $simm16">;
948 let Uses = [EXEC, M0] in {
949 // FIXME: Should this be mayLoad+mayStore?
950 def S_SENDMSG : SOPP <0x00000010, (ins SendMsgImm:$simm16), "s_sendmsg $simm16",
951 [(AMDGPUsendmsg (i32 imm:$simm16))]
954 def S_SENDMSGHALT : SOPP <0x00000011, (ins SendMsgImm:$simm16), "s_sendmsghalt $simm16",
955 [(AMDGPUsendmsghalt (i32 imm:$simm16))]
957 } // End Uses = [EXEC, M0]
959 def S_TRAP : SOPP <0x00000012, (ins i16imm:$simm16), "s_trap $simm16">;
960 def S_ICACHE_INV : SOPP <0x00000013, (ins), "s_icache_inv"> {
963 def S_INCPERFLEVEL : SOPP <0x00000014, (ins i32imm:$simm16), "s_incperflevel $simm16",
964 [(int_amdgcn_s_incperflevel SIMM16bit:$simm16)]> {
965 let hasSideEffects = 1;
969 def S_DECPERFLEVEL : SOPP <0x00000015, (ins i32imm:$simm16), "s_decperflevel $simm16",
970 [(int_amdgcn_s_decperflevel SIMM16bit:$simm16)]> {
971 let hasSideEffects = 1;
975 def S_TTRACEDATA : SOPP <0x00000016, (ins), "s_ttracedata"> {
979 let SubtargetPredicate = HasVGPRIndexMode in {
980 def S_SET_GPR_IDX_OFF : SOPP<0x1c, (ins), "s_set_gpr_idx_off"> {
984 } // End hasSideEffects
986 let SubtargetPredicate = HasVGPRIndexMode in {
987 def S_SET_GPR_IDX_MODE : SOPP<0x1d, (ins GPRIdxMode:$simm16),
988 "s_set_gpr_idx_mode$simm16"> {
993 //===----------------------------------------------------------------------===//
994 // S_GETREG_B32 Intrinsic Pattern.
995 //===----------------------------------------------------------------------===//
997 (int_amdgcn_s_getreg imm:$simm16),
998 (S_GETREG_B32 (as_i16imm $simm16))
1001 //===----------------------------------------------------------------------===//
1003 //===----------------------------------------------------------------------===//
1006 (i64 (ctpop i64:$src)),
1007 (i64 (REG_SEQUENCE SReg_64,
1008 (i32 (COPY_TO_REGCLASS (S_BCNT1_I32_B64 $src), SReg_32)), sub0,
1009 (S_MOV_B32 (i32 0)), sub1))
1013 (i32 (smax i32:$x, (i32 (ineg i32:$x)))),
1019 (S_MOV_B32 imm:$imm)
1022 // Same as a 32-bit inreg
1024 (i32 (sext i16:$src)),
1025 (S_SEXT_I32_I16 $src)
1029 //===----------------------------------------------------------------------===//
1031 //===----------------------------------------------------------------------===//
1033 // V_ADD_I32_e32/S_ADD_U32 produces carry in VCC/SCC. For the vector
1034 // case, the sgpr-copies pass will fix this to use the vector version.
1036 (i32 (addc i32:$src0, i32:$src1)),
1037 (S_ADD_U32 $src0, $src1)
1040 // FIXME: We need to use COPY_TO_REGCLASS to work-around the fact that
1041 // REG_SEQUENCE patterns don't support instructions with multiple
1044 (i64 (zext i16:$src)),
1045 (REG_SEQUENCE SReg_64,
1046 (i32 (COPY_TO_REGCLASS (S_AND_B32 $src, (S_MOV_B32 (i32 0xffff))), SGPR_32)), sub0,
1047 (S_MOV_B32 (i32 0)), sub1)
1051 (i64 (sext i16:$src)),
1052 (REG_SEQUENCE SReg_64, (i32 (S_SEXT_I32_I16 $src)), sub0,
1053 (i32 (COPY_TO_REGCLASS (S_ASHR_I32 (i32 (S_SEXT_I32_I16 $src)), (S_MOV_B32 (i32 31))), SGPR_32)), sub1)
1057 (i32 (zext i16:$src)),
1058 (S_AND_B32 (S_MOV_B32 (i32 0xffff)), $src)
1063 //===----------------------------------------------------------------------===//
1065 //===----------------------------------------------------------------------===//
1068 (int_amdgcn_s_waitcnt i32:$simm16),
1069 (S_WAITCNT (as_i16imm $simm16))
1073 //===----------------------------------------------------------------------===//
1074 // Real target instructions, move this to the appropriate subtarget TD file
1075 //===----------------------------------------------------------------------===//
1077 class Select_si<string opName> :
1078 SIMCInstr<opName, SIEncodingFamily.SI> {
1079 list<Predicate> AssemblerPredicates = [isSICI];
1080 string DecoderNamespace = "SICI";
1083 class SOP1_Real_si<bits<8> op, SOP1_Pseudo ps> :
1085 Select_si<ps.Mnemonic>;
1087 class SOP2_Real_si<bits<7> op, SOP2_Pseudo ps> :
1089 Select_si<ps.Mnemonic>;
1091 class SOPK_Real_si<bits<5> op, SOPK_Pseudo ps> :
1092 SOPK_Real32<op, ps>,
1093 Select_si<ps.Mnemonic>;
1095 def S_MOV_B32_si : SOP1_Real_si <0x03, S_MOV_B32>;
1096 def S_MOV_B64_si : SOP1_Real_si <0x04, S_MOV_B64>;
1097 def S_CMOV_B32_si : SOP1_Real_si <0x05, S_CMOV_B32>;
1098 def S_CMOV_B64_si : SOP1_Real_si <0x06, S_CMOV_B64>;
1099 def S_NOT_B32_si : SOP1_Real_si <0x07, S_NOT_B32>;
1100 def S_NOT_B64_si : SOP1_Real_si <0x08, S_NOT_B64>;
1101 def S_WQM_B32_si : SOP1_Real_si <0x09, S_WQM_B32>;
1102 def S_WQM_B64_si : SOP1_Real_si <0x0a, S_WQM_B64>;
1103 def S_BREV_B32_si : SOP1_Real_si <0x0b, S_BREV_B32>;
1104 def S_BREV_B64_si : SOP1_Real_si <0x0c, S_BREV_B64>;
1105 def S_BCNT0_I32_B32_si : SOP1_Real_si <0x0d, S_BCNT0_I32_B32>;
1106 def S_BCNT0_I32_B64_si : SOP1_Real_si <0x0e, S_BCNT0_I32_B64>;
1107 def S_BCNT1_I32_B32_si : SOP1_Real_si <0x0f, S_BCNT1_I32_B32>;
1108 def S_BCNT1_I32_B64_si : SOP1_Real_si <0x10, S_BCNT1_I32_B64>;
1109 def S_FF0_I32_B32_si : SOP1_Real_si <0x11, S_FF0_I32_B32>;
1110 def S_FF0_I32_B64_si : SOP1_Real_si <0x12, S_FF0_I32_B64>;
1111 def S_FF1_I32_B32_si : SOP1_Real_si <0x13, S_FF1_I32_B32>;
1112 def S_FF1_I32_B64_si : SOP1_Real_si <0x14, S_FF1_I32_B64>;
1113 def S_FLBIT_I32_B32_si : SOP1_Real_si <0x15, S_FLBIT_I32_B32>;
1114 def S_FLBIT_I32_B64_si : SOP1_Real_si <0x16, S_FLBIT_I32_B64>;
1115 def S_FLBIT_I32_si : SOP1_Real_si <0x17, S_FLBIT_I32>;
1116 def S_FLBIT_I32_I64_si : SOP1_Real_si <0x18, S_FLBIT_I32_I64>;
1117 def S_SEXT_I32_I8_si : SOP1_Real_si <0x19, S_SEXT_I32_I8>;
1118 def S_SEXT_I32_I16_si : SOP1_Real_si <0x1a, S_SEXT_I32_I16>;
1119 def S_BITSET0_B32_si : SOP1_Real_si <0x1b, S_BITSET0_B32>;
1120 def S_BITSET0_B64_si : SOP1_Real_si <0x1c, S_BITSET0_B64>;
1121 def S_BITSET1_B32_si : SOP1_Real_si <0x1d, S_BITSET1_B32>;
1122 def S_BITSET1_B64_si : SOP1_Real_si <0x1e, S_BITSET1_B64>;
1123 def S_GETPC_B64_si : SOP1_Real_si <0x1f, S_GETPC_B64>;
1124 def S_SETPC_B64_si : SOP1_Real_si <0x20, S_SETPC_B64>;
1125 def S_SWAPPC_B64_si : SOP1_Real_si <0x21, S_SWAPPC_B64>;
1126 def S_RFE_B64_si : SOP1_Real_si <0x22, S_RFE_B64>;
1127 def S_AND_SAVEEXEC_B64_si : SOP1_Real_si <0x24, S_AND_SAVEEXEC_B64>;
1128 def S_OR_SAVEEXEC_B64_si : SOP1_Real_si <0x25, S_OR_SAVEEXEC_B64>;
1129 def S_XOR_SAVEEXEC_B64_si : SOP1_Real_si <0x26, S_XOR_SAVEEXEC_B64>;
1130 def S_ANDN2_SAVEEXEC_B64_si: SOP1_Real_si <0x27, S_ANDN2_SAVEEXEC_B64>;
1131 def S_ORN2_SAVEEXEC_B64_si : SOP1_Real_si <0x28, S_ORN2_SAVEEXEC_B64>;
1132 def S_NAND_SAVEEXEC_B64_si : SOP1_Real_si <0x29, S_NAND_SAVEEXEC_B64>;
1133 def S_NOR_SAVEEXEC_B64_si : SOP1_Real_si <0x2a, S_NOR_SAVEEXEC_B64>;
1134 def S_XNOR_SAVEEXEC_B64_si : SOP1_Real_si <0x2b, S_XNOR_SAVEEXEC_B64>;
1135 def S_QUADMASK_B32_si : SOP1_Real_si <0x2c, S_QUADMASK_B32>;
1136 def S_QUADMASK_B64_si : SOP1_Real_si <0x2d, S_QUADMASK_B64>;
1137 def S_MOVRELS_B32_si : SOP1_Real_si <0x2e, S_MOVRELS_B32>;
1138 def S_MOVRELS_B64_si : SOP1_Real_si <0x2f, S_MOVRELS_B64>;
1139 def S_MOVRELD_B32_si : SOP1_Real_si <0x30, S_MOVRELD_B32>;
1140 def S_MOVRELD_B64_si : SOP1_Real_si <0x31, S_MOVRELD_B64>;
1141 def S_CBRANCH_JOIN_si : SOP1_Real_si <0x32, S_CBRANCH_JOIN>;
1142 def S_MOV_REGRD_B32_si : SOP1_Real_si <0x33, S_MOV_REGRD_B32>;
1143 def S_ABS_I32_si : SOP1_Real_si <0x34, S_ABS_I32>;
1144 def S_MOV_FED_B32_si : SOP1_Real_si <0x35, S_MOV_FED_B32>;
1146 def S_ADD_U32_si : SOP2_Real_si <0x00, S_ADD_U32>;
1147 def S_ADD_I32_si : SOP2_Real_si <0x02, S_ADD_I32>;
1148 def S_SUB_U32_si : SOP2_Real_si <0x01, S_SUB_U32>;
1149 def S_SUB_I32_si : SOP2_Real_si <0x03, S_SUB_I32>;
1150 def S_ADDC_U32_si : SOP2_Real_si <0x04, S_ADDC_U32>;
1151 def S_SUBB_U32_si : SOP2_Real_si <0x05, S_SUBB_U32>;
1152 def S_MIN_I32_si : SOP2_Real_si <0x06, S_MIN_I32>;
1153 def S_MIN_U32_si : SOP2_Real_si <0x07, S_MIN_U32>;
1154 def S_MAX_I32_si : SOP2_Real_si <0x08, S_MAX_I32>;
1155 def S_MAX_U32_si : SOP2_Real_si <0x09, S_MAX_U32>;
1156 def S_CSELECT_B32_si : SOP2_Real_si <0x0a, S_CSELECT_B32>;
1157 def S_CSELECT_B64_si : SOP2_Real_si <0x0b, S_CSELECT_B64>;
1158 def S_AND_B32_si : SOP2_Real_si <0x0e, S_AND_B32>;
1159 def S_AND_B64_si : SOP2_Real_si <0x0f, S_AND_B64>;
1160 def S_OR_B32_si : SOP2_Real_si <0x10, S_OR_B32>;
1161 def S_OR_B64_si : SOP2_Real_si <0x11, S_OR_B64>;
1162 def S_XOR_B32_si : SOP2_Real_si <0x12, S_XOR_B32>;
1163 def S_XOR_B64_si : SOP2_Real_si <0x13, S_XOR_B64>;
1164 def S_ANDN2_B32_si : SOP2_Real_si <0x14, S_ANDN2_B32>;
1165 def S_ANDN2_B64_si : SOP2_Real_si <0x15, S_ANDN2_B64>;
1166 def S_ORN2_B32_si : SOP2_Real_si <0x16, S_ORN2_B32>;
1167 def S_ORN2_B64_si : SOP2_Real_si <0x17, S_ORN2_B64>;
1168 def S_NAND_B32_si : SOP2_Real_si <0x18, S_NAND_B32>;
1169 def S_NAND_B64_si : SOP2_Real_si <0x19, S_NAND_B64>;
1170 def S_NOR_B32_si : SOP2_Real_si <0x1a, S_NOR_B32>;
1171 def S_NOR_B64_si : SOP2_Real_si <0x1b, S_NOR_B64>;
1172 def S_XNOR_B32_si : SOP2_Real_si <0x1c, S_XNOR_B32>;
1173 def S_XNOR_B64_si : SOP2_Real_si <0x1d, S_XNOR_B64>;
1174 def S_LSHL_B32_si : SOP2_Real_si <0x1e, S_LSHL_B32>;
1175 def S_LSHL_B64_si : SOP2_Real_si <0x1f, S_LSHL_B64>;
1176 def S_LSHR_B32_si : SOP2_Real_si <0x20, S_LSHR_B32>;
1177 def S_LSHR_B64_si : SOP2_Real_si <0x21, S_LSHR_B64>;
1178 def S_ASHR_I32_si : SOP2_Real_si <0x22, S_ASHR_I32>;
1179 def S_ASHR_I64_si : SOP2_Real_si <0x23, S_ASHR_I64>;
1180 def S_BFM_B32_si : SOP2_Real_si <0x24, S_BFM_B32>;
1181 def S_BFM_B64_si : SOP2_Real_si <0x25, S_BFM_B64>;
1182 def S_MUL_I32_si : SOP2_Real_si <0x26, S_MUL_I32>;
1183 def S_BFE_U32_si : SOP2_Real_si <0x27, S_BFE_U32>;
1184 def S_BFE_I32_si : SOP2_Real_si <0x28, S_BFE_I32>;
1185 def S_BFE_U64_si : SOP2_Real_si <0x29, S_BFE_U64>;
1186 def S_BFE_I64_si : SOP2_Real_si <0x2a, S_BFE_I64>;
1187 def S_CBRANCH_G_FORK_si : SOP2_Real_si <0x2b, S_CBRANCH_G_FORK>;
1188 def S_ABSDIFF_I32_si : SOP2_Real_si <0x2c, S_ABSDIFF_I32>;
1190 def S_MOVK_I32_si : SOPK_Real_si <0x00, S_MOVK_I32>;
1191 def S_CMOVK_I32_si : SOPK_Real_si <0x02, S_CMOVK_I32>;
1192 def S_CMPK_EQ_I32_si : SOPK_Real_si <0x03, S_CMPK_EQ_I32>;
1193 def S_CMPK_LG_I32_si : SOPK_Real_si <0x04, S_CMPK_LG_I32>;
1194 def S_CMPK_GT_I32_si : SOPK_Real_si <0x05, S_CMPK_GT_I32>;
1195 def S_CMPK_GE_I32_si : SOPK_Real_si <0x06, S_CMPK_GE_I32>;
1196 def S_CMPK_LT_I32_si : SOPK_Real_si <0x07, S_CMPK_LT_I32>;
1197 def S_CMPK_LE_I32_si : SOPK_Real_si <0x08, S_CMPK_LE_I32>;
1198 def S_CMPK_EQ_U32_si : SOPK_Real_si <0x09, S_CMPK_EQ_U32>;
1199 def S_CMPK_LG_U32_si : SOPK_Real_si <0x0a, S_CMPK_LG_U32>;
1200 def S_CMPK_GT_U32_si : SOPK_Real_si <0x0b, S_CMPK_GT_U32>;
1201 def S_CMPK_GE_U32_si : SOPK_Real_si <0x0c, S_CMPK_GE_U32>;
1202 def S_CMPK_LT_U32_si : SOPK_Real_si <0x0d, S_CMPK_LT_U32>;
1203 def S_CMPK_LE_U32_si : SOPK_Real_si <0x0e, S_CMPK_LE_U32>;
1204 def S_ADDK_I32_si : SOPK_Real_si <0x0f, S_ADDK_I32>;
1205 def S_MULK_I32_si : SOPK_Real_si <0x10, S_MULK_I32>;
1206 def S_CBRANCH_I_FORK_si : SOPK_Real_si <0x11, S_CBRANCH_I_FORK>;
1207 def S_GETREG_B32_si : SOPK_Real_si <0x12, S_GETREG_B32>;
1208 def S_SETREG_B32_si : SOPK_Real_si <0x13, S_SETREG_B32>;
1209 //def S_GETREG_REGRD_B32_si : SOPK_Real_si <0x14, S_GETREG_REGRD_B32>; // see pseudo for comments
1210 def S_SETREG_IMM32_B32_si : SOPK_Real64<0x15, S_SETREG_IMM32_B32>,
1211 Select_si<S_SETREG_IMM32_B32.Mnemonic>;
1214 class Select_vi<string opName> :
1215 SIMCInstr<opName, SIEncodingFamily.VI> {
1216 list<Predicate> AssemblerPredicates = [isVI];
1217 string DecoderNamespace = "VI";
1220 class SOP1_Real_vi<bits<8> op, SOP1_Pseudo ps> :
1222 Select_vi<ps.Mnemonic>;
1225 class SOP2_Real_vi<bits<7> op, SOP2_Pseudo ps> :
1227 Select_vi<ps.Mnemonic>;
1229 class SOPK_Real_vi<bits<5> op, SOPK_Pseudo ps> :
1230 SOPK_Real32<op, ps>,
1231 Select_vi<ps.Mnemonic>;
1233 def S_MOV_B32_vi : SOP1_Real_vi <0x00, S_MOV_B32>;
1234 def S_MOV_B64_vi : SOP1_Real_vi <0x01, S_MOV_B64>;
1235 def S_CMOV_B32_vi : SOP1_Real_vi <0x02, S_CMOV_B32>;
1236 def S_CMOV_B64_vi : SOP1_Real_vi <0x03, S_CMOV_B64>;
1237 def S_NOT_B32_vi : SOP1_Real_vi <0x04, S_NOT_B32>;
1238 def S_NOT_B64_vi : SOP1_Real_vi <0x05, S_NOT_B64>;
1239 def S_WQM_B32_vi : SOP1_Real_vi <0x06, S_WQM_B32>;
1240 def S_WQM_B64_vi : SOP1_Real_vi <0x07, S_WQM_B64>;
1241 def S_BREV_B32_vi : SOP1_Real_vi <0x08, S_BREV_B32>;
1242 def S_BREV_B64_vi : SOP1_Real_vi <0x09, S_BREV_B64>;
1243 def S_BCNT0_I32_B32_vi : SOP1_Real_vi <0x0a, S_BCNT0_I32_B32>;
1244 def S_BCNT0_I32_B64_vi : SOP1_Real_vi <0x0b, S_BCNT0_I32_B64>;
1245 def S_BCNT1_I32_B32_vi : SOP1_Real_vi <0x0c, S_BCNT1_I32_B32>;
1246 def S_BCNT1_I32_B64_vi : SOP1_Real_vi <0x0d, S_BCNT1_I32_B64>;
1247 def S_FF0_I32_B32_vi : SOP1_Real_vi <0x0e, S_FF0_I32_B32>;
1248 def S_FF0_I32_B64_vi : SOP1_Real_vi <0x0f, S_FF0_I32_B64>;
1249 def S_FF1_I32_B32_vi : SOP1_Real_vi <0x10, S_FF1_I32_B32>;
1250 def S_FF1_I32_B64_vi : SOP1_Real_vi <0x11, S_FF1_I32_B64>;
1251 def S_FLBIT_I32_B32_vi : SOP1_Real_vi <0x12, S_FLBIT_I32_B32>;
1252 def S_FLBIT_I32_B64_vi : SOP1_Real_vi <0x13, S_FLBIT_I32_B64>;
1253 def S_FLBIT_I32_vi : SOP1_Real_vi <0x14, S_FLBIT_I32>;
1254 def S_FLBIT_I32_I64_vi : SOP1_Real_vi <0x15, S_FLBIT_I32_I64>;
1255 def S_SEXT_I32_I8_vi : SOP1_Real_vi <0x16, S_SEXT_I32_I8>;
1256 def S_SEXT_I32_I16_vi : SOP1_Real_vi <0x17, S_SEXT_I32_I16>;
1257 def S_BITSET0_B32_vi : SOP1_Real_vi <0x18, S_BITSET0_B32>;
1258 def S_BITSET0_B64_vi : SOP1_Real_vi <0x19, S_BITSET0_B64>;
1259 def S_BITSET1_B32_vi : SOP1_Real_vi <0x1a, S_BITSET1_B32>;
1260 def S_BITSET1_B64_vi : SOP1_Real_vi <0x1b, S_BITSET1_B64>;
1261 def S_GETPC_B64_vi : SOP1_Real_vi <0x1c, S_GETPC_B64>;
1262 def S_SETPC_B64_vi : SOP1_Real_vi <0x1d, S_SETPC_B64>;
1263 def S_SWAPPC_B64_vi : SOP1_Real_vi <0x1e, S_SWAPPC_B64>;
1264 def S_RFE_B64_vi : SOP1_Real_vi <0x1f, S_RFE_B64>;
1265 def S_AND_SAVEEXEC_B64_vi : SOP1_Real_vi <0x20, S_AND_SAVEEXEC_B64>;
1266 def S_OR_SAVEEXEC_B64_vi : SOP1_Real_vi <0x21, S_OR_SAVEEXEC_B64>;
1267 def S_XOR_SAVEEXEC_B64_vi : SOP1_Real_vi <0x22, S_XOR_SAVEEXEC_B64>;
1268 def S_ANDN2_SAVEEXEC_B64_vi: SOP1_Real_vi <0x23, S_ANDN2_SAVEEXEC_B64>;
1269 def S_ORN2_SAVEEXEC_B64_vi : SOP1_Real_vi <0x24, S_ORN2_SAVEEXEC_B64>;
1270 def S_NAND_SAVEEXEC_B64_vi : SOP1_Real_vi <0x25, S_NAND_SAVEEXEC_B64>;
1271 def S_NOR_SAVEEXEC_B64_vi : SOP1_Real_vi <0x26, S_NOR_SAVEEXEC_B64>;
1272 def S_XNOR_SAVEEXEC_B64_vi : SOP1_Real_vi <0x27, S_XNOR_SAVEEXEC_B64>;
1273 def S_QUADMASK_B32_vi : SOP1_Real_vi <0x28, S_QUADMASK_B32>;
1274 def S_QUADMASK_B64_vi : SOP1_Real_vi <0x29, S_QUADMASK_B64>;
1275 def S_MOVRELS_B32_vi : SOP1_Real_vi <0x2a, S_MOVRELS_B32>;
1276 def S_MOVRELS_B64_vi : SOP1_Real_vi <0x2b, S_MOVRELS_B64>;
1277 def S_MOVRELD_B32_vi : SOP1_Real_vi <0x2c, S_MOVRELD_B32>;
1278 def S_MOVRELD_B64_vi : SOP1_Real_vi <0x2d, S_MOVRELD_B64>;
1279 def S_CBRANCH_JOIN_vi : SOP1_Real_vi <0x2e, S_CBRANCH_JOIN>;
1280 def S_MOV_REGRD_B32_vi : SOP1_Real_vi <0x2f, S_MOV_REGRD_B32>;
1281 def S_ABS_I32_vi : SOP1_Real_vi <0x30, S_ABS_I32>;
1282 def S_MOV_FED_B32_vi : SOP1_Real_vi <0x31, S_MOV_FED_B32>;
1283 def S_SET_GPR_IDX_IDX_vi : SOP1_Real_vi <0x32, S_SET_GPR_IDX_IDX>;
1285 def S_ADD_U32_vi : SOP2_Real_vi <0x00, S_ADD_U32>;
1286 def S_ADD_I32_vi : SOP2_Real_vi <0x02, S_ADD_I32>;
1287 def S_SUB_U32_vi : SOP2_Real_vi <0x01, S_SUB_U32>;
1288 def S_SUB_I32_vi : SOP2_Real_vi <0x03, S_SUB_I32>;
1289 def S_ADDC_U32_vi : SOP2_Real_vi <0x04, S_ADDC_U32>;
1290 def S_SUBB_U32_vi : SOP2_Real_vi <0x05, S_SUBB_U32>;
1291 def S_MIN_I32_vi : SOP2_Real_vi <0x06, S_MIN_I32>;
1292 def S_MIN_U32_vi : SOP2_Real_vi <0x07, S_MIN_U32>;
1293 def S_MAX_I32_vi : SOP2_Real_vi <0x08, S_MAX_I32>;
1294 def S_MAX_U32_vi : SOP2_Real_vi <0x09, S_MAX_U32>;
1295 def S_CSELECT_B32_vi : SOP2_Real_vi <0x0a, S_CSELECT_B32>;
1296 def S_CSELECT_B64_vi : SOP2_Real_vi <0x0b, S_CSELECT_B64>;
1297 def S_AND_B32_vi : SOP2_Real_vi <0x0c, S_AND_B32>;
1298 def S_AND_B64_vi : SOP2_Real_vi <0x0d, S_AND_B64>;
1299 def S_OR_B32_vi : SOP2_Real_vi <0x0e, S_OR_B32>;
1300 def S_OR_B64_vi : SOP2_Real_vi <0x0f, S_OR_B64>;
1301 def S_XOR_B32_vi : SOP2_Real_vi <0x10, S_XOR_B32>;
1302 def S_XOR_B64_vi : SOP2_Real_vi <0x11, S_XOR_B64>;
1303 def S_ANDN2_B32_vi : SOP2_Real_vi <0x12, S_ANDN2_B32>;
1304 def S_ANDN2_B64_vi : SOP2_Real_vi <0x13, S_ANDN2_B64>;
1305 def S_ORN2_B32_vi : SOP2_Real_vi <0x14, S_ORN2_B32>;
1306 def S_ORN2_B64_vi : SOP2_Real_vi <0x15, S_ORN2_B64>;
1307 def S_NAND_B32_vi : SOP2_Real_vi <0x16, S_NAND_B32>;
1308 def S_NAND_B64_vi : SOP2_Real_vi <0x17, S_NAND_B64>;
1309 def S_NOR_B32_vi : SOP2_Real_vi <0x18, S_NOR_B32>;
1310 def S_NOR_B64_vi : SOP2_Real_vi <0x19, S_NOR_B64>;
1311 def S_XNOR_B32_vi : SOP2_Real_vi <0x1a, S_XNOR_B32>;
1312 def S_XNOR_B64_vi : SOP2_Real_vi <0x1b, S_XNOR_B64>;
1313 def S_LSHL_B32_vi : SOP2_Real_vi <0x1c, S_LSHL_B32>;
1314 def S_LSHL_B64_vi : SOP2_Real_vi <0x1d, S_LSHL_B64>;
1315 def S_LSHR_B32_vi : SOP2_Real_vi <0x1e, S_LSHR_B32>;
1316 def S_LSHR_B64_vi : SOP2_Real_vi <0x1f, S_LSHR_B64>;
1317 def S_ASHR_I32_vi : SOP2_Real_vi <0x20, S_ASHR_I32>;
1318 def S_ASHR_I64_vi : SOP2_Real_vi <0x21, S_ASHR_I64>;
1319 def S_BFM_B32_vi : SOP2_Real_vi <0x22, S_BFM_B32>;
1320 def S_BFM_B64_vi : SOP2_Real_vi <0x23, S_BFM_B64>;
1321 def S_MUL_I32_vi : SOP2_Real_vi <0x24, S_MUL_I32>;
1322 def S_BFE_U32_vi : SOP2_Real_vi <0x25, S_BFE_U32>;
1323 def S_BFE_I32_vi : SOP2_Real_vi <0x26, S_BFE_I32>;
1324 def S_BFE_U64_vi : SOP2_Real_vi <0x27, S_BFE_U64>;
1325 def S_BFE_I64_vi : SOP2_Real_vi <0x28, S_BFE_I64>;
1326 def S_CBRANCH_G_FORK_vi : SOP2_Real_vi <0x29, S_CBRANCH_G_FORK>;
1327 def S_ABSDIFF_I32_vi : SOP2_Real_vi <0x2a, S_ABSDIFF_I32>;
1328 def S_PACK_LL_B32_B16_vi : SOP2_Real_vi <0x32, S_PACK_LL_B32_B16>;
1329 def S_PACK_LH_B32_B16_vi : SOP2_Real_vi <0x33, S_PACK_LH_B32_B16>;
1330 def S_PACK_HH_B32_B16_vi : SOP2_Real_vi <0x34, S_PACK_HH_B32_B16>;
1331 def S_RFE_RESTORE_B64_vi : SOP2_Real_vi <0x2b, S_RFE_RESTORE_B64>;
1333 def S_MOVK_I32_vi : SOPK_Real_vi <0x00, S_MOVK_I32>;
1334 def S_CMOVK_I32_vi : SOPK_Real_vi <0x01, S_CMOVK_I32>;
1335 def S_CMPK_EQ_I32_vi : SOPK_Real_vi <0x02, S_CMPK_EQ_I32>;
1336 def S_CMPK_LG_I32_vi : SOPK_Real_vi <0x03, S_CMPK_LG_I32>;
1337 def S_CMPK_GT_I32_vi : SOPK_Real_vi <0x04, S_CMPK_GT_I32>;
1338 def S_CMPK_GE_I32_vi : SOPK_Real_vi <0x05, S_CMPK_GE_I32>;
1339 def S_CMPK_LT_I32_vi : SOPK_Real_vi <0x06, S_CMPK_LT_I32>;
1340 def S_CMPK_LE_I32_vi : SOPK_Real_vi <0x07, S_CMPK_LE_I32>;
1341 def S_CMPK_EQ_U32_vi : SOPK_Real_vi <0x08, S_CMPK_EQ_U32>;
1342 def S_CMPK_LG_U32_vi : SOPK_Real_vi <0x09, S_CMPK_LG_U32>;
1343 def S_CMPK_GT_U32_vi : SOPK_Real_vi <0x0A, S_CMPK_GT_U32>;
1344 def S_CMPK_GE_U32_vi : SOPK_Real_vi <0x0B, S_CMPK_GE_U32>;
1345 def S_CMPK_LT_U32_vi : SOPK_Real_vi <0x0C, S_CMPK_LT_U32>;
1346 def S_CMPK_LE_U32_vi : SOPK_Real_vi <0x0D, S_CMPK_LE_U32>;
1347 def S_ADDK_I32_vi : SOPK_Real_vi <0x0E, S_ADDK_I32>;
1348 def S_MULK_I32_vi : SOPK_Real_vi <0x0F, S_MULK_I32>;
1349 def S_CBRANCH_I_FORK_vi : SOPK_Real_vi <0x10, S_CBRANCH_I_FORK>;
1350 def S_GETREG_B32_vi : SOPK_Real_vi <0x11, S_GETREG_B32>;
1351 def S_SETREG_B32_vi : SOPK_Real_vi <0x12, S_SETREG_B32>;
1352 //def S_GETREG_REGRD_B32_vi : SOPK_Real_vi <0x13, S_GETREG_REGRD_B32>; // see pseudo for comments
1353 def S_SETREG_IMM32_B32_vi : SOPK_Real64<0x14, S_SETREG_IMM32_B32>,
1354 Select_vi<S_SETREG_IMM32_B32.Mnemonic>;
1356 def S_CALL_B64_vi : SOPK_Real_vi <0x15, S_CALL_B64>;
1358 //===----------------------------------------------------------------------===//
1360 //===----------------------------------------------------------------------===//
1362 def S_ANDN1_SAVEEXEC_B64_vi : SOP1_Real_vi<0x33, S_ANDN1_SAVEEXEC_B64>;
1363 def S_ORN1_SAVEEXEC_B64_vi : SOP1_Real_vi<0x34, S_ORN1_SAVEEXEC_B64>;
1364 def S_ANDN1_WREXEC_B64_vi : SOP1_Real_vi<0x35, S_ANDN1_WREXEC_B64>;
1365 def S_ANDN2_WREXEC_B64_vi : SOP1_Real_vi<0x36, S_ANDN2_WREXEC_B64>;
1366 def S_BITREPLICATE_B64_B32_vi : SOP1_Real_vi<0x37, S_BITREPLICATE_B64_B32>;
1368 //===----------------------------------------------------------------------===//
1370 //===----------------------------------------------------------------------===//
1372 def S_LSHL1_ADD_U32_vi : SOP2_Real_vi<0x2e, S_LSHL1_ADD_U32>;
1373 def S_LSHL2_ADD_U32_vi : SOP2_Real_vi<0x2f, S_LSHL2_ADD_U32>;
1374 def S_LSHL3_ADD_U32_vi : SOP2_Real_vi<0x30, S_LSHL3_ADD_U32>;
1375 def S_LSHL4_ADD_U32_vi : SOP2_Real_vi<0x31, S_LSHL4_ADD_U32>;
1376 def S_MUL_HI_U32_vi : SOP2_Real_vi<0x2c, S_MUL_HI_U32>;
1377 def S_MUL_HI_I32_vi : SOP2_Real_vi<0x2d, S_MUL_HI_I32>;