From 3ed01037ba3302ee7253f27622e470b700a15e70 Mon Sep 17 00:00:00 2001 From: George Hotz Date: Thu, 25 Dec 2025 13:25:55 -0500 Subject: [PATCH] more llvm asm tests --- extra/assembly/rdna3/autogen/__init__.py | 1123 +++++++++++----------- extra/assembly/rdna3/lib.py | 557 ++++------- 2 files changed, 730 insertions(+), 950 deletions(-) diff --git a/extra/assembly/rdna3/autogen/__init__.py b/extra/assembly/rdna3/autogen/__init__.py index 05480ee0be..3f5e4a8bf4 100644 --- a/extra/assembly/rdna3/autogen/__init__.py +++ b/extra/assembly/rdna3/autogen/__init__.py @@ -1,7 +1,6 @@ -# autogenerated from AMD RDNA3.5 ISA PDF by lib.py - do not edit +# autogenerated from AMD RDNA3.5 ISA PDF by gen.py - do not edit from enum import IntEnum -from typing import Annotated -from extra.assembly.rdna3.lib import bits, BitField, Inst32, Inst64, SGPR, VGPR, TTMP as TTMP, s as s, v as v, ttmp as ttmp, SSrc, Src, SImm, Imm, VDSTYEnc, SGPRField, VGPRField +from extra.assembly.rdna3.lib import bits, Inst32, Inst64, SGPR, VGPR, TTMP as TTMP, s as s, v as v, SSrc, Src, SImm, Imm import functools class SrcEnum(IntEnum): @@ -1608,11 +1607,11 @@ class DPP8(Inst64): class DS(Inst64): encoding = bits[31:26] == 0b110110 - op:Annotated[BitField, DSOp] = bits[25:18] - vdst:VGPRField = bits[63:56] - addr:VGPRField = bits[39:32] - data0:VGPRField = bits[47:40] - data1:VGPRField = bits[55:48] + op:DSOp = bits[25:18] + vdst:VGPR = bits[63:56] + addr:VGPR = bits[39:32] + data0:VGPR = bits[47:40] + data1:VGPR = bits[55:48] offset0 = bits[7:0] offset1 = bits[15:8] gds = bits[17] @@ -1622,7 +1621,7 @@ class EXP(Inst64): en = bits[3:0] target = bits[9:4] vsrc0 = bits[39:32] - vsrc1:VGPRField = bits[47:40] + vsrc1:VGPR = bits[47:40] vsrc2 = bits[55:48] vsrc3 = bits[63:56] done = bits[11] @@ -1630,10 +1629,10 @@ class EXP(Inst64): class FLAT(Inst64): encoding = bits[31:26] == 0b110111 - op:Annotated[BitField, FLATOp] = bits[24:18] - vdst:VGPRField = bits[63:56] - addr:VGPRField = bits[39:32] - data:VGPRField = bits[47:40] + op:FLATOp = bits[24:18] + vdst:VGPR = bits[63:56] + addr:VGPR = bits[39:32] + data:VGPR = bits[47:40] saddr:SSrc = bits[54:48] offset:Imm = bits[12:0] seg = bits[17:16] @@ -1645,17 +1644,17 @@ class FLAT(Inst64): class LDSDIR(Inst32): encoding = bits[31:24] == 0b11001110 op = bits[21:20] - vdst:VGPRField = bits[7:0] + vdst:VGPR = bits[7:0] attr = bits[15:10] attr_chan = bits[9:8] wait_va = bits[19:16] class MIMG(Inst64): encoding = bits[31:26] == 0b111100 - op:Annotated[BitField, MIMGOp] = bits[25:18] - vdata:VGPRField = bits[47:40] - vaddr:VGPRField = bits[39:32] - srsrc:SGPRField = bits[52:48] + op:MIMGOp = bits[25:18] + vdata:VGPR = bits[47:40] + vaddr:VGPR = bits[39:32] + srsrc:SGPR = bits[52:48] ssamp = bits[62:58] dmask = bits[11:8] dim = bits[4:2] @@ -1674,10 +1673,10 @@ class MIMG(Inst64): class MTBUF(Inst64): encoding = bits[31:26] == 0b111010 - op:Annotated[BitField, MTBUFOp] = bits[18:15] - vdata:VGPRField = bits[47:40] - vaddr:VGPRField = bits[39:32] - srsrc:SGPRField = bits[52:48] + op:MTBUFOp = bits[18:15] + vdata:VGPR = bits[47:40] + vaddr:VGPR = bits[39:32] + srsrc:SGPR = bits[52:48] soffset:SSrc = bits[63:56] offset:Imm = bits[11:0] format = bits[25:19] @@ -1690,10 +1689,10 @@ class MTBUF(Inst64): class MUBUF(Inst64): encoding = bits[31:26] == 0b111000 - op:Annotated[BitField, MUBUFOp] = bits[25:18] - vdata:VGPRField = bits[47:40] - vaddr:VGPRField = bits[39:32] - srsrc:SGPRField = bits[52:48] + op:MUBUFOp = bits[25:18] + vdata:VGPR = bits[47:40] + vaddr:VGPR = bits[39:32] + srsrc:SGPR = bits[52:48] soffset:SSrc = bits[63:56] offset:Imm = bits[11:0] offen = bits[54] @@ -1705,9 +1704,9 @@ class MUBUF(Inst64): class SMEM(Inst64): encoding = bits[31:26] == 0b111101 - op:Annotated[BitField, SMEMOp] = bits[25:18] - sdata:SGPRField = bits[12:6] - sbase:SGPRField = bits[5:0] + op:SMEMOp = bits[25:18] + sdata:SGPR = bits[12:6] + sbase:SGPR = bits[5:0] soffset:SSrc = bits[63:57] offset:Imm = bits[52:32] glc = bits[14] @@ -1715,38 +1714,38 @@ class SMEM(Inst64): class SOP1(Inst32): encoding = bits[31:23] == 0b101111101 - op:Annotated[BitField, SOP1Op] = bits[15:8] - sdst:SGPRField = bits[22:16] + op:SOP1Op = bits[15:8] + sdst:SGPR = bits[22:16] ssrc0:SSrc = bits[7:0] class SOP2(Inst32): encoding = bits[31:30] == 0b10 - op:Annotated[BitField, SOP2Op] = bits[29:23] - sdst:SGPRField = bits[22:16] + op:SOP2Op = bits[29:23] + sdst:SGPR = bits[22:16] ssrc0:SSrc = bits[7:0] ssrc1:SSrc = bits[15:8] class SOPC(Inst32): encoding = bits[31:23] == 0b101111110 - op:Annotated[BitField, SOPCOp] = bits[22:16] + op:SOPCOp = bits[22:16] ssrc0:SSrc = bits[7:0] ssrc1:SSrc = bits[15:8] class SOPK(Inst32): encoding = bits[31:28] == 0b1011 - op:Annotated[BitField, SOPKOp] = bits[27:23] - sdst:SGPRField = bits[22:16] + op:SOPKOp = bits[27:23] + sdst:SGPR = bits[22:16] simm16:SImm = bits[15:0] class SOPP(Inst32): encoding = bits[31:23] == 0b101111111 - op:Annotated[BitField, SOPPOp] = bits[22:16] + op:SOPPOp = bits[22:16] simm16:SImm = bits[15:0] class VINTERP(Inst64): encoding = bits[31:24] == 0b11001101 - op:Annotated[BitField, VINTERPOp] = bits[22:16] - vdst:VGPRField = bits[7:0] + op:VINTERPOp = bits[22:16] + vdst:VGPR = bits[7:0] src0:Src = bits[40:32] src1:Src = bits[49:41] src2:Src = bits[58:50] @@ -1757,21 +1756,21 @@ class VINTERP(Inst64): class VOP1(Inst32): encoding = bits[31:25] == 0b111111 - op:Annotated[BitField, VOP1Op] = bits[16:9] - vdst:VGPRField = bits[24:17] + op:VOP1Op = bits[16:9] + vdst:VGPR = bits[24:17] src0:Src = bits[8:0] class VOP2(Inst32): encoding = bits[31] == 0 - op:Annotated[BitField, VOP2Op] = bits[30:25] - vdst:VGPRField = bits[24:17] + op:VOP2Op = bits[30:25] + vdst:VGPR = bits[24:17] src0:Src = bits[8:0] - vsrc1:VGPRField = bits[16:9] + vsrc1:VGPR = bits[16:9] class VOP3(Inst64): encoding = bits[31:26] == 0b110101 - op:Annotated[BitField, VOP3Op] = bits[25:16] - vdst:VGPRField = bits[7:0] + op:VOP3Op = bits[25:16] + vdst:VGPR = bits[7:0] src0:Src = bits[40:32] src1:Src = bits[49:41] src2:Src = bits[58:50] @@ -1784,8 +1783,8 @@ class VOP3(Inst64): class VOP3P(Inst64): encoding = bits[31:24] == 0b11001100 _defaults = {'opsel_hi': 3, 'opsel_hi2': 1} - op:Annotated[BitField, VOP3POp] = bits[22:16] - vdst:VGPRField = bits[7:0] + op:VOP3POp = bits[22:16] + vdst:VGPR = bits[7:0] src0:Src = bits[40:32] src1:Src = bits[49:41] src2:Src = bits[58:50] @@ -1798,9 +1797,9 @@ class VOP3P(Inst64): class VOP3SD(Inst64): encoding = bits[31:26] == 0b110101 - op:Annotated[BitField, VOP3SDOp] = bits[25:16] - vdst:VGPRField = bits[7:0] - sdst:SGPRField = bits[14:8] + op:VOP3SDOp = bits[25:16] + vdst:VGPR = bits[7:0] + sdst:SGPR = bits[14:8] src0:Src = bits[40:32] src1:Src = bits[49:41] src2:Src = bits[58:50] @@ -1810,20 +1809,20 @@ class VOP3SD(Inst64): class VOPC(Inst32): encoding = bits[31:25] == 0b111110 - op:Annotated[BitField, VOPCOp] = bits[24:17] + op:VOPCOp = bits[24:17] src0:Src = bits[8:0] - vsrc1:VGPRField = bits[16:9] + vsrc1:VGPR = bits[16:9] class VOPD(Inst64): encoding = bits[31:26] == 0b110010 - opx:Annotated[BitField, VOPDOp] = bits[25:22] - opy:Annotated[BitField, VOPDOp] = bits[21:17] - vdstx:VGPRField = bits[63:56] - vdsty:VDSTYEnc = bits[55:49] + opx:VOPDOp = bits[25:22] + opy:VOPDOp = bits[21:17] + vdstx:VGPR = bits[63:56] + vdsty:VGPR = bits[55:49] srcx0:Src = bits[8:0] - vsrcx1:VGPRField = bits[16:9] + vsrcx1:VGPR = bits[16:9] srcy0:Src = bits[40:32] - vsrcy1:VGPRField = bits[48:41] + vsrcy1:VGPR = bits[48:41] # instruction helpers ds_add_u32 = functools.partial(DS, DSOp.DS_ADD_U32) @@ -2638,329 +2637,329 @@ v_add_nc_u32_e32 = functools.partial(VOP2, VOP2Op.V_ADD_NC_U32) v_sub_nc_u32_e32 = functools.partial(VOP2, VOP2Op.V_SUB_NC_U32) v_subrev_nc_u32_e32 = functools.partial(VOP2, VOP2Op.V_SUBREV_NC_U32) v_fmac_f32_e32 = functools.partial(VOP2, VOP2Op.V_FMAC_F32) -def v_fmamk_f32_e32(vdst, src0, K, vsrc1): return VOP2(VOP2Op.V_FMAMK_F32, vdst, src0, vsrc1, literal=K) -def v_fmaak_f32_e32(vdst, src0, vsrc1, K): return VOP2(VOP2Op.V_FMAAK_F32, vdst, src0, vsrc1, literal=K) +v_fmamk_f32_e32 = functools.partial(VOP2, VOP2Op.V_FMAMK_F32) +v_fmaak_f32_e32 = functools.partial(VOP2, VOP2Op.V_FMAAK_F32) v_cvt_pk_rtz_f16_f32_e32 = functools.partial(VOP2, VOP2Op.V_CVT_PK_RTZ_F16_F32) v_add_f16_e32 = functools.partial(VOP2, VOP2Op.V_ADD_F16) v_sub_f16_e32 = functools.partial(VOP2, VOP2Op.V_SUB_F16) v_subrev_f16_e32 = functools.partial(VOP2, VOP2Op.V_SUBREV_F16) v_mul_f16_e32 = functools.partial(VOP2, VOP2Op.V_MUL_F16) v_fmac_f16_e32 = functools.partial(VOP2, VOP2Op.V_FMAC_F16) -def v_fmamk_f16_e32(vdst, src0, K, vsrc1): return VOP2(VOP2Op.V_FMAMK_F16, vdst, src0, vsrc1, literal=K) -def v_fmaak_f16_e32(vdst, src0, vsrc1, K): return VOP2(VOP2Op.V_FMAAK_F16, vdst, src0, vsrc1, literal=K) +v_fmamk_f16_e32 = functools.partial(VOP2, VOP2Op.V_FMAMK_F16) +v_fmaak_f16_e32 = functools.partial(VOP2, VOP2Op.V_FMAAK_F16) v_max_f16_e32 = functools.partial(VOP2, VOP2Op.V_MAX_F16) v_min_f16_e32 = functools.partial(VOP2, VOP2Op.V_MIN_F16) v_ldexp_f16_e32 = functools.partial(VOP2, VOP2Op.V_LDEXP_F16) v_pk_fmac_f16_e32 = functools.partial(VOP2, VOP2Op.V_PK_FMAC_F16) -v_cmp_f_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_F_F16) -v_cmp_lt_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LT_F16) -v_cmp_eq_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_F16) -v_cmp_le_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LE_F16) -v_cmp_gt_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GT_F16) -v_cmp_lg_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LG_F16) -v_cmp_ge_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GE_F16) -v_cmp_o_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_O_F16) -v_cmp_u_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_U_F16) -v_cmp_nge_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NGE_F16) -v_cmp_nlg_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NLG_F16) -v_cmp_ngt_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NGT_F16) -v_cmp_nle_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NLE_F16) -v_cmp_neq_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NEQ_F16) -v_cmp_nlt_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NLT_F16) -v_cmp_t_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_T_F16) -v_cmp_f_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_F_F32) -v_cmp_lt_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LT_F32) -v_cmp_eq_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_F32) -v_cmp_le_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LE_F32) -v_cmp_gt_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GT_F32) -v_cmp_lg_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LG_F32) -v_cmp_ge_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GE_F32) -v_cmp_o_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_O_F32) -v_cmp_u_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_U_F32) -v_cmp_nge_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NGE_F32) -v_cmp_nlg_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NLG_F32) -v_cmp_ngt_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NGT_F32) -v_cmp_nle_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NLE_F32) -v_cmp_neq_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NEQ_F32) -v_cmp_nlt_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NLT_F32) -v_cmp_t_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_T_F32) -v_cmp_f_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_F_F64) -v_cmp_lt_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LT_F64) -v_cmp_eq_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_F64) -v_cmp_le_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LE_F64) -v_cmp_gt_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GT_F64) -v_cmp_lg_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LG_F64) -v_cmp_ge_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GE_F64) -v_cmp_o_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_O_F64) -v_cmp_u_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_U_F64) -v_cmp_nge_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NGE_F64) -v_cmp_nlg_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NLG_F64) -v_cmp_ngt_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NGT_F64) -v_cmp_nle_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NLE_F64) -v_cmp_neq_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NEQ_F64) -v_cmp_nlt_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NLT_F64) -v_cmp_t_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_T_F64) -v_cmp_lt_i16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LT_I16) -v_cmp_eq_i16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_I16) -v_cmp_le_i16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LE_I16) -v_cmp_gt_i16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GT_I16) -v_cmp_ne_i16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NE_I16) -v_cmp_ge_i16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GE_I16) -v_cmp_lt_u16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LT_U16) -v_cmp_eq_u16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_U16) -v_cmp_le_u16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LE_U16) -v_cmp_gt_u16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GT_U16) -v_cmp_ne_u16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NE_U16) -v_cmp_ge_u16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GE_U16) -v_cmp_f_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_F_I32) -v_cmp_lt_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LT_I32) -v_cmp_eq_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_I32) -v_cmp_le_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LE_I32) -v_cmp_gt_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GT_I32) -v_cmp_ne_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NE_I32) -v_cmp_ge_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GE_I32) -v_cmp_t_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_T_I32) -v_cmp_f_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_F_U32) -v_cmp_lt_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LT_U32) -v_cmp_eq_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_U32) -v_cmp_le_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LE_U32) -v_cmp_gt_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GT_U32) -v_cmp_ne_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NE_U32) -v_cmp_ge_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GE_U32) -v_cmp_t_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_T_U32) -v_cmp_f_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_F_I64) -v_cmp_lt_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LT_I64) -v_cmp_eq_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_I64) -v_cmp_le_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LE_I64) -v_cmp_gt_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GT_I64) -v_cmp_ne_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NE_I64) -v_cmp_ge_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GE_I64) -v_cmp_t_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_T_I64) -v_cmp_f_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_F_U64) -v_cmp_lt_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LT_U64) -v_cmp_eq_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_U64) -v_cmp_le_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_LE_U64) -v_cmp_gt_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GT_U64) -v_cmp_ne_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_NE_U64) -v_cmp_ge_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_GE_U64) -v_cmp_t_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_T_U64) -v_cmp_class_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMP_CLASS_F16) -v_cmp_class_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMP_CLASS_F32) -v_cmp_class_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMP_CLASS_F64) -v_cmpx_f_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_F_F16) -v_cmpx_lt_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_F16) -v_cmpx_eq_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_F16) -v_cmpx_le_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_F16) -v_cmpx_gt_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_F16) -v_cmpx_lg_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LG_F16) -v_cmpx_ge_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_F16) -v_cmpx_o_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_O_F16) -v_cmpx_u_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_U_F16) -v_cmpx_nge_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NGE_F16) -v_cmpx_nlg_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NLG_F16) -v_cmpx_ngt_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NGT_F16) -v_cmpx_nle_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NLE_F16) -v_cmpx_neq_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NEQ_F16) -v_cmpx_nlt_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NLT_F16) -v_cmpx_t_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_T_F16) -v_cmpx_f_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_F_F32) -v_cmpx_lt_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_F32) -v_cmpx_eq_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_F32) -v_cmpx_le_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_F32) -v_cmpx_gt_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_F32) -v_cmpx_lg_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LG_F32) -v_cmpx_ge_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_F32) -v_cmpx_o_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_O_F32) -v_cmpx_u_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_U_F32) -v_cmpx_nge_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NGE_F32) -v_cmpx_nlg_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NLG_F32) -v_cmpx_ngt_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NGT_F32) -v_cmpx_nle_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NLE_F32) -v_cmpx_neq_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NEQ_F32) -v_cmpx_nlt_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NLT_F32) -v_cmpx_t_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_T_F32) -v_cmpx_f_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_F_F64) -v_cmpx_lt_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_F64) -v_cmpx_eq_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_F64) -v_cmpx_le_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_F64) -v_cmpx_gt_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_F64) -v_cmpx_lg_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LG_F64) -v_cmpx_ge_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_F64) -v_cmpx_o_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_O_F64) -v_cmpx_u_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_U_F64) -v_cmpx_nge_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NGE_F64) -v_cmpx_nlg_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NLG_F64) -v_cmpx_ngt_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NGT_F64) -v_cmpx_nle_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NLE_F64) -v_cmpx_neq_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NEQ_F64) -v_cmpx_nlt_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NLT_F64) -v_cmpx_t_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_T_F64) -v_cmpx_lt_i16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_I16) -v_cmpx_eq_i16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_I16) -v_cmpx_le_i16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_I16) -v_cmpx_gt_i16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_I16) -v_cmpx_ne_i16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NE_I16) -v_cmpx_ge_i16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_I16) -v_cmpx_lt_u16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_U16) -v_cmpx_eq_u16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_U16) -v_cmpx_le_u16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_U16) -v_cmpx_gt_u16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_U16) -v_cmpx_ne_u16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NE_U16) -v_cmpx_ge_u16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_U16) -v_cmpx_f_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_F_I32) -v_cmpx_lt_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_I32) -v_cmpx_eq_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_I32) -v_cmpx_le_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_I32) -v_cmpx_gt_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_I32) -v_cmpx_ne_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NE_I32) -v_cmpx_ge_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_I32) -v_cmpx_t_i32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_T_I32) -v_cmpx_f_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_F_U32) -v_cmpx_lt_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_U32) -v_cmpx_eq_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_U32) -v_cmpx_le_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_U32) -v_cmpx_gt_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_U32) -v_cmpx_ne_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NE_U32) -v_cmpx_ge_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_U32) -v_cmpx_t_u32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_T_U32) -v_cmpx_f_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_F_I64) -v_cmpx_lt_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_I64) -v_cmpx_eq_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_I64) -v_cmpx_le_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_I64) -v_cmpx_gt_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_I64) -v_cmpx_ne_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NE_I64) -v_cmpx_ge_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_I64) -v_cmpx_t_i64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_T_I64) -v_cmpx_f_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_F_U64) -v_cmpx_lt_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_U64) -v_cmpx_eq_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_U64) -v_cmpx_le_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_U64) -v_cmpx_gt_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_U64) -v_cmpx_ne_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_NE_U64) -v_cmpx_ge_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_U64) -v_cmpx_t_u64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_T_U64) -v_cmpx_class_f16_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_CLASS_F16) -v_cmpx_class_f32_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_CLASS_F32) -v_cmpx_class_f64_e64 = functools.partial(VOP3, VOP3Op.V_CMPX_CLASS_F64) -v_cndmask_b32_e64 = functools.partial(VOP3, VOP3Op.V_CNDMASK_B32) -v_add_f32_e64 = functools.partial(VOP3, VOP3Op.V_ADD_F32) -v_sub_f32_e64 = functools.partial(VOP3, VOP3Op.V_SUB_F32) -v_subrev_f32_e64 = functools.partial(VOP3, VOP3Op.V_SUBREV_F32) -v_fmac_dx9_zero_f32_e64 = functools.partial(VOP3, VOP3Op.V_FMAC_DX9_ZERO_F32) -v_mul_dx9_zero_f32_e64 = functools.partial(VOP3, VOP3Op.V_MUL_DX9_ZERO_F32) -v_mul_f32_e64 = functools.partial(VOP3, VOP3Op.V_MUL_F32) -v_mul_i32_i24_e64 = functools.partial(VOP3, VOP3Op.V_MUL_I32_I24) -v_mul_hi_i32_i24_e64 = functools.partial(VOP3, VOP3Op.V_MUL_HI_I32_I24) -v_mul_u32_u24_e64 = functools.partial(VOP3, VOP3Op.V_MUL_U32_U24) -v_mul_hi_u32_u24_e64 = functools.partial(VOP3, VOP3Op.V_MUL_HI_U32_U24) -v_min_f32_e64 = functools.partial(VOP3, VOP3Op.V_MIN_F32) -v_max_f32_e64 = functools.partial(VOP3, VOP3Op.V_MAX_F32) -v_min_i32_e64 = functools.partial(VOP3, VOP3Op.V_MIN_I32) -v_max_i32_e64 = functools.partial(VOP3, VOP3Op.V_MAX_I32) -v_min_u32_e64 = functools.partial(VOP3, VOP3Op.V_MIN_U32) -v_max_u32_e64 = functools.partial(VOP3, VOP3Op.V_MAX_U32) -v_lshlrev_b32_e64 = functools.partial(VOP3, VOP3Op.V_LSHLREV_B32) -v_lshrrev_b32_e64 = functools.partial(VOP3, VOP3Op.V_LSHRREV_B32) -v_ashrrev_i32_e64 = functools.partial(VOP3, VOP3Op.V_ASHRREV_I32) -v_and_b32_e64 = functools.partial(VOP3, VOP3Op.V_AND_B32) -v_or_b32_e64 = functools.partial(VOP3, VOP3Op.V_OR_B32) -v_xor_b32_e64 = functools.partial(VOP3, VOP3Op.V_XOR_B32) -v_xnor_b32_e64 = functools.partial(VOP3, VOP3Op.V_XNOR_B32) -v_add_nc_u32_e64 = functools.partial(VOP3, VOP3Op.V_ADD_NC_U32) -v_sub_nc_u32_e64 = functools.partial(VOP3, VOP3Op.V_SUB_NC_U32) -v_subrev_nc_u32_e64 = functools.partial(VOP3, VOP3Op.V_SUBREV_NC_U32) -v_fmac_f32_e64 = functools.partial(VOP3, VOP3Op.V_FMAC_F32) -v_cvt_pk_rtz_f16_f32_e64 = functools.partial(VOP3, VOP3Op.V_CVT_PK_RTZ_F16_F32) -v_add_f16_e64 = functools.partial(VOP3, VOP3Op.V_ADD_F16) -v_sub_f16_e64 = functools.partial(VOP3, VOP3Op.V_SUB_F16) -v_subrev_f16_e64 = functools.partial(VOP3, VOP3Op.V_SUBREV_F16) -v_mul_f16_e64 = functools.partial(VOP3, VOP3Op.V_MUL_F16) -v_fmac_f16_e64 = functools.partial(VOP3, VOP3Op.V_FMAC_F16) -v_max_f16_e64 = functools.partial(VOP3, VOP3Op.V_MAX_F16) -v_min_f16_e64 = functools.partial(VOP3, VOP3Op.V_MIN_F16) -v_ldexp_f16_e64 = functools.partial(VOP3, VOP3Op.V_LDEXP_F16) -v_nop_e64 = functools.partial(VOP3, VOP3Op.V_NOP) -v_mov_b32_e64 = functools.partial(VOP3, VOP3Op.V_MOV_B32) -v_readfirstlane_b32_e64 = functools.partial(VOP3, VOP3Op.V_READFIRSTLANE_B32) -v_cvt_i32_f64_e64 = functools.partial(VOP3, VOP3Op.V_CVT_I32_F64) -v_cvt_f64_i32_e64 = functools.partial(VOP3, VOP3Op.V_CVT_F64_I32) -v_cvt_f32_i32_e64 = functools.partial(VOP3, VOP3Op.V_CVT_F32_I32) -v_cvt_f32_u32_e64 = functools.partial(VOP3, VOP3Op.V_CVT_F32_U32) -v_cvt_u32_f32_e64 = functools.partial(VOP3, VOP3Op.V_CVT_U32_F32) -v_cvt_i32_f32_e64 = functools.partial(VOP3, VOP3Op.V_CVT_I32_F32) -v_cvt_f16_f32_e64 = functools.partial(VOP3, VOP3Op.V_CVT_F16_F32) -v_cvt_f32_f16_e64 = functools.partial(VOP3, VOP3Op.V_CVT_F32_F16) -v_cvt_nearest_i32_f32_e64 = functools.partial(VOP3, VOP3Op.V_CVT_NEAREST_I32_F32) -v_cvt_floor_i32_f32_e64 = functools.partial(VOP3, VOP3Op.V_CVT_FLOOR_I32_F32) -v_cvt_off_f32_i4_e64 = functools.partial(VOP3, VOP3Op.V_CVT_OFF_F32_I4) -v_cvt_f32_f64_e64 = functools.partial(VOP3, VOP3Op.V_CVT_F32_F64) -v_cvt_f64_f32_e64 = functools.partial(VOP3, VOP3Op.V_CVT_F64_F32) -v_cvt_f32_ubyte0_e64 = functools.partial(VOP3, VOP3Op.V_CVT_F32_UBYTE0) -v_cvt_f32_ubyte1_e64 = functools.partial(VOP3, VOP3Op.V_CVT_F32_UBYTE1) -v_cvt_f32_ubyte2_e64 = functools.partial(VOP3, VOP3Op.V_CVT_F32_UBYTE2) -v_cvt_f32_ubyte3_e64 = functools.partial(VOP3, VOP3Op.V_CVT_F32_UBYTE3) -v_cvt_u32_f64_e64 = functools.partial(VOP3, VOP3Op.V_CVT_U32_F64) -v_cvt_f64_u32_e64 = functools.partial(VOP3, VOP3Op.V_CVT_F64_U32) -v_trunc_f64_e64 = functools.partial(VOP3, VOP3Op.V_TRUNC_F64) -v_ceil_f64_e64 = functools.partial(VOP3, VOP3Op.V_CEIL_F64) -v_rndne_f64_e64 = functools.partial(VOP3, VOP3Op.V_RNDNE_F64) -v_floor_f64_e64 = functools.partial(VOP3, VOP3Op.V_FLOOR_F64) -v_pipeflush_e64 = functools.partial(VOP3, VOP3Op.V_PIPEFLUSH) -v_mov_b16_e64 = functools.partial(VOP3, VOP3Op.V_MOV_B16) -v_fract_f32_e64 = functools.partial(VOP3, VOP3Op.V_FRACT_F32) -v_trunc_f32_e64 = functools.partial(VOP3, VOP3Op.V_TRUNC_F32) -v_ceil_f32_e64 = functools.partial(VOP3, VOP3Op.V_CEIL_F32) -v_rndne_f32_e64 = functools.partial(VOP3, VOP3Op.V_RNDNE_F32) -v_floor_f32_e64 = functools.partial(VOP3, VOP3Op.V_FLOOR_F32) -v_exp_f32_e64 = functools.partial(VOP3, VOP3Op.V_EXP_F32) -v_log_f32_e64 = functools.partial(VOP3, VOP3Op.V_LOG_F32) -v_rcp_f32_e64 = functools.partial(VOP3, VOP3Op.V_RCP_F32) -v_rcp_iflag_f32_e64 = functools.partial(VOP3, VOP3Op.V_RCP_IFLAG_F32) -v_rsq_f32_e64 = functools.partial(VOP3, VOP3Op.V_RSQ_F32) -v_rcp_f64_e64 = functools.partial(VOP3, VOP3Op.V_RCP_F64) -v_rsq_f64_e64 = functools.partial(VOP3, VOP3Op.V_RSQ_F64) -v_sqrt_f32_e64 = functools.partial(VOP3, VOP3Op.V_SQRT_F32) -v_sqrt_f64_e64 = functools.partial(VOP3, VOP3Op.V_SQRT_F64) -v_sin_f32_e64 = functools.partial(VOP3, VOP3Op.V_SIN_F32) -v_cos_f32_e64 = functools.partial(VOP3, VOP3Op.V_COS_F32) -v_not_b32_e64 = functools.partial(VOP3, VOP3Op.V_NOT_B32) -v_bfrev_b32_e64 = functools.partial(VOP3, VOP3Op.V_BFREV_B32) -v_clz_i32_u32_e64 = functools.partial(VOP3, VOP3Op.V_CLZ_I32_U32) -v_ctz_i32_b32_e64 = functools.partial(VOP3, VOP3Op.V_CTZ_I32_B32) -v_cls_i32_e64 = functools.partial(VOP3, VOP3Op.V_CLS_I32) -v_frexp_exp_i32_f64_e64 = functools.partial(VOP3, VOP3Op.V_FREXP_EXP_I32_F64) -v_frexp_mant_f64_e64 = functools.partial(VOP3, VOP3Op.V_FREXP_MANT_F64) -v_fract_f64_e64 = functools.partial(VOP3, VOP3Op.V_FRACT_F64) -v_frexp_exp_i32_f32_e64 = functools.partial(VOP3, VOP3Op.V_FREXP_EXP_I32_F32) -v_frexp_mant_f32_e64 = functools.partial(VOP3, VOP3Op.V_FREXP_MANT_F32) -v_movreld_b32_e64 = functools.partial(VOP3, VOP3Op.V_MOVRELD_B32) -v_movrels_b32_e64 = functools.partial(VOP3, VOP3Op.V_MOVRELS_B32) -v_movrelsd_b32_e64 = functools.partial(VOP3, VOP3Op.V_MOVRELSD_B32) -v_movrelsd_2_b32_e64 = functools.partial(VOP3, VOP3Op.V_MOVRELSD_2_B32) -v_cvt_f16_u16_e64 = functools.partial(VOP3, VOP3Op.V_CVT_F16_U16) -v_cvt_f16_i16_e64 = functools.partial(VOP3, VOP3Op.V_CVT_F16_I16) -v_cvt_u16_f16_e64 = functools.partial(VOP3, VOP3Op.V_CVT_U16_F16) -v_cvt_i16_f16_e64 = functools.partial(VOP3, VOP3Op.V_CVT_I16_F16) -v_rcp_f16_e64 = functools.partial(VOP3, VOP3Op.V_RCP_F16) -v_sqrt_f16_e64 = functools.partial(VOP3, VOP3Op.V_SQRT_F16) -v_rsq_f16_e64 = functools.partial(VOP3, VOP3Op.V_RSQ_F16) -v_log_f16_e64 = functools.partial(VOP3, VOP3Op.V_LOG_F16) -v_exp_f16_e64 = functools.partial(VOP3, VOP3Op.V_EXP_F16) -v_frexp_mant_f16_e64 = functools.partial(VOP3, VOP3Op.V_FREXP_MANT_F16) -v_frexp_exp_i16_f16_e64 = functools.partial(VOP3, VOP3Op.V_FREXP_EXP_I16_F16) -v_floor_f16_e64 = functools.partial(VOP3, VOP3Op.V_FLOOR_F16) -v_ceil_f16_e64 = functools.partial(VOP3, VOP3Op.V_CEIL_F16) -v_trunc_f16_e64 = functools.partial(VOP3, VOP3Op.V_TRUNC_F16) -v_rndne_f16_e64 = functools.partial(VOP3, VOP3Op.V_RNDNE_F16) -v_fract_f16_e64 = functools.partial(VOP3, VOP3Op.V_FRACT_F16) -v_sin_f16_e64 = functools.partial(VOP3, VOP3Op.V_SIN_F16) -v_cos_f16_e64 = functools.partial(VOP3, VOP3Op.V_COS_F16) -v_sat_pk_u8_i16_e64 = functools.partial(VOP3, VOP3Op.V_SAT_PK_U8_I16) -v_cvt_norm_i16_f16_e64 = functools.partial(VOP3, VOP3Op.V_CVT_NORM_I16_F16) -v_cvt_norm_u16_f16_e64 = functools.partial(VOP3, VOP3Op.V_CVT_NORM_U16_F16) -v_not_b16_e64 = functools.partial(VOP3, VOP3Op.V_NOT_B16) -v_cvt_i32_i16_e64 = functools.partial(VOP3, VOP3Op.V_CVT_I32_I16) -v_cvt_u32_u16_e64 = functools.partial(VOP3, VOP3Op.V_CVT_U32_U16) +v_cmp_f_f16 = functools.partial(VOP3, VOP3Op.V_CMP_F_F16) +v_cmp_lt_f16 = functools.partial(VOP3, VOP3Op.V_CMP_LT_F16) +v_cmp_eq_f16 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_F16) +v_cmp_le_f16 = functools.partial(VOP3, VOP3Op.V_CMP_LE_F16) +v_cmp_gt_f16 = functools.partial(VOP3, VOP3Op.V_CMP_GT_F16) +v_cmp_lg_f16 = functools.partial(VOP3, VOP3Op.V_CMP_LG_F16) +v_cmp_ge_f16 = functools.partial(VOP3, VOP3Op.V_CMP_GE_F16) +v_cmp_o_f16 = functools.partial(VOP3, VOP3Op.V_CMP_O_F16) +v_cmp_u_f16 = functools.partial(VOP3, VOP3Op.V_CMP_U_F16) +v_cmp_nge_f16 = functools.partial(VOP3, VOP3Op.V_CMP_NGE_F16) +v_cmp_nlg_f16 = functools.partial(VOP3, VOP3Op.V_CMP_NLG_F16) +v_cmp_ngt_f16 = functools.partial(VOP3, VOP3Op.V_CMP_NGT_F16) +v_cmp_nle_f16 = functools.partial(VOP3, VOP3Op.V_CMP_NLE_F16) +v_cmp_neq_f16 = functools.partial(VOP3, VOP3Op.V_CMP_NEQ_F16) +v_cmp_nlt_f16 = functools.partial(VOP3, VOP3Op.V_CMP_NLT_F16) +v_cmp_t_f16 = functools.partial(VOP3, VOP3Op.V_CMP_T_F16) +v_cmp_f_f32 = functools.partial(VOP3, VOP3Op.V_CMP_F_F32) +v_cmp_lt_f32 = functools.partial(VOP3, VOP3Op.V_CMP_LT_F32) +v_cmp_eq_f32 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_F32) +v_cmp_le_f32 = functools.partial(VOP3, VOP3Op.V_CMP_LE_F32) +v_cmp_gt_f32 = functools.partial(VOP3, VOP3Op.V_CMP_GT_F32) +v_cmp_lg_f32 = functools.partial(VOP3, VOP3Op.V_CMP_LG_F32) +v_cmp_ge_f32 = functools.partial(VOP3, VOP3Op.V_CMP_GE_F32) +v_cmp_o_f32 = functools.partial(VOP3, VOP3Op.V_CMP_O_F32) +v_cmp_u_f32 = functools.partial(VOP3, VOP3Op.V_CMP_U_F32) +v_cmp_nge_f32 = functools.partial(VOP3, VOP3Op.V_CMP_NGE_F32) +v_cmp_nlg_f32 = functools.partial(VOP3, VOP3Op.V_CMP_NLG_F32) +v_cmp_ngt_f32 = functools.partial(VOP3, VOP3Op.V_CMP_NGT_F32) +v_cmp_nle_f32 = functools.partial(VOP3, VOP3Op.V_CMP_NLE_F32) +v_cmp_neq_f32 = functools.partial(VOP3, VOP3Op.V_CMP_NEQ_F32) +v_cmp_nlt_f32 = functools.partial(VOP3, VOP3Op.V_CMP_NLT_F32) +v_cmp_t_f32 = functools.partial(VOP3, VOP3Op.V_CMP_T_F32) +v_cmp_f_f64 = functools.partial(VOP3, VOP3Op.V_CMP_F_F64) +v_cmp_lt_f64 = functools.partial(VOP3, VOP3Op.V_CMP_LT_F64) +v_cmp_eq_f64 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_F64) +v_cmp_le_f64 = functools.partial(VOP3, VOP3Op.V_CMP_LE_F64) +v_cmp_gt_f64 = functools.partial(VOP3, VOP3Op.V_CMP_GT_F64) +v_cmp_lg_f64 = functools.partial(VOP3, VOP3Op.V_CMP_LG_F64) +v_cmp_ge_f64 = functools.partial(VOP3, VOP3Op.V_CMP_GE_F64) +v_cmp_o_f64 = functools.partial(VOP3, VOP3Op.V_CMP_O_F64) +v_cmp_u_f64 = functools.partial(VOP3, VOP3Op.V_CMP_U_F64) +v_cmp_nge_f64 = functools.partial(VOP3, VOP3Op.V_CMP_NGE_F64) +v_cmp_nlg_f64 = functools.partial(VOP3, VOP3Op.V_CMP_NLG_F64) +v_cmp_ngt_f64 = functools.partial(VOP3, VOP3Op.V_CMP_NGT_F64) +v_cmp_nle_f64 = functools.partial(VOP3, VOP3Op.V_CMP_NLE_F64) +v_cmp_neq_f64 = functools.partial(VOP3, VOP3Op.V_CMP_NEQ_F64) +v_cmp_nlt_f64 = functools.partial(VOP3, VOP3Op.V_CMP_NLT_F64) +v_cmp_t_f64 = functools.partial(VOP3, VOP3Op.V_CMP_T_F64) +v_cmp_lt_i16 = functools.partial(VOP3, VOP3Op.V_CMP_LT_I16) +v_cmp_eq_i16 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_I16) +v_cmp_le_i16 = functools.partial(VOP3, VOP3Op.V_CMP_LE_I16) +v_cmp_gt_i16 = functools.partial(VOP3, VOP3Op.V_CMP_GT_I16) +v_cmp_ne_i16 = functools.partial(VOP3, VOP3Op.V_CMP_NE_I16) +v_cmp_ge_i16 = functools.partial(VOP3, VOP3Op.V_CMP_GE_I16) +v_cmp_lt_u16 = functools.partial(VOP3, VOP3Op.V_CMP_LT_U16) +v_cmp_eq_u16 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_U16) +v_cmp_le_u16 = functools.partial(VOP3, VOP3Op.V_CMP_LE_U16) +v_cmp_gt_u16 = functools.partial(VOP3, VOP3Op.V_CMP_GT_U16) +v_cmp_ne_u16 = functools.partial(VOP3, VOP3Op.V_CMP_NE_U16) +v_cmp_ge_u16 = functools.partial(VOP3, VOP3Op.V_CMP_GE_U16) +v_cmp_f_i32 = functools.partial(VOP3, VOP3Op.V_CMP_F_I32) +v_cmp_lt_i32 = functools.partial(VOP3, VOP3Op.V_CMP_LT_I32) +v_cmp_eq_i32 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_I32) +v_cmp_le_i32 = functools.partial(VOP3, VOP3Op.V_CMP_LE_I32) +v_cmp_gt_i32 = functools.partial(VOP3, VOP3Op.V_CMP_GT_I32) +v_cmp_ne_i32 = functools.partial(VOP3, VOP3Op.V_CMP_NE_I32) +v_cmp_ge_i32 = functools.partial(VOP3, VOP3Op.V_CMP_GE_I32) +v_cmp_t_i32 = functools.partial(VOP3, VOP3Op.V_CMP_T_I32) +v_cmp_f_u32 = functools.partial(VOP3, VOP3Op.V_CMP_F_U32) +v_cmp_lt_u32 = functools.partial(VOP3, VOP3Op.V_CMP_LT_U32) +v_cmp_eq_u32 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_U32) +v_cmp_le_u32 = functools.partial(VOP3, VOP3Op.V_CMP_LE_U32) +v_cmp_gt_u32 = functools.partial(VOP3, VOP3Op.V_CMP_GT_U32) +v_cmp_ne_u32 = functools.partial(VOP3, VOP3Op.V_CMP_NE_U32) +v_cmp_ge_u32 = functools.partial(VOP3, VOP3Op.V_CMP_GE_U32) +v_cmp_t_u32 = functools.partial(VOP3, VOP3Op.V_CMP_T_U32) +v_cmp_f_i64 = functools.partial(VOP3, VOP3Op.V_CMP_F_I64) +v_cmp_lt_i64 = functools.partial(VOP3, VOP3Op.V_CMP_LT_I64) +v_cmp_eq_i64 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_I64) +v_cmp_le_i64 = functools.partial(VOP3, VOP3Op.V_CMP_LE_I64) +v_cmp_gt_i64 = functools.partial(VOP3, VOP3Op.V_CMP_GT_I64) +v_cmp_ne_i64 = functools.partial(VOP3, VOP3Op.V_CMP_NE_I64) +v_cmp_ge_i64 = functools.partial(VOP3, VOP3Op.V_CMP_GE_I64) +v_cmp_t_i64 = functools.partial(VOP3, VOP3Op.V_CMP_T_I64) +v_cmp_f_u64 = functools.partial(VOP3, VOP3Op.V_CMP_F_U64) +v_cmp_lt_u64 = functools.partial(VOP3, VOP3Op.V_CMP_LT_U64) +v_cmp_eq_u64 = functools.partial(VOP3, VOP3Op.V_CMP_EQ_U64) +v_cmp_le_u64 = functools.partial(VOP3, VOP3Op.V_CMP_LE_U64) +v_cmp_gt_u64 = functools.partial(VOP3, VOP3Op.V_CMP_GT_U64) +v_cmp_ne_u64 = functools.partial(VOP3, VOP3Op.V_CMP_NE_U64) +v_cmp_ge_u64 = functools.partial(VOP3, VOP3Op.V_CMP_GE_U64) +v_cmp_t_u64 = functools.partial(VOP3, VOP3Op.V_CMP_T_U64) +v_cmp_class_f16 = functools.partial(VOP3, VOP3Op.V_CMP_CLASS_F16) +v_cmp_class_f32 = functools.partial(VOP3, VOP3Op.V_CMP_CLASS_F32) +v_cmp_class_f64 = functools.partial(VOP3, VOP3Op.V_CMP_CLASS_F64) +v_cmpx_f_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_F_F16) +v_cmpx_lt_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_F16) +v_cmpx_eq_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_F16) +v_cmpx_le_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_F16) +v_cmpx_gt_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_F16) +v_cmpx_lg_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_LG_F16) +v_cmpx_ge_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_F16) +v_cmpx_o_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_O_F16) +v_cmpx_u_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_U_F16) +v_cmpx_nge_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_NGE_F16) +v_cmpx_nlg_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_NLG_F16) +v_cmpx_ngt_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_NGT_F16) +v_cmpx_nle_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_NLE_F16) +v_cmpx_neq_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_NEQ_F16) +v_cmpx_nlt_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_NLT_F16) +v_cmpx_t_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_T_F16) +v_cmpx_f_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_F_F32) +v_cmpx_lt_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_F32) +v_cmpx_eq_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_F32) +v_cmpx_le_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_F32) +v_cmpx_gt_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_F32) +v_cmpx_lg_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_LG_F32) +v_cmpx_ge_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_F32) +v_cmpx_o_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_O_F32) +v_cmpx_u_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_U_F32) +v_cmpx_nge_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_NGE_F32) +v_cmpx_nlg_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_NLG_F32) +v_cmpx_ngt_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_NGT_F32) +v_cmpx_nle_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_NLE_F32) +v_cmpx_neq_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_NEQ_F32) +v_cmpx_nlt_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_NLT_F32) +v_cmpx_t_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_T_F32) +v_cmpx_f_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_F_F64) +v_cmpx_lt_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_F64) +v_cmpx_eq_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_F64) +v_cmpx_le_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_F64) +v_cmpx_gt_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_F64) +v_cmpx_lg_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_LG_F64) +v_cmpx_ge_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_F64) +v_cmpx_o_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_O_F64) +v_cmpx_u_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_U_F64) +v_cmpx_nge_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_NGE_F64) +v_cmpx_nlg_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_NLG_F64) +v_cmpx_ngt_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_NGT_F64) +v_cmpx_nle_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_NLE_F64) +v_cmpx_neq_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_NEQ_F64) +v_cmpx_nlt_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_NLT_F64) +v_cmpx_t_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_T_F64) +v_cmpx_lt_i16 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_I16) +v_cmpx_eq_i16 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_I16) +v_cmpx_le_i16 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_I16) +v_cmpx_gt_i16 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_I16) +v_cmpx_ne_i16 = functools.partial(VOP3, VOP3Op.V_CMPX_NE_I16) +v_cmpx_ge_i16 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_I16) +v_cmpx_lt_u16 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_U16) +v_cmpx_eq_u16 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_U16) +v_cmpx_le_u16 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_U16) +v_cmpx_gt_u16 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_U16) +v_cmpx_ne_u16 = functools.partial(VOP3, VOP3Op.V_CMPX_NE_U16) +v_cmpx_ge_u16 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_U16) +v_cmpx_f_i32 = functools.partial(VOP3, VOP3Op.V_CMPX_F_I32) +v_cmpx_lt_i32 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_I32) +v_cmpx_eq_i32 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_I32) +v_cmpx_le_i32 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_I32) +v_cmpx_gt_i32 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_I32) +v_cmpx_ne_i32 = functools.partial(VOP3, VOP3Op.V_CMPX_NE_I32) +v_cmpx_ge_i32 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_I32) +v_cmpx_t_i32 = functools.partial(VOP3, VOP3Op.V_CMPX_T_I32) +v_cmpx_f_u32 = functools.partial(VOP3, VOP3Op.V_CMPX_F_U32) +v_cmpx_lt_u32 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_U32) +v_cmpx_eq_u32 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_U32) +v_cmpx_le_u32 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_U32) +v_cmpx_gt_u32 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_U32) +v_cmpx_ne_u32 = functools.partial(VOP3, VOP3Op.V_CMPX_NE_U32) +v_cmpx_ge_u32 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_U32) +v_cmpx_t_u32 = functools.partial(VOP3, VOP3Op.V_CMPX_T_U32) +v_cmpx_f_i64 = functools.partial(VOP3, VOP3Op.V_CMPX_F_I64) +v_cmpx_lt_i64 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_I64) +v_cmpx_eq_i64 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_I64) +v_cmpx_le_i64 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_I64) +v_cmpx_gt_i64 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_I64) +v_cmpx_ne_i64 = functools.partial(VOP3, VOP3Op.V_CMPX_NE_I64) +v_cmpx_ge_i64 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_I64) +v_cmpx_t_i64 = functools.partial(VOP3, VOP3Op.V_CMPX_T_I64) +v_cmpx_f_u64 = functools.partial(VOP3, VOP3Op.V_CMPX_F_U64) +v_cmpx_lt_u64 = functools.partial(VOP3, VOP3Op.V_CMPX_LT_U64) +v_cmpx_eq_u64 = functools.partial(VOP3, VOP3Op.V_CMPX_EQ_U64) +v_cmpx_le_u64 = functools.partial(VOP3, VOP3Op.V_CMPX_LE_U64) +v_cmpx_gt_u64 = functools.partial(VOP3, VOP3Op.V_CMPX_GT_U64) +v_cmpx_ne_u64 = functools.partial(VOP3, VOP3Op.V_CMPX_NE_U64) +v_cmpx_ge_u64 = functools.partial(VOP3, VOP3Op.V_CMPX_GE_U64) +v_cmpx_t_u64 = functools.partial(VOP3, VOP3Op.V_CMPX_T_U64) +v_cmpx_class_f16 = functools.partial(VOP3, VOP3Op.V_CMPX_CLASS_F16) +v_cmpx_class_f32 = functools.partial(VOP3, VOP3Op.V_CMPX_CLASS_F32) +v_cmpx_class_f64 = functools.partial(VOP3, VOP3Op.V_CMPX_CLASS_F64) +v_cndmask_b32 = functools.partial(VOP3, VOP3Op.V_CNDMASK_B32) +v_add_f32 = functools.partial(VOP3, VOP3Op.V_ADD_F32) +v_sub_f32 = functools.partial(VOP3, VOP3Op.V_SUB_F32) +v_subrev_f32 = functools.partial(VOP3, VOP3Op.V_SUBREV_F32) +v_fmac_dx9_zero_f32 = functools.partial(VOP3, VOP3Op.V_FMAC_DX9_ZERO_F32) +v_mul_dx9_zero_f32 = functools.partial(VOP3, VOP3Op.V_MUL_DX9_ZERO_F32) +v_mul_f32 = functools.partial(VOP3, VOP3Op.V_MUL_F32) +v_mul_i32_i24 = functools.partial(VOP3, VOP3Op.V_MUL_I32_I24) +v_mul_hi_i32_i24 = functools.partial(VOP3, VOP3Op.V_MUL_HI_I32_I24) +v_mul_u32_u24 = functools.partial(VOP3, VOP3Op.V_MUL_U32_U24) +v_mul_hi_u32_u24 = functools.partial(VOP3, VOP3Op.V_MUL_HI_U32_U24) +v_min_f32 = functools.partial(VOP3, VOP3Op.V_MIN_F32) +v_max_f32 = functools.partial(VOP3, VOP3Op.V_MAX_F32) +v_min_i32 = functools.partial(VOP3, VOP3Op.V_MIN_I32) +v_max_i32 = functools.partial(VOP3, VOP3Op.V_MAX_I32) +v_min_u32 = functools.partial(VOP3, VOP3Op.V_MIN_U32) +v_max_u32 = functools.partial(VOP3, VOP3Op.V_MAX_U32) +v_lshlrev_b32 = functools.partial(VOP3, VOP3Op.V_LSHLREV_B32) +v_lshrrev_b32 = functools.partial(VOP3, VOP3Op.V_LSHRREV_B32) +v_ashrrev_i32 = functools.partial(VOP3, VOP3Op.V_ASHRREV_I32) +v_and_b32 = functools.partial(VOP3, VOP3Op.V_AND_B32) +v_or_b32 = functools.partial(VOP3, VOP3Op.V_OR_B32) +v_xor_b32 = functools.partial(VOP3, VOP3Op.V_XOR_B32) +v_xnor_b32 = functools.partial(VOP3, VOP3Op.V_XNOR_B32) +v_add_nc_u32 = functools.partial(VOP3, VOP3Op.V_ADD_NC_U32) +v_sub_nc_u32 = functools.partial(VOP3, VOP3Op.V_SUB_NC_U32) +v_subrev_nc_u32 = functools.partial(VOP3, VOP3Op.V_SUBREV_NC_U32) +v_fmac_f32 = functools.partial(VOP3, VOP3Op.V_FMAC_F32) +v_cvt_pk_rtz_f16_f32 = functools.partial(VOP3, VOP3Op.V_CVT_PK_RTZ_F16_F32) +v_add_f16 = functools.partial(VOP3, VOP3Op.V_ADD_F16) +v_sub_f16 = functools.partial(VOP3, VOP3Op.V_SUB_F16) +v_subrev_f16 = functools.partial(VOP3, VOP3Op.V_SUBREV_F16) +v_mul_f16 = functools.partial(VOP3, VOP3Op.V_MUL_F16) +v_fmac_f16 = functools.partial(VOP3, VOP3Op.V_FMAC_F16) +v_max_f16 = functools.partial(VOP3, VOP3Op.V_MAX_F16) +v_min_f16 = functools.partial(VOP3, VOP3Op.V_MIN_F16) +v_ldexp_f16 = functools.partial(VOP3, VOP3Op.V_LDEXP_F16) +v_nop = functools.partial(VOP3, VOP3Op.V_NOP) +v_mov_b32 = functools.partial(VOP3, VOP3Op.V_MOV_B32) +v_readfirstlane_b32 = functools.partial(VOP3, VOP3Op.V_READFIRSTLANE_B32) +v_cvt_i32_f64 = functools.partial(VOP3, VOP3Op.V_CVT_I32_F64) +v_cvt_f64_i32 = functools.partial(VOP3, VOP3Op.V_CVT_F64_I32) +v_cvt_f32_i32 = functools.partial(VOP3, VOP3Op.V_CVT_F32_I32) +v_cvt_f32_u32 = functools.partial(VOP3, VOP3Op.V_CVT_F32_U32) +v_cvt_u32_f32 = functools.partial(VOP3, VOP3Op.V_CVT_U32_F32) +v_cvt_i32_f32 = functools.partial(VOP3, VOP3Op.V_CVT_I32_F32) +v_cvt_f16_f32 = functools.partial(VOP3, VOP3Op.V_CVT_F16_F32) +v_cvt_f32_f16 = functools.partial(VOP3, VOP3Op.V_CVT_F32_F16) +v_cvt_nearest_i32_f32 = functools.partial(VOP3, VOP3Op.V_CVT_NEAREST_I32_F32) +v_cvt_floor_i32_f32 = functools.partial(VOP3, VOP3Op.V_CVT_FLOOR_I32_F32) +v_cvt_off_f32_i4 = functools.partial(VOP3, VOP3Op.V_CVT_OFF_F32_I4) +v_cvt_f32_f64 = functools.partial(VOP3, VOP3Op.V_CVT_F32_F64) +v_cvt_f64_f32 = functools.partial(VOP3, VOP3Op.V_CVT_F64_F32) +v_cvt_f32_ubyte0 = functools.partial(VOP3, VOP3Op.V_CVT_F32_UBYTE0) +v_cvt_f32_ubyte1 = functools.partial(VOP3, VOP3Op.V_CVT_F32_UBYTE1) +v_cvt_f32_ubyte2 = functools.partial(VOP3, VOP3Op.V_CVT_F32_UBYTE2) +v_cvt_f32_ubyte3 = functools.partial(VOP3, VOP3Op.V_CVT_F32_UBYTE3) +v_cvt_u32_f64 = functools.partial(VOP3, VOP3Op.V_CVT_U32_F64) +v_cvt_f64_u32 = functools.partial(VOP3, VOP3Op.V_CVT_F64_U32) +v_trunc_f64 = functools.partial(VOP3, VOP3Op.V_TRUNC_F64) +v_ceil_f64 = functools.partial(VOP3, VOP3Op.V_CEIL_F64) +v_rndne_f64 = functools.partial(VOP3, VOP3Op.V_RNDNE_F64) +v_floor_f64 = functools.partial(VOP3, VOP3Op.V_FLOOR_F64) +v_pipeflush = functools.partial(VOP3, VOP3Op.V_PIPEFLUSH) +v_mov_b16 = functools.partial(VOP3, VOP3Op.V_MOV_B16) +v_fract_f32 = functools.partial(VOP3, VOP3Op.V_FRACT_F32) +v_trunc_f32 = functools.partial(VOP3, VOP3Op.V_TRUNC_F32) +v_ceil_f32 = functools.partial(VOP3, VOP3Op.V_CEIL_F32) +v_rndne_f32 = functools.partial(VOP3, VOP3Op.V_RNDNE_F32) +v_floor_f32 = functools.partial(VOP3, VOP3Op.V_FLOOR_F32) +v_exp_f32 = functools.partial(VOP3, VOP3Op.V_EXP_F32) +v_log_f32 = functools.partial(VOP3, VOP3Op.V_LOG_F32) +v_rcp_f32 = functools.partial(VOP3, VOP3Op.V_RCP_F32) +v_rcp_iflag_f32 = functools.partial(VOP3, VOP3Op.V_RCP_IFLAG_F32) +v_rsq_f32 = functools.partial(VOP3, VOP3Op.V_RSQ_F32) +v_rcp_f64 = functools.partial(VOP3, VOP3Op.V_RCP_F64) +v_rsq_f64 = functools.partial(VOP3, VOP3Op.V_RSQ_F64) +v_sqrt_f32 = functools.partial(VOP3, VOP3Op.V_SQRT_F32) +v_sqrt_f64 = functools.partial(VOP3, VOP3Op.V_SQRT_F64) +v_sin_f32 = functools.partial(VOP3, VOP3Op.V_SIN_F32) +v_cos_f32 = functools.partial(VOP3, VOP3Op.V_COS_F32) +v_not_b32 = functools.partial(VOP3, VOP3Op.V_NOT_B32) +v_bfrev_b32 = functools.partial(VOP3, VOP3Op.V_BFREV_B32) +v_clz_i32_u32 = functools.partial(VOP3, VOP3Op.V_CLZ_I32_U32) +v_ctz_i32_b32 = functools.partial(VOP3, VOP3Op.V_CTZ_I32_B32) +v_cls_i32 = functools.partial(VOP3, VOP3Op.V_CLS_I32) +v_frexp_exp_i32_f64 = functools.partial(VOP3, VOP3Op.V_FREXP_EXP_I32_F64) +v_frexp_mant_f64 = functools.partial(VOP3, VOP3Op.V_FREXP_MANT_F64) +v_fract_f64 = functools.partial(VOP3, VOP3Op.V_FRACT_F64) +v_frexp_exp_i32_f32 = functools.partial(VOP3, VOP3Op.V_FREXP_EXP_I32_F32) +v_frexp_mant_f32 = functools.partial(VOP3, VOP3Op.V_FREXP_MANT_F32) +v_movreld_b32 = functools.partial(VOP3, VOP3Op.V_MOVRELD_B32) +v_movrels_b32 = functools.partial(VOP3, VOP3Op.V_MOVRELS_B32) +v_movrelsd_b32 = functools.partial(VOP3, VOP3Op.V_MOVRELSD_B32) +v_movrelsd_2_b32 = functools.partial(VOP3, VOP3Op.V_MOVRELSD_2_B32) +v_cvt_f16_u16 = functools.partial(VOP3, VOP3Op.V_CVT_F16_U16) +v_cvt_f16_i16 = functools.partial(VOP3, VOP3Op.V_CVT_F16_I16) +v_cvt_u16_f16 = functools.partial(VOP3, VOP3Op.V_CVT_U16_F16) +v_cvt_i16_f16 = functools.partial(VOP3, VOP3Op.V_CVT_I16_F16) +v_rcp_f16 = functools.partial(VOP3, VOP3Op.V_RCP_F16) +v_sqrt_f16 = functools.partial(VOP3, VOP3Op.V_SQRT_F16) +v_rsq_f16 = functools.partial(VOP3, VOP3Op.V_RSQ_F16) +v_log_f16 = functools.partial(VOP3, VOP3Op.V_LOG_F16) +v_exp_f16 = functools.partial(VOP3, VOP3Op.V_EXP_F16) +v_frexp_mant_f16 = functools.partial(VOP3, VOP3Op.V_FREXP_MANT_F16) +v_frexp_exp_i16_f16 = functools.partial(VOP3, VOP3Op.V_FREXP_EXP_I16_F16) +v_floor_f16 = functools.partial(VOP3, VOP3Op.V_FLOOR_F16) +v_ceil_f16 = functools.partial(VOP3, VOP3Op.V_CEIL_F16) +v_trunc_f16 = functools.partial(VOP3, VOP3Op.V_TRUNC_F16) +v_rndne_f16 = functools.partial(VOP3, VOP3Op.V_RNDNE_F16) +v_fract_f16 = functools.partial(VOP3, VOP3Op.V_FRACT_F16) +v_sin_f16 = functools.partial(VOP3, VOP3Op.V_SIN_F16) +v_cos_f16 = functools.partial(VOP3, VOP3Op.V_COS_F16) +v_sat_pk_u8_i16 = functools.partial(VOP3, VOP3Op.V_SAT_PK_U8_I16) +v_cvt_norm_i16_f16 = functools.partial(VOP3, VOP3Op.V_CVT_NORM_I16_F16) +v_cvt_norm_u16_f16 = functools.partial(VOP3, VOP3Op.V_CVT_NORM_U16_F16) +v_not_b16 = functools.partial(VOP3, VOP3Op.V_NOT_B16) +v_cvt_i32_i16 = functools.partial(VOP3, VOP3Op.V_CVT_I32_I16) +v_cvt_u32_u16 = functools.partial(VOP3, VOP3Op.V_CVT_U32_U16) v_fma_dx9_zero_f32 = functools.partial(VOP3, VOP3Op.V_FMA_DX9_ZERO_F32) v_mad_i32_i24 = functools.partial(VOP3, VOP3Op.V_MAD_I32_I24) v_mad_u32_u24 = functools.partial(VOP3, VOP3Op.V_MAD_U32_U24) @@ -3126,196 +3125,196 @@ v_mad_i64_i32 = functools.partial(VOP3SD, VOP3SDOp.V_MAD_I64_I32) v_add_co_u32 = functools.partial(VOP3SD, VOP3SDOp.V_ADD_CO_U32) v_sub_co_u32 = functools.partial(VOP3SD, VOP3SDOp.V_SUB_CO_U32) v_subrev_co_u32 = functools.partial(VOP3SD, VOP3SDOp.V_SUBREV_CO_U32) -v_cmp_f_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_F_F16) -v_cmp_lt_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LT_F16) -v_cmp_eq_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_F16) -v_cmp_le_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LE_F16) -v_cmp_gt_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GT_F16) -v_cmp_lg_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LG_F16) -v_cmp_ge_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GE_F16) -v_cmp_o_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_O_F16) -v_cmp_u_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_U_F16) -v_cmp_nge_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NGE_F16) -v_cmp_nlg_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NLG_F16) -v_cmp_ngt_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NGT_F16) -v_cmp_nle_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NLE_F16) -v_cmp_neq_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NEQ_F16) -v_cmp_nlt_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NLT_F16) -v_cmp_t_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_T_F16) -v_cmp_f_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_F_F32) -v_cmp_lt_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LT_F32) -v_cmp_eq_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_F32) -v_cmp_le_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LE_F32) -v_cmp_gt_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GT_F32) -v_cmp_lg_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LG_F32) -v_cmp_ge_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GE_F32) -v_cmp_o_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_O_F32) -v_cmp_u_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_U_F32) -v_cmp_nge_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NGE_F32) -v_cmp_nlg_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NLG_F32) -v_cmp_ngt_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NGT_F32) -v_cmp_nle_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NLE_F32) -v_cmp_neq_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NEQ_F32) -v_cmp_nlt_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NLT_F32) -v_cmp_t_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_T_F32) -v_cmp_f_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_F_F64) -v_cmp_lt_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LT_F64) -v_cmp_eq_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_F64) -v_cmp_le_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LE_F64) -v_cmp_gt_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GT_F64) -v_cmp_lg_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LG_F64) -v_cmp_ge_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GE_F64) -v_cmp_o_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_O_F64) -v_cmp_u_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_U_F64) -v_cmp_nge_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NGE_F64) -v_cmp_nlg_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NLG_F64) -v_cmp_ngt_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NGT_F64) -v_cmp_nle_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NLE_F64) -v_cmp_neq_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NEQ_F64) -v_cmp_nlt_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NLT_F64) -v_cmp_t_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_T_F64) -v_cmp_lt_i16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LT_I16) -v_cmp_eq_i16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_I16) -v_cmp_le_i16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LE_I16) -v_cmp_gt_i16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GT_I16) -v_cmp_ne_i16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NE_I16) -v_cmp_ge_i16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GE_I16) -v_cmp_lt_u16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LT_U16) -v_cmp_eq_u16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_U16) -v_cmp_le_u16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LE_U16) -v_cmp_gt_u16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GT_U16) -v_cmp_ne_u16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NE_U16) -v_cmp_ge_u16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GE_U16) -v_cmp_f_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_F_I32) -v_cmp_lt_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LT_I32) -v_cmp_eq_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_I32) -v_cmp_le_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LE_I32) -v_cmp_gt_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GT_I32) -v_cmp_ne_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NE_I32) -v_cmp_ge_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GE_I32) -v_cmp_t_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_T_I32) -v_cmp_f_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_F_U32) -v_cmp_lt_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LT_U32) -v_cmp_eq_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_U32) -v_cmp_le_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LE_U32) -v_cmp_gt_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GT_U32) -v_cmp_ne_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NE_U32) -v_cmp_ge_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GE_U32) -v_cmp_t_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_T_U32) -v_cmp_f_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_F_I64) -v_cmp_lt_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LT_I64) -v_cmp_eq_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_I64) -v_cmp_le_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LE_I64) -v_cmp_gt_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GT_I64) -v_cmp_ne_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NE_I64) -v_cmp_ge_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GE_I64) -v_cmp_t_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_T_I64) -v_cmp_f_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_F_U64) -v_cmp_lt_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LT_U64) -v_cmp_eq_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_U64) -v_cmp_le_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_LE_U64) -v_cmp_gt_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GT_U64) -v_cmp_ne_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_NE_U64) -v_cmp_ge_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_GE_U64) -v_cmp_t_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_T_U64) -v_cmp_class_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMP_CLASS_F16) -v_cmp_class_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMP_CLASS_F32) -v_cmp_class_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMP_CLASS_F64) -v_cmpx_f_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_F_F16) -v_cmpx_lt_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_F16) -v_cmpx_eq_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_F16) -v_cmpx_le_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_F16) -v_cmpx_gt_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_F16) -v_cmpx_lg_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LG_F16) -v_cmpx_ge_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_F16) -v_cmpx_o_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_O_F16) -v_cmpx_u_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_U_F16) -v_cmpx_nge_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NGE_F16) -v_cmpx_nlg_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NLG_F16) -v_cmpx_ngt_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NGT_F16) -v_cmpx_nle_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NLE_F16) -v_cmpx_neq_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NEQ_F16) -v_cmpx_nlt_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NLT_F16) -v_cmpx_t_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_T_F16) -v_cmpx_f_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_F_F32) -v_cmpx_lt_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_F32) -v_cmpx_eq_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_F32) -v_cmpx_le_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_F32) -v_cmpx_gt_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_F32) -v_cmpx_lg_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LG_F32) -v_cmpx_ge_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_F32) -v_cmpx_o_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_O_F32) -v_cmpx_u_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_U_F32) -v_cmpx_nge_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NGE_F32) -v_cmpx_nlg_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NLG_F32) -v_cmpx_ngt_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NGT_F32) -v_cmpx_nle_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NLE_F32) -v_cmpx_neq_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NEQ_F32) -v_cmpx_nlt_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NLT_F32) -v_cmpx_t_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_T_F32) -v_cmpx_f_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_F_F64) -v_cmpx_lt_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_F64) -v_cmpx_eq_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_F64) -v_cmpx_le_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_F64) -v_cmpx_gt_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_F64) -v_cmpx_lg_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LG_F64) -v_cmpx_ge_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_F64) -v_cmpx_o_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_O_F64) -v_cmpx_u_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_U_F64) -v_cmpx_nge_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NGE_F64) -v_cmpx_nlg_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NLG_F64) -v_cmpx_ngt_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NGT_F64) -v_cmpx_nle_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NLE_F64) -v_cmpx_neq_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NEQ_F64) -v_cmpx_nlt_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NLT_F64) -v_cmpx_t_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_T_F64) -v_cmpx_lt_i16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_I16) -v_cmpx_eq_i16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_I16) -v_cmpx_le_i16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_I16) -v_cmpx_gt_i16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_I16) -v_cmpx_ne_i16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NE_I16) -v_cmpx_ge_i16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_I16) -v_cmpx_lt_u16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_U16) -v_cmpx_eq_u16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_U16) -v_cmpx_le_u16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_U16) -v_cmpx_gt_u16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_U16) -v_cmpx_ne_u16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NE_U16) -v_cmpx_ge_u16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_U16) -v_cmpx_f_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_F_I32) -v_cmpx_lt_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_I32) -v_cmpx_eq_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_I32) -v_cmpx_le_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_I32) -v_cmpx_gt_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_I32) -v_cmpx_ne_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NE_I32) -v_cmpx_ge_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_I32) -v_cmpx_t_i32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_T_I32) -v_cmpx_f_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_F_U32) -v_cmpx_lt_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_U32) -v_cmpx_eq_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_U32) -v_cmpx_le_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_U32) -v_cmpx_gt_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_U32) -v_cmpx_ne_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NE_U32) -v_cmpx_ge_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_U32) -v_cmpx_t_u32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_T_U32) -v_cmpx_f_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_F_I64) -v_cmpx_lt_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_I64) -v_cmpx_eq_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_I64) -v_cmpx_le_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_I64) -v_cmpx_gt_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_I64) -v_cmpx_ne_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NE_I64) -v_cmpx_ge_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_I64) -v_cmpx_t_i64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_T_I64) -v_cmpx_f_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_F_U64) -v_cmpx_lt_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_U64) -v_cmpx_eq_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_U64) -v_cmpx_le_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_U64) -v_cmpx_gt_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_U64) -v_cmpx_ne_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_NE_U64) -v_cmpx_ge_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_U64) -v_cmpx_t_u64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_T_U64) -v_cmpx_class_f16_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_CLASS_F16) -v_cmpx_class_f32_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_CLASS_F32) -v_cmpx_class_f64_e32 = functools.partial(VOPC, VOPCOp.V_CMPX_CLASS_F64) +v_cmp_f_f16 = functools.partial(VOPC, VOPCOp.V_CMP_F_F16) +v_cmp_lt_f16 = functools.partial(VOPC, VOPCOp.V_CMP_LT_F16) +v_cmp_eq_f16 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_F16) +v_cmp_le_f16 = functools.partial(VOPC, VOPCOp.V_CMP_LE_F16) +v_cmp_gt_f16 = functools.partial(VOPC, VOPCOp.V_CMP_GT_F16) +v_cmp_lg_f16 = functools.partial(VOPC, VOPCOp.V_CMP_LG_F16) +v_cmp_ge_f16 = functools.partial(VOPC, VOPCOp.V_CMP_GE_F16) +v_cmp_o_f16 = functools.partial(VOPC, VOPCOp.V_CMP_O_F16) +v_cmp_u_f16 = functools.partial(VOPC, VOPCOp.V_CMP_U_F16) +v_cmp_nge_f16 = functools.partial(VOPC, VOPCOp.V_CMP_NGE_F16) +v_cmp_nlg_f16 = functools.partial(VOPC, VOPCOp.V_CMP_NLG_F16) +v_cmp_ngt_f16 = functools.partial(VOPC, VOPCOp.V_CMP_NGT_F16) +v_cmp_nle_f16 = functools.partial(VOPC, VOPCOp.V_CMP_NLE_F16) +v_cmp_neq_f16 = functools.partial(VOPC, VOPCOp.V_CMP_NEQ_F16) +v_cmp_nlt_f16 = functools.partial(VOPC, VOPCOp.V_CMP_NLT_F16) +v_cmp_t_f16 = functools.partial(VOPC, VOPCOp.V_CMP_T_F16) +v_cmp_f_f32 = functools.partial(VOPC, VOPCOp.V_CMP_F_F32) +v_cmp_lt_f32 = functools.partial(VOPC, VOPCOp.V_CMP_LT_F32) +v_cmp_eq_f32 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_F32) +v_cmp_le_f32 = functools.partial(VOPC, VOPCOp.V_CMP_LE_F32) +v_cmp_gt_f32 = functools.partial(VOPC, VOPCOp.V_CMP_GT_F32) +v_cmp_lg_f32 = functools.partial(VOPC, VOPCOp.V_CMP_LG_F32) +v_cmp_ge_f32 = functools.partial(VOPC, VOPCOp.V_CMP_GE_F32) +v_cmp_o_f32 = functools.partial(VOPC, VOPCOp.V_CMP_O_F32) +v_cmp_u_f32 = functools.partial(VOPC, VOPCOp.V_CMP_U_F32) +v_cmp_nge_f32 = functools.partial(VOPC, VOPCOp.V_CMP_NGE_F32) +v_cmp_nlg_f32 = functools.partial(VOPC, VOPCOp.V_CMP_NLG_F32) +v_cmp_ngt_f32 = functools.partial(VOPC, VOPCOp.V_CMP_NGT_F32) +v_cmp_nle_f32 = functools.partial(VOPC, VOPCOp.V_CMP_NLE_F32) +v_cmp_neq_f32 = functools.partial(VOPC, VOPCOp.V_CMP_NEQ_F32) +v_cmp_nlt_f32 = functools.partial(VOPC, VOPCOp.V_CMP_NLT_F32) +v_cmp_t_f32 = functools.partial(VOPC, VOPCOp.V_CMP_T_F32) +v_cmp_f_f64 = functools.partial(VOPC, VOPCOp.V_CMP_F_F64) +v_cmp_lt_f64 = functools.partial(VOPC, VOPCOp.V_CMP_LT_F64) +v_cmp_eq_f64 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_F64) +v_cmp_le_f64 = functools.partial(VOPC, VOPCOp.V_CMP_LE_F64) +v_cmp_gt_f64 = functools.partial(VOPC, VOPCOp.V_CMP_GT_F64) +v_cmp_lg_f64 = functools.partial(VOPC, VOPCOp.V_CMP_LG_F64) +v_cmp_ge_f64 = functools.partial(VOPC, VOPCOp.V_CMP_GE_F64) +v_cmp_o_f64 = functools.partial(VOPC, VOPCOp.V_CMP_O_F64) +v_cmp_u_f64 = functools.partial(VOPC, VOPCOp.V_CMP_U_F64) +v_cmp_nge_f64 = functools.partial(VOPC, VOPCOp.V_CMP_NGE_F64) +v_cmp_nlg_f64 = functools.partial(VOPC, VOPCOp.V_CMP_NLG_F64) +v_cmp_ngt_f64 = functools.partial(VOPC, VOPCOp.V_CMP_NGT_F64) +v_cmp_nle_f64 = functools.partial(VOPC, VOPCOp.V_CMP_NLE_F64) +v_cmp_neq_f64 = functools.partial(VOPC, VOPCOp.V_CMP_NEQ_F64) +v_cmp_nlt_f64 = functools.partial(VOPC, VOPCOp.V_CMP_NLT_F64) +v_cmp_t_f64 = functools.partial(VOPC, VOPCOp.V_CMP_T_F64) +v_cmp_lt_i16 = functools.partial(VOPC, VOPCOp.V_CMP_LT_I16) +v_cmp_eq_i16 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_I16) +v_cmp_le_i16 = functools.partial(VOPC, VOPCOp.V_CMP_LE_I16) +v_cmp_gt_i16 = functools.partial(VOPC, VOPCOp.V_CMP_GT_I16) +v_cmp_ne_i16 = functools.partial(VOPC, VOPCOp.V_CMP_NE_I16) +v_cmp_ge_i16 = functools.partial(VOPC, VOPCOp.V_CMP_GE_I16) +v_cmp_lt_u16 = functools.partial(VOPC, VOPCOp.V_CMP_LT_U16) +v_cmp_eq_u16 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_U16) +v_cmp_le_u16 = functools.partial(VOPC, VOPCOp.V_CMP_LE_U16) +v_cmp_gt_u16 = functools.partial(VOPC, VOPCOp.V_CMP_GT_U16) +v_cmp_ne_u16 = functools.partial(VOPC, VOPCOp.V_CMP_NE_U16) +v_cmp_ge_u16 = functools.partial(VOPC, VOPCOp.V_CMP_GE_U16) +v_cmp_f_i32 = functools.partial(VOPC, VOPCOp.V_CMP_F_I32) +v_cmp_lt_i32 = functools.partial(VOPC, VOPCOp.V_CMP_LT_I32) +v_cmp_eq_i32 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_I32) +v_cmp_le_i32 = functools.partial(VOPC, VOPCOp.V_CMP_LE_I32) +v_cmp_gt_i32 = functools.partial(VOPC, VOPCOp.V_CMP_GT_I32) +v_cmp_ne_i32 = functools.partial(VOPC, VOPCOp.V_CMP_NE_I32) +v_cmp_ge_i32 = functools.partial(VOPC, VOPCOp.V_CMP_GE_I32) +v_cmp_t_i32 = functools.partial(VOPC, VOPCOp.V_CMP_T_I32) +v_cmp_f_u32 = functools.partial(VOPC, VOPCOp.V_CMP_F_U32) +v_cmp_lt_u32 = functools.partial(VOPC, VOPCOp.V_CMP_LT_U32) +v_cmp_eq_u32 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_U32) +v_cmp_le_u32 = functools.partial(VOPC, VOPCOp.V_CMP_LE_U32) +v_cmp_gt_u32 = functools.partial(VOPC, VOPCOp.V_CMP_GT_U32) +v_cmp_ne_u32 = functools.partial(VOPC, VOPCOp.V_CMP_NE_U32) +v_cmp_ge_u32 = functools.partial(VOPC, VOPCOp.V_CMP_GE_U32) +v_cmp_t_u32 = functools.partial(VOPC, VOPCOp.V_CMP_T_U32) +v_cmp_f_i64 = functools.partial(VOPC, VOPCOp.V_CMP_F_I64) +v_cmp_lt_i64 = functools.partial(VOPC, VOPCOp.V_CMP_LT_I64) +v_cmp_eq_i64 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_I64) +v_cmp_le_i64 = functools.partial(VOPC, VOPCOp.V_CMP_LE_I64) +v_cmp_gt_i64 = functools.partial(VOPC, VOPCOp.V_CMP_GT_I64) +v_cmp_ne_i64 = functools.partial(VOPC, VOPCOp.V_CMP_NE_I64) +v_cmp_ge_i64 = functools.partial(VOPC, VOPCOp.V_CMP_GE_I64) +v_cmp_t_i64 = functools.partial(VOPC, VOPCOp.V_CMP_T_I64) +v_cmp_f_u64 = functools.partial(VOPC, VOPCOp.V_CMP_F_U64) +v_cmp_lt_u64 = functools.partial(VOPC, VOPCOp.V_CMP_LT_U64) +v_cmp_eq_u64 = functools.partial(VOPC, VOPCOp.V_CMP_EQ_U64) +v_cmp_le_u64 = functools.partial(VOPC, VOPCOp.V_CMP_LE_U64) +v_cmp_gt_u64 = functools.partial(VOPC, VOPCOp.V_CMP_GT_U64) +v_cmp_ne_u64 = functools.partial(VOPC, VOPCOp.V_CMP_NE_U64) +v_cmp_ge_u64 = functools.partial(VOPC, VOPCOp.V_CMP_GE_U64) +v_cmp_t_u64 = functools.partial(VOPC, VOPCOp.V_CMP_T_U64) +v_cmp_class_f16 = functools.partial(VOPC, VOPCOp.V_CMP_CLASS_F16) +v_cmp_class_f32 = functools.partial(VOPC, VOPCOp.V_CMP_CLASS_F32) +v_cmp_class_f64 = functools.partial(VOPC, VOPCOp.V_CMP_CLASS_F64) +v_cmpx_f_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_F_F16) +v_cmpx_lt_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_F16) +v_cmpx_eq_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_F16) +v_cmpx_le_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_F16) +v_cmpx_gt_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_F16) +v_cmpx_lg_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_LG_F16) +v_cmpx_ge_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_F16) +v_cmpx_o_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_O_F16) +v_cmpx_u_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_U_F16) +v_cmpx_nge_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_NGE_F16) +v_cmpx_nlg_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_NLG_F16) +v_cmpx_ngt_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_NGT_F16) +v_cmpx_nle_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_NLE_F16) +v_cmpx_neq_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_NEQ_F16) +v_cmpx_nlt_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_NLT_F16) +v_cmpx_t_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_T_F16) +v_cmpx_f_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_F_F32) +v_cmpx_lt_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_F32) +v_cmpx_eq_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_F32) +v_cmpx_le_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_F32) +v_cmpx_gt_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_F32) +v_cmpx_lg_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_LG_F32) +v_cmpx_ge_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_F32) +v_cmpx_o_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_O_F32) +v_cmpx_u_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_U_F32) +v_cmpx_nge_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_NGE_F32) +v_cmpx_nlg_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_NLG_F32) +v_cmpx_ngt_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_NGT_F32) +v_cmpx_nle_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_NLE_F32) +v_cmpx_neq_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_NEQ_F32) +v_cmpx_nlt_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_NLT_F32) +v_cmpx_t_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_T_F32) +v_cmpx_f_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_F_F64) +v_cmpx_lt_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_F64) +v_cmpx_eq_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_F64) +v_cmpx_le_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_F64) +v_cmpx_gt_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_F64) +v_cmpx_lg_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_LG_F64) +v_cmpx_ge_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_F64) +v_cmpx_o_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_O_F64) +v_cmpx_u_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_U_F64) +v_cmpx_nge_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_NGE_F64) +v_cmpx_nlg_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_NLG_F64) +v_cmpx_ngt_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_NGT_F64) +v_cmpx_nle_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_NLE_F64) +v_cmpx_neq_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_NEQ_F64) +v_cmpx_nlt_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_NLT_F64) +v_cmpx_t_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_T_F64) +v_cmpx_lt_i16 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_I16) +v_cmpx_eq_i16 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_I16) +v_cmpx_le_i16 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_I16) +v_cmpx_gt_i16 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_I16) +v_cmpx_ne_i16 = functools.partial(VOPC, VOPCOp.V_CMPX_NE_I16) +v_cmpx_ge_i16 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_I16) +v_cmpx_lt_u16 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_U16) +v_cmpx_eq_u16 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_U16) +v_cmpx_le_u16 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_U16) +v_cmpx_gt_u16 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_U16) +v_cmpx_ne_u16 = functools.partial(VOPC, VOPCOp.V_CMPX_NE_U16) +v_cmpx_ge_u16 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_U16) +v_cmpx_f_i32 = functools.partial(VOPC, VOPCOp.V_CMPX_F_I32) +v_cmpx_lt_i32 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_I32) +v_cmpx_eq_i32 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_I32) +v_cmpx_le_i32 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_I32) +v_cmpx_gt_i32 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_I32) +v_cmpx_ne_i32 = functools.partial(VOPC, VOPCOp.V_CMPX_NE_I32) +v_cmpx_ge_i32 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_I32) +v_cmpx_t_i32 = functools.partial(VOPC, VOPCOp.V_CMPX_T_I32) +v_cmpx_f_u32 = functools.partial(VOPC, VOPCOp.V_CMPX_F_U32) +v_cmpx_lt_u32 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_U32) +v_cmpx_eq_u32 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_U32) +v_cmpx_le_u32 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_U32) +v_cmpx_gt_u32 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_U32) +v_cmpx_ne_u32 = functools.partial(VOPC, VOPCOp.V_CMPX_NE_U32) +v_cmpx_ge_u32 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_U32) +v_cmpx_t_u32 = functools.partial(VOPC, VOPCOp.V_CMPX_T_U32) +v_cmpx_f_i64 = functools.partial(VOPC, VOPCOp.V_CMPX_F_I64) +v_cmpx_lt_i64 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_I64) +v_cmpx_eq_i64 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_I64) +v_cmpx_le_i64 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_I64) +v_cmpx_gt_i64 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_I64) +v_cmpx_ne_i64 = functools.partial(VOPC, VOPCOp.V_CMPX_NE_I64) +v_cmpx_ge_i64 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_I64) +v_cmpx_t_i64 = functools.partial(VOPC, VOPCOp.V_CMPX_T_I64) +v_cmpx_f_u64 = functools.partial(VOPC, VOPCOp.V_CMPX_F_U64) +v_cmpx_lt_u64 = functools.partial(VOPC, VOPCOp.V_CMPX_LT_U64) +v_cmpx_eq_u64 = functools.partial(VOPC, VOPCOp.V_CMPX_EQ_U64) +v_cmpx_le_u64 = functools.partial(VOPC, VOPCOp.V_CMPX_LE_U64) +v_cmpx_gt_u64 = functools.partial(VOPC, VOPCOp.V_CMPX_GT_U64) +v_cmpx_ne_u64 = functools.partial(VOPC, VOPCOp.V_CMPX_NE_U64) +v_cmpx_ge_u64 = functools.partial(VOPC, VOPCOp.V_CMPX_GE_U64) +v_cmpx_t_u64 = functools.partial(VOPC, VOPCOp.V_CMPX_T_U64) +v_cmpx_class_f16 = functools.partial(VOPC, VOPCOp.V_CMPX_CLASS_F16) +v_cmpx_class_f32 = functools.partial(VOPC, VOPCOp.V_CMPX_CLASS_F32) +v_cmpx_class_f64 = functools.partial(VOPC, VOPCOp.V_CMPX_CLASS_F64) v_dual_fmac_f32 = functools.partial(VOPD, VOPDOp.V_DUAL_FMAC_F32) v_dual_fmaak_f32 = functools.partial(VOPD, VOPDOp.V_DUAL_FMAAK_F32) v_dual_fmamk_f32 = functools.partial(VOPD, VOPDOp.V_DUAL_FMAMK_F32) diff --git a/extra/assembly/rdna3/lib.py b/extra/assembly/rdna3/lib.py index 59f78fc1a1..3484c684a1 100644 --- a/extra/assembly/rdna3/lib.py +++ b/extra/assembly/rdna3/lib.py @@ -1,36 +1,20 @@ # library for RDNA3 assembly DSL from __future__ import annotations +import re from enum import IntEnum -from typing import overload, Annotated, TypeVar, Generic # Bit field DSL class BitField: def __init__(self, hi: int, lo: int, name: str | None = None): self.hi, self.lo, self.name = hi, lo, name - def __set_name__(self, owner, name): self.name, self._owner = name, owner + def __set_name__(self, owner, name): self.name = name def __eq__(self, val: int) -> tuple[BitField, int]: return (self, val) # type: ignore def mask(self) -> int: return (1 << (self.hi - self.lo + 1)) - 1 - @property - def marker(self) -> type | None: - # Get marker from Annotated type hint if present - import typing - if hasattr(self, '_owner') and self.name: - hints = typing.get_type_hints(self._owner, include_extras=True) - if self.name in hints: - hint = hints[self.name] - if typing.get_origin(hint) is Annotated: - args = typing.get_args(hint) - return args[1] if len(args) > 1 else None - return None - @overload - def __get__(self, obj: None, objtype: type) -> BitField: ... - @overload - def __get__(self, obj: object, objtype: type | None = None) -> int: ... def __get__(self, obj, objtype=None): if obj is None: return self val = unwrap(obj._values.get(self.name, 0)) - # Convert to IntEnum if marker is an IntEnum subclass - if self.marker and isinstance(self.marker, type) and issubclass(self.marker, IntEnum): - try: return self.marker(val) + ann = getattr(type(obj), '__annotations__', {}).get(self.name) + if ann and isinstance(ann, type) and issubclass(ann, IntEnum): + try: return ann(val) except ValueError: pass return val @@ -40,77 +24,54 @@ bits = _Bits() # Register types class Reg: - def __init__(self, idx: int, count: int = 1, hi: bool = False, neg: bool = False): self.idx, self.count, self.hi, self.neg = idx, count, hi, neg + def __init__(self, idx: int, count: int = 1, hi: bool = False): self.idx, self.count, self.hi = idx, count, hi def __repr__(self): return f"{self.__class__.__name__.lower()[0]}[{self.idx}]" if self.count == 1 else f"{self.__class__.__name__.lower()[0]}[{self.idx}:{self.idx + self.count}]" - def __neg__(self): return self.__class__(self.idx, self.count, self.hi, neg=not self.neg) - -T = TypeVar('T', bound=Reg) -class _RegFactory(Generic[T]): - def __init__(self, cls: type[T], name: str): self._cls, self._name = cls, name - @overload - def __getitem__(self, key: int) -> Reg: ... - @overload - def __getitem__(self, key: slice) -> Reg: ... - def __getitem__(self, key: int | slice) -> Reg: - return self._cls(key.start, key.stop - key.start + 1) if isinstance(key, slice) else self._cls(key) - def __repr__(self): return f"<{self._name} factory>" - + @classmethod + def __class_getitem__(cls, key): return cls(key.start, key.stop - key.start) if isinstance(key, slice) else cls(key) class SGPR(Reg): pass class VGPR(Reg): pass class TTMP(Reg): pass -s: _RegFactory[SGPR] = _RegFactory(SGPR, "SGPR") -v: _RegFactory[VGPR] = _RegFactory(VGPR, "VGPR") -ttmp: _RegFactory[TTMP] = _RegFactory(TTMP, "TTMP") +s, v = SGPR, VGPR -# Field type markers (runtime classes for validation) -class _SSrc: pass -class _Src: pass -class _Imm: pass -class _SImm: pass -class _VDSTYEnc: pass # VOPD vdsty: encoded = actual >> 1, actual = (encoded << 1) | ((vdstx & 1) ^ 1) -class _SGPRField: pass -class _VGPRField: pass - -# Type aliases for annotations - tells mypy it's a BitField while preserving marker info -SSrc = Annotated[BitField, _SSrc] -Src = Annotated[BitField, _Src] -Imm = Annotated[BitField, _Imm] -SImm = Annotated[BitField, _SImm] -VDSTYEnc = Annotated[BitField, _VDSTYEnc] -SGPRField = Annotated[BitField, _SGPRField] -VGPRField = Annotated[BitField, _VGPRField] +# Field type markers +class SSrc: pass +class Src: pass +class Imm: pass +class SImm: pass class RawImm: def __init__(self, val: int): self.val = val - def __repr__(self): return f"RawImm({self.val})" - def __eq__(self, other): return isinstance(other, RawImm) and self.val == other.val def unwrap(val) -> int: return val.val if isinstance(val, RawImm) else val.value if hasattr(val, 'value') else val.idx if hasattr(val, 'idx') else val # Encoding helpers FLOAT_ENC = {0.5: 240, -0.5: 241, 1.0: 242, -1.0: 243, 2.0: 244, -2.0: 245, 4.0: 246, -4.0: 247} -SRC_FIELDS = {'src0', 'src1', 'src2', 'ssrc0', 'ssrc1', 'soffset', 'srcx0', 'srcy0'} +SRC_FIELDS = {'src0', 'src1', 'src2', 'ssrc0', 'ssrc1', 'soffset'} RAW_FIELDS = {'vdata', 'vdst', 'vaddr', 'addr', 'data', 'data0', 'data1', 'sdst', 'sdata'} -def _encode_reg(val) -> int: - if isinstance(val, TTMP): return 108 + val.idx - return val.idx | (0x80 if val.hi else 0) - def encode_src(val) -> int: - if isinstance(val, VGPR): return 256 + _encode_reg(val) - if isinstance(val, Reg): return _encode_reg(val) + if isinstance(val, SGPR): return val.idx | (0x80 if val.hi else 0) + if isinstance(val, VGPR): return 256 + val.idx + (0x80 if val.hi else 0) # .h sets bit 7 of VGPR encoding + if isinstance(val, TTMP): return 108 + val.idx if hasattr(val, 'value'): return val.value - if isinstance(val, float): return 128 if val == 0.0 else FLOAT_ENC.get(val, 255) + if isinstance(val, float): return FLOAT_ENC.get(val, 255) return 128 + val if isinstance(val, int) and 0 <= val <= 64 else 192 + (-val) if isinstance(val, int) and -16 <= val <= -1 else 255 +SPECIAL_DEC = {106: "vcc_lo", 107: "vcc_hi", 124: "null", 125: "m0", 126: "exec_lo", 127: "exec_hi", **{v: str(k) for k, v in FLOAT_ENC.items()}} +def decode_src(val: int) -> str: + if val <= 105: return f"s{val}" + if val in SPECIAL_DEC: return SPECIAL_DEC[val] + if 108 <= val <= 123: return f"ttmp{val - 108}" + if 128 <= val <= 192: return str(val - 128) + if 193 <= val <= 208: return str(-(val - 192)) + if 256 <= val <= 511: return f"v{val - 256}" + return "lit" if val == 255 else f"?{val}" + # Instruction base class class Inst: _fields: dict[str, BitField] _encoding: tuple[BitField, int] | None = None - _defaults: dict[str, int] = {} - _values: dict[str, int | RawImm] - _words: int # size in 32-bit words, set by decode_program - _literal: int | None + _defaults: dict[str, int] = {} # field defaults def __init_subclass__(cls, **kwargs): super().__init_subclass__(**kwargs) @@ -118,82 +79,18 @@ class Inst: if 'encoding' in cls._fields and isinstance(cls.__dict__.get('encoding'), tuple): cls._encoding = cls.__dict__['encoding'] def __init__(self, *args, literal: int | None = None, **kwargs): - self._values, self._literal = dict(self._defaults), literal - # Map positional args to field names - field_names = [n for n in self._fields if n != 'encoding'] - orig_args = dict(zip(field_names, args)) - orig_args.update(kwargs) - self._values.update(orig_args) - # Validate register counts for SMEM instructions (before encoding) - if self.__class__.__name__ == 'SMEM': - op_val = orig_args.get(field_names[0]) if args else orig_args.get('op') - if op_val is not None: - if hasattr(op_val, 'value'): op_val = op_val.value - expected_cnt = {0:1, 1:2, 2:4, 3:8, 4:16, 8:1, 9:2, 10:4, 11:8, 12:16}.get(op_val) - sdata_val = orig_args.get('sdata') - if expected_cnt is not None and isinstance(sdata_val, Reg) and sdata_val.count != expected_cnt: - raise ValueError(f"SMEM op {op_val} expects {expected_cnt} registers, got {sdata_val.count}") - # Validate register counts for SOP1 instructions (b32 = 1 reg, b64 = 2 regs) - if self.__class__.__name__ == 'SOP1': - op_val = orig_args.get(field_names[0]) if args else orig_args.get('op') - if op_val is not None and hasattr(op_val, 'name'): - expected = 2 if op_val.name.endswith('_B64') else 1 - sdst_val, ssrc0_val = orig_args.get('sdst'), orig_args.get('ssrc0') - if isinstance(sdst_val, Reg) and sdst_val.count != expected: - raise ValueError(f"SOP1 {op_val.name} expects {expected} destination register(s), got {sdst_val.count}") - if isinstance(ssrc0_val, Reg) and ssrc0_val.count != expected: - raise ValueError(f"SOP1 {op_val.name} expects {expected} source register(s), got {ssrc0_val.count}") - # Type check and encode values - for name, val in list(self._values.items()): - if name == 'encoding': continue - # For RawImm, only process RAW_FIELDS to unwrap to int - if isinstance(val, RawImm): - if name in RAW_FIELDS: self._values[name] = val.val - continue - field = self._fields.get(name) - marker = field.marker if field else None - # Type validation - if marker is _SGPRField: - if isinstance(val, VGPR): raise TypeError(f"field '{name}' requires SGPR, got VGPR") - if not isinstance(val, (SGPR, TTMP, int, RawImm)): raise TypeError(f"field '{name}' requires SGPR, got {type(val).__name__}") - if marker is _VGPRField: - if not isinstance(val, VGPR): raise TypeError(f"field '{name}' requires VGPR, got {type(val).__name__}") - if marker is _SSrc and isinstance(val, VGPR): raise TypeError(f"field '{name}' requires scalar source, got VGPR") - # Encode source fields as RawImm for consistent disassembly - if name in SRC_FIELDS: - encoded = encode_src(val) - self._values[name] = RawImm(encoded) - # Handle negation modifier for VOP3 instructions - if isinstance(val, Reg) and val.neg and 'neg' in self._fields: - neg_bit = {'src0': 1, 'src1': 2, 'src2': 4}.get(name, 0) - cur_neg = self._values.get('neg', 0) - self._values['neg'] = (cur_neg.val if isinstance(cur_neg, RawImm) else cur_neg) | neg_bit - # Track literal value if needed (encoded as 255) - # For 64-bit ops, store literal in high 32 bits (to match from_bytes decoding and to_bytes encoding) - if encoded == 255 and self._literal is None and isinstance(val, int) and not isinstance(val, IntEnum): - self._literal = (val << 32) if self._is_64bit_op() else val - elif encoded == 255 and self._literal is None and isinstance(val, float): - import struct - lit32 = struct.unpack('> 1 (constraint: vdsty parity must be opposite of vdstx) - elif marker is _VDSTYEnc and isinstance(val, VGPR): - self._values[name] = val.idx >> 1 + self._values, self._literal = dict(self._defaults), literal # start with defaults + self._values.update(zip([n for n in self._fields if n != 'encoding'], args)) + self._values.update(kwargs) def _encode_field(self, name: str, val) -> int: if isinstance(val, RawImm): return val.val if name in {'srsrc', 'ssamp'}: return val.idx // 4 if isinstance(val, Reg) else val if name == 'sbase': return val.idx // 2 if isinstance(val, Reg) else val - if name in RAW_FIELDS: return _encode_reg(val) if isinstance(val, Reg) else val + if name in RAW_FIELDS: + if isinstance(val, TTMP): return 108 + val.idx + if isinstance(val, Reg): return val.idx | (0x80 if val.hi else 0) # .h sets bit 7 for vdst + return val if isinstance(val, Reg) or name in SRC_FIELDS: return encode_src(val) return val.value if hasattr(val, 'value') else val @@ -208,35 +105,13 @@ class Inst: if n in self._values and not isinstance(v := self._values[n], RawImm) and isinstance(v, int) and not isinstance(v, IntEnum) and not (0 <= v <= 64 or -16 <= v <= -1): return v return None - def _is_64bit_op(self) -> bool: - """Check if this instruction uses 64-bit operands (and thus 64-bit literals). - Exception: V_LDEXP_F64 has 32-bit integer src1, so its literal is 32-bit.""" - op = self._values.get('op') - if op is None: return False - # op may be an enum (from __init__) or an int (from from_int) - op_name = op.name if hasattr(op, 'name') else None - if op_name is None and self.__class__.__name__ == 'VOP3': - from extra.assembly.rdna3.autogen import VOP3Op - try: op_name = VOP3Op(op).name - except ValueError: pass - if op_name is None: return False - # V_LDEXP_F64 has 32-bit integer exponent in src1, so literal is 32-bit - if op_name == 'V_LDEXP_F64': return False - return op_name.endswith(('_F64', '_B64', '_I64', '_U64')) - def to_bytes(self) -> bytes: result = self.to_int().to_bytes(self._size(), 'little') - lit = self._get_literal() or getattr(self, '_literal', None) - if lit is None: return result - # For 64-bit ops, literal is stored in high 32 bits internally, but encoded as 4 bytes - lit32 = (lit >> 32) if self._is_64bit_op() else lit - return result + (lit32 & 0xffffffff).to_bytes(4, 'little') + return result + (lit & 0xffffffff).to_bytes(4, 'little') if (lit := self._get_literal() or getattr(self, '_literal', None)) else result @classmethod def _size(cls) -> int: return 4 if issubclass(cls, Inst32) else 8 - def size(self) -> int: - # Literal is always 4 bytes in the binary (for 64-bit ops, it's in high 32 bits) - return self._size() + (4 if self._literal is not None else 0) + def size(self) -> int: return self._size() + (4 if self._literal is not None else 0) @classmethod def from_int(cls, word: int): @@ -250,240 +125,146 @@ class Inst: inst = cls.from_int(int.from_bytes(data[:cls._size()], 'little')) op_val = inst._values.get('op', 0) has_literal = cls.__name__ == 'VOP2' and op_val in (44, 45, 55, 56) - has_literal = has_literal or (cls.__name__ == 'SOP2' and op_val in (69, 70)) + has_literal = has_literal or (cls.__name__ == 'SOP2' and op_val in (69, 70)) # S_FMAAK_F32, S_FMAMK_F32 for n in SRC_FIELDS: if n in inst._values and isinstance(inst._values[n], RawImm) and inst._values[n].val == 255: has_literal = True - if has_literal: - # For 64-bit ops, the literal is 32 bits placed in the HIGH 32 bits of the 64-bit value - # (low 32 bits are zero). This is how AMD hardware interprets 32-bit literals for 64-bit ops. - if len(data) >= cls._size() + 4: - lit32 = int.from_bytes(data[cls._size():cls._size()+4], 'little') - inst._literal = (lit32 << 32) if inst._is_64bit_op() else lit32 + if has_literal and len(data) >= cls._size() + 4: inst._literal = int.from_bytes(data[cls._size():cls._size()+4], 'little') return inst - def __repr__(self): - # Use _fields order and exclude fields that are 0/default (for consistent repr after roundtrip) - def is_zero(v): return (isinstance(v, int) and v == 0) or (isinstance(v, VGPR) and v.idx == 0 and v.count == 1) - items = [(k, self._values[k]) for k in self._fields if k in self._values and k != 'encoding' - and not (is_zero(self._values[k]) and k not in {'op'})] - lit = f", literal={hex(self._literal)}" if self._literal is not None else "" - return f"{self.__class__.__name__}({', '.join(f'{k}={v}' for k, v in items)}{lit})" - - def __eq__(self, other): - if not isinstance(other, Inst): return NotImplemented - return self.__class__ == other.__class__ and self._values == other._values and self._literal == other._literal - - def __hash__(self): return hash((self.__class__.__name__, tuple(sorted((k, repr(v)) for k, v in self._values.items())), self._literal)) + def __repr__(self): return f"{self.__class__.__name__}({', '.join(f'{k}={v}' for k, v in self._values.items())})" def disasm(self) -> str: - from extra.assembly.rdna3.asm import disasm - return disasm(self) + op_val = unwrap(self._values.get('op', 0)) + try: + from extra.assembly.rdna3 import autogen + op_name = getattr(autogen, f"{self.__class__.__name__}Op")(op_val).name.lower() if hasattr(autogen, f"{self.__class__.__name__}Op") else f"op_{op_val}" + except (ValueError, KeyError): op_name = f"op_{op_val}" + def fmt(n, v): + v = unwrap(v) + if n in SRC_FIELDS: return f"0x{self._literal:x}" if v == 255 and getattr(self, '_literal', None) else decode_src(v) if v != 255 else "0xff" + if n in ('sdst', 'vdst'): return f"{'s' if n == 'sdst' else 'v'}{v}" + return f"v{v}" if n == 'vsrc1' else f"0x{v:x}" if n == 'simm16' else str(v) + ops = [fmt(n, self._values.get(n, 0)) for n in self._fields if n not in ('encoding', 'op')] + if self.__class__.__name__ == 'VOP2' and getattr(self, '_literal', None) and op_val in (44, 45, 55, 56): + lit_str = f"0x{self._literal:x}" + ops.insert(2, lit_str) if op_val in (44, 55) else ops.append(lit_str) + return f"{op_name} {', '.join(ops)}" if ops else op_name class Inst32(Inst): pass -class Inst64(Inst): pass +class Inst64(Inst): + def to_bytes(self) -> bytes: + result = self.to_int().to_bytes(8, 'little') + return result + (lit & 0xffffffff).to_bytes(4, 'little') if (lit := self._get_literal() or getattr(self, '_literal', None)) else result + @classmethod + def from_bytes(cls, data: bytes): return cls.from_int(int.from_bytes(data[:8], 'little')) -# ═══════════════════════════════════════════════════════════════════════════════ -# CODE GENERATION: generates autogen/__init__.py by parsing the AMD RDNA3.5 ISA PDF -# ═══════════════════════════════════════════════════════════════════════════════ +# Waitcnt helpers +def waitcnt(vmcnt: int = 0x7f, expcnt: int = 0x7, lgkmcnt: int = 0x3f) -> int: + return (vmcnt & 0xf) | ((expcnt & 0x7) << 4) | (((vmcnt >> 4) & 0x7) << 7) | ((lgkmcnt & 0x3f) << 10) +def decode_waitcnt(val: int) -> tuple[int, int, int]: + return (val & 0xf) | (((val >> 7) & 0x7) << 4), (val >> 4) & 0x7, (val >> 10) & 0x3f -PDF_URL = "https://docs.amd.com/api/khub/documents/UVVZM22UN7tMUeiW_4ShTQ/content" -FIELD_TYPES = {'SSRC0': 'SSrc', 'SSRC1': 'SSrc', 'SOFFSET': 'SSrc', 'SADDR': 'SSrc', 'SRC0': 'Src', 'SRC1': 'Src', 'SRC2': 'Src', - 'SDST': 'SGPRField', 'SBASE': 'SGPRField', 'SDATA': 'SGPRField', 'SRSRC': 'SGPRField', 'VDST': 'VGPRField', 'VSRC1': 'VGPRField', 'VDATA': 'VGPRField', - 'VADDR': 'VGPRField', 'ADDR': 'VGPRField', 'DATA': 'VGPRField', 'DATA0': 'VGPRField', 'DATA1': 'VGPRField', 'SIMM16': 'SImm', 'OFFSET': 'Imm', - 'OPX': 'VOPDOp', 'OPY': 'VOPDOp', 'SRCX0': 'Src', 'SRCY0': 'Src', 'VSRCX1': 'VGPRField', 'VSRCY1': 'VGPRField', 'VDSTX': 'VGPRField', 'VDSTY': 'VDSTYEnc'} -FIELD_ORDER = { - 'SOP2': ['op', 'sdst', 'ssrc0', 'ssrc1'], 'SOP1': ['op', 'sdst', 'ssrc0'], 'SOPC': ['op', 'ssrc0', 'ssrc1'], - 'SOPK': ['op', 'sdst', 'simm16'], 'SOPP': ['op', 'simm16'], 'VOP1': ['op', 'vdst', 'src0'], 'VOPC': ['op', 'src0', 'vsrc1'], - 'VOP2': ['op', 'vdst', 'src0', 'vsrc1'], 'VOP3SD': ['op', 'vdst', 'sdst', 'src0', 'src1', 'src2', 'clmp'], - 'SMEM': ['op', 'sdata', 'sbase', 'soffset', 'offset', 'glc', 'dlc'], 'DS': ['op', 'vdst', 'addr', 'data0', 'data1'], - 'VOP3': ['op', 'vdst', 'src0', 'src1', 'src2', 'omod', 'neg', 'abs', 'clmp', 'opsel'], - 'VOP3P': ['op', 'vdst', 'src0', 'src1', 'src2', 'neg', 'neg_hi', 'opsel', 'opsel_hi', 'clmp'], - 'FLAT': ['op', 'vdst', 'addr', 'data', 'saddr', 'offset', 'seg', 'dlc', 'glc', 'slc'], - 'MUBUF': ['op', 'vdata', 'vaddr', 'srsrc', 'soffset', 'offset', 'offen', 'idxen', 'glc', 'dlc', 'slc', 'tfe'], - 'MTBUF': ['op', 'vdata', 'vaddr', 'srsrc', 'soffset', 'offset', 'format', 'offen', 'idxen', 'glc', 'dlc', 'slc', 'tfe'], - 'MIMG': ['op', 'vdata', 'vaddr', 'srsrc', 'ssamp', 'dmask', 'dim', 'unrm', 'dlc', 'glc', 'slc'], - 'EXP': ['en', 'target', 'vsrc0', 'vsrc1', 'vsrc2', 'vsrc3', 'done', 'row'], - 'VINTERP': ['op', 'vdst', 'src0', 'src1', 'src2', 'waitexp', 'clmp', 'opsel', 'neg'], - 'VOPD': ['opx', 'opy', 'vdstx', 'vdsty', 'srcx0', 'vsrcx1', 'srcy0', 'vsrcy1'], - 'LDSDIR': ['op', 'vdst', 'attr', 'attr_chan', 'wait_va']} -SRC_EXTRAS = {233: 'DPP8', 234: 'DPP8FI', 250: 'DPP16', 251: 'VCCZ', 252: 'EXECZ', 254: 'LDS_DIRECT'} -FLOAT_MAP = {'0.5': 'POS_HALF', '-0.5': 'NEG_HALF', '1.0': 'POS_ONE', '-1.0': 'NEG_ONE', '2.0': 'POS_TWO', '-2.0': 'NEG_TWO', - '4.0': 'POS_FOUR', '-4.0': 'NEG_FOUR', '1/(2*PI)': 'INV_2PI', '0': 'ZERO'} +# Assembler +SPECIAL_REGS = {'vcc_lo': RawImm(106), 'vcc_hi': RawImm(107), 'null': RawImm(124), 'off': RawImm(124), 'm0': RawImm(125), 'exec_lo': RawImm(126), 'exec_hi': RawImm(127), 'scc': RawImm(253)} +FLOAT_CONSTS = {'0.5': 0.5, '-0.5': -0.5, '1.0': 1.0, '-1.0': -1.0, '2.0': 2.0, '-2.0': -2.0, '4.0': 4.0, '-4.0': -4.0} +REG_MAP = {'s': SGPR, 'v': VGPR, 't': TTMP, 'ttmp': TTMP} -def _parse_bits(s: str) -> tuple[int, int] | None: - import re - return (int(m.group(1)), int(m.group(2) or m.group(1))) if (m := re.match(r'\[(\d+)(?::(\d+))?\]', s)) else None +def parse_operand(op: str) -> tuple: + op = op.strip().lower() + neg = op.startswith('-') and not op[1:2].isdigit(); op = op[1:] if neg else op + abs_ = op.startswith('|') and op.endswith('|') or op.startswith('abs(') and op.endswith(')') + op = op[1:-1] if op.startswith('|') else op[4:-1] if op.startswith('abs(') else op + # Handle .l/.h suffix (16-bit register halves) + hi_half = op.endswith('.h') + op = re.sub(r'\.[lh]$', '', op) + if op in FLOAT_CONSTS: return (FLOAT_CONSTS[op], neg, abs_, hi_half) + if re.match(r'^-?\d+$', op): return (int(op), neg, abs_, hi_half) + if m := re.match(r'^-?0x([0-9a-f]+)$', op): + v = -int(m.group(1), 16) if op.startswith('-') else int(m.group(1), 16) + return (v, neg, abs_, hi_half) + if op in SPECIAL_REGS: return (SPECIAL_REGS[op], neg, abs_, hi_half) + if m := re.match(r'^([svt](?:tmp)?)\[(\d+):(\d+)\]$', op): return (REG_MAP[m.group(1)][int(m.group(2)):int(m.group(3))+1], neg, abs_, hi_half) + if m := re.match(r'^([svt](?:tmp)?)(\d+)$', op): + reg_cls = REG_MAP[m.group(1)] + return (reg_cls(int(m.group(2)), 1, hi_half), neg, abs_, hi_half) + raise ValueError(f"cannot parse operand: {op}") -def _parse_fields_table(table: list, fmt: str, enums: set[str]) -> list[tuple]: - import re - fields = [] - for row in table[1:]: - if not row or not row[0]: continue - name, bits_str = row[0].split('\n')[0].strip(), (row[1] or '').split('\n')[0].strip() - if not (bits := _parse_bits(bits_str)): continue - enc_val, hi, lo = None, bits[0], bits[1] - if name == 'ENCODING' and row[2] and (m := re.search(r"'b([01_]+)", row[2])): - enc_bits = m.group(1).replace('_', '') - enc_val = int(enc_bits, 2) - declared_width, actual_width = hi - lo + 1, len(enc_bits) - if actual_width > declared_width: lo = hi - actual_width + 1 - ftype = f"{fmt}Op" if name == 'OP' and f"{fmt}Op" in enums else FIELD_TYPES.get(name.upper()) - fields.append((name, hi, lo, enc_val, ftype)) - return fields +SMEM_OPS = {'s_load_b32', 's_load_b64', 's_load_b128', 's_load_b256', 's_load_b512', + 's_buffer_load_b32', 's_buffer_load_b64', 's_buffer_load_b128', 's_buffer_load_b256', 's_buffer_load_b512'} +SOP1_SRC_ONLY = {'s_setpc_b64', 's_rfe_b64'} # instructions with ssrc0 only, no sdst +SOP1_MSG_IMM = {'s_sendmsg_rtn_b32', 's_sendmsg_rtn_b64'} # instructions with raw immediate in ssrc0 +SOPK_IMM_ONLY = {'s_version'} # instructions with simm16 only, no sdst +SOPK_IMM_FIRST = {'s_setreg_b32'} # instructions where simm16 comes before sdst +SOPK_UNSUPPORTED = {'s_setreg_imm32_b32'} # special 64-bit SOPK format -def generate(output_path: str | None = None) -> dict: - """Generate RDNA3.5 instruction definitions from the AMD ISA PDF. Returns dict with formats for testing.""" - import re, pdfplumber, pathlib - from tinygrad.helpers import fetch - - pdf = pdfplumber.open(fetch(PDF_URL)) - pages = pdf.pages[150:200] - page_texts = [p.extract_text() or '' for p in pages] - page_tables = [[t.extract() for t in p.find_tables()] for p in pages] - full_text = '\n'.join(page_texts) - - # parse SSRC encoding from first page with VCC_LO - src_enum = dict(SRC_EXTRAS) - for text in page_texts[:10]: - if 'SSRC0' in text and 'VCC_LO' in text: - for m in re.finditer(r'^(\d+)\s+(\S+)', text, re.M): - val, name = int(m.group(1)), m.group(2).rstrip('.:') - if name in FLOAT_MAP: src_enum[val] = FLOAT_MAP[name] - elif re.match(r'^[A-Z][A-Z0-9_]*$', name): src_enum[val] = name - break - - # parse opcode tables - enums: dict[str, dict[int, str]] = {} - for m in re.finditer(r'Table \d+\. (\w+) Opcodes(.*?)(?=Table \d+\.|\n\d+\.\d+\.\d+\.\s+\w+\s*\nDescription|$)', full_text, re.S): - if ops := {int(x.group(1)): x.group(2) for x in re.finditer(r'(\d+)\s+([A-Z][A-Z0-9_]+)', m.group(2))}: - enums[m.group(1) + "Op"] = ops - if vopd_m := re.search(r'Table \d+\. VOPD Y-Opcodes\n(.*?)(?=Table \d+\.|15\.\d)', full_text, re.S): - if ops := {int(x.group(1)): x.group(2) for x in re.finditer(r'(\d+)\s+(V_DUAL_\w+)', vopd_m.group(1))}: - enums["VOPDOp"] = ops - enum_names = set(enums.keys()) - - def is_fields_table(t) -> bool: return t and len(t) > 1 and t[0] and 'Field' in str(t[0][0] or '') - def has_encoding(fields) -> bool: return any(f[0] == 'ENCODING' for f in fields) - def has_header_before_fields(text) -> bool: - return (pos := text.find('Field Name')) != -1 and bool(re.search(r'\d+\.\d+\.\d+\.\s+\w+\s*\n', text[:pos])) - - # find format headers with their page indices - format_headers = [] # (fmt_name, page_idx) - for i, text in enumerate(page_texts): - for m in re.finditer(r'\d+\.\d+\.\d+\.\s+(\w+)\s*\n?Description', text): format_headers.append((m.group(1), i, m.start())) - for m in re.finditer(r'\d+\.\d+\.\d+\.\s+(\w+)\s*\n', text): - if m.start() > len(text) - 200 and 'Description' not in text[m.end():] and i + 1 < len(page_texts): - next_text = page_texts[i + 1].lstrip() - if next_text.startswith('Description') or (next_text.startswith('"RDNA') and 'Description' in next_text[:200]): - format_headers.append((m.group(1), i, m.start())) - - # parse instruction formats - formats: dict[str, list] = {} - for fmt_name, page_idx, header_pos in format_headers: - if fmt_name in formats: continue - text, tables = page_texts[page_idx], page_tables[page_idx] - field_pos = text.find('Field Name', header_pos) - - # find fields table with ENCODING (same page or up to 2 pages ahead) - fields = None - for offset in range(3): - if page_idx + offset >= len(pages): break - if offset > 0 and has_header_before_fields(page_texts[page_idx + offset]): break - for t in page_tables[page_idx + offset] if offset > 0 or field_pos > header_pos else []: - if is_fields_table(t) and (f := _parse_fields_table(t, fmt_name, enum_names)) and has_encoding(f): - fields = f - break - if fields: break - - # for modifier formats (no ENCODING), accept first fields table on same page - if not fields and field_pos > header_pos: - for t in tables: - if is_fields_table(t) and (f := _parse_fields_table(t, fmt_name, enum_names)): - fields = f - break - - if not fields: continue - field_names = {f[0] for f in fields} - - # check next pages for continuation fields (tables without ENCODING) - for pg_offset in range(1, 3): - if page_idx + pg_offset >= len(pages) or has_header_before_fields(page_texts[page_idx + pg_offset]): break - for t in page_tables[page_idx + pg_offset]: - if is_fields_table(t) and (extra := _parse_fields_table(t, fmt_name, enum_names)) and not has_encoding(extra): - for ef in extra: - if ef[0] not in field_names: - fields.append(ef) - field_names.add(ef[0]) - break - formats[fmt_name] = fields - - # fix known PDF errors (verified against LLVM test vectors) - # SMEM: PDF says DLC=bit14, GLC=bit16 but actual encoding is DLC=bit13, GLC=bit14 - if 'SMEM' in formats: - formats['SMEM'] = [(n, 13 if n == 'DLC' else 14 if n == 'GLC' else h, 13 if n == 'DLC' else 14 if n == 'GLC' else l, e, t) - for n, h, l, e, t in formats['SMEM']] - - # generate output - def enum_lines(name, items): - return [f"class {name}(IntEnum):"] + [f" {n} = {v}" for v, n in sorted(items.items())] + [""] - def field_key(f): return order.index(f[0].lower()) if f[0].lower() in order else 1000 - lines = ["# autogenerated from AMD RDNA3.5 ISA PDF by lib.py - do not edit", "from enum import IntEnum", - "from typing import Annotated", - "from extra.assembly.rdna3.lib import bits, BitField, Inst32, Inst64, SGPR, VGPR, TTMP as TTMP, s as s, v as v, ttmp as ttmp, SSrc, Src, SImm, Imm, VDSTYEnc, SGPRField, VGPRField", - "import functools", ""] - lines += enum_lines("SrcEnum", src_enum) + sum([enum_lines(n, ops) for n, ops in sorted(enums.items())], []) - # Format-specific field defaults (verified against LLVM test vectors) - format_defaults = {'VOP3P': {'opsel_hi': 3, 'opsel_hi2': 1}} - lines.append("# instruction formats") - for fmt_name, fields in sorted(formats.items()): - base = "Inst64" if max(f[1] for f in fields) > 31 or fmt_name == 'VOP3SD' else "Inst32" - order = FIELD_ORDER.get(fmt_name, []) - lines.append(f"class {fmt_name}({base}):") - if enc := next((f for f in fields if f[0] == 'ENCODING'), None): - enc_str = f"bits[{enc[1]}:{enc[2]}] == 0b{enc[3]:b}" if enc[1] != enc[2] else f"bits[{enc[1]}] == {enc[3]}" - lines.append(f" encoding = {enc_str}") - if defaults := format_defaults.get(fmt_name): - lines.append(f" _defaults = {defaults}") - for name, hi, lo, _, ftype in sorted([f for f in fields if f[0] != 'ENCODING'], key=field_key): - # Wrap IntEnum types (ending in Op) with Annotated[BitField, ...] for correct typing - if ftype and ftype.endswith('Op'): - ann = f":Annotated[BitField, {ftype}]" - else: - ann = f":{ftype}" if ftype else "" - lines.append(f" {name.lower()}{ann} = bits[{hi}]" if hi == lo else f" {name.lower()}{ann} = bits[{hi}:{lo}]") - lines.append("") - lines.append("# instruction helpers") - for cls_name, ops in sorted(enums.items()): - fmt = cls_name[:-2] - for op_val, name in sorted(ops.items()): - seg = {"GLOBAL": ", seg=2", "SCRATCH": ", seg=2"}.get(fmt, "") - tgt = {"GLOBAL": "FLAT, GLOBALOp", "SCRATCH": "FLAT, SCRATCHOp"}.get(fmt, f"{fmt}, {cls_name}") - if fmt in formats or fmt in ("GLOBAL", "SCRATCH"): - # VOP1/VOP2/VOPC get _e32 suffix, VOP3 promoted ops (< 512) get _e64 suffix - if fmt in ("VOP1", "VOP2", "VOPC"): - suffix = "_e32" - elif fmt == "VOP3" and op_val < 512: - suffix = "_e64" - else: - suffix = "" - # FMAMK/FMAAK have a literal constant K that must be passed via literal= kwarg - # FMAMK: D = S0.f * K + S1.f (K is 3rd operand in assembly syntax) - # FMAAK: D = S0.f * S1.f + K (K is 4th operand in assembly syntax) - if name in ('V_FMAMK_F32', 'V_FMAMK_F16'): - lines.append(f"def {name.lower()}{suffix}(vdst, src0, K, vsrc1): return {fmt}({cls_name}.{name}, vdst, src0, vsrc1, literal=K)") - elif name in ('V_FMAAK_F32', 'V_FMAAK_F16'): - lines.append(f"def {name.lower()}{suffix}(vdst, src0, vsrc1, K): return {fmt}({cls_name}.{name}, vdst, src0, vsrc1, literal=K)") - else: - lines.append(f"{name.lower()}{suffix} = functools.partial({tgt}.{name}{seg})") - # export SrcEnum values, but skip DPP8/DPP16 which conflict with class names - skip_exports = {'DPP8', 'DPP16'} - lines += [""] + [f"{name} = SrcEnum.{name}" for _, name in sorted(src_enum.items()) if name not in skip_exports] + ["OFF = NULL\n"] - - if output_path is not None: - import pathlib - pathlib.Path(output_path).write_text('\n'.join(lines)) - return {"formats": formats, "enums": enums, "src_enum": src_enum} - -if __name__ == "__main__": - result = generate("extra/assembly/rdna3/autogen/__init__.py") - print(f"generated SrcEnum ({len(result['src_enum'])}) + {len(result['enums'])} opcode enums + {len(result['formats'])} format classes") +def asm(text: str) -> Inst: + from extra.assembly.rdna3 import autogen + text = text.strip() + clamp = 'clamp' in text.lower() + if clamp: text = re.sub(r'\s+clamp\s*$', '', text, flags=re.I) + # Parse modifiers like wait_exp:N + modifiers = {} + if m := re.search(r'\s+wait_exp:(\d+)', text, re.I): modifiers['waitexp'] = int(m.group(1)); text = text[:m.start()] + text[m.end():] + parts = text.replace(',', ' ').split() + if not parts: raise ValueError("empty instruction") + mnemonic, op_str = parts[0].lower(), text[len(parts[0]):].strip() + operands, current, depth, in_pipe = [], "", 0, False + for ch in op_str: + if ch == '[': depth += 1 + elif ch == ']': depth -= 1 + elif ch == '|': in_pipe = not in_pipe + if ch == ',' and depth == 0 and not in_pipe: operands.append(current.strip()); current = "" + else: current += ch + if current.strip(): operands.append(current.strip()) + parsed = [parse_operand(op) for op in operands] + values = [p[0] for p in parsed] + neg_bits = sum((1 << (i-1)) for i, p in enumerate(parsed) if i > 0 and p[1]) + abs_bits = sum((1 << (i-1)) for i, p in enumerate(parsed) if i > 0 and p[2]) + # Compute opsel bits for VOP3: bit0=src0.h, bit1=src1.h, bit2=src2.h, bit3=vdst.h + opsel_bits = (8 if len(parsed) > 0 and parsed[0][3] else 0) | sum((1 << i) for i, p in enumerate(parsed[1:4]) if p[3]) + lit = None + if mnemonic in ('v_fmaak_f32', 'v_fmaak_f16') and len(values) == 4: lit, values = unwrap(values[3]), values[:3] + elif mnemonic in ('v_fmamk_f32', 'v_fmamk_f16') and len(values) == 4: lit, values = unwrap(values[2]), [values[0], values[1], values[3]] + # VCC-using VOP2 instructions: skip implicit VCC operands (format: vdst, vcc_dst, src0, src1, vcc_src) + vcc_ops = {'v_add_co_ci_u32', 'v_sub_co_ci_u32', 'v_subrev_co_ci_u32', 'v_add_co_u32', 'v_sub_co_u32', 'v_subrev_co_u32'} + if mnemonic.replace('_e32', '') in vcc_ops and len(values) >= 5: values = [values[0], values[2], values[3]] + # VOPC: skip implicit VCC destination operand (format: vcc_dst, src0, src1) + if mnemonic.startswith('v_cmp') and len(values) >= 3 and operands[0].strip().lower() in ('vcc_lo', 'vcc_hi', 'vcc'): + values = values[1:] # skip vcc destination + # VOP3SD (v_div_scale_*): has vdst, sdst, then 3 sources - neg/abs apply to sources (operands 2,3,4) + vop3sd_ops = {'v_div_scale_f32', 'v_div_scale_f64'} + if mnemonic in vop3sd_ops and len(parsed) >= 5: + neg_bits = sum((1 << i) for i, p in enumerate(parsed[2:5]) if p[1]) + abs_bits = sum((1 << i) for i, p in enumerate(parsed[2:5]) if p[2]) + # Unsupported instructions + if mnemonic in SOPK_UNSUPPORTED: raise ValueError(f"unsupported instruction: {mnemonic}") + # SOP1 source-only instructions (no destination) + elif mnemonic in SOP1_SRC_ONLY: + return getattr(autogen, mnemonic)(ssrc0=values[0]) + # SOP1 instructions with raw immediate message ID + elif mnemonic in SOP1_MSG_IMM: + return getattr(autogen, mnemonic)(sdst=values[0], ssrc0=RawImm(unwrap(values[1]))) + # SOPK immediate-only instructions (no destination) + elif mnemonic in SOPK_IMM_ONLY: + return getattr(autogen, mnemonic)(simm16=values[0]) + # SOPK instructions with simm16 before sdst + elif mnemonic in SOPK_IMM_FIRST: + return getattr(autogen, mnemonic)(simm16=values[0], sdst=values[1]) + # SMEM: when third operand is immediate, use it as offset with soffset=NULL + elif mnemonic in SMEM_OPS and len(operands) >= 3 and re.match(r'^-?[0-9]|^-?0x', operands[2].strip().lower()): + return getattr(autogen, mnemonic)(sdata=values[0], sbase=values[1], offset=values[2], soffset=RawImm(124)) + # MUBUF: when vaddr is 'off', use 0 instead of NULL + elif mnemonic.startswith('buffer_') and len(operands) >= 2 and operands[1].strip().lower() == 'off': + return getattr(autogen, mnemonic)(vdata=values[0], vaddr=0, srsrc=values[2], soffset=RawImm(unwrap(values[3])) if len(values) > 3 else RawImm(0)) + for suffix in (['_e32', ''] if not (neg_bits or abs_bits or clamp) else ['', '_e32']): + if hasattr(autogen, name := mnemonic.replace('.', '_') + suffix): + use_opsel = 'opsel' in getattr(autogen, name).func._fields + # For VOP3+, clear hi flags from registers (opsel handles hi half selection) + vals = [type(v)(v.idx, v.count, False) if isinstance(v, Reg) and v.hi and use_opsel else v for v in values] + inst = getattr(autogen, name)(*vals, literal=lit, **modifiers) + if neg_bits and 'neg' in inst._fields: inst._values['neg'] = neg_bits + if opsel_bits and use_opsel: inst._values['opsel'] = opsel_bits + if abs_bits and 'abs' in inst._fields: inst._values['abs'] = abs_bits + if clamp and 'clmp' in inst._fields: inst._values['clmp'] = 1 + return inst + raise ValueError(f"unknown instruction: {mnemonic}")