""" THIS FILE IS AUTO GENERATED. ANY MODIFICATION WILL BE LOST AFTER REGENERATION. """ # flake8: noqa # noinspection PyUnresolvedReferences from typing import Optional, Hashable, Dict, Set # noinspection PyUnresolvedReferences from .autogen_validate_operands import * # noinspection PyUnresolvedReferences from .autogen_validate_modifiers import * # noinspection PyUnresolvedReferences from ...basic.instr import InstrCall, MemToken, SrcLoc # noinspection DuplicatedCode,PyDictCreation def v_add_co_u32(vdst, vcc_out, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_co_u32 Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_co_u32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_add_co_u32', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_src('vop2', 'v_add_co_u32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_co_u32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_co_u32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vcc_out, vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_add_co_u32_dpp(vdst, vcc_out, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_co_u32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_co_u32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_add_co_u32_dpp', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_co_u32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_co_u32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_add_co_u32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_add_co_u32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_add_co_u32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_add_co_u32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_co_u32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vcc_out, vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_add_co_u32_sdwa(vdst, vcc_out, src0, src1, /, clamp=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_co_u32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: clamp/*synid-clamp*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_co_u32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_add_co_u32_sdwa', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_src_1('vop2', 'v_add_co_u32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_add_co_u32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_add_co_u32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_dst_sel('vop2', 'v_add_co_u32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_add_co_u32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_add_co_u32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_add_co_u32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_co_u32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vcc_out, vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_add_f16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_f16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_f16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_add_f16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_f16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_f16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_add_f16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_f16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_f16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_f16_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_f16_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_add_f16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_add_f16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_add_f16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_add_f16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_f16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_add_f16_sdwa(vdst, src0, src1, /, clamp=None, omod=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_f16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ Modifiers: clamp/*synid-clamp*/ omod/*synid-omod*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'omod': omod, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_f16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_add_f16_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_src_1('vop2', 'v_add_f16_sdwa', operands, modifiers, 'src1', src1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_add_f16_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_omod('vop2', 'v_add_f16_sdwa', operands, modifiers, 'omod', omod) validate_modifier_synid_dst_sel('vop2', 'v_add_f16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_add_f16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_add_f16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_add_f16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_f16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_add_f32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_f32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_f32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_add_f32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_f32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_f32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_add_f32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_f32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_f32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_f32_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_f32_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_add_f32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_add_f32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_add_f32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_add_f32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_f32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_add_f32_sdwa(vdst, src0, src1, /, clamp=None, omod=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_f32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ Modifiers: clamp/*synid-clamp*/ omod/*synid-omod*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'omod': omod, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_f32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_add_f32_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_src_1('vop2', 'v_add_f32_sdwa', operands, modifiers, 'src1', src1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_add_f32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_omod('vop2', 'v_add_f32_sdwa', operands, modifiers, 'omod', omod) validate_modifier_synid_dst_sel('vop2', 'v_add_f32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_add_f32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_add_f32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_add_f32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_f32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_add_u16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_u16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-3*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_u16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_3('vop2', 'v_add_u16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_u16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_u16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_add_u16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_u16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_u16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_u16_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_u16_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_add_u16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_add_u16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_add_u16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_add_u16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_u16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_add_u16_sdwa(vdst, src0, src1, /, clamp=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_u16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ Modifiers: clamp/*synid-clamp*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_u16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_4('vop2', 'v_add_u16_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_4('vop2', 'v_add_u16_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_add_u16_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_dst_sel('vop2', 'v_add_u16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_add_u16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_add_u16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_add_u16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_u16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_add_u32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_u32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_u32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_add_u32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_u32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_u32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_add_u32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_u32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_u32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_u32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_add_u32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_add_u32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_add_u32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_add_u32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_add_u32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_u32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_add_u32_sdwa(vdst, src0, src1, /, clamp=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_add_u32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: clamp/*synid-clamp*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_add_u32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_add_u32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_add_u32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_add_u32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_dst_sel('vop2', 'v_add_u32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_add_u32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_add_u32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_add_u32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_add_u32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_addc_co_u32(vdst, vcc_out, src0, vsrc1, vcc_in, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_addc_co_u32 Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ src2: vcc_in/*synid-gfx9-vcc*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'src0': src0, 'vsrc1': vsrc1, 'vcc_in': vcc_in} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_addc_co_u32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_addc_co_u32', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_src('vop2', 'v_addc_co_u32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_addc_co_u32', operands, modifiers, 'vsrc1', vsrc1) validate_operand_synid_gfx9_vcc('vop2', 'v_addc_co_u32', operands, modifiers, 'vcc_in', vcc_in) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_addc_co_u32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vcc_in, vsrc1) call.add_gpr_defs(vcc_out, vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_addc_co_u32_dpp(vdst, vcc_out, vsrc0, vsrc1, vcc_in, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_addc_co_u32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ src2: vcc_in/*synid-gfx9-vcc*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'vsrc0': vsrc0, 'vsrc1': vsrc1, 'vcc_in': vcc_in} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_addc_co_u32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_addc_co_u32_dpp', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_addc_co_u32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_addc_co_u32_dpp', operands, modifiers, 'vsrc1', vsrc1) validate_operand_synid_gfx9_vcc('vop2', 'v_addc_co_u32_dpp', operands, modifiers, 'vcc_in', vcc_in) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_addc_co_u32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_addc_co_u32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_addc_co_u32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_addc_co_u32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_addc_co_u32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vcc_in, vsrc0, vsrc1) call.add_gpr_defs(vcc_out, vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_addc_co_u32_sdwa(vdst, vcc_out, src0, src1, vcc_in, /, clamp=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_addc_co_u32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src2: vcc_in/*synid-gfx9-vcc*/ Modifiers: clamp/*synid-clamp*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'src0': src0, 'src1': src1, 'vcc_in': vcc_in} modifiers = {'clamp': clamp, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_addc_co_u32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_addc_co_u32_sdwa', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_src_1('vop2', 'v_addc_co_u32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_addc_co_u32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) validate_operand_synid_gfx9_vcc('vop2', 'v_addc_co_u32_sdwa', operands, modifiers, 'vcc_in', vcc_in) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_addc_co_u32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_dst_sel('vop2', 'v_addc_co_u32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_addc_co_u32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_addc_co_u32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_addc_co_u32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_addc_co_u32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1, vcc_in) call.add_gpr_defs(vcc_out, vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_and_b32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_and_b32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_and_b32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_and_b32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_and_b32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_and_b32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_and_b32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_and_b32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_and_b32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_and_b32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_and_b32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_and_b32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_and_b32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_and_b32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_and_b32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_and_b32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_and_b32_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_and_b32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_and_b32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_and_b32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_and_b32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_and_b32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_and_b32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_and_b32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_and_b32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_and_b32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_ashrrev_i16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_ashrrev_i16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-6*/:u16/*synid-gfx9-type-deviation*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_ashrrev_i16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_6('vop2', 'v_ashrrev_i16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_ashrrev_i16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_ashrrev_i16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_ashrrev_i16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_ashrrev_i16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:u16/*synid-gfx9-type-deviation*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_ashrrev_i16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_ashrrev_i16_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_ashrrev_i16_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_ashrrev_i16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_ashrrev_i16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_ashrrev_i16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_ashrrev_i16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_ashrrev_i16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_ashrrev_i16_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_ashrrev_i16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/:u16/*synid-gfx9-type-deviation*/ src1: src1/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_ashrrev_i16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_4('vop2', 'v_ashrrev_i16_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_4('vop2', 'v_ashrrev_i16_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_ashrrev_i16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_ashrrev_i16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_ashrrev_i16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_ashrrev_i16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_ashrrev_i16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_ashrrev_i32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_ashrrev_i32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-7*/:u32/*synid-gfx9-type-deviation*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_ashrrev_i32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_7('vop2', 'v_ashrrev_i32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_ashrrev_i32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_ashrrev_i32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_ashrrev_i32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_ashrrev_i32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:u32/*synid-gfx9-type-deviation*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_ashrrev_i32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_ashrrev_i32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_ashrrev_i32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_ashrrev_i32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_ashrrev_i32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_ashrrev_i32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_ashrrev_i32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_ashrrev_i32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_ashrrev_i32_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_ashrrev_i32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/:u32/*synid-gfx9-type-deviation*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_ashrrev_i32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_ashrrev_i32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_ashrrev_i32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_ashrrev_i32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_ashrrev_i32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_ashrrev_i32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_ashrrev_i32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_ashrrev_i32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_cndmask_b32(vdst, src0, vsrc1, vcc_in, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_cndmask_b32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ src2: vcc_in/*synid-gfx9-vcc*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1, 'vcc_in': vcc_in} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_cndmask_b32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_cndmask_b32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_cndmask_b32', operands, modifiers, 'vsrc1', vsrc1) validate_operand_synid_gfx9_vcc('vop2', 'v_cndmask_b32', operands, modifiers, 'vcc_in', vcc_in) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_cndmask_b32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vcc_in, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_cndmask_b32_dpp(vdst, vsrc0, vsrc1, vcc_in, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_cndmask_b32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ src2: vcc_in/*synid-gfx9-vcc*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1, 'vcc_in': vcc_in} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_cndmask_b32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_cndmask_b32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_cndmask_b32_dpp', operands, modifiers, 'vsrc1', vsrc1) validate_operand_synid_gfx9_vcc('vop2', 'v_cndmask_b32_dpp', operands, modifiers, 'vcc_in', vcc_in) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_cndmask_b32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_cndmask_b32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_cndmask_b32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_cndmask_b32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_cndmask_b32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vcc_in, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_cndmask_b32_sdwa(vdst, src0, src1, vcc_in, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_cndmask_b32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src2: vcc_in/*synid-gfx9-vcc*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1, 'vcc_in': vcc_in} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_cndmask_b32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_cndmask_b32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_cndmask_b32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) validate_operand_synid_gfx9_vcc('vop2', 'v_cndmask_b32_sdwa', operands, modifiers, 'vcc_in', vcc_in) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_cndmask_b32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_cndmask_b32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_cndmask_b32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_cndmask_b32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_cndmask_b32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1, vcc_in) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_ldexp_f16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_ldexp_f16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:i16/*synid-gfx9-type-deviation*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_ldexp_f16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_ldexp_f16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_ldexp_f16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_ldexp_f16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_ldexp_f16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_ldexp_f16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:i16/*synid-gfx9-type-deviation*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_ldexp_f16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_ldexp_f16_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_ldexp_f16_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_ldexp_f16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_ldexp_f16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_ldexp_f16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_ldexp_f16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_ldexp_f16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_ldexp_f16_sdwa(vdst, src0, src1, /, clamp=None, omod=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_ldexp_f16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/:i16/*synid-gfx9-type-deviation*/ Modifiers: clamp/*synid-clamp*/ omod/*synid-omod*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'omod': omod, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_ldexp_f16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_ldexp_f16_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_src_1('vop2', 'v_ldexp_f16_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_ldexp_f16_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_omod('vop2', 'v_ldexp_f16_sdwa', operands, modifiers, 'omod', omod) validate_modifier_synid_dst_sel('vop2', 'v_ldexp_f16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_ldexp_f16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_ldexp_f16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_ldexp_f16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_ldexp_f16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_lshlrev_b16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_lshlrev_b16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-6*/:u16/*synid-gfx9-type-deviation*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_lshlrev_b16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_6('vop2', 'v_lshlrev_b16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_lshlrev_b16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_lshlrev_b16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_lshlrev_b16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_lshlrev_b16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:u16/*synid-gfx9-type-deviation*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_lshlrev_b16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_lshlrev_b16_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_lshlrev_b16_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_lshlrev_b16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_lshlrev_b16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_lshlrev_b16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_lshlrev_b16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_lshlrev_b16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_lshlrev_b16_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_lshlrev_b16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/:u16/*synid-gfx9-type-deviation*/ src1: src1/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_lshlrev_b16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_4('vop2', 'v_lshlrev_b16_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_4('vop2', 'v_lshlrev_b16_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_lshlrev_b16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_lshlrev_b16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_lshlrev_b16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_lshlrev_b16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_lshlrev_b16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_lshlrev_b32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_lshlrev_b32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-7*/:u32/*synid-gfx9-type-deviation*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_lshlrev_b32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_7('vop2', 'v_lshlrev_b32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_lshlrev_b32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_lshlrev_b32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_lshlrev_b32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_lshlrev_b32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:u32/*synid-gfx9-type-deviation*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_lshlrev_b32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_lshlrev_b32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_lshlrev_b32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_lshlrev_b32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_lshlrev_b32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_lshlrev_b32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_lshlrev_b32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_lshlrev_b32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_lshlrev_b32_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_lshlrev_b32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/:u32/*synid-gfx9-type-deviation*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_lshlrev_b32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_lshlrev_b32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_lshlrev_b32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_lshlrev_b32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_lshlrev_b32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_lshlrev_b32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_lshlrev_b32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_lshlrev_b32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_lshrrev_b16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_lshrrev_b16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-6*/:u16/*synid-gfx9-type-deviation*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_lshrrev_b16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_6('vop2', 'v_lshrrev_b16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_lshrrev_b16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_lshrrev_b16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_lshrrev_b16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_lshrrev_b16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:u16/*synid-gfx9-type-deviation*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_lshrrev_b16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_lshrrev_b16_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_lshrrev_b16_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_lshrrev_b16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_lshrrev_b16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_lshrrev_b16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_lshrrev_b16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_lshrrev_b16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_lshrrev_b16_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_lshrrev_b16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/:u16/*synid-gfx9-type-deviation*/ src1: src1/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_lshrrev_b16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_4('vop2', 'v_lshrrev_b16_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_4('vop2', 'v_lshrrev_b16_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_lshrrev_b16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_lshrrev_b16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_lshrrev_b16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_lshrrev_b16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_lshrrev_b16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_lshrrev_b32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_lshrrev_b32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-7*/:u32/*synid-gfx9-type-deviation*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_lshrrev_b32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_7('vop2', 'v_lshrrev_b32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_lshrrev_b32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_lshrrev_b32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_lshrrev_b32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_lshrrev_b32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:u32/*synid-gfx9-type-deviation*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_lshrrev_b32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_lshrrev_b32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_lshrrev_b32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_lshrrev_b32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_lshrrev_b32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_lshrrev_b32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_lshrrev_b32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_lshrrev_b32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_lshrrev_b32_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_lshrrev_b32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/:u32/*synid-gfx9-type-deviation*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_lshrrev_b32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_lshrrev_b32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_lshrrev_b32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_lshrrev_b32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_lshrrev_b32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_lshrrev_b32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_lshrrev_b32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_lshrrev_b32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mac_f16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mac_f16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mac_f16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_mac_f16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mac_f16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mac_f16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mac_f16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mac_f16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mac_f16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mac_f16_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mac_f16_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_mac_f16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_mac_f16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_mac_f16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_mac_f16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mac_f16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mac_f32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mac_f32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mac_f32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_mac_f32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mac_f32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mac_f32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mac_f32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mac_f32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mac_f32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mac_f32_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mac_f32_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_mac_f32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_mac_f32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_mac_f32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_mac_f32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mac_f32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_madak_f16(vdst, src0, vsrc1, simm32, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_madak_f16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-8*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ src2: simm32/*synid-gfx9-simm32-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1, 'simm32': simm32} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_madak_f16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_8('vop2', 'v_madak_f16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_madak_f16', operands, modifiers, 'vsrc1', vsrc1) validate_operand_synid_gfx9_simm32_1('vop2', 'v_madak_f16', operands, modifiers, 'simm32', simm32) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_madak_f16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, simm32, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_madak_f32(vdst, src0, vsrc1, simm32, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_madak_f32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-8*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ src2: simm32/*synid-gfx9-simm32-2*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1, 'simm32': simm32} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_madak_f32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_8('vop2', 'v_madak_f32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_madak_f32', operands, modifiers, 'vsrc1', vsrc1) validate_operand_synid_gfx9_simm32_2('vop2', 'v_madak_f32', operands, modifiers, 'simm32', simm32) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_madak_f32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, simm32, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_madmk_f16(vdst, src0, simm32, vsrc2, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_madmk_f16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-8*/ src1: simm32/*synid-gfx9-simm32-1*/ src2: vsrc2/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'simm32': simm32, 'vsrc2': vsrc2} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_madmk_f16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_8('vop2', 'v_madmk_f16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_simm32_1('vop2', 'v_madmk_f16', operands, modifiers, 'simm32', simm32) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_madmk_f16', operands, modifiers, 'vsrc2', vsrc2) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_madmk_f16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, simm32, src0, vsrc2) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_madmk_f32(vdst, src0, simm32, vsrc2, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_madmk_f32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-8*/ src1: simm32/*synid-gfx9-simm32-2*/ src2: vsrc2/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'simm32': simm32, 'vsrc2': vsrc2} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_madmk_f32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_8('vop2', 'v_madmk_f32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_simm32_2('vop2', 'v_madmk_f32', operands, modifiers, 'simm32', simm32) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_madmk_f32', operands, modifiers, 'vsrc2', vsrc2) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_madmk_f32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, simm32, src0, vsrc2) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_f16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_f16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_f16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_max_f16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_f16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_f16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_f16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_f16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_f16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_f16_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_f16_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_max_f16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_max_f16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_max_f16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_max_f16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_f16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_f16_sdwa(vdst, src0, src1, /, clamp=None, omod=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_f16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ Modifiers: clamp/*synid-clamp*/ omod/*synid-omod*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'omod': omod, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_f16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_max_f16_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_src_1('vop2', 'v_max_f16_sdwa', operands, modifiers, 'src1', src1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_max_f16_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_omod('vop2', 'v_max_f16_sdwa', operands, modifiers, 'omod', omod) validate_modifier_synid_dst_sel('vop2', 'v_max_f16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_max_f16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_max_f16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_max_f16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_f16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_f32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_f32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_f32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_max_f32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_f32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_f32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_f32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_f32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_f32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_f32_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_f32_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_max_f32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_max_f32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_max_f32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_max_f32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_f32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_f32_sdwa(vdst, src0, src1, /, clamp=None, omod=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_f32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ Modifiers: clamp/*synid-clamp*/ omod/*synid-omod*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'omod': omod, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_f32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_max_f32_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_src_1('vop2', 'v_max_f32_sdwa', operands, modifiers, 'src1', src1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_max_f32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_omod('vop2', 'v_max_f32_sdwa', operands, modifiers, 'omod', omod) validate_modifier_synid_dst_sel('vop2', 'v_max_f32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_max_f32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_max_f32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_max_f32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_f32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_i16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_i16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-3*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_i16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_3('vop2', 'v_max_i16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_i16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_i16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_i16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_i16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_i16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_i16_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_i16_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_max_i16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_max_i16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_max_i16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_max_i16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_i16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_i16_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_i16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_i16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_4('vop2', 'v_max_i16_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_4('vop2', 'v_max_i16_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_max_i16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_max_i16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_max_i16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_max_i16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_i16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_i32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_i32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_i32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_max_i32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_i32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_i32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_i32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_i32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_i32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_i32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_i32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_max_i32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_max_i32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_max_i32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_max_i32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_i32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_i32_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_i32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_i32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_max_i32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_max_i32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_max_i32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_max_i32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_max_i32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_max_i32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_i32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_u16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_u16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-3*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_u16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_3('vop2', 'v_max_u16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_u16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_u16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_u16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_u16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_u16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_u16_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_u16_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_max_u16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_max_u16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_max_u16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_max_u16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_u16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_u16_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_u16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_u16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_4('vop2', 'v_max_u16_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_4('vop2', 'v_max_u16_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_max_u16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_max_u16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_max_u16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_max_u16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_u16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_u32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_u32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_u32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_max_u32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_u32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_u32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_u32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_u32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_u32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_u32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_max_u32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_max_u32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_max_u32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_max_u32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_max_u32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_u32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_max_u32_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_max_u32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_max_u32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_max_u32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_max_u32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_max_u32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_max_u32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_max_u32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_max_u32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_max_u32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_f16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_f16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_f16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_min_f16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_f16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_f16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_f16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_f16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_f16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_f16_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_f16_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_min_f16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_min_f16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_min_f16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_min_f16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_f16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_f16_sdwa(vdst, src0, src1, /, clamp=None, omod=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_f16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ Modifiers: clamp/*synid-clamp*/ omod/*synid-omod*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'omod': omod, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_f16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_min_f16_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_src_1('vop2', 'v_min_f16_sdwa', operands, modifiers, 'src1', src1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_min_f16_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_omod('vop2', 'v_min_f16_sdwa', operands, modifiers, 'omod', omod) validate_modifier_synid_dst_sel('vop2', 'v_min_f16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_min_f16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_min_f16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_min_f16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_f16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_f32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_f32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_f32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_min_f32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_f32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_f32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_f32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_f32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_f32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_f32_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_f32_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_min_f32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_min_f32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_min_f32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_min_f32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_f32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_f32_sdwa(vdst, src0, src1, /, clamp=None, omod=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_f32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ Modifiers: clamp/*synid-clamp*/ omod/*synid-omod*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'omod': omod, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_f32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_min_f32_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_src_1('vop2', 'v_min_f32_sdwa', operands, modifiers, 'src1', src1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_min_f32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_omod('vop2', 'v_min_f32_sdwa', operands, modifiers, 'omod', omod) validate_modifier_synid_dst_sel('vop2', 'v_min_f32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_min_f32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_min_f32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_min_f32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_f32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_i16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_i16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-3*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_i16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_3('vop2', 'v_min_i16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_i16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_i16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_i16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_i16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_i16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_i16_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_i16_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_min_i16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_min_i16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_min_i16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_min_i16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_i16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_i16_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_i16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_i16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_4('vop2', 'v_min_i16_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_4('vop2', 'v_min_i16_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_min_i16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_min_i16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_min_i16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_min_i16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_i16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_i32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_i32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_i32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_min_i32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_i32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_i32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_i32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_i32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_i32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_i32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_i32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_min_i32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_min_i32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_min_i32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_min_i32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_i32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_i32_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_i32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_i32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_min_i32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_min_i32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_min_i32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_min_i32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_min_i32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_min_i32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_i32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_u16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_u16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-3*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_u16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_3('vop2', 'v_min_u16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_u16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_u16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_u16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_u16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_u16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_u16_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_u16_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_min_u16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_min_u16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_min_u16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_min_u16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_u16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_u16_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_u16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_u16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_4('vop2', 'v_min_u16_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_4('vop2', 'v_min_u16_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_min_u16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_min_u16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_min_u16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_min_u16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_u16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_u32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_u32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_u32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_min_u32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_u32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_u32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_u32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_u32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_u32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_u32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_min_u32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_min_u32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_min_u32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_min_u32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_min_u32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_u32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_min_u32_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_min_u32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_min_u32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_min_u32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_min_u32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_min_u32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_min_u32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_min_u32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_min_u32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_min_u32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_f16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_f16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_f16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_mul_f16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_f16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_f16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_f16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_f16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_f16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_f16_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_f16_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_mul_f16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_mul_f16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_mul_f16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_mul_f16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_f16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_f16_sdwa(vdst, src0, src1, /, clamp=None, omod=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_f16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ Modifiers: clamp/*synid-clamp*/ omod/*synid-omod*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'omod': omod, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_f16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_mul_f16_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_src_1('vop2', 'v_mul_f16_sdwa', operands, modifiers, 'src1', src1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_mul_f16_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_omod('vop2', 'v_mul_f16_sdwa', operands, modifiers, 'omod', omod) validate_modifier_synid_dst_sel('vop2', 'v_mul_f16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_mul_f16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_mul_f16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_mul_f16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_f16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_f32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_f32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_f32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_mul_f32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_f32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_f32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_f32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_f32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_f32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_f32_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_f32_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_mul_f32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_mul_f32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_mul_f32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_mul_f32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_f32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_f32_sdwa(vdst, src0, src1, /, clamp=None, omod=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_f32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ Modifiers: clamp/*synid-clamp*/ omod/*synid-omod*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'omod': omod, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_f32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_mul_f32_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_src_1('vop2', 'v_mul_f32_sdwa', operands, modifiers, 'src1', src1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_mul_f32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_omod('vop2', 'v_mul_f32_sdwa', operands, modifiers, 'omod', omod) validate_modifier_synid_dst_sel('vop2', 'v_mul_f32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_mul_f32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_mul_f32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_mul_f32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_f32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_hi_i32_i24(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_hi_i32_i24 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_hi_i32_i24', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_mul_hi_i32_i24', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_hi_i32_i24', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_hi_i32_i24', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_hi_i32_i24_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_hi_i32_i24_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_hi_i32_i24_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_hi_i32_i24_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_hi_i32_i24_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_mul_hi_i32_i24_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_mul_hi_i32_i24_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_mul_hi_i32_i24_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_mul_hi_i32_i24_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_hi_i32_i24_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_hi_i32_i24_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_hi_i32_i24_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_hi_i32_i24_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_mul_hi_i32_i24_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_mul_hi_i32_i24_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_mul_hi_i32_i24_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_mul_hi_i32_i24_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_mul_hi_i32_i24_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_mul_hi_i32_i24_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_hi_i32_i24_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_hi_u32_u24(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_hi_u32_u24 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_hi_u32_u24', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_mul_hi_u32_u24', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_hi_u32_u24', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_hi_u32_u24', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_hi_u32_u24_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_hi_u32_u24_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_hi_u32_u24_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_hi_u32_u24_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_hi_u32_u24_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_mul_hi_u32_u24_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_mul_hi_u32_u24_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_mul_hi_u32_u24_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_mul_hi_u32_u24_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_hi_u32_u24_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_hi_u32_u24_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_hi_u32_u24_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_hi_u32_u24_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_mul_hi_u32_u24_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_mul_hi_u32_u24_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_mul_hi_u32_u24_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_mul_hi_u32_u24_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_mul_hi_u32_u24_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_mul_hi_u32_u24_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_hi_u32_u24_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_i32_i24(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_i32_i24 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_i32_i24', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_mul_i32_i24', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_i32_i24', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_i32_i24', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_i32_i24_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_i32_i24_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_i32_i24_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_i32_i24_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_i32_i24_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_mul_i32_i24_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_mul_i32_i24_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_mul_i32_i24_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_mul_i32_i24_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_i32_i24_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_i32_i24_sdwa(vdst, src0, src1, /, clamp=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_i32_i24_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: clamp/*synid-clamp*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_i32_i24_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_mul_i32_i24_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_mul_i32_i24_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_mul_i32_i24_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_dst_sel('vop2', 'v_mul_i32_i24_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_mul_i32_i24_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_mul_i32_i24_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_mul_i32_i24_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_i32_i24_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_legacy_f32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_legacy_f32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_legacy_f32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_mul_legacy_f32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_legacy_f32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_legacy_f32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_legacy_f32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_legacy_f32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_legacy_f32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_legacy_f32_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_legacy_f32_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_mul_legacy_f32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_mul_legacy_f32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_mul_legacy_f32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_mul_legacy_f32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_legacy_f32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_legacy_f32_sdwa(vdst, src0, src1, /, clamp=None, omod=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_legacy_f32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ Modifiers: clamp/*synid-clamp*/ omod/*synid-omod*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'omod': omod, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_legacy_f32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_mul_legacy_f32_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_src_1('vop2', 'v_mul_legacy_f32_sdwa', operands, modifiers, 'src1', src1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_mul_legacy_f32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_omod('vop2', 'v_mul_legacy_f32_sdwa', operands, modifiers, 'omod', omod) validate_modifier_synid_dst_sel('vop2', 'v_mul_legacy_f32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_mul_legacy_f32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_mul_legacy_f32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_mul_legacy_f32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_legacy_f32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_lo_u16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_lo_u16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-3*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_lo_u16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_3('vop2', 'v_mul_lo_u16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_lo_u16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_lo_u16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_lo_u16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_lo_u16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_lo_u16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_lo_u16_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_lo_u16_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_mul_lo_u16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_mul_lo_u16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_mul_lo_u16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_mul_lo_u16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_lo_u16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_lo_u16_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_lo_u16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_lo_u16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_4('vop2', 'v_mul_lo_u16_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_4('vop2', 'v_mul_lo_u16_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_mul_lo_u16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_mul_lo_u16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_mul_lo_u16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_mul_lo_u16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_lo_u16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_u32_u24(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_u32_u24 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_u32_u24', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_mul_u32_u24', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_u32_u24', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_u32_u24', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_u32_u24_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_u32_u24_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_u32_u24_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_u32_u24_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_mul_u32_u24_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_mul_u32_u24_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_mul_u32_u24_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_mul_u32_u24_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_mul_u32_u24_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_u32_u24_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_mul_u32_u24_sdwa(vdst, src0, src1, /, clamp=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_mul_u32_u24_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: clamp/*synid-clamp*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_mul_u32_u24_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_mul_u32_u24_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_mul_u32_u24_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_mul_u32_u24_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_dst_sel('vop2', 'v_mul_u32_u24_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_mul_u32_u24_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_mul_u32_u24_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_mul_u32_u24_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_mul_u32_u24_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_or_b32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_or_b32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_or_b32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_or_b32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_or_b32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_or_b32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_or_b32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_or_b32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_or_b32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_or_b32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_or_b32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_or_b32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_or_b32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_or_b32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_or_b32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_or_b32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_or_b32_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_or_b32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_or_b32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_or_b32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_or_b32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_or_b32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_or_b32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_or_b32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_or_b32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_or_b32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_co_u32(vdst, vcc_out, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_co_u32 Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_co_u32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_sub_co_u32', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_src('vop2', 'v_sub_co_u32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_co_u32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_co_u32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vcc_out, vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_co_u32_dpp(vdst, vcc_out, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_co_u32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_co_u32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_sub_co_u32_dpp', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_co_u32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_co_u32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_sub_co_u32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_sub_co_u32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_sub_co_u32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_sub_co_u32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_co_u32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vcc_out, vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_co_u32_sdwa(vdst, vcc_out, src0, src1, /, clamp=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_co_u32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: clamp/*synid-clamp*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_co_u32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_sub_co_u32_sdwa', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_src_1('vop2', 'v_sub_co_u32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_sub_co_u32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_sub_co_u32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_dst_sel('vop2', 'v_sub_co_u32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_sub_co_u32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_sub_co_u32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_sub_co_u32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_co_u32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vcc_out, vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_f16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_f16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_f16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_sub_f16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_f16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_f16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_f16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_f16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_f16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_f16_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_f16_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_sub_f16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_sub_f16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_sub_f16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_sub_f16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_f16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_f16_sdwa(vdst, src0, src1, /, clamp=None, omod=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_f16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ Modifiers: clamp/*synid-clamp*/ omod/*synid-omod*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'omod': omod, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_f16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_sub_f16_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_src_1('vop2', 'v_sub_f16_sdwa', operands, modifiers, 'src1', src1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_sub_f16_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_omod('vop2', 'v_sub_f16_sdwa', operands, modifiers, 'omod', omod) validate_modifier_synid_dst_sel('vop2', 'v_sub_f16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_sub_f16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_sub_f16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_sub_f16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_f16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_f32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_f32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_f32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_sub_f32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_f32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_f32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_f32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_f32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_f32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_f32_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_f32_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_sub_f32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_sub_f32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_sub_f32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_sub_f32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_f32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_f32_sdwa(vdst, src0, src1, /, clamp=None, omod=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_f32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ Modifiers: clamp/*synid-clamp*/ omod/*synid-omod*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'omod': omod, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_f32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_sub_f32_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_src_1('vop2', 'v_sub_f32_sdwa', operands, modifiers, 'src1', src1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_sub_f32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_omod('vop2', 'v_sub_f32_sdwa', operands, modifiers, 'omod', omod) validate_modifier_synid_dst_sel('vop2', 'v_sub_f32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_sub_f32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_sub_f32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_sub_f32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_f32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_u16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_u16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-3*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_u16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_3('vop2', 'v_sub_u16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_u16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_u16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_u16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_u16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_u16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_u16_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_u16_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_sub_u16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_sub_u16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_sub_u16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_sub_u16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_u16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_u16_sdwa(vdst, src0, src1, /, clamp=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_u16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ Modifiers: clamp/*synid-clamp*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_u16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_4('vop2', 'v_sub_u16_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_4('vop2', 'v_sub_u16_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_sub_u16_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_dst_sel('vop2', 'v_sub_u16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_sub_u16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_sub_u16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_sub_u16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_u16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_u32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_u32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_u32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_sub_u32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_u32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_u32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_u32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_u32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_u32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_u32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_sub_u32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_sub_u32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_sub_u32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_sub_u32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_sub_u32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_u32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_sub_u32_sdwa(vdst, src0, src1, /, clamp=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_sub_u32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: clamp/*synid-clamp*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_sub_u32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_sub_u32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_sub_u32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_sub_u32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_dst_sel('vop2', 'v_sub_u32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_sub_u32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_sub_u32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_sub_u32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_sub_u32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subb_co_u32(vdst, vcc_out, src0, vsrc1, vcc_in, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subb_co_u32 Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ src2: vcc_in/*synid-gfx9-vcc*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'src0': src0, 'vsrc1': vsrc1, 'vcc_in': vcc_in} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subb_co_u32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_subb_co_u32', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_src('vop2', 'v_subb_co_u32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subb_co_u32', operands, modifiers, 'vsrc1', vsrc1) validate_operand_synid_gfx9_vcc('vop2', 'v_subb_co_u32', operands, modifiers, 'vcc_in', vcc_in) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subb_co_u32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vcc_in, vsrc1) call.add_gpr_defs(vcc_out, vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subb_co_u32_dpp(vdst, vcc_out, vsrc0, vsrc1, vcc_in, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subb_co_u32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ src2: vcc_in/*synid-gfx9-vcc*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'vsrc0': vsrc0, 'vsrc1': vsrc1, 'vcc_in': vcc_in} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subb_co_u32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_subb_co_u32_dpp', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subb_co_u32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subb_co_u32_dpp', operands, modifiers, 'vsrc1', vsrc1) validate_operand_synid_gfx9_vcc('vop2', 'v_subb_co_u32_dpp', operands, modifiers, 'vcc_in', vcc_in) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_subb_co_u32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_subb_co_u32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_subb_co_u32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_subb_co_u32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subb_co_u32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vcc_in, vsrc0, vsrc1) call.add_gpr_defs(vcc_out, vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subb_co_u32_sdwa(vdst, vcc_out, src0, src1, vcc_in, /, clamp=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subb_co_u32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src2: vcc_in/*synid-gfx9-vcc*/ Modifiers: clamp/*synid-clamp*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'src0': src0, 'src1': src1, 'vcc_in': vcc_in} modifiers = {'clamp': clamp, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subb_co_u32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_subb_co_u32_sdwa', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_src_1('vop2', 'v_subb_co_u32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_subb_co_u32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) validate_operand_synid_gfx9_vcc('vop2', 'v_subb_co_u32_sdwa', operands, modifiers, 'vcc_in', vcc_in) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_subb_co_u32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_dst_sel('vop2', 'v_subb_co_u32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_subb_co_u32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_subb_co_u32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_subb_co_u32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subb_co_u32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1, vcc_in) call.add_gpr_defs(vcc_out, vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subbrev_co_u32(vdst, vcc_out, src0, vsrc1, vcc_in, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subbrev_co_u32 Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: src0/*synid-gfx9-src-7*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ src2: vcc_in/*synid-gfx9-vcc*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'src0': src0, 'vsrc1': vsrc1, 'vcc_in': vcc_in} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subbrev_co_u32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_subbrev_co_u32', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_src_7('vop2', 'v_subbrev_co_u32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subbrev_co_u32', operands, modifiers, 'vsrc1', vsrc1) validate_operand_synid_gfx9_vcc('vop2', 'v_subbrev_co_u32', operands, modifiers, 'vcc_in', vcc_in) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subbrev_co_u32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vcc_in, vsrc1) call.add_gpr_defs(vcc_out, vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subbrev_co_u32_dpp(vdst, vcc_out, vsrc0, vsrc1, vcc_in, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subbrev_co_u32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ src2: vcc_in/*synid-gfx9-vcc*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'vsrc0': vsrc0, 'vsrc1': vsrc1, 'vcc_in': vcc_in} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subbrev_co_u32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_subbrev_co_u32_dpp', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subbrev_co_u32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subbrev_co_u32_dpp', operands, modifiers, 'vsrc1', vsrc1) validate_operand_synid_gfx9_vcc('vop2', 'v_subbrev_co_u32_dpp', operands, modifiers, 'vcc_in', vcc_in) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_subbrev_co_u32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_subbrev_co_u32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_subbrev_co_u32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_subbrev_co_u32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subbrev_co_u32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vcc_in, vsrc0, vsrc1) call.add_gpr_defs(vcc_out, vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subbrev_co_u32_sdwa(vdst, vcc_out, src0, src1, vcc_in, /, clamp=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subbrev_co_u32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src2: vcc_in/*synid-gfx9-vcc*/ Modifiers: clamp/*synid-clamp*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'src0': src0, 'src1': src1, 'vcc_in': vcc_in} modifiers = {'clamp': clamp, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subbrev_co_u32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_subbrev_co_u32_sdwa', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_src_1('vop2', 'v_subbrev_co_u32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_subbrev_co_u32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) validate_operand_synid_gfx9_vcc('vop2', 'v_subbrev_co_u32_sdwa', operands, modifiers, 'vcc_in', vcc_in) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_subbrev_co_u32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_dst_sel('vop2', 'v_subbrev_co_u32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_subbrev_co_u32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_subbrev_co_u32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_subbrev_co_u32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subbrev_co_u32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1, vcc_in) call.add_gpr_defs(vcc_out, vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_co_u32(vdst, vcc_out, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_co_u32 Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: src0/*synid-gfx9-src-7*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_co_u32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_subrev_co_u32', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_src_7('vop2', 'v_subrev_co_u32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_co_u32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_co_u32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vcc_out, vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_co_u32_dpp(vdst, vcc_out, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_co_u32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_co_u32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_subrev_co_u32_dpp', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_co_u32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_co_u32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_subrev_co_u32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_subrev_co_u32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_subrev_co_u32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_subrev_co_u32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_co_u32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vcc_out, vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_co_u32_sdwa(vdst, vcc_out, src0, src1, /, clamp=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_co_u32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ dst1: vcc_out/*synid-gfx9-vcc*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: clamp/*synid-clamp*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vcc_out': vcc_out, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_co_u32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vcc('vop2', 'v_subrev_co_u32_sdwa', operands, modifiers, 'vcc_out', vcc_out) validate_operand_synid_gfx9_src_1('vop2', 'v_subrev_co_u32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_subrev_co_u32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_subrev_co_u32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_dst_sel('vop2', 'v_subrev_co_u32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_subrev_co_u32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_subrev_co_u32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_subrev_co_u32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_co_u32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vcc_out, vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_f16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_f16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-7*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_f16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_7('vop2', 'v_subrev_f16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_f16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_f16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_f16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_f16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_f16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_f16_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_f16_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_subrev_f16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_subrev_f16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_subrev_f16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_subrev_f16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_f16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_f16_sdwa(vdst, src0, src1, /, clamp=None, omod=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_f16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ Modifiers: clamp/*synid-clamp*/ omod/*synid-omod*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'omod': omod, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_f16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_subrev_f16_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_src_1('vop2', 'v_subrev_f16_sdwa', operands, modifiers, 'src1', src1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_subrev_f16_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_omod('vop2', 'v_subrev_f16_sdwa', operands, modifiers, 'omod', omod) validate_modifier_synid_dst_sel('vop2', 'v_subrev_f16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_subrev_f16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_subrev_f16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_subrev_f16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_f16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_f32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_f32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-7*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_f32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_7('vop2', 'v_subrev_f32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_f32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_f32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_f32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_f32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/:m/*synid-gfx9-m-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_f32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_f32_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_f32_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_subrev_f32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_subrev_f32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_subrev_f32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_subrev_f32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_f32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_f32_sdwa(vdst, src0, src1, /, clamp=None, omod=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_f32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m-1*/ Modifiers: clamp/*synid-clamp*/ omod/*synid-omod*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'omod': omod, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_f32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_subrev_f32_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx9_src_1('vop2', 'v_subrev_f32_sdwa', operands, modifiers, 'src1', src1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_subrev_f32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_omod('vop2', 'v_subrev_f32_sdwa', operands, modifiers, 'omod', omod) validate_modifier_synid_dst_sel('vop2', 'v_subrev_f32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_subrev_f32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_subrev_f32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_subrev_f32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_f32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_u16(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_u16 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-6*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_u16', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_6('vop2', 'v_subrev_u16', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_u16', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_u16', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_u16_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_u16_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_u16_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_u16_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_u16_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_subrev_u16_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_subrev_u16_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_subrev_u16_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_subrev_u16_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_u16_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_u16_sdwa(vdst, src0, src1, /, clamp=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_u16_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-4*/:m/*synid-gfx9-m*/ Modifiers: clamp/*synid-clamp*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_u16_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_4('vop2', 'v_subrev_u16_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_4('vop2', 'v_subrev_u16_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_subrev_u16_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_dst_sel('vop2', 'v_subrev_u16_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_subrev_u16_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_subrev_u16_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_subrev_u16_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_u16_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_u32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_u32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-7*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_u32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_7('vop2', 'v_subrev_u32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_u32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_u32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_u32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_u32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_u32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_u32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_subrev_u32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_subrev_u32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_subrev_u32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_subrev_u32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_subrev_u32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_u32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_subrev_u32_sdwa(vdst, src0, src1, /, clamp=None, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_subrev_u32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: clamp/*synid-clamp*/ dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'clamp': clamp, 'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_subrev_u32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_subrev_u32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_subrev_u32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_clamp('vop2', 'v_subrev_u32_sdwa', operands, modifiers, 'clamp', clamp) validate_modifier_synid_dst_sel('vop2', 'v_subrev_u32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_subrev_u32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_subrev_u32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_subrev_u32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_subrev_u32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_xor_b32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_xor_b32 Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_xor_b32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src('vop2', 'v_xor_b32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_xor_b32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_xor_b32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_xor_b32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_xor_b32_dpp Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: vsrc0/*synid-gfx9-vsrc-1*/ src1: vsrc1/*synid-gfx9-vsrc-1*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_xor_b32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_xor_b32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx9_vsrc_1('vop2', 'v_xor_b32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_xor_b32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_xor_b32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_xor_b32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_xor_b32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_xor_b32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_xor_b32_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_xor_b32_sdwa Operands: dst0: vdst/*synid-gfx9-vdst*/ src0: src0/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ src1: src1/*synid-gfx9-src-1*/:m/*synid-gfx9-m*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx9_vdst('vop2', 'v_xor_b32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx9_src_1('vop2', 'v_xor_b32_sdwa', operands, modifiers, 'src0', src0, allow_sext=True) validate_operand_synid_gfx9_src_1('vop2', 'v_xor_b32_sdwa', operands, modifiers, 'src1', src1, allow_sext=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_xor_b32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_xor_b32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_xor_b32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_xor_b32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_xor_b32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_fmac_f32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_fmac_f32 Operands: dst: vdst/*synid-gfx906-vdst*/ src0: src0/*synid-gfx906-src*/ src1: vsrc1/*synid-gfx906-vsrc*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx906_vdst('vop2', 'v_fmac_f32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx906_src('vop2', 'v_fmac_f32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx906_vsrc('vop2', 'v_fmac_f32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_fmac_f32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_fmac_f32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_fmac_f32_dpp Operands: dst: vdst/*synid-gfx906-vdst*/ src0: vsrc0/*synid-gfx906-vsrc*/:m/*synid-gfx906-m*/ src1: vsrc1/*synid-gfx906-vsrc*/:m/*synid-gfx906-m*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx906_vdst('vop2', 'v_fmac_f32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx906_vsrc('vop2', 'v_fmac_f32_dpp', operands, modifiers, 'vsrc0', vsrc0, allow_sext=True) validate_operand_synid_gfx906_vsrc('vop2', 'v_fmac_f32_dpp', operands, modifiers, 'vsrc1', vsrc1, allow_sext=True) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_fmac_f32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_fmac_f32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_fmac_f32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_fmac_f32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_fmac_f32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_xnor_b32(vdst, src0, vsrc1, /, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_xnor_b32 Operands: dst: vdst/*synid-gfx906-vdst*/ src0: src0/*synid-gfx906-src*/ src1: vsrc1/*synid-gfx906-vsrc*/ Modifiers: - """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'vsrc1': vsrc1} modifiers = {} # Operands validation validate_operand_synid_gfx906_vdst('vop2', 'v_xnor_b32', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx906_src('vop2', 'v_xnor_b32', operands, modifiers, 'src0', src0) validate_operand_synid_gfx906_vsrc('vop2', 'v_xnor_b32', operands, modifiers, 'vsrc1', vsrc1) # No modifiers to validate # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_xnor_b32', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_xnor_b32_dpp(vdst, vsrc0, vsrc1, /, dpp_ctrl=None, row_mask=None, bank_mask=None, bound_ctrl=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_xnor_b32_dpp Operands: dst: vdst/*synid-gfx906-vdst*/ src0: vsrc0/*synid-gfx906-vsrc*/ src1: vsrc1/*synid-gfx906-vsrc*/ Modifiers: dpp_ctrl/*synid-dpp-ctrl*/ row_mask/*synid-row-mask*/ bank_mask/*synid-bank-mask*/ bound_ctrl/*synid-bound-ctrl*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'vsrc0': vsrc0, 'vsrc1': vsrc1} modifiers = {'dpp_ctrl': dpp_ctrl, 'row_mask': row_mask, 'bank_mask': bank_mask, 'bound_ctrl': bound_ctrl} # Operands validation validate_operand_synid_gfx906_vdst('vop2', 'v_xnor_b32_dpp', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx906_vsrc('vop2', 'v_xnor_b32_dpp', operands, modifiers, 'vsrc0', vsrc0) validate_operand_synid_gfx906_vsrc('vop2', 'v_xnor_b32_dpp', operands, modifiers, 'vsrc1', vsrc1) # Modifiers validation validate_modifier_synid_dpp_ctrl('vop2', 'v_xnor_b32_dpp', operands, modifiers, 'dpp_ctrl', dpp_ctrl) validate_modifier_synid_row_mask('vop2', 'v_xnor_b32_dpp', operands, modifiers, 'row_mask', row_mask) validate_modifier_synid_bank_mask('vop2', 'v_xnor_b32_dpp', operands, modifiers, 'bank_mask', bank_mask) validate_modifier_synid_bound_ctrl('vop2', 'v_xnor_b32_dpp', operands, modifiers, 'bound_ctrl', bound_ctrl) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_xnor_b32_dpp', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, vsrc0, vsrc1) call.add_gpr_defs(vdst) # Add instruction call to current block call.add_to_current_block() # noinspection DuplicatedCode,PyDictCreation def v_xnor_b32_sdwa(vdst, src0, src1, /, dst_sel=None, dst_unused=None, src0_sel=None, src1_sel=None, comment: str = None, srcloc: Optional[SrcLoc] = None): """ Instruction: v_xnor_b32_sdwa Operands: dst: vdst/*synid-gfx906-vdst*/ src0: src0/*synid-gfx906-src-1*/:m/*synid-gfx906-m-1*/ src1: src1/*synid-gfx906-src-1*/:m/*synid-gfx906-m-1*/ Modifiers: dst_sel/*synid-dst-sel*/ dst_unused/*synid-dst-unused*/ src0_sel/*synid-src0-sel*/ src1_sel/*synid-src1-sel*/ """ # Prepare for a new instruction call operands = {'vdst': vdst, 'src0': src0, 'src1': src1} modifiers = {'dst_sel': dst_sel, 'dst_unused': dst_unused, 'src0_sel': src0_sel, 'src1_sel': src1_sel} # Operands validation validate_operand_synid_gfx906_vdst('vop2', 'v_xnor_b32_sdwa', operands, modifiers, 'vdst', vdst) validate_operand_synid_gfx906_src_1('vop2', 'v_xnor_b32_sdwa', operands, modifiers, 'src0', src0, allow_abs=True, allow_neg=True) validate_operand_synid_gfx906_src_1('vop2', 'v_xnor_b32_sdwa', operands, modifiers, 'src1', src1, allow_abs=True, allow_neg=True) # Modifiers validation validate_modifier_synid_dst_sel('vop2', 'v_xnor_b32_sdwa', operands, modifiers, 'dst_sel', dst_sel) validate_modifier_synid_dst_unused('vop2', 'v_xnor_b32_sdwa', operands, modifiers, 'dst_unused', dst_unused) validate_modifier_synid_src0_sel('vop2', 'v_xnor_b32_sdwa', operands, modifiers, 'src0_sel', src0_sel) validate_modifier_synid_src1_sel('vop2', 'v_xnor_b32_sdwa', operands, modifiers, 'src1_sel', src1_sel) # Generate the source location if srcloc is None: srcloc = SrcLoc.get_caller_srcloc() # Generate memory token mem_token = None # this instruction does not access memory # Generate the instruction call call = InstrCall('vop2', 'v_xnor_b32_sdwa', operands, modifiers, mem_token, comment, srcloc) # Do we use/hold/define any Gpr call.add_gpr_uses(exec, src0, src1) call.add_gpr_defs(vdst) if dst_sel in ('BYTE_0', 'BYTE_1', 'BYTE_2', 'BYTE_3', 'WORD_0', 'WORD_1') and dst_unused in (None, 'UNUSED_PRESERVE'): call.add_gpr_uses(vdst) call.add_gpr_holds(vdst) # Add instruction call to current block call.add_to_current_block()