diff --git a/emulation/rocjitsu/lib/python/amdisa/codegen/_generator.py b/emulation/rocjitsu/lib/python/amdisa/codegen/_generator.py index 3d08c284b0c2..d70074dc214c 100644 --- a/emulation/rocjitsu/lib/python/amdisa/codegen/_generator.py +++ b/emulation/rocjitsu/lib/python/amdisa/codegen/_generator.py @@ -114,6 +114,63 @@ } +def _exec_mask_flag_stmts(sem) -> list[str]: + """Return ``flags_ |= ...;`` statements for EXEC instruction metadata. + + The flags are derived from the instruction's semantic AST so generic + liveness/dataflow analyses do not have to know AMDGPU instruction names: + + * ``IGNORES_EXEC`` - branch-style instructions that run regardless of EXEC. + * ``WRITES_EXEC`` - the instruction writes EXEC. + + Returns an empty list when ``sem`` is None or its semantic class has no + deriver (``derive_sema_block`` returns None) or derives to an empty stub; + those instructions stay flag-free and analyses treat them conservatively. + """ + if sem is None: + return [] + # Lazy import mirrors the execute-body generation path and avoids a + # module-load import cycle with the sema_* modules. + from amdisa.sema_derive import derive_sema_block + from amdisa.sema_properties import InstructionProperty, derive_properties + + block = derive_sema_block(sem) + if block is None or block.is_empty: + return [] + props = derive_properties(block) + return [ + f'flags_ |= {name};' + for prop, name in ( + (InstructionProperty.IGNORES_EXEC, 'IGNORES_EXEC'), + (InstructionProperty.WRITES_EXEC, 'WRITES_EXEC'), + ) + if prop in props + ] + + +def _result_combinator_flag_stmts(sem) -> list[str]: + """Return ``flags_ |= ...;`` for how the instruction forms its result value. + Only returns flags for scalar operations. + + + * ``RESULT_COPY`` - result is a plain copy of a single source (s_mov). + * ``RESULT_OR`` - result is the bitwise OR of its sources (s_or, + s_or_saveexec) + + Derived from the per-opcode semantic class/operation. + EXEC-state analysis uses this to prove an all-ones EXEC write: + """ + if sem is None: + return [] + cls = sem.semantic_class + op = (sem.operation or '').lower() + if cls == 'scalar_mov': + return ['flags_ |= RESULT_COPY;'] + if cls in ('scalar_binop', 'scalar_saveexec') and op == 'or': + return ['flags_ |= RESULT_OR;'] + return [] + + @dataclass class _SourceImplUnit: file_stem: str | None @@ -6987,6 +7044,24 @@ def gen_insts(self) -> None: for tag in ('IMM', 'LABEL', 'CONST') ) ] + # v_writelane preserves the other lanes of vdst, so it reads + # the old value: a lane-partial def, distinct from the + # sub-dword partial defs above. Surface it only where the XML + # marks vdst output-only (e.g. CDNA4, gfx1250); elsewhere + # vdst is already a source. implicit_uses keeps it out of the + # printed operand list. + _writelane_implicit_use_opnd = None + if inst_sem and inst_sem.semantic_class == 'vector_writelane': + _writelane_implicit_use_opnd = next( + ( + o.name + for o in inst.operands + if o.is_output + and not o.is_input + and o.name in ('vdst', 'sdst') + ), + None, + ) if _partial_def_outputs: public_members.append( cgen.Statement( @@ -7003,6 +7078,12 @@ def gen_insts(self) -> None: 'override' ) ) + elif _writelane_implicit_use_opnd: + public_members.append( + cgen.Statement( + 'void implicit_uses(RegisterSet &uses) const override' + ) + ) if gfx1250_f8f6f4_shape is not None or gfx1250_swmmac_has_modifiers: public_members.append( cgen.Statement( @@ -7544,6 +7625,14 @@ def gen_insts(self) -> None: }: ctor_body_parts.append('flags_ |= ACCVGPR;') + # EXEC-mask metadata for liveness/dataflow analyses, + # derived from the instruction's semantic AST (see + # _exec_mask_flag_stmts). + ctor_body_parts.extend(_exec_mask_flag_stmts(_mem_sem)) + # Result-combinator metadata (RESULT_COPY / RESULT_OR) for + # EXEC-state all-ones reasoning. + ctor_body_parts.extend(_result_combinator_flag_stmts(_mem_sem)) + # Per-instruction size overrides (e.g., VOP3PX2 128-bit # instructions decoded under 64-bit VOP3P_MFMA). _size_overrides = self.isa_spec.profile.inst_size_overrides @@ -8116,6 +8205,23 @@ def _dpp_write_mask_lines( f'}}' ) ) + elif _writelane_implicit_use_opnd: + inst_impls.append( + cgen.Line( + f'void {inst.fmt_name}::implicit_uses' + f'(RegisterSet &uses) const {{\n' + f' {inst.fmt_true_enc_name}::implicit_uses(uses);\n' + f' if (auto r = ' + f'{_writelane_implicit_use_opnd}.to_register_ref())\n' + f' uses.expand(*r);\n' + f'}}' + ) + ) + if profile.split_execution_sources: + exec_impl = cgen.Line( + f'const bool {inst.fmt_name}::execute_registered_ = ' + f'register_exec_fn<{inst.fmt_name}>();\n\n{exec_impl}' + ) execution_impls = [exec_impl] if not profile.split_execution_sources: inst_impls.extend(execution_impls) @@ -9511,6 +9617,31 @@ def gen_operand_types(self) -> None: fn += ' default: return false; } }' code_lines.append(cgen.Line(fn)) + # Generate is_immediate_type() constexpr function. Kept here (rather than + # in a generated .cpp anonymous namespace) so both the model operand.cpp + # (Operand::const_value) and the execution operand.cpp can use it. + imm_types = [ + t + for t in ( + 'OPR_SIMM4', + 'OPR_SIMM8', + 'OPR_SIMM16', + 'OPR_SIMM32', + 'OPR_SIMM64', + 'OPR_LABEL', + 'OPR_WAITCNT', + ) + if t in self.isa_spec.operand_types + ] + if imm_types: + fn = '[[nodiscard]] constexpr bool is_immediate_type(OperandType t) {' + fn += ' switch (t) {' + for t in imm_types: + fn += f' case OperandType::{t}:' + fn += ' return true;' + fn += ' default: return false; } }' + code_lines.append(cgen.Line(fn)) + opnd_type_def_file = CppFile( 'operand_types', self.out_path, @@ -9535,6 +9666,17 @@ def _reg_class_for_prefix(prefix: str) -> str | None: case _: return None + @staticmethod + def _named_reg_ref(operand_name: str) -> tuple[str, int] | None: + """Map a named special register to (RegClass, index) for to_register_ref.""" + match operand_name.upper(): + case 'EXEC' | 'EXEC_LO': + return ('RegClass::EXEC', 0) + case 'EXEC_HI': + return ('RegClass::EXEC', 1) + case _: + return None + def gen_operand(self) -> None: """Generate the ISA-specific Operand class with name resolution.""" arch = self.isa_spec.arch_name @@ -9542,15 +9684,6 @@ def gen_operand(self) -> None: uses_packed_16bit_sources = ( self.isa_spec.profile.uses_packed_16bit_e32_source_selectors ) - # In wave32, EXEC_HI remains addressable as scalar scratch even though - # it is not part of the active-lane mask. Wave64-only ISAs can keep the - # conventional EXEC accessors in their generated operand code. - exec_register = ( - 'exec_raw()' if self.isa_spec.profile.wave_size == 32 else 'exec()' - ) - set_exec_register = ( - 'set_exec_raw' if self.isa_spec.profile.wave_size == 32 else 'set_exec' - ) switch_cases = [] ref_switch_cases = [] @@ -9607,6 +9740,13 @@ def gen_operand(self) -> None: f'if (encoding_value_ == {opsel_name}::{pattern.enum_name}) ' f'return "{pattern.operand_name}";' ) + named_ref = self._named_reg_ref(pattern.operand_name) + if named_ref is not None: + named_class, named_index = named_ref + ref_case_lines.append( + f'if (encoding_value_ == {opsel_name}::{pattern.enum_name}) ' + f'return RegisterRef{{{named_class}, {named_index}, reg_width}};' + ) elif pattern.kind == OperandNamePattern.LITERAL: case_lines.append( f'if (encoding_value_ == {opsel_name}::{pattern.enum_name}) ' @@ -9713,7 +9853,10 @@ def gen_operand(self) -> None: if uses_packed_16bit_sources else ' Operand(int size_bits, OperandType opr_type, int encoding_value);\n' ) - literal64_decl = ' std::optional literal64_value() const override;\n' + literal64_decl = ( + ' std::optional literal64_value() const override;\n' + ' std::optional const_value() const override;\n' + ) simd_public_decl = '' simd_private_decl = '' execution_backend_public_decl = '' @@ -9878,6 +10021,22 @@ def gen_operand(self) -> None: ' return literal64_value_;\n' '}' ) + # Wavefront-free constant value: the register-state-free subset of + # read_scalar(). Registers are not constants and return nullopt, which + # also keeps inline-const resolution from misreading a raw register + # index as a small immediate. This is a model virtual (it participates in + # the Operand vtable), so it must live in the model translation unit. + const_value_impl = ( + 'std::optional Operand::const_value() const {\n' + ' if (has_literal64_)\n' + ' return literal64_value_;\n' + ' if (is_immediate_type(opr_type_))\n' + ' return static_cast(static_cast(encoding_value_));\n' + ' if (to_register_ref())\n' + ' return std::nullopt;\n' + ' return amdgpu::resolve_src_scalar_statically(encoding_value_);\n' + '}' + ) class_impl = _ImplOutputs( model=[ cgen.Line( @@ -9908,6 +10067,7 @@ def gen_operand(self) -> None: '}' ), cgen.Line(literal64_impl), + cgen.Line(const_value_impl), cgen.Line(name_impl), cgen.Line(ref_impl), ] @@ -10169,18 +10329,6 @@ def gen_operand(self) -> None: ' return ' + ' ||\n '.join(_vgpr_only_parts) + ';\n' '}' ) - _imm_parts = ['t == OperandType::OPR_SIMM16', 't == OperandType::OPR_SIMM32'] - for _opt in ('OPR_SIMM4', 'OPR_SIMM8', 'OPR_SIMM64'): - if _opt in _opr: - _imm_parts.append(f't == OperandType::{_opt}') - for _opt in ('OPR_LABEL', 'OPR_WAITCNT'): - if _opt in _opr: - _imm_parts.append(f't == OperandType::{_opt}') - _is_immediate_body = ( - 'bool is_immediate_type(OperandType t) {\n' - ' return ' + ' ||\n '.join(_imm_parts) + ';\n' - '}' - ) # AccVGPR offset within the unified VGPR block. On CDNA3/4, AccVGPRs # live at indices 256-511 within each wavefront's VGPR allocation. The # encoding values differ between destination (512-767) and source @@ -10339,8 +10487,8 @@ def _inert_guard(ret_expr: str = '', cond: str = _inert_cond) -> str: ' if (is_immediate_type(opr_type_))', ' return static_cast(ev);', ' if (size_bits_ == 16)', - ' return resolve_src_scalar16(wf, ev);', - ' return resolve_src_scalar(wf, ev);', + ' return amdgpu::resolve_src_scalar16(wf, ev, kM0EncodingValue);', + ' return amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue);', '}', ] ) @@ -10360,7 +10508,7 @@ def _inert_guard(ret_expr: str = '', cond: str = _inert_cond) -> str: ' return literal64_value_;\n' ' if (is_immediate_type(opr_type_))\n' ' return read_immediate64(opr_type_, ev);\n' - ' return resolve_src_scalar64(wf, ev);\n' + ' return amdgpu::resolve_src_scalar64(wf, ev, kM0EncodingValue);\n' '}' ) @@ -10489,266 +10637,10 @@ def _inert_guard(ret_expr: str = '', cond: str = _inert_cond) -> str: resolve_code = cgen.Line( 'namespace {\n' '\n' - 'uint32_t resolve_src_scalar(const amdgpu::Wavefront &wf, int ev) {\n' - ' if (ev == 102)\n' - ' return static_cast(wf.scratch_base());\n' - ' if (ev == 103)\n' - ' return static_cast(wf.scratch_base() >> 32);\n' - ' if (ev <= 105)\n' - ' return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev));\n' - ' if (ev == 106)\n' - ' return static_cast(wf.vcc());\n' - ' if (ev == 107)\n' - ' return static_cast(wf.vcc() >> 32);\n' - ' if (ev >= 108 && ev <= 123)\n' - ' return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev));\n' - + ( - ' if (ev == 124)\n' - ' return 0u; // NULL\n' - ' if (ev == 125)\n' - ' return wf.m0();\n' - if scalar_null_precedes_m0 - else ' if (ev == 124)\n' ' return wf.m0();\n' - ) - + ' if (ev == 126)\n' - ' return static_cast(wf.exec());\n' - ' if (ev == 127)\n' - f' return static_cast(wf.{exec_register} >> 32);\n' - ' if (ev >= 128 && ev <= 192)\n' - ' return static_cast(ev - 128);\n' - ' if (ev >= 193 && ev <= 208)\n' - ' return static_cast(static_cast(-(ev - 192)));\n' - ' if (ev == 230)\n' - ' return static_cast(wf.scratch_base()); // SRC_FLAT_SCRATCH_BASE_LO\n' - ' if (ev == 231)\n' - ' return static_cast(wf.scratch_base() >> 32); // SRC_FLAT_SCRATCH_BASE_HI\n' - ' if (ev == 240)\n' - ' return 0x3F000000u; // 0.5f\n' - ' if (ev == 241)\n' - ' return 0xBF000000u; // -0.5f\n' - ' if (ev == 242)\n' - ' return 0x3F800000u; // 1.0f\n' - ' if (ev == 243)\n' - ' return 0xBF800000u; // -1.0f\n' - ' if (ev == 244)\n' - ' return 0x40000000u; // 2.0f\n' - ' if (ev == 245)\n' - ' return 0xC0000000u; // -2.0f\n' - ' if (ev == 246)\n' - ' return 0x40800000u; // 4.0f\n' - ' if (ev == 247)\n' - ' return 0xC0800000u; // -4.0f\n' - ' if (ev == 248)\n' - ' return 0x3E22F983u; // 1/(2*pi)\n' - ' if (ev == 235)\n' - ' return static_cast(wf.shared_aperture_base() >> 32); // SRC_SHARED_BASE\n' - ' if (ev == 236)\n' - ' return static_cast(wf.shared_aperture_limit() >> 32); // SRC_SHARED_LIMIT\n' - ' if (ev == 237)\n' - ' return static_cast(wf.private_aperture_base() >> 32); // SRC_PRIVATE_BASE\n' - ' if (ev == 238)\n' - ' return static_cast(wf.private_aperture_limit() >> 32); // SRC_PRIVATE_LIMIT\n' - ' if (ev == 249)\n' - ' return 0u; // SRC_POPS_EXITING_WAVE_ID (not used in compute)\n' - ' if (ev == 250)\n' - ' return 0u; // NULL\n' - ' if (ev == 251)\n' - ' return (wf.vcc() & (wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL))) == 0 ? 1u : 0u; // VCCZ\n' - ' if (ev == 252) {\n' - ' uint64_t active = wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL);\n' - ' return (wf.exec() & active) == 0 ? 1u : 0u; // EXECZ\n' - ' }\n' - ' if (ev == 253)\n' - ' return wf.read_scc() ? 1u : 0u; // SCC\n' - ' throw std::logic_error("Unsupported encoding value for scalar read: " + std::to_string(ev));\n' - '}\n' - '\n' - 'uint32_t resolve_src_scalar16(const amdgpu::Wavefront &wf, int ev) {\n' - ' switch (ev) {\n' - ' case 240:\n' - ' return 0x3800u; // 0.5h\n' - ' case 241:\n' - ' return 0xB800u; // -0.5h\n' - ' case 242:\n' - ' return 0x3C00u; // 1.0h\n' - ' case 243:\n' - ' return 0xBC00u; // -1.0h\n' - ' case 244:\n' - ' return 0x4000u; // 2.0h\n' - ' case 245:\n' - ' return 0xC000u; // -2.0h\n' - ' case 246:\n' - ' return 0x4400u; // 4.0h\n' - ' case 247:\n' - ' return 0xC400u; // -4.0h\n' - ' case 248:\n' - ' return 0x3118u; // f16 1/(2*pi)\n' - ' default:\n' - ' return resolve_src_scalar(wf, ev);\n' - ' }\n' - '}\n' - '\n' - '// Must stay in sync with resolve_src_scalar above — returns true for\n' - '// exactly the encoding values that resolve_src_scalar handles without\n' - '// throwing. Used by Isa::simd_capable_value() to keep the SIMD fast\n' - '// path off operands whose scalar broadcast would throw at runtime.\n' - 'bool can_resolve_src_scalar(int ev) {\n' - + ( - ' return (ev >= 0 && ev <= 107) || (ev >= 108 && ev <= 123) ||\n' - ' ev == 124 || ev == 125 || ev == 126 || ev == 127 ||\n' - ' (ev >= 128 && ev <= 208) || ev == 230 || ev == 231 ||\n' - ' (ev >= 235 && ev <= 238) || (ev >= 240 && ev <= 253);\n' - if scalar_null_precedes_m0 - else ' return (ev >= 0 && ev <= 107) || (ev >= 108 && ev <= 123) ||\n' - ' ev == 124 || ev == 126 || ev == 127 ||\n' - ' (ev >= 128 && ev <= 208) || (ev >= 235 && ev <= 238) ||\n' - ' (ev >= 240 && ev <= 253);\n' - ) - + '}\n' - '\n' - 'uint64_t resolve_src_scalar64(const amdgpu::Wavefront &wf, int ev) {\n' - ' if (ev == 102)\n' - ' return wf.scratch_base();\n' - ' if (ev <= 105) {\n' - ' uint32_t lo = amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev));\n' - ' uint32_t hi = amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1));\n' - ' return static_cast(hi) << 32 | lo;\n' - ' }\n' - ' if (ev == 106)\n' - ' return wf.vcc();\n' - ' if (ev >= 108 && ev <= 122) {\n' - ' uint32_t lo = amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev));\n' - ' uint32_t hi = amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1));\n' - ' return static_cast(hi) << 32 | lo;\n' - ' }\n' - + ( - ' if (ev == 124)\n' - ' return 0u; // NULL\n' - ' if (ev == 125)\n' - ' return wf.m0();\n' - if scalar_null_precedes_m0 - else ' if (ev == 124)\n' ' return wf.m0();\n' - ) - + ' if (ev == 126)\n' - f' return wf.{exec_register};\n' - ' if (ev >= 128 && ev <= 192)\n' - ' return static_cast(ev - 128);\n' - ' if (ev >= 193 && ev <= 208)\n' - ' return static_cast(static_cast(static_cast(-(ev - 192))));\n' - ' if (ev == 230)\n' - ' return wf.scratch_base(); // SRC_FLAT_SCRATCH_BASE\n' - ' if (ev == 240)\n' - ' return 0x3FE0000000000000ULL; // 0.5\n' - ' if (ev == 241)\n' - ' return 0xBFE0000000000000ULL; // -0.5\n' - ' if (ev == 242)\n' - ' return 0x3FF0000000000000ULL; // 1.0\n' - ' if (ev == 243)\n' - ' return 0xBFF0000000000000ULL; // -1.0\n' - ' if (ev == 244)\n' - ' return 0x4000000000000000ULL; // 2.0\n' - ' if (ev == 245)\n' - ' return 0xC000000000000000ULL; // -2.0\n' - ' if (ev == 246)\n' - ' return 0x4010000000000000ULL; // 4.0\n' - ' if (ev == 247)\n' - ' return 0xC010000000000000ULL; // -4.0\n' - ' if (ev == 248)\n' - ' return 0x3FC45F306DC9C883ULL; // 1/(2*pi)\n' - ' if (ev == 235)\n' - ' return wf.shared_aperture_base(); // SRC_SHARED_BASE\n' - ' if (ev == 236)\n' - ' return wf.shared_aperture_limit(); // SRC_SHARED_LIMIT\n' - ' if (ev == 237)\n' - ' return wf.private_aperture_base(); // SRC_PRIVATE_BASE\n' - ' if (ev == 238)\n' - ' return wf.private_aperture_limit(); // SRC_PRIVATE_LIMIT\n' - ' throw std::logic_error("Unsupported encoding value for scalar64 read: " + std::to_string(ev));\n' - '}\n' - '\n' - 'void resolve_dst_write(amdgpu::Wavefront &wf, int ev, uint32_t val) {\n' - ' if (ev == 102) {\n' - ' uint64_t sb = wf.scratch_base();\n' - ' wf.set_scratch_base((sb & 0xFFFFFFFF00000000ULL) | val);\n' - ' return;\n' - ' }\n' - ' if (ev == 103) {\n' - ' uint64_t sb = wf.scratch_base();\n' - ' wf.set_scratch_base((sb & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32));\n' - ' return;\n' - ' }\n' - ' if (ev <= 105) {\n' - ' amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val);\n' - ' return;\n' - ' }\n' - ' if (ev == 106) {\n' - ' wf.set_vcc((wf.vcc() & 0xFFFFFFFF00000000ULL) | val);\n' - ' return;\n' - ' }\n' - ' if (ev == 107) {\n' - ' wf.set_vcc((wf.vcc() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32));\n' - ' return;\n' - ' }\n' - ' if (ev >= 108 && ev <= 123) {\n' - ' amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val);\n' - ' return;\n' - ' }\n' - + ( - ' if (ev == 124)\n' - ' return;\n' - ' if (ev == 125) {\n' - ' wf.set_m0(val);\n' - ' return;\n' - ' }\n' - if scalar_null_precedes_m0 - else ' if (ev == 124) {\n' - ' wf.set_m0(val);\n' - ' return;\n' - ' }\n' - ) - + ' if (ev == 126) {\n' - ' wf.set_exec((wf.exec() & 0xFFFFFFFF00000000ULL) | val);\n' - ' return;\n' - ' }\n' - ' if (ev == 127) {\n' - f' wf.{set_exec_register}((wf.{exec_register} & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32));\n' - ' return;\n' - ' }\n' - ' throw std::logic_error("Unsupported encoding value for scalar write: " + std::to_string(ev));\n' - '}\n' - '\n' - 'void resolve_dst_write64(amdgpu::Wavefront &wf, int ev, uint64_t val) {\n' - ' if (ev == 102) {\n' - ' wf.set_scratch_base(val);\n' - ' return;\n' - ' }\n' - ' if (ev <= 105) {\n' - ' amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), static_cast(val));\n' - ' amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), static_cast(val >> 32));\n' - ' return;\n' - ' }\n' - ' if (ev == 106) {\n' - ' wf.set_vcc(val);\n' - ' return;\n' - ' }\n' - ' if (ev >= 108 && ev <= 122) {\n' - ' amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), static_cast(val));\n' - ' amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), static_cast(val >> 32));\n' - ' return;\n' - ' }\n' - ' if (ev == 124)\n' - ' return;\n' - ' if (ev == 126) {\n' - f' wf.{set_exec_register}(val);\n' - ' return;\n' - ' }\n' - ' throw std::logic_error("Unsupported encoding value for scalar64 write: " + std::to_string(ev));\n' - '}\n' + f'constexpr int kM0EncodingValue = {125 if scalar_null_precedes_m0 else 124};\n' '\n' + _is_vgpr_only_body + '\n\n' - + _is_immediate_body - + '\n\n' + _vgpr_index_body + '\n\n' + _read_immediate64_body @@ -10763,13 +10655,13 @@ def _inert_guard(ret_expr: str = '', cond: str = _inert_cond) -> str: + '\n\n' 'bool Isa::simd_capable_value(OperandType opr_type, int ev) {\n' ' return resolved_vgpr_offset(opr_type, ev).has_value() ||\n' - ' is_immediate_type(opr_type) || can_resolve_src_scalar(ev);\n' + ' is_immediate_type(opr_type) || amdgpu::can_resolve_src_scalar(ev, kM0EncodingValue);\n' '}\n' '\n' 'uint32_t Isa::simd_broadcast_value(const amdgpu::Wavefront &wf, OperandType opr_type,\n' ' int ev) {\n' ' return is_immediate_type(opr_type) ? static_cast(ev)\n' - ' : resolve_src_scalar(wf, ev);\n' + ' : amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue);\n' '}\n' '\n' + simd_methods @@ -10780,12 +10672,12 @@ def _inert_guard(ret_expr: str = '', cond: str = _inert_cond) -> str: ' return static_cast(literal64_value_);\n' ' if (is_immediate_type(opr_type_))\n' ' return static_cast(encoding_value_);\n' - ' return resolve_src_scalar(wf, encoding_value_);\n' + ' return amdgpu::resolve_src_scalar(wf, encoding_value_, kM0EncodingValue);\n' '}\n' '\n' + _read_lane_body + '\n\n' 'void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const {\n' + _inert_guard(cond='!is_writable()') - + ' resolve_dst_write(wf, encoding_value_, val);\n' + + ' amdgpu::resolve_dst_write(wf, encoding_value_, val, kM0EncodingValue);\n' '}\n' '\n' 'void Operand::write_lane(amdgpu::Wavefront &wf, uint32_t lane, uint32_t val) const {\n' @@ -10816,12 +10708,12 @@ def _inert_guard(ret_expr: str = '', cond: str = _inert_cond) -> str: ' return literal64_value_;\n' ' if (is_immediate_type(opr_type_))\n' ' return read_immediate64(opr_type_, encoding_value_);\n' - ' return resolve_src_scalar64(wf, encoding_value_);\n' + ' return amdgpu::resolve_src_scalar64(wf, encoding_value_, kM0EncodingValue);\n' '}\n' '\n' 'void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const {\n' + _inert_guard(cond='!is_writable()') - + ' resolve_dst_write64(wf, encoding_value_, val);\n' + + ' amdgpu::resolve_dst_write64(wf, encoding_value_, val);\n' '}' ) if self.isa_spec.profile.split_execution_sources: @@ -11057,6 +10949,7 @@ def _inert_guard(ret_expr: str = '', cond: str = _inert_cond) -> str: False, [ (f'rocjitsu/isa/arch/amdgpu/{arch}/operand.h', False), + ('rocjitsu/isa/arch/amdgpu/shared/scalar_static_resolve.h', False), ('format', True), ('optional', True), ('stdexcept', True), @@ -11076,6 +10969,7 @@ def _inert_guard(ret_expr: str = '', cond: str = _inert_cond) -> str: ('rocjitsu/vm/amdgpu/compute_unit.h', False), ('rocjitsu/vm/amdgpu/register_access.h', False), ('rocjitsu/vm/amdgpu/wavefront.h', False), + ('rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h', False), ('format', True), ('optional', True), ('stdexcept', True), @@ -11096,6 +10990,7 @@ def _inert_guard(ret_expr: str = '', cond: str = _inert_cond) -> str: ('rocjitsu/vm/amdgpu/compute_unit.h', False), ('rocjitsu/vm/amdgpu/register_access.h', False), ('rocjitsu/vm/amdgpu/wavefront.h', False), + ('rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h', False), ('format', True), ('optional', True), ('stdexcept', True), diff --git a/emulation/rocjitsu/lib/python/amdisa/tests/test_exec_mask_flags.py b/emulation/rocjitsu/lib/python/amdisa/tests/test_exec_mask_flags.py new file mode 100644 index 000000000000..fe3a071dbc31 --- /dev/null +++ b/emulation/rocjitsu/lib/python/amdisa/tests/test_exec_mask_flags.py @@ -0,0 +1,180 @@ +# Copyright (c) 2025-2026 Advanced Micro Devices, Inc. +# SPDX-License-Identifier: MIT + +"""Tests for EXEC-mask instruction flag emission.""" + +import pytest + +from amdisa.codegen._generator import ( + _exec_mask_flag_stmts, + _result_combinator_flag_stmts, +) +from amdisa.semantics import InstructionSemantics + +# Flag names emitted for EXEC tracking. +ALL = {'IGNORES_EXEC', 'WRITES_EXEC'} + + +def _flags(sem): + """Run the generator helper and return the set of emitted flag names.""" + return {s[len('flags_ |= ') : -1] for s in _exec_mask_flag_stmts(sem)} + + +# (InstructionSemantics, expected-present flags, id). Anything in ALL but not in +# the expected set must be ABSENT — see the test below. +_CASES = [ + # Scalar EXEC writers: write EXEC, but are not themselves EXEC-masked. + pytest.param( + InstructionSemantics( + 'S_AND_SAVEEXEC_B64', + 'scalar_saveexec', + operation='and', + data_type='b64', + sets_scc='nonzero', + ), + {'WRITES_EXEC'}, + id='scalar_saveexec', + ), + pytest.param( + InstructionSemantics( + 'S_ANDN2_WREXEC_B64', + 'scalar_wrexec', + operation='andn2', + data_type='b64', + sets_scc='nonzero', + ), + {'WRITES_EXEC'}, + id='scalar_wrexec', + ), + # Vector ALU: no EXEC interaction flags. + pytest.param( + InstructionSemantics( + 'V_ADD_F32', 'vector_binop', operation='add', data_type='f32' + ), + set(), + id='vector_binop', + ), + pytest.param( + InstructionSemantics('V_MOV_B32', 'vector_mov', data_type='b32'), + set(), + id='vector_mov', + ), + pytest.param( + InstructionSemantics('V_CNDMASK_B32', 'vector_cndmask', data_type='b32'), + set(), + id='vector_cndmask', + ), + # Vector compare-and-set-exec: writes EXEC. + pytest.param( + InstructionSemantics( + 'V_CMPX_LT_F32', 'vector_cmpx', operation='lt', data_type='f32' + ), + {'WRITES_EXEC'}, + id='vector_cmpx', + ), + # Branches: ignore EXEC, never EXEC-masked. + pytest.param( + InstructionSemantics('S_BRANCH', 'branch'), + {'IGNORES_EXEC'}, + id='branch', + ), + pytest.param( + InstructionSemantics('S_CBRANCH_SCC1', 'cbranch', branch_condition='scc1'), + {'IGNORES_EXEC'}, + id='cbranch', + ), + # Plain scalar op: no EXEC interaction at all. + pytest.param( + InstructionSemantics('S_MOV_B32', 'scalar_mov', data_type='b32'), + set(), + id='scalar_mov', + ), +] + + +class TestExecMaskFlagStmts: + def test_none_semantics_yields_no_flags(self): + assert _exec_mask_flag_stmts(None) == [] + + def test_unsupported_class_yields_no_flags(self): + # A semantic class with no registered deriver -> derive_sema_block + # returns None -> conservatively no flags. + sem = InstructionSemantics('NOT_A_REAL_INST', 'no_such_class') + assert _exec_mask_flag_stmts(sem) == [] + + @pytest.mark.parametrize('sem, expected', _CASES) + def test_flags_per_instruction_kind(self, sem, expected): + flags = _flags(sem) + assert expected <= flags, f'{sem.name}: missing {expected - flags}' + unexpected = (ALL - expected) & flags + assert not unexpected, f'{sem.name}: unexpected {unexpected}' + + def test_flag_statement_format(self): + sem = InstructionSemantics( + 'S_OR_SAVEEXEC_B64', + 'scalar_saveexec', + operation='or', + data_type='b64', + sets_scc='nonzero', + ) + stmts = _exec_mask_flag_stmts(sem) + assert stmts + for s in stmts: + assert s.startswith('flags_ |= ') + assert s.endswith(';') + + +class TestResultCombinatorFlagStmts: + """RESULT_COPY / RESULT_OR drive EXEC-state all-ones reasoning.""" + + def _combinator(self, sem): + return {s[len('flags_ |= ') : -1] for s in _result_combinator_flag_stmts(sem)} + + def test_scalar_mov_is_copy(self): + sem = InstructionSemantics('S_MOV_B64', 'scalar_mov', data_type='b64') + assert self._combinator(sem) == {'RESULT_COPY'} + + def test_binop_or_is_or(self): + sem = InstructionSemantics( + 'S_OR_B64', 'scalar_binop', operation='or', data_type='b64' + ) + assert self._combinator(sem) == {'RESULT_OR'} + + def test_saveexec_or_is_or(self): + sem = InstructionSemantics( + 'S_OR_SAVEEXEC_B64', 'scalar_saveexec', operation='or', data_type='b64' + ) + assert self._combinator(sem) == {'RESULT_OR'} + + def test_saveexec_and_is_other(self): + # exec = exec & src -> not provably all-ones; no combinator flag. + sem = InstructionSemantics( + 'S_AND_SAVEEXEC_B64', 'scalar_saveexec', operation='and', data_type='b64' + ) + assert _result_combinator_flag_stmts(sem) == [] + + def test_binop_and_is_other(self): + sem = InstructionSemantics( + 'S_AND_B64', 'scalar_binop', operation='and', data_type='b64' + ) + assert _result_combinator_flag_stmts(sem) == [] + + def test_vector_mov_is_not_copy(self): + # RESULT_COPY is scalar-only; a vector mov must not emit it. + sem = InstructionSemantics('V_MOV_B32', 'vector_mov', data_type='b32') + assert _result_combinator_flag_stmts(sem) == [] + + def test_vector_binop_or_is_not_or(self): + # RESULT_OR is scalar-only; a vector bitwise-or must not emit it. + sem = InstructionSemantics( + 'V_OR_B32', 'vector_binop', operation='or', data_type='b32' + ) + assert _result_combinator_flag_stmts(sem) == [] + + def test_vector_cndmask_is_not_copy(self): + # A non-scalar select is not a plain copy. + sem = InstructionSemantics('V_CNDMASK_B32', 'vector_cndmask', data_type='b32') + assert _result_combinator_flag_stmts(sem) == [] + + def test_none_is_empty(self): + assert _result_combinator_flag_stmts(None) == [] diff --git a/emulation/rocjitsu/lib/python/amdisa/tests/test_generator_profile_gates.py b/emulation/rocjitsu/lib/python/amdisa/tests/test_generator_profile_gates.py index 10350c0b4d6e..31a6d6df9798 100644 --- a/emulation/rocjitsu/lib/python/amdisa/tests/test_generator_profile_gates.py +++ b/emulation/rocjitsu/lib/python/amdisa/tests/test_generator_profile_gates.py @@ -3141,21 +3141,42 @@ def test_gfx1250_buffer_u64_atomic_payload_width_uses_two_dwords(): def test_ev124_125_arch_gating_in_generated_operand(amdgpu_generated_root: Path): - rdna4_op = (amdgpu_generated_root / 'rdna4' / 'operand.cpp').read_text() - assert 'if (ev == 124)\n return 0u; // NULL' in rdna4_op - assert 'if (ev == 125)\n return wf.m0()' in rdna4_op - - rdna3_op = (amdgpu_generated_root / 'rdna3' / 'operand.cpp').read_text() - assert 'if (ev == 124)\n return 0u; // NULL' in rdna3_op - assert 'if (ev == 125)\n return wf.m0()' in rdna3_op - - rdna3_5_op = (amdgpu_generated_root / 'rdna3_5' / 'operand.cpp').read_text() - assert 'if (ev == 124)\n return 0u; // NULL' in rdna3_5_op - assert 'if (ev == 125)\n return wf.m0()' in rdna3_5_op - - cdna4_op = (amdgpu_generated_root / 'cdna4' / 'operand.cpp').read_text() - assert 'if (ev == 124)\n return wf.m0()' in cdna4_op - assert 'ev == 125' not in cdna4_op.split('can_resolve_src_scalar')[1].split('}')[0] + # M0 is encoded as 125 on RDNA3+ (and gfx1250) and as 124 on the + # older RDNA1/2 and all CDNA arches. Verify the generated operand.cpp + # carries the correct kM0EncodingValue constant for each ISA. + expected_m0_encoding = { + 'cdna1': 124, + 'cdna2': 124, + 'cdna3': 124, + 'cdna4': 124, + 'rdna1': 124, + 'rdna2': 124, + 'rdna3': 125, + 'rdna3_5': 125, + 'rdna4': 125, + 'gfx1250': 125, + } + for arch, encoding in expected_m0_encoding.items(): + # The kM0EncodingValue constant lives with the scalar-resolve code, which + # is emitted into operand.cpp for unsplit arches and into operand_exec.cpp + # for arches that split model/execution sources (e.g. gfx1250). + op = (amdgpu_generated_root / arch / 'operand.cpp').read_text() + exec_path = amdgpu_generated_root / arch / 'operand_exec.cpp' + if exec_path.exists(): + op += exec_path.read_text() + assert ( + f'constexpr int kM0EncodingValue = {encoding};' in op + ), f'{arch}: expected kM0EncodingValue = {encoding}' + + # The M0 resolution logic is shared (parameterized by m0_ev) in + # scalar_operand_resolve.h rather than emitted per-arch, so verify the gating + # there: encoding value 124 is the NULL slot when M0 is 125, and the operand + # matching the arch's M0 encoding reads M0. + shared_resolve = ( + amdgpu_generated_root / 'shared' / 'scalar_operand_resolve.h' + ).read_text() + assert 'if (m0_ev == 125 && ev == 124)\n return 0u; // NULL' in shared_resolve + assert 'if (ev == m0_ev)\n return wf.m0();' in shared_resolve def test_cdna4_mfma_f8f6f4_accepts_standalone_and_prefixed_encodings( diff --git a/emulation/rocjitsu/lib/python/amdisa/tests/test_profile_properties.py b/emulation/rocjitsu/lib/python/amdisa/tests/test_profile_properties.py index d3fc4ef81727..a7ea235639b9 100644 --- a/emulation/rocjitsu/lib/python/amdisa/tests/test_profile_properties.py +++ b/emulation/rocjitsu/lib/python/amdisa/tests/test_profile_properties.py @@ -167,39 +167,6 @@ def test_isa_properties_codegen_uses_profile_values(tmp_path): ) in output -@pytest.mark.parametrize( - ('arch', 'profile', 'raw_exec'), - [ - ('cdna3', CdnaProfile(), False), - ('rdna4', Rdna4Profile(), True), - ], -) -def test_operand_exec_register_access_is_wave32_gated( - tmp_path, arch, profile, raw_exec -): - generator = CodeGenerator( - SimpleNamespace( - arch_name=arch, - opnd_selectors=[], - operand_types=['OPR_SIMM16', 'OPR_SIMM32', 'OPR_VGPR'], - profile=profile, - ), - str(tmp_path), - ) - - generator.gen_operand() - operand_cpp = (tmp_path / arch / 'operand.cpp').read_text() - - assert 'return static_cast(wf.exec());' in operand_cpp - assert 'wf.set_exec((wf.exec() & 0xFFFFFFFF00000000ULL) | val);' in operand_cpp - if raw_exec: - assert 'return static_cast(wf.exec_raw() >> 32);' in operand_cpp - assert 'wf.set_exec_raw((wf.exec_raw() & 0x00000000FFFFFFFFULL)' in operand_cpp - else: - assert 'exec_raw' not in operand_cpp - assert 'set_exec_raw' not in operand_cpp - - def test_gfx1250_operand_execution_backend_uses_separate_source(tmp_path): generator = CodeGenerator( SimpleNamespace( diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/CMakeLists.txt b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/CMakeLists.txt index 5b53873af496..cc18ad7eef0f 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/CMakeLists.txt +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/CMakeLists.txt @@ -3,6 +3,7 @@ rj_add_object_library(rocjitsu_analysis def_use_chain.cpp + exec_state.cpp gfx1250_vgpr_msb.cpp indirect_branch_discovery.cpp liveness.cpp diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/def_use_chain.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/def_use_chain.cpp index 0e5e1f7445fa..79e38a5c84af 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/def_use_chain.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/def_use_chain.cpp @@ -15,7 +15,8 @@ namespace rocjitsu { namespace { -[[nodiscard]] bool is_exec_masked_def(RegisterRef ref) { +// Checks if a RegisterRef class is a vector (VGPR/AccVGPR). +[[nodiscard]] bool is_vector_def(RegisterRef ref) { return ref.cls == RegClass::VGPR || ref.cls == RegClass::ACC_VGPR; } @@ -55,24 +56,12 @@ void expand_operand_register(RegisterSet &set, const Instruction &inst, const Op } // Must-write with an unknown bank: expanding to all four tuples would falsely - // kill three the instruction does not write, so record NOTHING in the def set. - // This is only sound because such a def never contributes a liveness kill: - // control reaches here only for a VGPR ref (see the early return above), every - // VGPR def is exec-masked (is_exec_masked_def), and kill_defs() drops all VGPR - // kills once has_exec_masked_vector_def is set. If any of those change (a - // non-exec-masked VGPR def, or kill_defs no longer suppressing VGPR kills), an - // unknown-bank def would start over-killing and this must record the precise - // physical tuple instead. (An assert(is_exec_masked_def(ref)) here would be - // tautological — ref is already known to be a VGPR — so the invariant is - // documented rather than checked.) -} - -void add_def(InstDefUse &du, const Instruction &inst, const Operand &operand, RegisterRef ref, - const Gfx1250VgprMsbAnalysis *vgpr_msb, UnknownVgprDefPolicy unknown_vgpr_defs) { - expand_operand_register(du.defs, inst, operand, ref, vgpr_msb, OperandExpansionKind::Def, - unknown_vgpr_defs); - if (is_exec_masked_def(ref)) - du.has_exec_masked_vector_def = true; + // kill three tuples the instruction does not write (an over-kill, which is + // unsound for liveness), so record NOTHING in the def set instead. An + // unrecorded def can only cause an under-kill, which merely keeps a value live + // longer than necessary and is always a sound (conservative) approximation. + // Known-bank defs above record the precise physical tuple and kill as usual, + // subject to the EXEC-masking rules in kill_defs(). } } // namespace @@ -80,14 +69,20 @@ void add_def(InstDefUse &du, const Instruction &inst, const Operand &operand, Re InstDefUse::InstDefUse(const Instruction &inst, const Gfx1250VgprMsbAnalysis *vgpr_msb, UnknownVgprDefPolicy unknown_vgpr_defs) { has_predicated_def = inst.flags() & PREDICATED_DEF; + const bool ignores_exec = inst.flags() & IGNORES_EXEC; + bool has_vector_def = false; for (int i = 0; i < inst.num_dst_operands(); ++i) { const auto *op = inst.dst_operand(i); if (op == nullptr) continue; - if (auto ref = op->to_register_ref()) - add_def(*this, inst, *op, *ref, vgpr_msb, unknown_vgpr_defs); + if (auto ref = op->to_register_ref()) { + expand_operand_register(defs, inst, *op, *ref, vgpr_msb, OperandExpansionKind::Def, + unknown_vgpr_defs); + has_vector_def |= is_vector_def(*ref); + } } + has_exec_masked_vector_def = has_vector_def && !ignores_exec; // No generated instruction currently reports an implicit VGPR def. If one is // added for gfx1250, it must expose an operand with a VGPR-MSB role so global // usage can resolve the physical bank instead of recording only the raw low diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/def_use_chain.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/def_use_chain.h index dd63a8fb6461..4c6e4d6bd922 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/def_use_chain.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/def_use_chain.h @@ -33,10 +33,11 @@ class InstDefUse { InstDefUse(const Instruction &inst, const Gfx1250VgprMsbAnalysis *vgpr_msb = nullptr, UnknownVgprDefPolicy unknown_vgpr_defs = UnknownVgprDefPolicy::Omit); - RegisterSet defs; ///< Registers overwritten by the instruction. - RegisterSet uses; ///< Registers read before the instruction writes defs. - bool has_exec_masked_vector_def = false; ///< True if any vector def is predicated by EXEC. - bool has_predicated_def = false; ///< True if defs preserve old values on some paths. + RegisterSet defs; ///< Registers overwritten by the instruction. + RegisterSet uses; ///< Registers read before the instruction writes defs. + bool has_exec_masked_vector_def = + false; ///< True if the instruction doesn't ignore EXEC and has a vector def. + bool has_predicated_def = false; ///< True if defs preserve old values on some paths. }; } // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/exec_state.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/exec_state.cpp new file mode 100644 index 000000000000..9a911aebae42 --- /dev/null +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/exec_state.cpp @@ -0,0 +1,384 @@ +// Copyright (c) 2026 Advanced Micro Devices, Inc. +// SPDX-License-Identifier: MIT + +#include "rocjitsu/analysis/exec_state.h" + +#include "rocjitsu/code/basic_block.h" +#include "rocjitsu/isa/instruction.h" +#include "rocjitsu/isa/operand.h" + +#include +#include +#include +#include +#include +#include + +namespace rocjitsu { + +namespace { + +/// @brief How an instruction affects the EXEC mask. +enum class ExecWrite : uint8_t { + None, ///< Does not write EXEC; state unchanged. + AllOnes, ///< Writes the whole EXEC mask to all-ones -> Full. + Preserve, ///< Sets a subset of EXEC to all-ones (e.g. only exec_lo on + ///< Wave64); keeps an already-Full mask Full and leaves Unknown + ///< as Unknown, but cannot establish Full on its own. + Narrowing, ///< Writes EXEC some other way -> Unknown. +}; + +[[nodiscard]] bool writes_exec(const Instruction &inst) { + // Two complementary signals: the WRITES_EXEC flag covers instructions whose + // semantics always write EXEC (s_*_saveexec, s_wrexec, v_cmpx), while an EXEC + // destination operand covers the generic move case (`s_mov_b64 exec, ...`), + // which has no flag because writing EXEC is a property of the instance's + // destination, not the opcode. + if (inst.flags() & WRITES_EXEC) + return true; + for (int i = 0; i < inst.num_dst_operands(); ++i) { + const Operand *op = inst.dst_operand(i); + if (op == nullptr) + continue; + auto ref = op->to_register_ref(); + if (ref && ref->cls == RegClass::EXEC) + return true; + } + return false; +} + +/// @brief All-ones mask for an EXEC register of @p wave_size lanes. +[[nodiscard]] uint64_t full_exec_mask(uint32_t wave_size) { + return wave_size >= 64 ? ~0ULL : ((1ULL << wave_size) - 1ULL); +} + +/// @brief The EXEC bits an instruction writes: a mask of the written bits and +/// whether they cover the whole @p wave_size-lane EXEC register. +/// +/// @details Semantic EXEC writers (WRITES_EXEC: saveexec/wrexec/v_cmpx) write the +/// whole mask. A generic write via an EXEC destination operand covers only that +/// operand's lanes at the sub-register's position: `exec_lo` (index 0) writes +/// bits [0,32), `exec_hi` (index 1) bits [32,64). Only an exec_lo-based write can +/// cover the active mask; an exec_hi write never touches lanes [0,wave_size). +struct ExecWriteExtent { + uint64_t mask = 0; ///< Bits written into EXEC (sub-register width, unpositioned). + bool full = false; ///< True when those bits cover the entire active EXEC mask. + bool disjoint = false; ///< True when the written bits lie entirely outside the active + ///< mask [0,wave_size) (e.g. exec_hi on Wave32), so the write + ///< touches no active lane whatever value it stores. +}; + +[[nodiscard]] ExecWriteExtent exec_write_extent(const Instruction &inst, uint32_t wave_size) { + if (inst.flags() & WRITES_EXEC) + return {full_exec_mask(wave_size), /*full=*/true, /*disjoint=*/false}; + for (int i = 0; i < inst.num_dst_operands(); ++i) { + const Operand *op = inst.dst_operand(i); + if (op == nullptr) + continue; + if (auto ref = op->to_register_ref(); ref && ref->cls == RegClass::EXEC) { + const int w = op->size_bits(); + const uint64_t mask = (w >= 64) ? ~0ULL : ((1ULL << w) - 1ULL); + // Full only when the write starts at exec_lo (index 0) and spans the mask. + const bool full = ref->index == 0 && w >= static_cast(wave_size); + // Position the written bits within EXEC (exec_lo -> [0,w), exec_hi -> + // [32,32+w)) and test them against the active mask. A write landing wholly + // above the active lanes -- most notably exec_hi on Wave32 -- leaves every + // active lane untouched. + const int shift = ref->index * 32; + const uint64_t positioned = shift >= 64 ? 0ULL : (mask << shift); + const bool disjoint = (positioned & full_exec_mask(wave_size)) == 0; + return {mask, full, disjoint}; + } + } + return {}; +} + +/// @brief True when @p op is a compile-time all-ones constant across @p mask. +[[nodiscard]] bool src_const_is_all_ones(const Operand *op, uint64_t mask) { + if (op == nullptr) + return false; + const std::optional cv = op->const_value(); + return cv && (*cv & mask) == mask; +} + +/// @brief How the value written to the destination is formed from the sources. +enum class Combinator { Other, Copy, Or }; + +[[nodiscard]] Combinator combinator(const Instruction &inst) { + if (inst.flags() & RESULT_OR) + return Combinator::Or; + if (inst.flags() & RESULT_COPY) + return Combinator::Copy; + return Combinator::Other; +} + +/// @brief True when the value written into the EXEC bits is provably all-ones +/// across @p mask (the written width). +/// +/// @details Operation-aware via the result combinator and compile-time-constant +/// sources (`const_value()` resolves literals and inline constants without a +/// wavefront): +/// * `Copy` (`exec = src`): the single source is all-ones. +/// * `Or` (`exec = a | b …`): any source is an all-ones constant. +/// * everything else (and/xor/not/cmpx/register restores/...): not provable. +[[nodiscard]] bool writes_all_ones_value(const Instruction &inst, uint64_t mask) { + switch (combinator(inst)) { + case Combinator::Copy: + return inst.num_src_operands() == 1 && src_const_is_all_ones(inst.src_operand(0), mask); + case Combinator::Or: + for (int i = 0; i < inst.num_src_operands(); ++i) + if (src_const_is_all_ones(inst.src_operand(i), mask)) + return true; + return false; + case Combinator::Other: + return false; + } + return false; +} + +/// @details A write disjoint from the active mask (e.g. `s_mov_b32 exec_hi, N` on +/// Wave32, where the active lanes are exec_lo) touches no active lane, so it is +/// `Preserve` regardless of the value written. Otherwise: a full all-ones write +/// establishes `Full`; a *partial* all-ones write (e.g. `s_mov_b32 exec_lo, -1` +/// on Wave64) only sets a subset of the mask to ones, so it keeps an already-`Full` +/// mask `Full` but cannot establish `Full` from `Unknown` — that is `Preserve`. +/// AND-style writes (incl. `s_and_saveexec exec, -1`, where `exec & -1 == exec`) +/// and writes of any other value fall through to `Narrowing`. +[[nodiscard]] ExecWrite classify(const Instruction &inst, uint32_t wave_size) { + if (!writes_exec(inst)) + return ExecWrite::None; + const ExecWriteExtent ext = exec_write_extent(inst, wave_size); + if (ext.disjoint) + return ExecWrite::Preserve; + if (writes_all_ones_value(inst, ext.mask)) + return ext.full ? ExecWrite::AllOnes : ExecWrite::Preserve; + return ExecWrite::Narrowing; +} + +[[nodiscard]] ExecState transfer(ExecState in, const Instruction &inst, uint32_t wave_size) { + switch (classify(inst, wave_size)) { + case ExecWrite::AllOnes: + return ExecState::Full; + case ExecWrite::Narrowing: + return ExecState::Unknown; + case ExecWrite::Preserve: // partial all-ones: keep Full as Full, Unknown as Unknown + case ExecWrite::None: + break; + } + return in; +} + +/// @brief Lattice meet: `Full` only when both inputs are `Full`. +[[nodiscard]] ExecState meet(ExecState a, ExecState b) { + return (a == ExecState::Full && b == ExecState::Full) ? ExecState::Full : ExecState::Unknown; +} + +/// @brief A block's whole transfer function over the two-point lattice. +/// +/// @details Since every per-instruction transfer is either a constant +/// (AllOnes -> Full, Narrowing -> Unknown) or the identity (Preserve/None), the +/// composition over a block is fully determined by its *last* constant EXEC +/// write. Summarizing it once lets the worklist apply a block in O(1) instead of +/// re-walking (and re-classifying) the whole instruction list on every re-visit. +enum class BlockEffect : uint8_t { + Identity, ///< No constant EXEC write: out == in. + ConstFull, ///< Last constant write is all-ones: out == Full. + ConstUnknown, ///< Last constant write narrows EXEC: out == Unknown. +}; + +[[nodiscard]] BlockEffect summarize_block_exec_effect(BasicBlock &block, uint32_t wave_size) { + BlockEffect effect = BlockEffect::Identity; + for (const auto &inst : block.instructions()) { + switch (classify(inst, wave_size)) { + case ExecWrite::AllOnes: + effect = BlockEffect::ConstFull; + break; + case ExecWrite::Narrowing: + effect = BlockEffect::ConstUnknown; + break; + case ExecWrite::Preserve: + case ExecWrite::None: + break; + } + } + return effect; +} + +/// @brief Summarize every in-scope block's transfer function once, up front, so +/// the fixpoint worklist can apply each block in O(1) without re-walking (and +/// re-classifying) its instructions on every re-visit. +[[nodiscard]] std::vector summarize_all_block_exec_effects(KernelBlockScope blocks, + uint32_t wave_size) { + std::vector effects(blocks.size(), BlockEffect::Identity); + for (size_t i = 0; i < blocks.size(); ++i) { + if (blocks[i] != nullptr) + effects[i] = summarize_block_exec_effect(*blocks[i], wave_size); + } + return effects; +} + +[[nodiscard]] ExecState apply_block_effect(BlockEffect effect, ExecState in) { + switch (effect) { + case BlockEffect::ConstFull: + return ExecState::Full; + case BlockEffect::ConstUnknown: + return ExecState::Unknown; + case BlockEffect::Identity: + break; + } + return in; +} + +} // namespace + +ExecMaskAnalysis::ExecMaskAnalysis(KernelBlockScope blocks, uint8_t wave_size, + std::span extra_edges, + std::span entry_blocks) + : wave_size_(wave_size) { + if (wave_size != 32 && wave_size != 64) + throw std::invalid_argument("ExecMaskAnalysis: wave_size must be 32 or 64"); + analyze(blocks, extra_edges, entry_blocks); +} + +void ExecMaskAnalysis::analyze(KernelBlockScope blocks, std::span extra_edges, + std::span entry_blocks) { + states_.assign(blocks.size(), BlockExec{}); + block_index_.reserve(blocks.size()); + for (size_t i = 0; i < blocks.size(); ++i) { + if (blocks[i] != nullptr) + block_index_.emplace(blocks[i], i); + } + + // BasicBlock::successors()/predecessors() carry only context-free local CFG + // edges. Fold the caller-provided scoped call/return edges into an index-based + // adjacency the same way LivenessAnalysis does, so both analyses see the same + // graph. Only edges whose endpoints are both in scope are kept. + std::vector> successors(blocks.size()); + std::vector> predecessors(blocks.size()); + auto add_edge = [&](const BasicBlock *from, const BasicBlock *to) { + auto from_it = block_index_.find(from); + auto to_it = block_index_.find(to); + if (from_it == block_index_.end() || to_it == block_index_.end()) + return; + auto &succs = successors[from_it->second]; + if (std::ranges::find(succs, to_it->second) != succs.end()) + return; + succs.push_back(to_it->second); + predecessors[to_it->second].push_back(from_it->second); + }; + + for (const BasicBlock *block : blocks) { + if (block == nullptr) + continue; + for (const BasicBlock *succ : block->successors()) + add_edge(block, succ); + } + for (const ScopedCfgEdge &edge : extra_edges) + add_edge(edge.from, edge.to); + + // A block is an entry when it is a caller-supplied kernel entry or has no + // in-scope predecessor (scoped edges included). Entries are pinned to + // `Unknown`; interior blocks start optimistically `Full` so the forward `must` + // meet can pull them down to `Unknown` to a fixpoint. A real entry may be a + // loop header with a backedge, so predecessor count alone cannot find it -- + // hence the explicit entry_blocks. Over-marking a block as entry only loses + // precision, never soundness. + std::unordered_set entry_set(entry_blocks.begin(), entry_blocks.end()); + for (size_t i = 0; i < blocks.size(); ++i) { + if (blocks[i] == nullptr) + continue; + states_[i].is_entry = predecessors[i].empty() || entry_set.contains(blocks[i]); + } + // Fallback when no entry was supplied and none was found (e.g. a fully cyclic + // scope): seed the scope leader so the meet has at least one `Unknown` source. + if (entry_blocks.empty() && + std::ranges::none_of(states_, [](const BlockExec &s) { return s.is_entry; })) { + for (size_t i = 0; i < blocks.size(); ++i) { + if (blocks[i] != nullptr) { + states_[i].is_entry = true; + break; + } + } + } + + const std::vector block_effects = + summarize_all_block_exec_effects(blocks, wave_size_); + + const auto rpo = reverse_post_order(blocks); + std::deque worklist; + std::vector in_worklist(blocks.size(), false); + auto enqueue = [&](size_t idx) { + if (idx >= in_worklist.size() || in_worklist[idx]) + return; + in_worklist[idx] = true; + worklist.push_back(idx); + }; + + // Seed in reverse-post-order for fast forward convergence, then queue any + // remaining blocks: a block reachable only through a scoped edge is absent + // from the successors()-based RPO but still needs to be processed. + for (const BasicBlock *block : rpo) { + auto it = block_index_.find(block); + if (it != block_index_.end()) + enqueue(it->second); + } + for (size_t idx = 0; idx < blocks.size(); ++idx) + enqueue(idx); + + while (!worklist.empty()) { + const size_t idx = worklist.front(); + worklist.pop_front(); + in_worklist[idx] = false; + + BasicBlock *block = blocks[idx]; + if (block == nullptr) + continue; + + ExecState in; + if (states_[idx].is_entry) { + in = ExecState::Unknown; + } else { + std::optional acc; + for (size_t pred_idx : predecessors[idx]) { + const ExecState pred_out = states_[pred_idx].out; + acc = acc ? meet(*acc, pred_out) : pred_out; + } + in = acc.value_or(ExecState::Unknown); + } + + const ExecState out = apply_block_effect(block_effects[idx], in); + if (in != states_[idx].in || out != states_[idx].out) { + states_[idx].in = in; + states_[idx].out = out; + for (size_t succ_idx : successors[idx]) + enqueue(succ_idx); + } + } + + // Materialize the EXEC state entering each instruction. Size full_before_ once + // from the total instruction count so the per-instruction inserts never + // rehash. + size_t total_instructions = 0; + for (const BasicBlock *block : blocks) { + if (block != nullptr) + total_instructions += block->num_instructions(); + } + full_before_.reserve(total_instructions); + for (size_t i = 0; i < blocks.size(); ++i) { + BasicBlock *block = blocks[i]; + if (block == nullptr) + continue; + ExecState state = states_[i].in; + for (const auto &inst : block->instructions()) { + if (state == ExecState::Full) + full_before_.insert(&inst); + state = transfer(state, inst, wave_size_); + } + } +} + +ExecState ExecMaskAnalysis::before(const Instruction &inst) const { + return full_before_.contains(&inst) ? ExecState::Full : ExecState::Unknown; +} + +} // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/exec_state.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/exec_state.h new file mode 100644 index 000000000000..9a74a111d41d --- /dev/null +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/exec_state.h @@ -0,0 +1,81 @@ +// Copyright (c) 2026 Advanced Micro Devices, Inc. +// SPDX-License-Identifier: MIT + +/// @file exec_state.h +/// @brief Forward "EXEC is provably full" dataflow over one kernel CFG scope. +/// +/// @details Liveness must know whether an EXEC-masked vector write overwrites +/// every lane (a real kill) or only the active lanes (inactive lanes keep their +/// old values, so it is not a kill). This pass computes a conservative +/// approximation of the EXEC mask at each program point as a two-point lattice. + +#pragma once + +#include "rocjitsu/analysis/liveness.h" // KernelBlockScope, ScopedCfgEdge + +#include +#include +#include +#include +#include + +namespace rocjitsu { + +class BasicBlock; +class Instruction; + +/// @brief Approximated EXEC mask state at a program point. +enum class ExecState : uint8_t { + Full, + Unknown, +}; + +/// @brief Forward "EXEC is provably full" analysis over one kernel CFG scope. +/// +/// @details Scope semantics match LivenessAnalysis: only the supplied blocks +/// participate, edges leaving the scope are ignored, and the same scoped +/// call/return `extra_edges` are folded in. Entries are seeded with `Unknown`: +/// the caller-supplied `entry_blocks`, plus any block with no in-scope +/// predecessor. +class ExecMaskAnalysis { +public: + /// @brief Compute EXEC state for one kernel's block set. + /// @param wave_size Lanes per wavefront (EXEC bit width): 64 for Wave64, 32 + /// for Wave32. Used to tell a full-EXEC write from a partial half-write + /// (e.g. `s_mov_b32 exec_lo` is the whole mask on Wave32 but only half + /// on Wave64). Defaults to 0 and fails if not set. + /// @param extra_edges Scoped call/return edges folded into the CFG for this + /// kernel, matching LivenessAnalysis. EXEC state then flows from a call + /// site into the callee and from a return into the continuation, so the + /// two analyses agree on which blocks are entries and how EXEC reaches + /// them. + /// @param entry_blocks Real kernel entry blocks, pinned to `Unknown`. A + /// hardware entry can be a loop header with an in-scope backedge, so it + /// is not recognizable by predecessor count alone; pinning it stops the + /// forward meet from deriving `Full` there. Empty falls back to the + /// scope leader. + explicit ExecMaskAnalysis(KernelBlockScope blocks, uint8_t wave_size = 0, + std::span extra_edges = {}, + std::span entry_blocks = {}); + + /// @brief EXEC state immediately before @p inst executes. + /// @returns `ExecState::Unknown` if @p inst was not part of this analysis. + [[nodiscard]] ExecState before(const Instruction &inst) const; + +private: + void analyze(KernelBlockScope blocks, std::span extra_edges, + std::span entry_blocks); + + struct BlockExec { + ExecState in = ExecState::Full; + ExecState out = ExecState::Full; + bool is_entry = false; + }; + + uint8_t wave_size_ = 0; + std::vector states_; + std::unordered_map block_index_; + std::unordered_set full_before_; +}; + +} // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/liveness.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/liveness.cpp index 214b09c94b7d..84f2930e0eef 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/liveness.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/liveness.cpp @@ -4,6 +4,7 @@ #include "rocjitsu/analysis/liveness.h" #include "rocjitsu/analysis/def_use_chain.h" +#include "rocjitsu/analysis/exec_state.h" #include "rocjitsu/analysis/gfx1250_vgpr_msb.h" #include "rocjitsu/code/basic_block.h" #include "rocjitsu/isa/instruction.h" @@ -58,21 +59,16 @@ void dfs_reverse_post_order(const BasicBlock &start, return false; } -[[nodiscard]] RegisterSet kill_defs(const InstDefUse &du) { +[[nodiscard]] RegisterSet kill_defs(const InstDefUse &du, ExecState exec_before) { RegisterSet kills = du.defs; - // Predicated defs and EXEC-masked vector defs preserve old values on at least - // one path or lane. Until EXEC state is tracked at each program point, those - // writes cannot be treated as unconditional liveness kills. - // - // The VGPR/ACC_VGPR kill suppression below is also load-bearing for the gfx1250 - // VGPR-MSB def handling: InstDefUse records NOTHING for an unknown-bank VGPR def - // (see expand_operand_register in def_use_chain.cpp) on the assumption that such - // a def never becomes a liveness kill. Every VGPR def is exec-masked, so this - // clear is what upholds that assumption. If this suppression is removed or made - // conditional, revisit that def handling so an unknown-bank def does not over-kill. + // Predicated defs preserve old values on at least one control-flow path, so + // they can never be unconditional kills. if (du.has_predicated_def) return {}; - if (du.has_exec_masked_vector_def) { + // EXEC-masked vector defs preserve inactive lanes' old values, so they are + // kills only where EXEC is provably full (every lane overwritten). Where the + // EXEC state is unknown we stay conservative and do not kill. + if (du.has_exec_masked_vector_def && exec_before != ExecState::Full) { kills.clear_class(RegClass::VGPR); kills.clear_class(RegClass::ACC_VGPR); } @@ -154,11 +150,16 @@ std::vector reverse_post_order(KernelBlockScope blocks) { return postorder; } -LivenessAnalysis::LivenessAnalysis(KernelBlockScope blocks, LivenessAnalysisOptions options, +LivenessAnalysis::LivenessAnalysis(KernelBlockScope blocks, std::unique_ptr exec, + LivenessAnalysisOptions options, std::span extra_edges) { min_free_vgpr_ = options.min_free_vgpr; max_free_vgpr_ = static_cast(std::min(options.max_free_vgpr, REGISTER_SET_MAX_VGPRS)); + // Own the EXEC-state analysis; the backward dataflow is deferred to the first + // query (ensure_analyzed), which consults it for kills. May be null: kills then + // treat every EXEC-masked vector def as `Unknown` (conservative, never a kill). + exec_ = std::move(exec); deferred_blocks_.assign(blocks.begin(), blocks.end()); scoped_blocks_.reserve(blocks.size()); for (const BasicBlock *block : blocks) { @@ -223,6 +224,12 @@ void LivenessAnalysis::analyze(KernelBlockScope blocks, bool restrict_live_befor block_index_.emplace(blocks[i], i); } + // Without an EXEC-state analysis, treat every program point as `Unknown` so + // kill_defs never promotes an EXEC-masked vector def to a kill. + const auto exec_before = [this](const Instruction &inst) { + return exec_ ? exec_->before(inst) : ExecState::Unknown; + }; + const bool filter_live_before = restrict_live_before_to_instructions; std::unordered_set requested_live_before; if (filter_live_before) { @@ -274,7 +281,7 @@ void LivenessAnalysis::analyze(KernelBlockScope blocks, bool restrict_live_befor if (filter_live_before && requested_live_before.contains(&inst)) ++requested_live_before_by_block[i]; InstDefUse du(inst, gfx1250_vgpr_msb_.get()); - RegisterSet kills = kill_defs(du); + RegisterSet kills = kill_defs(du, exec_before(inst)); RegisterSet upward_uses = du.uses; upward_uses -= state.kill; state.gen |= upward_uses; @@ -343,7 +350,7 @@ void LivenessAnalysis::analyze(KernelBlockScope blocks, bool restrict_live_befor --it; const Instruction *inst = &*it; InstDefUse du(*inst, gfx1250_vgpr_msb_.get()); - RegisterSet kills = kill_defs(du); + RegisterSet kills = kill_defs(du, exec_before(*inst)); live -= kills; live |= du.uses; if (!filter_live_before || requested_live_before.contains(inst)) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/liveness.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/liveness.h index 950a84b60ded..c11095b24330 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/liveness.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/analysis/liveness.h @@ -29,6 +29,7 @@ namespace rocjitsu { class BasicBlock; +class ExecMaskAnalysis; class Gfx1250VgprMsbAnalysis; class Instruction; @@ -141,7 +142,13 @@ class LivenessAnalysis { /// object. The pointed-to BasicBlocks and their Instructions must outlive this /// analysis because deferred CFG queries retain and later dereference them. /// @param blocks Blocks in one kernel CFG scope. - LivenessAnalysis(KernelBlockScope blocks, LivenessAnalysisOptions options = {}, + /// @param exec Optional program-point EXEC-state analysis over the same + /// @p blocks scope; lets EXEC-masked vector defs count as kills where EXEC is + /// provably full. Ownership is moved into the analysis. Defaults to null: with + /// no EXEC analysis every EXEC-masked vector def is treated as `Unknown`, so + /// the conservative behavior (never promote such a def to a kill) is preserved. + LivenessAnalysis(KernelBlockScope blocks, std::unique_ptr exec = nullptr, + LivenessAnalysisOptions options = {}, std::span extra_edges = {}); ~LivenessAnalysis(); @@ -257,6 +264,10 @@ class LivenessAnalysis { uint16_t min_free_vgpr_ = 0; uint16_t max_free_vgpr_ = 0; std::unique_ptr gfx1250_vgpr_msb_; + // EXEC-state analysis over the same scope, captured at construction so the + // deferred backward dataflow can treat an EXEC-masked vector def as a kill + // where EXEC is provably full. + std::unique_ptr exec_; RegisterSet globally_used_registers_; std::vector deferred_blocks_; std::unordered_set scoped_blocks_; diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/CMakeLists.txt b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/CMakeLists.txt index 184e592182ab..0a333a27ee1d 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/CMakeLists.txt +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/CMakeLists.txt @@ -12,6 +12,7 @@ rj_add_object_library(rocjitsu_code dbt/binary_translator.cpp dbt/legalization/gfx1250_b0_to_a0.cpp dbt/rj_code_translate.cpp + dbt/scoped_cfg_edges.cpp dbt/hazard_tracker.cpp dbt/kernel_descriptor_translator.cpp dbt/lane_permutation.cpp diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/amdgpu_code_object.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/amdgpu_code_object.cpp index 1872dfc9aab2..13c73006f539 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/amdgpu_code_object.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/amdgpu_code_object.cpp @@ -312,4 +312,96 @@ std::optional AmdGpuCodeObject::min_kernel_sgpr_count(rj_code_arch_t a return min_count; } +uint8_t AmdGpuCodeObject::kernel_wavefront_size(rj_code_arch_t arch) const { + namespace kd = rocr::llvm::amdhsa; + using KD = kd::kernel_descriptor_t; + + // CDNA kernels are always Wave64. + if (is_cdna_arch(arch)) + return 64; + + // RDNA opts into Wave32 via ENABLE_WAVEFRONT_SIZE32; a clear bit means Wave64. + // Return Wave32 only when every kernel is provably Wave32. + bool saw_kernel = false; + bool all_wave32 = true; + for (const auto &[name, kd_vaddr] : kd_offsets_) { + bool readable = false; + for (const auto §ion : all_sections()) { + const uint64_t base = section->vaddr(); + if (base == 0 || kd_vaddr < base) + continue; + const uint64_t off = kd_vaddr - base; + if (off + sizeof(KD) > section->size()) + continue; + KD desc; + std::memcpy(&desc, section->data() + off, sizeof(desc)); + const bool wave32 = AMDHSA_BITS_GET(desc.kernel_code_properties, + kd::KERNEL_CODE_PROPERTY_ENABLE_WAVEFRONT_SIZE32); + saw_kernel = true; + all_wave32 = all_wave32 && wave32; + readable = true; + break; + } + // An unreadable descriptor could be Wave64; fall back conservatively so a + // readable Wave32 kernel can't mislabel it and license unsound EXEC kills. + if (!readable) + return 64; + } + return (saw_kernel && all_wave32) ? 32 : 64; +} + +std::vector AmdGpuCodeObject::kernel_entry_text_offsets(rj_code_arch_t arch) const { + namespace kd = rocr::llvm::amdhsa; + using KD = kd::kernel_descriptor_t; + + // CDNA3/CDNA4 implement kernarg preloading through the legacy firmware + // compatibility window: compatible firmware enters 256 bytes past the + // descriptor entry, so a preload kernel has a second hardware entry there. + constexpr int64_t kKernargPreloadSkipBytes = 256; + const bool preload_firmware_skip = + arch == ROCJITSU_CODE_ARCH_CDNA3 || arch == ROCJITSU_CODE_ARCH_CDNA4; + + std::vector offsets; + for (const auto &[name, kd_vaddr] : kd_offsets_) { + for (const auto §ion : all_sections()) { + const uint64_t base = section->vaddr(); + if (base == 0 || kd_vaddr < base) + continue; + const uint64_t off = kd_vaddr - base; + if (off + sizeof(KD) > section->size()) + continue; + KD desc; + std::memcpy(&desc, section->data() + off, sizeof(desc)); + const int64_t entry_vaddr = + static_cast(kd_vaddr) + desc.kernel_code_entry_byte_offset; + if (entry_vaddr < 0) + break; + for (const Section *text : text_sections()) { + const uint64_t tbase = text->vaddr(); + if (static_cast(entry_vaddr) >= tbase && + static_cast(entry_vaddr) < tbase + text->size()) { + offsets.push_back(static_cast(entry_vaddr) - tbase); + break; + } + } + // A nonzero KERNARG_PRELOAD_SPEC_LENGTH lets compatible firmware enter the + // +256 window directly with unknown EXEC, so seed that second entry too. + if (preload_firmware_skip && + AMDHSA_BITS_GET(desc.kernarg_preload, kd::KERNARG_PRELOAD_SPEC_LENGTH) != 0) { + const int64_t firmware_vaddr = entry_vaddr + kKernargPreloadSkipBytes; + for (const Section *text : text_sections()) { + const uint64_t tbase = text->vaddr(); + if (static_cast(firmware_vaddr) >= tbase && + static_cast(firmware_vaddr) < tbase + text->size()) { + offsets.push_back(static_cast(firmware_vaddr) - tbase); + break; + } + } + } + break; + } + } + return offsets; +} + } // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/amdgpu_code_object.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/amdgpu_code_object.h index 884442b3596d..3ad220d0d871 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/amdgpu_code_object.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/amdgpu_code_object.h @@ -74,6 +74,24 @@ class AmdGpuCodeObject : public CodeObject { /// the fixed per-wave SGPR pool. @p arch selects that interpretation. [[nodiscard]] std::optional min_kernel_sgpr_count(rj_code_arch_t arch) const; + /// @brief Wavefront size (32 or 64) shared by this object's kernels. + /// + /// @details CDNA is always Wave64; RDNA opts into Wave32 via the descriptor's + /// `ENABLE_WAVEFRONT_SIZE32` bit. Returns 64 (the safe value for whole-object + /// EXEC-mask analysis) unless every kernel descriptor is readable and Wave32. + [[nodiscard]] uint8_t kernel_wavefront_size(rj_code_arch_t arch) const; + + /// @brief Text-section-relative entry offset of each hardware kernel entry. + /// + /// @details Decodes each descriptor's `kernel_code_entry_byte_offset` and maps + /// it to an offset within the containing .text section, matching + /// BasicBlock::start_offset(). Lets whole-object analyses pin the real kernel + /// entries even when an entry is a loop header with a backedge. On CDNA3/CDNA4 + /// a descriptor with a nonzero `KERNARG_PRELOAD_SPEC_LENGTH` has a second + /// hardware entry 256 bytes past the descriptor entry (the firmware + /// kernarg-preload window), which @p arch also enumerates. + [[nodiscard]] std::vector kernel_entry_text_offsets(rj_code_arch_t arch) const; + private: void load_sections(); diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/dbt/binary_translator.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/dbt/binary_translator.cpp index 01c2ebd4b35f..26b17dbd9f8b 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/dbt/binary_translator.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/dbt/binary_translator.cpp @@ -3,6 +3,7 @@ #include "rocjitsu/code/dbt/binary_translator.h" +#include "rocjitsu/analysis/exec_state.h" #include "rocjitsu/analysis/gfx1250_vgpr_msb.h" #include "rocjitsu/analysis/liveness.h" #include "rocjitsu/code/amdgpu_code_object.h" @@ -19,6 +20,7 @@ #include "rocjitsu/code/dbt/kernel_descriptor_translator.h" #include "rocjitsu/code/dbt/lds_virtualization.h" #include "rocjitsu/code/dbt/legalization/gfx1250_b0_to_a0.h" +#include "rocjitsu/code/dbt/scoped_cfg_edges.h" #include "rocjitsu/code/dbt/semantic/gfx1250_flat_scratch_base.h" #include "rocjitsu/code/dbt/semantic_translator.h" #include "rocjitsu/code/dbt/virtual_lds.h" @@ -682,123 +684,6 @@ kernel_translation_scopes(const std::vector> &blocks return scopes; } -/// @brief Return whether an instruction is a scalar set-PC through one SGPR pair. -/// -/// @details Return-like scalar control flow is left as an indirect branch in the -/// translated instruction stream, so DBT must validate that the block terminator -/// reads the call edge's saved return SGPR. This helper intentionally checks the -/// raw SOP1 source field instead of broader instruction semantics: only the exact -/// `s_setpc_b64`/`s_set_pc_i64 s[return:return+1]` form is a scoped call return. -[[nodiscard]] bool s_setpc_from_sreg(const Instruction &inst, uint32_t word, uint16_t ssrc0) { - const std::string_view mnemonic = inst.mnemonic(); - if (inst.size() != sizeof(uint32_t) || (mnemonic != "s_setpc_b64" && mnemonic != "s_set_pc_i64")) - return false; - return static_cast(word & 0xffu) == ssrc0; -} - -/// @brief Find return blocks inside one context-sensitive call target. -/// -/// @details Call-like scalar control flow is not represented as a normal CFG -/// edge from the callee back to every possible continuation. The same helper -/// block can be entered by multiple kernels or multiple call sites, and the -/// correct continuation is the one selected by the return SGPR written at that -/// call site. This walk therefore stays inside @p allowed_blocks and mirrors -/// call-return classification: nested callees are visited with their own return -/// SGPR as a stopping condition, while their continuations retain the enclosing -/// condition. This exposes paths that return directly through an enclosing pair -/// without mistaking a nested callee's normal return for the enclosing return. -/// The caller then pairs each reported return with the specific continuation -/// from the call edge being analyzed. -[[nodiscard]] std::vector -function_return_blocks(BasicBlock &callee, uint16_t return_sreg, std::span text, - const std::unordered_set &allowed_blocks) { - struct WalkPoint { - BasicBlock *block = nullptr; - std::optional terminal_return_sreg; - }; - - std::vector returns; - std::unordered_set return_set; - std::vector stack{{.block = &callee, .terminal_return_sreg = std::nullopt}}; - std::set>> visited; - - while (!stack.empty()) { - const WalkPoint point = stack.back(); - stack.pop_back(); - BasicBlock *block = point.block; - assert(block != nullptr && "return-block walk stack should contain only decoded blocks"); - if (!allowed_blocks.contains(block) || - !visited.insert({block, point.terminal_return_sreg}).second) - continue; - - const Instruction *term = block->terminator(); - assert(term != nullptr && "decoded BasicBlock should contain at least one instruction"); - if (point.terminal_return_sreg && s_setpc_from_sreg(*term, text_word_at(text, term->src_loc()), - *point.terminal_return_sreg)) { - continue; - } - if (s_setpc_from_sreg(*term, text_word_at(text, term->src_loc()), return_sreg)) { - if (return_set.insert(block).second) - returns.push_back(block); - continue; - } - - for (BasicBlock *succ : block->successors()) { - assert(succ != nullptr && "BasicBlock successors should never be null"); - stack.push_back({.block = succ, .terminal_return_sreg = point.terminal_return_sreg}); - } - for (const BasicBlock::CallEdge &call : block->call_edges()) { - assert(call.callee != nullptr && "BasicBlock call edges should always have a callee"); - assert(call.continuation != nullptr && - "BasicBlock call edges should always have a continuation"); - stack.push_back({.block = call.callee, .terminal_return_sreg = call.return_sreg}); - stack.push_back( - {.block = call.continuation, .terminal_return_sreg = point.terminal_return_sreg}); - } - } - - return returns; -} - -/// @brief Collect validated return-like terminators for one kernel scope. -/// -/// @details Binary translation rejects unresolved indirect branches after CFG -/// construction, but a call-return `s_setpc_b64` is intentionally left as an -/// indirect instruction in the emitted code: its dynamic target is the return PC -/// saved by the matching `s_call_b64` or `s_swappc_b64`. To avoid accepting an -/// arbitrary `s_setpc_b64`, this helper only marks return offsets that are -/// reachable from a `BasicBlock::CallEdge` whose callee and continuation both -/// belong to the current kernel-local scope. -[[nodiscard]] std::unordered_set -scoped_call_return_offsets(std::span blocks, std::span text) { - std::unordered_set allowed_blocks; - allowed_blocks.reserve(blocks.size()); - for (BasicBlock *block : blocks) { - assert(block != nullptr && "kernel scope should contain only decoded blocks"); - allowed_blocks.insert(block); - } - - std::unordered_set returns; - for (BasicBlock *block : blocks) { - assert(block != nullptr && "kernel scope should contain only decoded blocks"); - for (const BasicBlock::CallEdge &call : block->call_edges()) { - assert(call.callee != nullptr && "BasicBlock call edges should always have a callee"); - assert(call.continuation != nullptr && - "BasicBlock call edges should always have a continuation"); - if (!allowed_blocks.contains(call.callee) || !allowed_blocks.contains(call.continuation)) - continue; - - for (BasicBlock *return_block : - function_return_blocks(*call.callee, call.return_sreg, text, allowed_blocks)) { - const Instruction *term = return_block->terminator(); - assert(term != nullptr && "function_return_blocks returns non-empty decoded blocks"); - returns.insert(term->src_loc()); - } - } - } - return returns; -} - /// @brief Return offsets of the `s_setpc_b64` returns belonging to adopted device-function roots. /// /// @details An adopted root has no call edge, so scoped_call_return_offsets() -- which derives the @@ -1093,45 +978,6 @@ adopted_root_return_offsets(const BlockOffsetIndex &block_index, return returns; } -/// @brief Materialize context-sensitive call edges for liveness. -/// -/// @details `BasicBlock` deliberately separates call edges from ordinary CFG -/// successors. The translator still needs liveness to see the effects of a -/// call: values live into the callee are used by the callee, and values live -/// after the call continuation must be live at each validated return block. -/// This helper converts each scoped call edge into temporary analysis edges -/// `caller -> callee` and `return -> continuation` without mutating the CFG or -/// creating cross-kernel return edges. -[[nodiscard]] std::vector -scoped_call_liveness_edges(std::span blocks, std::span text) { - std::unordered_set allowed_blocks; - allowed_blocks.reserve(blocks.size()); - for (BasicBlock *block : blocks) { - assert(block != nullptr && "kernel scope should contain only decoded blocks"); - allowed_blocks.insert(block); - } - - std::vector edges; - for (BasicBlock *block : blocks) { - assert(block != nullptr && "kernel scope should contain only decoded blocks"); - for (const BasicBlock::CallEdge &call : block->call_edges()) { - assert(call.callee != nullptr && "BasicBlock call edges should always have a callee"); - assert(call.continuation != nullptr && - "BasicBlock call edges should always have a continuation"); - if (!allowed_blocks.contains(call.callee) || !allowed_blocks.contains(call.continuation)) - continue; - - edges.push_back({.from = block, .to = call.callee}); - for (BasicBlock *return_block : - function_return_blocks(*call.callee, call.return_sreg, text, allowed_blocks)) { - edges.push_back({.from = return_block, .to = call.continuation}); - } - } - } - - return edges; -} - /// @brief Commit translated text, descriptor plans, and runtime metadata to one ELF image. /// /// @details BinaryTranslator owns analysis and per-kernel lowering. This helper @@ -2301,8 +2147,18 @@ TranslatedCodeObject BinaryTranslator::translate(const AmdGpuCodeObject &obj) { std::vector scope_analysis_edges; if (scope_requires_liveness) { scope_analysis_edges = scoped_call_liveness_edges(KernelBlockScope(scope.blocks), text); - liveness = - LivenessAnalysis(KernelBlockScope(scope.blocks), liveness_options, scope_analysis_edges); + // DBT runs liveness without EXEC-state analysis: with a null ExecMaskAnalysis + // every EXEC-masked vector def is treated as `Unknown` and so is never + // promoted to a kill, keeping scratch allocation conservative. + // + // TODO: Once ExecMaskAnalysis is performance-optimized and ensures that it + // doesn't have any waitalu/hazard analysis interference, build one here (seeded + // with the descriptor entry plus, when present, the kernarg-preload firmware + // entry at +256, which hardware enters with unknown EXEC) and pass it to + // LivenessAnalysis so EXEC-masked vector defs can be promoted to kills where + // EXEC is provably full, freeing more scratch registers. Reference issue #9733. + liveness = LivenessAnalysis(KernelBlockScope(scope.blocks), /*exec=*/nullptr, + liveness_options, scope_analysis_edges); } std::unique_ptr wmma_completion_wait_vgpr_msb; diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/dbt/scoped_cfg_edges.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/dbt/scoped_cfg_edges.cpp new file mode 100644 index 000000000000..de4c7d1b413a --- /dev/null +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/dbt/scoped_cfg_edges.cpp @@ -0,0 +1,161 @@ +// Copyright (c) 2026 Advanced Micro Devices, Inc. +// SPDX-License-Identifier: MIT + +#include "rocjitsu/code/dbt/scoped_cfg_edges.h" + +#include "rocjitsu/code/basic_block.h" +#include "rocjitsu/isa/instruction.h" + +#include +#include +#include +#include +#include +#include + +namespace rocjitsu { + +namespace { + +[[nodiscard]] uint32_t text_word_at(std::span text, uint64_t offset) { + uint32_t word = 0; + if (offset + sizeof(word) <= text.size()) + std::memcpy(&word, text.data() + offset, sizeof(word)); + return word; +} + +/// @brief True when @p inst is exactly `s_setpc_b64/s_set_pc_i64 s[ssrc0:+1]`. +/// +/// @details Return-like scalar control flow is left as an indirect branch in the +/// translated stream, so callers must validate that the terminator reads the +/// call edge's saved return SGPR. Checks the raw SOP1 source field rather than +/// broader semantics so only the exact scoped call-return form matches. +[[nodiscard]] bool s_setpc_from_sreg(const Instruction &inst, uint32_t word, uint16_t ssrc0) { + const std::string_view mnemonic = inst.mnemonic(); + if (inst.size() != sizeof(uint32_t) || (mnemonic != "s_setpc_b64" && mnemonic != "s_set_pc_i64")) + return false; + return static_cast(word & 0xffu) == ssrc0; +} + +/// @brief Find return blocks inside one context-sensitive call target. +/// +/// @details The same helper block can be entered by multiple call sites, and the +/// correct continuation is selected by the return SGPR written at that site. The +/// walk stays inside @p allowed_blocks: nested callees are visited with their own +/// return SGPR as a stopping condition while their continuations retain the +/// enclosing condition, exposing paths that return directly through an enclosing +/// pair without mistaking a nested callee's return for the enclosing one. +[[nodiscard]] std::vector +function_return_blocks(BasicBlock &callee, uint16_t return_sreg, std::span text, + const std::unordered_set &allowed_blocks) { + struct WalkPoint { + BasicBlock *block = nullptr; + std::optional terminal_return_sreg; + }; + + std::vector returns; + std::unordered_set return_set; + std::vector stack{{.block = &callee, .terminal_return_sreg = std::nullopt}}; + std::set>> visited; + + while (!stack.empty()) { + const WalkPoint point = stack.back(); + stack.pop_back(); + BasicBlock *block = point.block; + assert(block != nullptr && "return-block walk stack should contain only decoded blocks"); + if (!allowed_blocks.contains(block) || + !visited.insert({block, point.terminal_return_sreg}).second) + continue; + + const Instruction *term = block->terminator(); + assert(term != nullptr && "decoded BasicBlock should contain at least one instruction"); + if (point.terminal_return_sreg && s_setpc_from_sreg(*term, text_word_at(text, term->src_loc()), + *point.terminal_return_sreg)) { + continue; + } + if (s_setpc_from_sreg(*term, text_word_at(text, term->src_loc()), return_sreg)) { + if (return_set.insert(block).second) + returns.push_back(block); + continue; + } + + for (BasicBlock *succ : block->successors()) { + assert(succ != nullptr && "BasicBlock successors should never be null"); + stack.push_back({.block = succ, .terminal_return_sreg = point.terminal_return_sreg}); + } + for (const BasicBlock::CallEdge &call : block->call_edges()) { + assert(call.callee != nullptr && "BasicBlock call edges should always have a callee"); + assert(call.continuation != nullptr && + "BasicBlock call edges should always have a continuation"); + stack.push_back({.block = call.callee, .terminal_return_sreg = call.return_sreg}); + stack.push_back( + {.block = call.continuation, .terminal_return_sreg = point.terminal_return_sreg}); + } + } + + return returns; +} + +} // namespace + +std::vector scoped_call_liveness_edges(std::span blocks, + std::span text) { + std::unordered_set allowed_blocks; + allowed_blocks.reserve(blocks.size()); + for (BasicBlock *block : blocks) { + assert(block != nullptr && "kernel scope should contain only decoded blocks"); + allowed_blocks.insert(block); + } + + std::vector edges; + for (BasicBlock *block : blocks) { + assert(block != nullptr && "kernel scope should contain only decoded blocks"); + for (const BasicBlock::CallEdge &call : block->call_edges()) { + assert(call.callee != nullptr && "BasicBlock call edges should always have a callee"); + assert(call.continuation != nullptr && + "BasicBlock call edges should always have a continuation"); + if (!allowed_blocks.contains(call.callee) || !allowed_blocks.contains(call.continuation)) + continue; + + edges.push_back({.from = block, .to = call.callee}); + for (BasicBlock *return_block : + function_return_blocks(*call.callee, call.return_sreg, text, allowed_blocks)) { + edges.push_back({.from = return_block, .to = call.continuation}); + } + } + } + + return edges; +} + +std::unordered_set scoped_call_return_offsets(std::span blocks, + std::span text) { + std::unordered_set allowed_blocks; + allowed_blocks.reserve(blocks.size()); + for (BasicBlock *block : blocks) { + assert(block != nullptr && "kernel scope should contain only decoded blocks"); + allowed_blocks.insert(block); + } + + std::unordered_set returns; + for (BasicBlock *block : blocks) { + assert(block != nullptr && "kernel scope should contain only decoded blocks"); + for (const BasicBlock::CallEdge &call : block->call_edges()) { + assert(call.callee != nullptr && "BasicBlock call edges should always have a callee"); + assert(call.continuation != nullptr && + "BasicBlock call edges should always have a continuation"); + if (!allowed_blocks.contains(call.callee) || !allowed_blocks.contains(call.continuation)) + continue; + + for (BasicBlock *return_block : + function_return_blocks(*call.callee, call.return_sreg, text, allowed_blocks)) { + const Instruction *term = return_block->terminator(); + assert(term != nullptr && "function_return_blocks returns non-empty decoded blocks"); + returns.insert(term->src_loc()); + } + } + } + return returns; +} + +} // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/dbt/scoped_cfg_edges.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/dbt/scoped_cfg_edges.h new file mode 100644 index 000000000000..0dd9139537ce --- /dev/null +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/dbt/scoped_cfg_edges.h @@ -0,0 +1,44 @@ +// Copyright (c) 2026 Advanced Micro Devices, Inc. +// SPDX-License-Identifier: MIT + +/// @file scoped_cfg_edges.h +/// @brief Context-sensitive call/return edges for kernel-scoped CFG analyses. +/// +/// @details BasicBlock deliberately separates call edges from ordinary CFG +/// successors, because a shared callee can return to different continuations +/// depending on the call site. Liveness and EXEC-state analyses still need to +/// see those flows, so these helpers turn each scoped call edge into temporary +/// analysis edges (`caller -> callee`, `return -> continuation`) without +/// mutating the CFG or creating cross-kernel return edges. Shared by the DBT +/// binary translator and the instrumentor so both analyze the same graph. + +#pragma once + +#include "rocjitsu/analysis/liveness.h" // ScopedCfgEdge + +#include +#include +#include +#include + +namespace rocjitsu { + +class BasicBlock; + +/// @brief Materialize context-sensitive call/return edges for a block scope. +/// +/// @details Each in-scope call edge yields `caller -> callee` plus, for every +/// validated return block, `return -> continuation`. @p text is the raw .text +/// image, used to confirm a terminator reads the call edge's saved return SGPR. +[[nodiscard]] std::vector +scoped_call_liveness_edges(std::span blocks, std::span text); + +/// @brief Collect validated return-like terminator offsets for a block scope. +/// +/// @details A call-return `s_setpc_b64` is left indirect in emitted code; this +/// marks only the return offsets reachable from a `BasicBlock::CallEdge` whose +/// callee and continuation both belong to @p blocks. +[[nodiscard]] std::unordered_set +scoped_call_return_offsets(std::span blocks, std::span text); + +} // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/patch/instrumentor.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/patch/instrumentor.cpp index 0c824733dc7d..f35982280c65 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/patch/instrumentor.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/code/patch/instrumentor.cpp @@ -3,10 +3,12 @@ #include "rocjitsu/code/patch/instrumentor.h" +#include "rocjitsu/analysis/exec_state.h" #include "rocjitsu/analysis/liveness.h" #include "rocjitsu/code/amdgpu_code_object.h" #include "rocjitsu/code/basic_block.h" #include "rocjitsu/code/code_object.h" +#include "rocjitsu/code/dbt/scoped_cfg_edges.h" #include "rocjitsu/code/patch/code_object_patcher.h" #include "rocjitsu/code/patch/error_report.h" #include "rocjitsu/code/patch/instruction_builder.h" @@ -22,6 +24,7 @@ #include #include #include +#include #include #include #include @@ -354,12 +357,21 @@ bool Instrumentor::ensure_blocks_built(std::string *error_out) { return false; } decoder_ = std::move(decoder); - blocks_ = BasicBlock::build(obj_, *decoder_, arch_); + // Force every kernel entry to begin a block. BasicBlock::build only leads at + // natural boundaries, so a descriptor entry inside a fallthrough block would + // not start a block and would be silently dropped by the entry match below; + // a preceding `s_mov exec, -1` could then make it look Full even though + // hardware may enter with unknown EXEC, licensing unsound VGPR kills. + const std::vector entry_offsets = obj_.kernel_entry_text_offsets(arch_); + blocks_ = BasicBlock::build(obj_, *decoder_, arch_, entry_offsets); // BasicBlock::build returns blocks in .text order. Keep clause state across // block boundaries because a branch target may split the linear instruction // stream in the middle of a clause. uint32_t clause_remaining = 0; + std::unordered_set block_starts; + block_starts.reserve(blocks_.size()); for (const auto &block : blocks_) { + block_starts.insert(block->start_offset()); uint64_t cur = block->start_offset(); for (const Instruction &inst : block->instructions()) { if (clause_remaining > 0) { @@ -372,6 +384,16 @@ bool Instrumentor::ensure_blocks_built(std::string *error_out) { cur += static_cast(inst.size()); } } + // Fail closed if a readable entry still has no exact block (e.g. it points + // into undecodable bytes). + for (const uint64_t entry : entry_offsets) { + if (!block_starts.contains(entry)) { + report(error_out, ("kernel entry offset " + std::to_string(entry) + + " has no basic block after construction") + .c_str()); + return false; + } + } blocks_built_ = true; return true; } @@ -529,7 +551,21 @@ InstrumentedCodeObjectDebug Instrumentor::patch_with_debug_summaries() { liveness_scope.reserve(blocks_.size()); for (const auto &block : blocks_) liveness_scope.push_back(block.get()); - const LivenessAnalysis liveness{KernelBlockScope(liveness_scope)}; + const std::span original_text = patcher.text_bytes(); + const auto liveness_edges = + scoped_call_liveness_edges(KernelBlockScope(liveness_scope), original_text); + const auto entry_offsets = obj_.kernel_entry_text_offsets(arch_); + const std::unordered_set entry_offset_set(entry_offsets.begin(), entry_offsets.end()); + std::vector entry_blocks; + for (BasicBlock *block : liveness_scope) { + if (block != nullptr && entry_offset_set.contains(block->start_offset())) + entry_blocks.push_back(block); + } + auto exec = std::make_unique(KernelBlockScope(liveness_scope), + obj_.kernel_wavefront_size(arch_), liveness_edges, + entry_blocks); + const LivenessAnalysis liveness{ + KernelBlockScope(liveness_scope), std::move(exec), {}, liveness_edges}; // Lay out the appended region as [probe bodies][trampolines]. Each distinct // probe body is copied once, ahead of the trampolines that call into it, so a diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/operand.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/operand.cpp index b4952f4a9ade..98ccd306bf3d 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/operand.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/operand.cpp @@ -5,6 +5,7 @@ // See lib/python/amdisa/README.md for regeneration instructions. #include "rocjitsu/isa/arch/amdgpu/cdna1/operand.h" +#include "rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h" #include "rocjitsu/isa/isa_operand_simd_inl.h" #include "rocjitsu/vm/amdgpu/compute_unit.h" #include "rocjitsu/vm/amdgpu/register_access.h" @@ -52,6 +53,16 @@ std::optional Operand::literal64_value() const { return literal64_value_; } +std::optional Operand::const_value() const { + if (has_literal64_) + return literal64_value_; + if (is_immediate_type(opr_type_)) + return static_cast(static_cast(encoding_value_)); + if (to_register_ref()) + return std::nullopt; + return amdgpu::resolve_src_scalar_statically(encoding_value_); +} + std::string Operand::name() const { if (has_literal64_) return std::format("0x{:x}", literal64_value_); @@ -958,9 +969,17 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSdst::OPR_SDST_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_EXEC: { + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_M0: { @@ -981,6 +1000,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSrc::OPR_SRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrc::OPR_SRC_VGPR_MIN && encoding_value_ <= OpSelSrc::OPR_SRC_VGPR_MAX) return RegisterRef{RegClass::VGPR, @@ -1014,6 +1037,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcNolds::OPR_SRC_NOLDS_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcNolds::OPR_SRC_NOLDS_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcNolds::OPR_SRC_NOLDS_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcNolds::OPR_SRC_NOLDS_VGPR_MIN && encoding_value_ <= OpSelSrcNolds::OPR_SRC_NOLDS_VGPR_MAX) return RegisterRef{ @@ -1029,6 +1056,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcNolit::OPR_SRC_NOLIT_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcNolit::OPR_SRC_NOLIT_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcNolit::OPR_SRC_NOLIT_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcNolit::OPR_SRC_NOLIT_VGPR_MIN && encoding_value_ <= OpSelSrcNolit::OPR_SRC_NOLIT_VGPR_MAX) return RegisterRef{ @@ -1044,6 +1075,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcSimple::OPR_SRC_SIMPLE_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcSimple::OPR_SRC_SIMPLE_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcSimple::OPR_SRC_SIMPLE_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcSimple::OPR_SRC_SIMPLE_VGPR_MIN && encoding_value_ <= OpSelSrcSimple::OPR_SRC_SIMPLE_VGPR_MAX) return RegisterRef{ @@ -1100,6 +1135,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrc::OPR_SSRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_LANESEL: { @@ -1118,6 +1157,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrcNolit::OPR_SSRC_NOLIT_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrcNolit::OPR_SSRC_NOLIT_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrcNolit::OPR_SSRC_NOLIT_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_SPECIAL_SCC: { @@ -1154,242 +1197,7 @@ std::optional Operand::to_register_ref() const { namespace { -uint32_t resolve_src_scalar(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return static_cast(wf.scratch_base()); - if (ev == 103) - return static_cast(wf.scratch_base() >> 32); - if (ev <= 105) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 106) - return static_cast(wf.vcc()); - if (ev == 107) - return static_cast(wf.vcc() >> 32); - if (ev >= 108 && ev <= 123) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 124) - return wf.m0(); - if (ev == 126) - return static_cast(wf.exec()); - if (ev == 127) - return static_cast(wf.exec() >> 32); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(-(ev - 192))); - if (ev == 230) - return static_cast(wf.scratch_base()); // SRC_FLAT_SCRATCH_BASE_LO - if (ev == 231) - return static_cast(wf.scratch_base() >> 32); // SRC_FLAT_SCRATCH_BASE_HI - if (ev == 240) - return 0x3F000000u; // 0.5f - if (ev == 241) - return 0xBF000000u; // -0.5f - if (ev == 242) - return 0x3F800000u; // 1.0f - if (ev == 243) - return 0xBF800000u; // -1.0f - if (ev == 244) - return 0x40000000u; // 2.0f - if (ev == 245) - return 0xC0000000u; // -2.0f - if (ev == 246) - return 0x40800000u; // 4.0f - if (ev == 247) - return 0xC0800000u; // -4.0f - if (ev == 248) - return 0x3E22F983u; // 1/(2*pi) - if (ev == 235) - return static_cast(wf.shared_aperture_base() >> 32); // SRC_SHARED_BASE - if (ev == 236) - return static_cast(wf.shared_aperture_limit() >> 32); // SRC_SHARED_LIMIT - if (ev == 237) - return static_cast(wf.private_aperture_base() >> 32); // SRC_PRIVATE_BASE - if (ev == 238) - return static_cast(wf.private_aperture_limit() >> 32); // SRC_PRIVATE_LIMIT - if (ev == 249) - return 0u; // SRC_POPS_EXITING_WAVE_ID (not used in compute) - if (ev == 250) - return 0u; // NULL - if (ev == 251) - return (wf.vcc() & (wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL))) == 0 - ? 1u - : 0u; // VCCZ - if (ev == 252) { - uint64_t active = wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL); - return (wf.exec() & active) == 0 ? 1u : 0u; // EXECZ - } - if (ev == 253) - return wf.read_scc() ? 1u : 0u; // SCC - throw std::logic_error("Unsupported encoding value for scalar read: " + std::to_string(ev)); -} - -uint32_t resolve_src_scalar16(const amdgpu::Wavefront &wf, int ev) { - switch (ev) { - case 240: - return 0x3800u; // 0.5h - case 241: - return 0xB800u; // -0.5h - case 242: - return 0x3C00u; // 1.0h - case 243: - return 0xBC00u; // -1.0h - case 244: - return 0x4000u; // 2.0h - case 245: - return 0xC000u; // -2.0h - case 246: - return 0x4400u; // 4.0h - case 247: - return 0xC400u; // -4.0h - case 248: - return 0x3118u; // f16 1/(2*pi) - default: - return resolve_src_scalar(wf, ev); - } -} - -// Must stay in sync with resolve_src_scalar above — returns true for -// exactly the encoding values that resolve_src_scalar handles without -// throwing. Used by Isa::simd_capable_value() to keep the SIMD fast -// path off operands whose scalar broadcast would throw at runtime. -bool can_resolve_src_scalar(int ev) { - return (ev >= 0 && ev <= 107) || (ev >= 108 && ev <= 123) || ev == 124 || ev == 126 || - ev == 127 || (ev >= 128 && ev <= 208) || (ev >= 235 && ev <= 238) || - (ev >= 240 && ev <= 253); -} - -uint64_t resolve_src_scalar64(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return wf.scratch_base(); - if (ev <= 105) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 106) - return wf.vcc(); - if (ev >= 108 && ev <= 122) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 124) - return wf.m0(); - if (ev == 126) - return wf.exec(); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(static_cast(-(ev - 192)))); - if (ev == 230) - return wf.scratch_base(); // SRC_FLAT_SCRATCH_BASE - if (ev == 240) - return 0x3FE0000000000000ULL; // 0.5 - if (ev == 241) - return 0xBFE0000000000000ULL; // -0.5 - if (ev == 242) - return 0x3FF0000000000000ULL; // 1.0 - if (ev == 243) - return 0xBFF0000000000000ULL; // -1.0 - if (ev == 244) - return 0x4000000000000000ULL; // 2.0 - if (ev == 245) - return 0xC000000000000000ULL; // -2.0 - if (ev == 246) - return 0x4010000000000000ULL; // 4.0 - if (ev == 247) - return 0xC010000000000000ULL; // -4.0 - if (ev == 248) - return 0x3FC45F306DC9C883ULL; // 1/(2*pi) - if (ev == 235) - return wf.shared_aperture_base(); // SRC_SHARED_BASE - if (ev == 236) - return wf.shared_aperture_limit(); // SRC_SHARED_LIMIT - if (ev == 237) - return wf.private_aperture_base(); // SRC_PRIVATE_BASE - if (ev == 238) - return wf.private_aperture_limit(); // SRC_PRIVATE_LIMIT - throw std::logic_error("Unsupported encoding value for scalar64 read: " + std::to_string(ev)); -} - -void resolve_dst_write(amdgpu::Wavefront &wf, int ev, uint32_t val) { - if (ev == 102) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 103) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 106) { - wf.set_vcc((wf.vcc() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 107) { - wf.set_vcc((wf.vcc() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev >= 108 && ev <= 123) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 124) { - wf.set_m0(val); - return; - } - if (ev == 126) { - wf.set_exec((wf.exec() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 127) { - wf.set_exec((wf.exec() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - throw std::logic_error("Unsupported encoding value for scalar write: " + std::to_string(ev)); -} - -void resolve_dst_write64(amdgpu::Wavefront &wf, int ev, uint64_t val) { - if (ev == 102) { - wf.set_scratch_base(val); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 106) { - wf.set_vcc(val); - return; - } - if (ev >= 108 && ev <= 122) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 124) - return; - if (ev == 126) { - wf.set_exec(val); - return; - } - throw std::logic_error("Unsupported encoding value for scalar64 write: " + std::to_string(ev)); -} +constexpr int kM0EncodingValue = 124; bool is_vgpr_only_type(OperandType t) { return t == OperandType::OPR_VGPR || t == OperandType::OPR_VGPR_OR_LDS || @@ -1397,12 +1205,6 @@ bool is_vgpr_only_type(OperandType t) { t == OperandType::OPR_SRC_ACCVGPR || t == OperandType::OPR_SRC_VGPR_OR_ACCVGPR; } -bool is_immediate_type(OperandType t) { - return t == OperandType::OPR_SIMM16 || t == OperandType::OPR_SIMM32 || - t == OperandType::OPR_SIMM4 || t == OperandType::OPR_SIMM8 || - t == OperandType::OPR_LABEL || t == OperandType::OPR_WAITCNT; -} - uint32_t vgpr_index(OperandType opr_type, int ev) { if (opr_type == OperandType::OPR_VGPR) return static_cast(ev); @@ -1451,11 +1253,12 @@ std::optional Isa::resolved_vgpr_offset(OperandType opr_type, int ev) bool Isa::simd_capable_value(OperandType opr_type, int ev) { return resolved_vgpr_offset(opr_type, ev).has_value() || is_immediate_type(opr_type) || - can_resolve_src_scalar(ev); + amdgpu::can_resolve_src_scalar(ev, kM0EncodingValue); } uint32_t Isa::simd_broadcast_value(const amdgpu::Wavefront &wf, OperandType opr_type, int ev) { - return is_immediate_type(opr_type) ? static_cast(ev) : resolve_src_scalar(wf, ev); + return is_immediate_type(opr_type) ? static_cast(ev) + : amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { @@ -1471,7 +1274,7 @@ uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { return static_cast(literal64_value_); if (is_immediate_type(opr_type_)) return static_cast(encoding_value_); - return resolve_src_scalar(wf, encoding_value_); + return amdgpu::resolve_src_scalar(wf, encoding_value_, kM0EncodingValue); } uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { @@ -1491,8 +1294,8 @@ uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { if (is_immediate_type(opr_type_)) return static_cast(ev); if (size_bits_ == 16) - return resolve_src_scalar16(wf, ev); - return resolve_src_scalar(wf, ev); + return amdgpu::resolve_src_scalar16(wf, ev, kM0EncodingValue); + return amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { @@ -1502,7 +1305,7 @@ void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write(wf, encoding_value_, val); + amdgpu::resolve_dst_write(wf, encoding_value_, val, kM0EncodingValue); } void Operand::write_lane(amdgpu::Wavefront &wf, uint32_t lane, uint32_t val) const { @@ -1539,7 +1342,7 @@ uint64_t Operand::read_lane64(const amdgpu::Wavefront &wf, uint32_t lane) const return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, ev); - return resolve_src_scalar64(wf, ev); + return amdgpu::resolve_src_scalar64(wf, ev, kM0EncodingValue); } void Operand::write_lane64(amdgpu::Wavefront &wf, uint32_t lane, uint64_t val) const { @@ -1569,7 +1372,7 @@ uint64_t Operand::read_scalar64(const amdgpu::Wavefront &wf) const { return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, encoding_value_); - return resolve_src_scalar64(wf, encoding_value_); + return amdgpu::resolve_src_scalar64(wf, encoding_value_, kM0EncodingValue); } void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { @@ -1579,7 +1382,7 @@ void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write64(wf, encoding_value_, val); + amdgpu::resolve_dst_write64(wf, encoding_value_, val); } } // namespace cdna1 diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/operand.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/operand.h index aaf939e32764..1755ebe6b949 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/operand.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/operand.h @@ -23,6 +23,7 @@ class Operand : public AmdgpuIsaOperand { Operand(int size_bits, OperandType opr_type, uint64_t literal64_value, bool is_literal64); std::string name() const override; std::optional literal64_value() const override; + std::optional const_value() const override; std::optional to_register_ref() const override; private: diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/operand_types.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/operand_types.h index 84cf74af259a..08e967a34877 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/operand_types.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/operand_types.h @@ -541,6 +541,20 @@ enum OpSelVgprOrLds { } } +[[nodiscard]] constexpr bool is_immediate_type(OperandType t) { + switch (t) { + case OperandType::OPR_SIMM4: + case OperandType::OPR_SIMM8: + case OperandType::OPR_SIMM16: + case OperandType::OPR_SIMM32: + case OperandType::OPR_LABEL: + case OperandType::OPR_WAITCNT: + return true; + default: + return false; + } +} + } // namespace cdna1 } // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/sop1.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/sop1.cpp index 3c779b2aecc1..bd6a6abdf331 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/sop1.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/sop1.cpp @@ -32,6 +32,7 @@ SMovB32Sop1::SMovB32Sop1(const MachineInst *inst) ssrc0 = Operand( 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB32Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b32_sop1(*this, wf); } @@ -48,6 +49,7 @@ SMovB64Sop1::SMovB64Sop1(const MachineInst *inst) ssrc0 = Operand( 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB64Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b64_sop1(*this, wf); } @@ -673,6 +675,7 @@ SAndSaveexecB64Sop1::SAndSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -701,6 +704,8 @@ SOrSaveexecB64Sop1::SOrSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } void SOrSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -729,6 +734,7 @@ SXorSaveexecB64Sop1::SXorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -757,6 +763,7 @@ SAndn2SaveexecB64Sop1::SAndn2SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -785,6 +792,7 @@ SOrn2SaveexecB64Sop1::SOrn2SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn2SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -813,6 +821,7 @@ SNandSaveexecB64Sop1::SNandSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNandSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -841,6 +850,7 @@ SNorSaveexecB64Sop1::SNorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -869,6 +879,7 @@ SXnorSaveexecB64Sop1::SXnorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXnorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1132,6 +1143,7 @@ SAndn1SaveexecB64Sop1::SAndn1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1160,6 +1172,7 @@ SOrn1SaveexecB64Sop1::SOrn1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1188,6 +1201,7 @@ SAndn1WrexecB64Sop1::SAndn1WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1216,6 +1230,7 @@ SAndn2WrexecB64Sop1::SAndn2WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/sop2.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/sop2.cpp index 508927983155..b28ce4eece31 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/sop2.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/sop2.cpp @@ -404,6 +404,7 @@ SOrB32Sop2::SOrB32Sop2(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB32Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b32_sop2(*this, wf); } @@ -429,6 +430,7 @@ SOrB64Sop2::SOrB64Sop2(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB64Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b64_sop2(*this, wf); } diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/sopp.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/sopp.cpp index b2c3edeff9c6..e5132ded555c 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/sopp.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/sopp.cpp @@ -43,6 +43,7 @@ SBranchSopp::SBranchSopp(const MachineInst *inst) num_src_ = 1; num_dst_ = 0; flags_ |= BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SBranchSopp::branch_offset_bytes() const { @@ -74,6 +75,7 @@ SCbranchScc0Sopp::SCbranchScc0Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc0Sopp::branch_offset_bytes() const { @@ -99,6 +101,7 @@ SCbranchScc1Sopp::SCbranchScc1Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc1Sopp::branch_offset_bytes() const { @@ -124,6 +127,7 @@ SCbranchVcczSopp::SCbranchVcczSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVcczSopp::branch_offset_bytes() const { @@ -151,6 +155,7 @@ SCbranchVccnzSopp::SCbranchVccnzSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVccnzSopp::branch_offset_bytes() const { @@ -178,6 +183,7 @@ SCbranchExeczSopp::SCbranchExeczSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExeczSopp::branch_offset_bytes() const { @@ -203,6 +209,7 @@ SCbranchExecnzSopp::SCbranchExecnzSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExecnzSopp::branch_offset_bytes() const { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/vop3.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/vop3.cpp index e52d548367cb..174245fe8372 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/vop3.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/vop3.cpp @@ -6212,6 +6212,7 @@ VCmpxClassF32Vop3::VCmpxClassF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6287,6 +6288,7 @@ VCmpxClassF64Vop3::VCmpxClassF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6435,6 +6437,7 @@ VCmpxClassF16Vop3::VCmpxClassF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7192,6 +7195,7 @@ VCmpxFF16Vop3::VCmpxFF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7220,6 +7224,7 @@ VCmpxLtF16Vop3::VCmpxLtF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7262,6 +7267,7 @@ VCmpxEqF16Vop3::VCmpxEqF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7304,6 +7310,7 @@ VCmpxLeF16Vop3::VCmpxLeF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7346,6 +7353,7 @@ VCmpxGtF16Vop3::VCmpxGtF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7388,6 +7396,7 @@ VCmpxLgF16Vop3::VCmpxLgF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7430,6 +7439,7 @@ VCmpxGeF16Vop3::VCmpxGeF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7472,6 +7482,7 @@ VCmpxOF16Vop3::VCmpxOF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7514,6 +7525,7 @@ VCmpxUF16Vop3::VCmpxUF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7556,6 +7568,7 @@ VCmpxNgeF16Vop3::VCmpxNgeF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7598,6 +7611,7 @@ VCmpxNlgF16Vop3::VCmpxNlgF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7640,6 +7654,7 @@ VCmpxNgtF16Vop3::VCmpxNgtF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7682,6 +7697,7 @@ VCmpxNleF16Vop3::VCmpxNleF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7724,6 +7740,7 @@ VCmpxNeqF16Vop3::VCmpxNeqF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7766,6 +7783,7 @@ VCmpxNltF16Vop3::VCmpxNltF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7808,6 +7826,7 @@ VCmpxTruF16Vop3::VCmpxTruF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8105,6 +8124,7 @@ VCmpxFF32Vop3::VCmpxFF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8133,6 +8153,7 @@ VCmpxLtF32Vop3::VCmpxLtF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8172,6 +8193,7 @@ VCmpxEqF32Vop3::VCmpxEqF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8211,6 +8233,7 @@ VCmpxLeF32Vop3::VCmpxLeF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8250,6 +8273,7 @@ VCmpxGtF32Vop3::VCmpxGtF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8289,6 +8313,7 @@ VCmpxLgF32Vop3::VCmpxLgF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8328,6 +8353,7 @@ VCmpxGeF32Vop3::VCmpxGeF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8367,6 +8393,7 @@ VCmpxOF32Vop3::VCmpxOF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8406,6 +8433,7 @@ VCmpxUF32Vop3::VCmpxUF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8445,6 +8473,7 @@ VCmpxNgeF32Vop3::VCmpxNgeF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8484,6 +8513,7 @@ VCmpxNlgF32Vop3::VCmpxNlgF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8523,6 +8553,7 @@ VCmpxNgtF32Vop3::VCmpxNgtF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8562,6 +8593,7 @@ VCmpxNleF32Vop3::VCmpxNleF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8601,6 +8633,7 @@ VCmpxNeqF32Vop3::VCmpxNeqF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8640,6 +8673,7 @@ VCmpxNltF32Vop3::VCmpxNltF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8679,6 +8713,7 @@ VCmpxTruF32Vop3::VCmpxTruF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8976,6 +9011,7 @@ VCmpxFF64Vop3::VCmpxFF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9004,6 +9040,7 @@ VCmpxLtF64Vop3::VCmpxLtF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9043,6 +9080,7 @@ VCmpxEqF64Vop3::VCmpxEqF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9082,6 +9120,7 @@ VCmpxLeF64Vop3::VCmpxLeF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9121,6 +9160,7 @@ VCmpxGtF64Vop3::VCmpxGtF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9160,6 +9200,7 @@ VCmpxLgF64Vop3::VCmpxLgF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9199,6 +9240,7 @@ VCmpxGeF64Vop3::VCmpxGeF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9238,6 +9280,7 @@ VCmpxOF64Vop3::VCmpxOF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9277,6 +9320,7 @@ VCmpxUF64Vop3::VCmpxUF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9316,6 +9360,7 @@ VCmpxNgeF64Vop3::VCmpxNgeF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9355,6 +9400,7 @@ VCmpxNlgF64Vop3::VCmpxNlgF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9394,6 +9440,7 @@ VCmpxNgtF64Vop3::VCmpxNgtF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9433,6 +9480,7 @@ VCmpxNleF64Vop3::VCmpxNleF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9472,6 +9520,7 @@ VCmpxNeqF64Vop3::VCmpxNeqF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9511,6 +9560,7 @@ VCmpxNltF64Vop3::VCmpxNltF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9550,6 +9600,7 @@ VCmpxTruF64Vop3::VCmpxTruF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10022,6 +10073,7 @@ VCmpxFI16Vop3::VCmpxFI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10050,6 +10102,7 @@ VCmpxLtI16Vop3::VCmpxLtI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10088,6 +10141,7 @@ VCmpxEqI16Vop3::VCmpxEqI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10126,6 +10180,7 @@ VCmpxLeI16Vop3::VCmpxLeI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10164,6 +10219,7 @@ VCmpxGtI16Vop3::VCmpxGtI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10202,6 +10258,7 @@ VCmpxNeI16Vop3::VCmpxNeI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10240,6 +10297,7 @@ VCmpxGeI16Vop3::VCmpxGeI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10278,6 +10336,7 @@ VCmpxTI16Vop3::VCmpxTI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10306,6 +10365,7 @@ VCmpxFU16Vop3::VCmpxFU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10334,6 +10394,7 @@ VCmpxLtU16Vop3::VCmpxLtU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10372,6 +10433,7 @@ VCmpxEqU16Vop3::VCmpxEqU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10410,6 +10472,7 @@ VCmpxLeU16Vop3::VCmpxLeU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10448,6 +10511,7 @@ VCmpxGtU16Vop3::VCmpxGtU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10486,6 +10550,7 @@ VCmpxNeU16Vop3::VCmpxNeU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10524,6 +10589,7 @@ VCmpxGeU16Vop3::VCmpxGeU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10562,6 +10628,7 @@ VCmpxTU16Vop3::VCmpxTU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10858,6 +10925,7 @@ VCmpxFI32Vop3::VCmpxFI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10886,6 +10954,7 @@ VCmpxLtI32Vop3::VCmpxLtI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10917,6 +10986,7 @@ VCmpxEqI32Vop3::VCmpxEqI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10948,6 +11018,7 @@ VCmpxLeI32Vop3::VCmpxLeI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10979,6 +11050,7 @@ VCmpxGtI32Vop3::VCmpxGtI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11010,6 +11082,7 @@ VCmpxNeI32Vop3::VCmpxNeI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11041,6 +11114,7 @@ VCmpxGeI32Vop3::VCmpxGeI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11072,6 +11146,7 @@ VCmpxTI32Vop3::VCmpxTI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11100,6 +11175,7 @@ VCmpxFU32Vop3::VCmpxFU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11128,6 +11204,7 @@ VCmpxLtU32Vop3::VCmpxLtU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11159,6 +11236,7 @@ VCmpxEqU32Vop3::VCmpxEqU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11190,6 +11268,7 @@ VCmpxLeU32Vop3::VCmpxLeU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11221,6 +11300,7 @@ VCmpxGtU32Vop3::VCmpxGtU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11252,6 +11332,7 @@ VCmpxNeU32Vop3::VCmpxNeU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11283,6 +11364,7 @@ VCmpxGeU32Vop3::VCmpxGeU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11314,6 +11396,7 @@ VCmpxTU32Vop3::VCmpxTU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11610,6 +11693,7 @@ VCmpxFI64Vop3::VCmpxFI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11638,6 +11722,7 @@ VCmpxLtI64Vop3::VCmpxLtI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11669,6 +11754,7 @@ VCmpxEqI64Vop3::VCmpxEqI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11700,6 +11786,7 @@ VCmpxLeI64Vop3::VCmpxLeI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11731,6 +11818,7 @@ VCmpxGtI64Vop3::VCmpxGtI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11762,6 +11850,7 @@ VCmpxNeI64Vop3::VCmpxNeI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11793,6 +11882,7 @@ VCmpxGeI64Vop3::VCmpxGeI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11824,6 +11914,7 @@ VCmpxTI64Vop3::VCmpxTI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11852,6 +11943,7 @@ VCmpxFU64Vop3::VCmpxFU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11880,6 +11972,7 @@ VCmpxLtU64Vop3::VCmpxLtU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11911,6 +12004,7 @@ VCmpxEqU64Vop3::VCmpxEqU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11942,6 +12036,7 @@ VCmpxLeU64Vop3::VCmpxLeU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11973,6 +12068,7 @@ VCmpxGtU64Vop3::VCmpxGtU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12004,6 +12100,7 @@ VCmpxNeU64Vop3::VCmpxNeU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12035,6 +12132,7 @@ VCmpxGeU64Vop3::VCmpxGeU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12066,6 +12164,7 @@ VCmpxTU64Vop3::VCmpxTU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vop3::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/vopc.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/vopc.cpp index 6f9332147bc2..26f91476cad6 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/vopc.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna1/vopc.cpp @@ -119,6 +119,7 @@ VCmpxClassF32Vopc::VCmpxClassF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -234,6 +235,7 @@ VCmpxClassF64Vopc::VCmpxClassF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_CLASS_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -377,6 +379,7 @@ VCmpxClassF16Vopc::VCmpxClassF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1491,6 +1494,7 @@ VCmpxFF16Vopc::VCmpxFF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1565,6 +1569,7 @@ VCmpxLtF16Vopc::VCmpxLtF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1644,6 +1649,7 @@ VCmpxEqF16Vopc::VCmpxEqF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1723,6 +1729,7 @@ VCmpxLeF16Vopc::VCmpxLeF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1802,6 +1809,7 @@ VCmpxGtF16Vopc::VCmpxGtF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1881,6 +1889,7 @@ VCmpxLgF16Vopc::VCmpxLgF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1960,6 +1969,7 @@ VCmpxGeF16Vopc::VCmpxGeF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2039,6 +2049,7 @@ VCmpxOF16Vopc::VCmpxOF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2118,6 +2129,7 @@ VCmpxUF16Vopc::VCmpxUF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2197,6 +2209,7 @@ VCmpxNgeF16Vopc::VCmpxNgeF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2276,6 +2289,7 @@ VCmpxNlgF16Vopc::VCmpxNlgF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2355,6 +2369,7 @@ VCmpxNgtF16Vopc::VCmpxNgtF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2434,6 +2449,7 @@ VCmpxNleF16Vopc::VCmpxNleF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2513,6 +2529,7 @@ VCmpxNeqF16Vopc::VCmpxNeqF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2592,6 +2609,7 @@ VCmpxNltF16Vopc::VCmpxNltF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2671,6 +2689,7 @@ VCmpxTruF16Vopc::VCmpxTruF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3736,6 +3755,7 @@ VCmpxFF32Vopc::VCmpxFF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3809,6 +3829,7 @@ VCmpxLtF32Vopc::VCmpxLtF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3885,6 +3906,7 @@ VCmpxEqF32Vopc::VCmpxEqF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3961,6 +3983,7 @@ VCmpxLeF32Vopc::VCmpxLeF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4037,6 +4060,7 @@ VCmpxGtF32Vopc::VCmpxGtF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4113,6 +4137,7 @@ VCmpxLgF32Vopc::VCmpxLgF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4189,6 +4214,7 @@ VCmpxGeF32Vopc::VCmpxGeF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4265,6 +4291,7 @@ VCmpxOF32Vopc::VCmpxOF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4341,6 +4368,7 @@ VCmpxUF32Vopc::VCmpxUF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4417,6 +4445,7 @@ VCmpxNgeF32Vopc::VCmpxNgeF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4493,6 +4522,7 @@ VCmpxNlgF32Vopc::VCmpxNlgF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4569,6 +4599,7 @@ VCmpxNgtF32Vopc::VCmpxNgtF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4645,6 +4676,7 @@ VCmpxNleF32Vopc::VCmpxNleF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4721,6 +4753,7 @@ VCmpxNeqF32Vopc::VCmpxNeqF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4797,6 +4830,7 @@ VCmpxNltF32Vopc::VCmpxNltF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4873,6 +4907,7 @@ VCmpxTruF32Vopc::VCmpxTruF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5382,6 +5417,7 @@ VCmpxFF64Vopc::VCmpxFF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5421,6 +5457,7 @@ VCmpxLtF64Vopc::VCmpxLtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5463,6 +5500,7 @@ VCmpxEqF64Vopc::VCmpxEqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5505,6 +5543,7 @@ VCmpxLeF64Vopc::VCmpxLeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5547,6 +5586,7 @@ VCmpxGtF64Vopc::VCmpxGtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5589,6 +5629,7 @@ VCmpxLgF64Vopc::VCmpxLgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LG_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5631,6 +5672,7 @@ VCmpxGeF64Vopc::VCmpxGeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5673,6 +5715,7 @@ VCmpxOF64Vopc::VCmpxOF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_O_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5715,6 +5758,7 @@ VCmpxUF64Vopc::VCmpxUF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_U_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5757,6 +5801,7 @@ VCmpxNgeF64Vopc::VCmpxNgeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5799,6 +5844,7 @@ VCmpxNlgF64Vopc::VCmpxNlgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLG_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5841,6 +5887,7 @@ VCmpxNgtF64Vopc::VCmpxNgtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5883,6 +5930,7 @@ VCmpxNleF64Vopc::VCmpxNleF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5925,6 +5973,7 @@ VCmpxNeqF64Vopc::VCmpxNeqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NEQ_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5967,6 +6016,7 @@ VCmpxNltF64Vopc::VCmpxNltF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6009,6 +6059,7 @@ VCmpxTruF64Vopc::VCmpxTruF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_TRU_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7069,6 +7120,7 @@ VCmpxFI16Vopc::VCmpxFI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7143,6 +7195,7 @@ VCmpxLtI16Vopc::VCmpxLtI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7220,6 +7273,7 @@ VCmpxEqI16Vopc::VCmpxEqI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7297,6 +7351,7 @@ VCmpxLeI16Vopc::VCmpxLeI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7374,6 +7429,7 @@ VCmpxGtI16Vopc::VCmpxGtI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7451,6 +7507,7 @@ VCmpxNeI16Vopc::VCmpxNeI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7528,6 +7585,7 @@ VCmpxGeI16Vopc::VCmpxGeI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7605,6 +7663,7 @@ VCmpxTI16Vopc::VCmpxTI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7679,6 +7738,7 @@ VCmpxFU16Vopc::VCmpxFU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7753,6 +7813,7 @@ VCmpxLtU16Vopc::VCmpxLtU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7830,6 +7891,7 @@ VCmpxEqU16Vopc::VCmpxEqU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7907,6 +7969,7 @@ VCmpxLeU16Vopc::VCmpxLeU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7984,6 +8047,7 @@ VCmpxGtU16Vopc::VCmpxGtU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8061,6 +8125,7 @@ VCmpxNeU16Vopc::VCmpxNeU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8138,6 +8203,7 @@ VCmpxGeU16Vopc::VCmpxGeU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8215,6 +8281,7 @@ VCmpxTU16Vopc::VCmpxTU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9280,6 +9347,7 @@ VCmpxFI32Vopc::VCmpxFI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9353,6 +9421,7 @@ VCmpxLtI32Vopc::VCmpxLtI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9429,6 +9498,7 @@ VCmpxEqI32Vopc::VCmpxEqI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9505,6 +9575,7 @@ VCmpxLeI32Vopc::VCmpxLeI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9581,6 +9652,7 @@ VCmpxGtI32Vopc::VCmpxGtI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9657,6 +9729,7 @@ VCmpxNeI32Vopc::VCmpxNeI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9733,6 +9806,7 @@ VCmpxGeI32Vopc::VCmpxGeI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9809,6 +9883,7 @@ VCmpxTI32Vopc::VCmpxTI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9882,6 +9957,7 @@ VCmpxFU32Vopc::VCmpxFU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9955,6 +10031,7 @@ VCmpxLtU32Vopc::VCmpxLtU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10031,6 +10108,7 @@ VCmpxEqU32Vopc::VCmpxEqU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10107,6 +10185,7 @@ VCmpxLeU32Vopc::VCmpxLeU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10183,6 +10262,7 @@ VCmpxGtU32Vopc::VCmpxGtU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10259,6 +10339,7 @@ VCmpxNeU32Vopc::VCmpxNeU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10335,6 +10416,7 @@ VCmpxGeU32Vopc::VCmpxGeU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10411,6 +10493,7 @@ VCmpxTU32Vopc::VCmpxTU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10886,6 +10969,7 @@ VCmpxFI64Vopc::VCmpxFI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10923,6 +11007,7 @@ VCmpxLtI64Vopc::VCmpxLtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10963,6 +11048,7 @@ VCmpxEqI64Vopc::VCmpxEqI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11003,6 +11089,7 @@ VCmpxLeI64Vopc::VCmpxLeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11043,6 +11130,7 @@ VCmpxGtI64Vopc::VCmpxGtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11083,6 +11171,7 @@ VCmpxNeI64Vopc::VCmpxNeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11123,6 +11212,7 @@ VCmpxGeI64Vopc::VCmpxGeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11163,6 +11253,7 @@ VCmpxTI64Vopc::VCmpxTI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11200,6 +11291,7 @@ VCmpxFU64Vopc::VCmpxFU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11237,6 +11329,7 @@ VCmpxLtU64Vopc::VCmpxLtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11277,6 +11370,7 @@ VCmpxEqU64Vopc::VCmpxEqU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11317,6 +11411,7 @@ VCmpxLeU64Vopc::VCmpxLeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11357,6 +11452,7 @@ VCmpxGtU64Vopc::VCmpxGtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11397,6 +11493,7 @@ VCmpxNeU64Vopc::VCmpxNeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11437,6 +11534,7 @@ VCmpxGeU64Vopc::VCmpxGeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11477,6 +11575,7 @@ VCmpxTU64Vopc::VCmpxTU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vopc::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/operand.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/operand.cpp index 0018e9cf8a4d..b96ef900c2b6 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/operand.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/operand.cpp @@ -5,6 +5,7 @@ // See lib/python/amdisa/README.md for regeneration instructions. #include "rocjitsu/isa/arch/amdgpu/cdna2/operand.h" +#include "rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h" #include "rocjitsu/isa/isa_operand_simd_inl.h" #include "rocjitsu/vm/amdgpu/compute_unit.h" #include "rocjitsu/vm/amdgpu/register_access.h" @@ -52,6 +53,16 @@ std::optional Operand::literal64_value() const { return literal64_value_; } +std::optional Operand::const_value() const { + if (has_literal64_) + return literal64_value_; + if (is_immediate_type(opr_type_)) + return static_cast(static_cast(encoding_value_)); + if (to_register_ref()) + return std::nullopt; + return amdgpu::resolve_src_scalar_statically(encoding_value_); +} + std::string Operand::name() const { if (has_literal64_) return std::format("0x{:x}", literal64_value_); @@ -805,9 +816,17 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSdst::OPR_SDST_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_EXEC: { + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_M0: { @@ -828,6 +847,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSrc::OPR_SRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrc::OPR_SRC_VGPR_MIN && encoding_value_ <= OpSelSrc::OPR_SRC_VGPR_MAX) return RegisterRef{RegClass::VGPR, @@ -851,6 +874,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcNolds::OPR_SRC_NOLDS_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcNolds::OPR_SRC_NOLDS_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcNolds::OPR_SRC_NOLDS_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcNolds::OPR_SRC_NOLDS_VGPR_MIN && encoding_value_ <= OpSelSrcNolds::OPR_SRC_NOLDS_VGPR_MAX) return RegisterRef{ @@ -866,6 +893,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcNolit::OPR_SRC_NOLIT_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcNolit::OPR_SRC_NOLIT_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcNolit::OPR_SRC_NOLIT_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcNolit::OPR_SRC_NOLIT_VGPR_MIN && encoding_value_ <= OpSelSrcNolit::OPR_SRC_NOLIT_VGPR_MAX) return RegisterRef{ @@ -881,6 +912,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcSimple::OPR_SRC_SIMPLE_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcSimple::OPR_SRC_SIMPLE_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcSimple::OPR_SRC_SIMPLE_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcSimple::OPR_SRC_SIMPLE_VGPR_MIN && encoding_value_ <= OpSelSrcSimple::OPR_SRC_SIMPLE_VGPR_MAX) return RegisterRef{ @@ -957,6 +992,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrc::OPR_SSRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_LANESEL: { @@ -975,6 +1014,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrcNolit::OPR_SSRC_NOLIT_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrcNolit::OPR_SSRC_NOLIT_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrcNolit::OPR_SSRC_NOLIT_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_SPECIAL_SCC: { @@ -1023,242 +1066,7 @@ std::optional Operand::to_register_ref() const { namespace { -uint32_t resolve_src_scalar(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return static_cast(wf.scratch_base()); - if (ev == 103) - return static_cast(wf.scratch_base() >> 32); - if (ev <= 105) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 106) - return static_cast(wf.vcc()); - if (ev == 107) - return static_cast(wf.vcc() >> 32); - if (ev >= 108 && ev <= 123) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 124) - return wf.m0(); - if (ev == 126) - return static_cast(wf.exec()); - if (ev == 127) - return static_cast(wf.exec() >> 32); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(-(ev - 192))); - if (ev == 230) - return static_cast(wf.scratch_base()); // SRC_FLAT_SCRATCH_BASE_LO - if (ev == 231) - return static_cast(wf.scratch_base() >> 32); // SRC_FLAT_SCRATCH_BASE_HI - if (ev == 240) - return 0x3F000000u; // 0.5f - if (ev == 241) - return 0xBF000000u; // -0.5f - if (ev == 242) - return 0x3F800000u; // 1.0f - if (ev == 243) - return 0xBF800000u; // -1.0f - if (ev == 244) - return 0x40000000u; // 2.0f - if (ev == 245) - return 0xC0000000u; // -2.0f - if (ev == 246) - return 0x40800000u; // 4.0f - if (ev == 247) - return 0xC0800000u; // -4.0f - if (ev == 248) - return 0x3E22F983u; // 1/(2*pi) - if (ev == 235) - return static_cast(wf.shared_aperture_base() >> 32); // SRC_SHARED_BASE - if (ev == 236) - return static_cast(wf.shared_aperture_limit() >> 32); // SRC_SHARED_LIMIT - if (ev == 237) - return static_cast(wf.private_aperture_base() >> 32); // SRC_PRIVATE_BASE - if (ev == 238) - return static_cast(wf.private_aperture_limit() >> 32); // SRC_PRIVATE_LIMIT - if (ev == 249) - return 0u; // SRC_POPS_EXITING_WAVE_ID (not used in compute) - if (ev == 250) - return 0u; // NULL - if (ev == 251) - return (wf.vcc() & (wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL))) == 0 - ? 1u - : 0u; // VCCZ - if (ev == 252) { - uint64_t active = wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL); - return (wf.exec() & active) == 0 ? 1u : 0u; // EXECZ - } - if (ev == 253) - return wf.read_scc() ? 1u : 0u; // SCC - throw std::logic_error("Unsupported encoding value for scalar read: " + std::to_string(ev)); -} - -uint32_t resolve_src_scalar16(const amdgpu::Wavefront &wf, int ev) { - switch (ev) { - case 240: - return 0x3800u; // 0.5h - case 241: - return 0xB800u; // -0.5h - case 242: - return 0x3C00u; // 1.0h - case 243: - return 0xBC00u; // -1.0h - case 244: - return 0x4000u; // 2.0h - case 245: - return 0xC000u; // -2.0h - case 246: - return 0x4400u; // 4.0h - case 247: - return 0xC400u; // -4.0h - case 248: - return 0x3118u; // f16 1/(2*pi) - default: - return resolve_src_scalar(wf, ev); - } -} - -// Must stay in sync with resolve_src_scalar above — returns true for -// exactly the encoding values that resolve_src_scalar handles without -// throwing. Used by Isa::simd_capable_value() to keep the SIMD fast -// path off operands whose scalar broadcast would throw at runtime. -bool can_resolve_src_scalar(int ev) { - return (ev >= 0 && ev <= 107) || (ev >= 108 && ev <= 123) || ev == 124 || ev == 126 || - ev == 127 || (ev >= 128 && ev <= 208) || (ev >= 235 && ev <= 238) || - (ev >= 240 && ev <= 253); -} - -uint64_t resolve_src_scalar64(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return wf.scratch_base(); - if (ev <= 105) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 106) - return wf.vcc(); - if (ev >= 108 && ev <= 122) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 124) - return wf.m0(); - if (ev == 126) - return wf.exec(); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(static_cast(-(ev - 192)))); - if (ev == 230) - return wf.scratch_base(); // SRC_FLAT_SCRATCH_BASE - if (ev == 240) - return 0x3FE0000000000000ULL; // 0.5 - if (ev == 241) - return 0xBFE0000000000000ULL; // -0.5 - if (ev == 242) - return 0x3FF0000000000000ULL; // 1.0 - if (ev == 243) - return 0xBFF0000000000000ULL; // -1.0 - if (ev == 244) - return 0x4000000000000000ULL; // 2.0 - if (ev == 245) - return 0xC000000000000000ULL; // -2.0 - if (ev == 246) - return 0x4010000000000000ULL; // 4.0 - if (ev == 247) - return 0xC010000000000000ULL; // -4.0 - if (ev == 248) - return 0x3FC45F306DC9C883ULL; // 1/(2*pi) - if (ev == 235) - return wf.shared_aperture_base(); // SRC_SHARED_BASE - if (ev == 236) - return wf.shared_aperture_limit(); // SRC_SHARED_LIMIT - if (ev == 237) - return wf.private_aperture_base(); // SRC_PRIVATE_BASE - if (ev == 238) - return wf.private_aperture_limit(); // SRC_PRIVATE_LIMIT - throw std::logic_error("Unsupported encoding value for scalar64 read: " + std::to_string(ev)); -} - -void resolve_dst_write(amdgpu::Wavefront &wf, int ev, uint32_t val) { - if (ev == 102) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 103) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 106) { - wf.set_vcc((wf.vcc() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 107) { - wf.set_vcc((wf.vcc() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev >= 108 && ev <= 123) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 124) { - wf.set_m0(val); - return; - } - if (ev == 126) { - wf.set_exec((wf.exec() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 127) { - wf.set_exec((wf.exec() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - throw std::logic_error("Unsupported encoding value for scalar write: " + std::to_string(ev)); -} - -void resolve_dst_write64(amdgpu::Wavefront &wf, int ev, uint64_t val) { - if (ev == 102) { - wf.set_scratch_base(val); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 106) { - wf.set_vcc(val); - return; - } - if (ev >= 108 && ev <= 122) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 124) - return; - if (ev == 126) { - wf.set_exec(val); - return; - } - throw std::logic_error("Unsupported encoding value for scalar64 write: " + std::to_string(ev)); -} +constexpr int kM0EncodingValue = 124; bool is_vgpr_only_type(OperandType t) { return t == OperandType::OPR_VGPR || t == OperandType::OPR_VGPR_OR_ACCVGPR || @@ -1267,12 +1075,6 @@ bool is_vgpr_only_type(OperandType t) { t == OperandType::OPR_SRC_VGPR_OR_ACCVGPR; } -bool is_immediate_type(OperandType t) { - return t == OperandType::OPR_SIMM16 || t == OperandType::OPR_SIMM32 || - t == OperandType::OPR_SIMM4 || t == OperandType::OPR_SIMM8 || - t == OperandType::OPR_LABEL || t == OperandType::OPR_WAITCNT; -} - uint32_t vgpr_index(OperandType opr_type, int ev) { if (opr_type == OperandType::OPR_VGPR || opr_type == OperandType::OPR_VGPR_OR_ACCVGPR) { if (ev >= OpSelAccvgpr::OPR_ACCVGPR_ACC_MIN) @@ -1330,11 +1132,12 @@ std::optional Isa::resolved_vgpr_offset(OperandType opr_type, int ev) bool Isa::simd_capable_value(OperandType opr_type, int ev) { return resolved_vgpr_offset(opr_type, ev).has_value() || is_immediate_type(opr_type) || - can_resolve_src_scalar(ev); + amdgpu::can_resolve_src_scalar(ev, kM0EncodingValue); } uint32_t Isa::simd_broadcast_value(const amdgpu::Wavefront &wf, OperandType opr_type, int ev) { - return is_immediate_type(opr_type) ? static_cast(ev) : resolve_src_scalar(wf, ev); + return is_immediate_type(opr_type) ? static_cast(ev) + : amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { @@ -1350,7 +1153,7 @@ uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { return static_cast(literal64_value_); if (is_immediate_type(opr_type_)) return static_cast(encoding_value_); - return resolve_src_scalar(wf, encoding_value_); + return amdgpu::resolve_src_scalar(wf, encoding_value_, kM0EncodingValue); } uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { @@ -1370,8 +1173,8 @@ uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { if (is_immediate_type(opr_type_)) return static_cast(ev); if (size_bits_ == 16) - return resolve_src_scalar16(wf, ev); - return resolve_src_scalar(wf, ev); + return amdgpu::resolve_src_scalar16(wf, ev, kM0EncodingValue); + return amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { @@ -1381,7 +1184,7 @@ void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write(wf, encoding_value_, val); + amdgpu::resolve_dst_write(wf, encoding_value_, val, kM0EncodingValue); } void Operand::write_lane(amdgpu::Wavefront &wf, uint32_t lane, uint32_t val) const { @@ -1418,7 +1221,7 @@ uint64_t Operand::read_lane64(const amdgpu::Wavefront &wf, uint32_t lane) const return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, ev); - return resolve_src_scalar64(wf, ev); + return amdgpu::resolve_src_scalar64(wf, ev, kM0EncodingValue); } void Operand::write_lane64(amdgpu::Wavefront &wf, uint32_t lane, uint64_t val) const { @@ -1448,7 +1251,7 @@ uint64_t Operand::read_scalar64(const amdgpu::Wavefront &wf) const { return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, encoding_value_); - return resolve_src_scalar64(wf, encoding_value_); + return amdgpu::resolve_src_scalar64(wf, encoding_value_, kM0EncodingValue); } void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { @@ -1458,7 +1261,7 @@ void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write64(wf, encoding_value_, val); + amdgpu::resolve_dst_write64(wf, encoding_value_, val); } } // namespace cdna2 diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/operand.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/operand.h index 7d27717fcf86..c67ce7c948b0 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/operand.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/operand.h @@ -23,6 +23,7 @@ class Operand : public AmdgpuIsaOperand { Operand(int size_bits, OperandType opr_type, uint64_t literal64_value, bool is_literal64); std::string name() const override; std::optional literal64_value() const override; + std::optional const_value() const override; std::optional to_register_ref() const override; private: diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/operand_types.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/operand_types.h index 2da9b60c256a..1747a1d4e6c4 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/operand_types.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/operand_types.h @@ -455,6 +455,20 @@ enum OpSelVgprOrLds { } } +[[nodiscard]] constexpr bool is_immediate_type(OperandType t) { + switch (t) { + case OperandType::OPR_SIMM4: + case OperandType::OPR_SIMM8: + case OperandType::OPR_SIMM16: + case OperandType::OPR_SIMM32: + case OperandType::OPR_LABEL: + case OperandType::OPR_WAITCNT: + return true; + default: + return false; + } +} + } // namespace cdna2 } // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/sop1.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/sop1.cpp index 1f6be74b8e7b..2da21e80a71b 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/sop1.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/sop1.cpp @@ -32,6 +32,7 @@ SMovB32Sop1::SMovB32Sop1(const MachineInst *inst) ssrc0 = Operand( 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB32Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b32_sop1(*this, wf); } @@ -48,6 +49,7 @@ SMovB64Sop1::SMovB64Sop1(const MachineInst *inst) ssrc0 = Operand( 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB64Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b64_sop1(*this, wf); } @@ -673,6 +675,7 @@ SAndSaveexecB64Sop1::SAndSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -701,6 +704,8 @@ SOrSaveexecB64Sop1::SOrSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } void SOrSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -729,6 +734,7 @@ SXorSaveexecB64Sop1::SXorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -757,6 +763,7 @@ SAndn2SaveexecB64Sop1::SAndn2SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -785,6 +792,7 @@ SOrn2SaveexecB64Sop1::SOrn2SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn2SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -813,6 +821,7 @@ SNandSaveexecB64Sop1::SNandSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNandSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -841,6 +850,7 @@ SNorSaveexecB64Sop1::SNorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -869,6 +879,7 @@ SXnorSaveexecB64Sop1::SXnorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXnorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1132,6 +1143,7 @@ SAndn1SaveexecB64Sop1::SAndn1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1160,6 +1172,7 @@ SOrn1SaveexecB64Sop1::SOrn1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1188,6 +1201,7 @@ SAndn1WrexecB64Sop1::SAndn1WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1216,6 +1230,7 @@ SAndn2WrexecB64Sop1::SAndn2WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/sop2.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/sop2.cpp index 7667870cd1f4..0a4c9222d793 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/sop2.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/sop2.cpp @@ -404,6 +404,7 @@ SOrB32Sop2::SOrB32Sop2(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB32Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b32_sop2(*this, wf); } @@ -429,6 +430,7 @@ SOrB64Sop2::SOrB64Sop2(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB64Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b64_sop2(*this, wf); } diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/sopp.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/sopp.cpp index cfec2c3ad04d..9e62c17def9f 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/sopp.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/sopp.cpp @@ -43,6 +43,7 @@ SBranchSopp::SBranchSopp(const MachineInst *inst) num_src_ = 1; num_dst_ = 0; flags_ |= BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SBranchSopp::branch_offset_bytes() const { @@ -74,6 +75,7 @@ SCbranchScc0Sopp::SCbranchScc0Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc0Sopp::branch_offset_bytes() const { @@ -99,6 +101,7 @@ SCbranchScc1Sopp::SCbranchScc1Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc1Sopp::branch_offset_bytes() const { @@ -124,6 +127,7 @@ SCbranchVcczSopp::SCbranchVcczSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVcczSopp::branch_offset_bytes() const { @@ -151,6 +155,7 @@ SCbranchVccnzSopp::SCbranchVccnzSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVccnzSopp::branch_offset_bytes() const { @@ -178,6 +183,7 @@ SCbranchExeczSopp::SCbranchExeczSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExeczSopp::branch_offset_bytes() const { @@ -203,6 +209,7 @@ SCbranchExecnzSopp::SCbranchExecnzSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExecnzSopp::branch_offset_bytes() const { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/vop3.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/vop3.cpp index d1bc73268d62..4cec277a9a11 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/vop3.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/vop3.cpp @@ -6106,6 +6106,7 @@ VCmpxClassF32Vop3::VCmpxClassF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6181,6 +6182,7 @@ VCmpxClassF64Vop3::VCmpxClassF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6329,6 +6331,7 @@ VCmpxClassF16Vop3::VCmpxClassF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7086,6 +7089,7 @@ VCmpxFF16Vop3::VCmpxFF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7114,6 +7118,7 @@ VCmpxLtF16Vop3::VCmpxLtF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7156,6 +7161,7 @@ VCmpxEqF16Vop3::VCmpxEqF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7198,6 +7204,7 @@ VCmpxLeF16Vop3::VCmpxLeF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7240,6 +7247,7 @@ VCmpxGtF16Vop3::VCmpxGtF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7282,6 +7290,7 @@ VCmpxLgF16Vop3::VCmpxLgF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7324,6 +7333,7 @@ VCmpxGeF16Vop3::VCmpxGeF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7366,6 +7376,7 @@ VCmpxOF16Vop3::VCmpxOF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7408,6 +7419,7 @@ VCmpxUF16Vop3::VCmpxUF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7450,6 +7462,7 @@ VCmpxNgeF16Vop3::VCmpxNgeF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7492,6 +7505,7 @@ VCmpxNlgF16Vop3::VCmpxNlgF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7534,6 +7548,7 @@ VCmpxNgtF16Vop3::VCmpxNgtF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7576,6 +7591,7 @@ VCmpxNleF16Vop3::VCmpxNleF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7618,6 +7634,7 @@ VCmpxNeqF16Vop3::VCmpxNeqF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7660,6 +7677,7 @@ VCmpxNltF16Vop3::VCmpxNltF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7702,6 +7720,7 @@ VCmpxTruF16Vop3::VCmpxTruF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7999,6 +8018,7 @@ VCmpxFF32Vop3::VCmpxFF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8027,6 +8047,7 @@ VCmpxLtF32Vop3::VCmpxLtF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8066,6 +8087,7 @@ VCmpxEqF32Vop3::VCmpxEqF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8105,6 +8127,7 @@ VCmpxLeF32Vop3::VCmpxLeF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8144,6 +8167,7 @@ VCmpxGtF32Vop3::VCmpxGtF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8183,6 +8207,7 @@ VCmpxLgF32Vop3::VCmpxLgF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8222,6 +8247,7 @@ VCmpxGeF32Vop3::VCmpxGeF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8261,6 +8287,7 @@ VCmpxOF32Vop3::VCmpxOF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8300,6 +8327,7 @@ VCmpxUF32Vop3::VCmpxUF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8339,6 +8367,7 @@ VCmpxNgeF32Vop3::VCmpxNgeF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8378,6 +8407,7 @@ VCmpxNlgF32Vop3::VCmpxNlgF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8417,6 +8447,7 @@ VCmpxNgtF32Vop3::VCmpxNgtF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8456,6 +8487,7 @@ VCmpxNleF32Vop3::VCmpxNleF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8495,6 +8527,7 @@ VCmpxNeqF32Vop3::VCmpxNeqF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8534,6 +8567,7 @@ VCmpxNltF32Vop3::VCmpxNltF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8573,6 +8607,7 @@ VCmpxTruF32Vop3::VCmpxTruF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8870,6 +8905,7 @@ VCmpxFF64Vop3::VCmpxFF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8898,6 +8934,7 @@ VCmpxLtF64Vop3::VCmpxLtF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8937,6 +8974,7 @@ VCmpxEqF64Vop3::VCmpxEqF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8976,6 +9014,7 @@ VCmpxLeF64Vop3::VCmpxLeF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9015,6 +9054,7 @@ VCmpxGtF64Vop3::VCmpxGtF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9054,6 +9094,7 @@ VCmpxLgF64Vop3::VCmpxLgF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9093,6 +9134,7 @@ VCmpxGeF64Vop3::VCmpxGeF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9132,6 +9174,7 @@ VCmpxOF64Vop3::VCmpxOF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9171,6 +9214,7 @@ VCmpxUF64Vop3::VCmpxUF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9210,6 +9254,7 @@ VCmpxNgeF64Vop3::VCmpxNgeF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9249,6 +9294,7 @@ VCmpxNlgF64Vop3::VCmpxNlgF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9288,6 +9334,7 @@ VCmpxNgtF64Vop3::VCmpxNgtF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9327,6 +9374,7 @@ VCmpxNleF64Vop3::VCmpxNleF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9366,6 +9414,7 @@ VCmpxNeqF64Vop3::VCmpxNeqF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9405,6 +9454,7 @@ VCmpxNltF64Vop3::VCmpxNltF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9444,6 +9494,7 @@ VCmpxTruF64Vop3::VCmpxTruF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9916,6 +9967,7 @@ VCmpxFI16Vop3::VCmpxFI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9944,6 +9996,7 @@ VCmpxLtI16Vop3::VCmpxLtI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9982,6 +10035,7 @@ VCmpxEqI16Vop3::VCmpxEqI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10020,6 +10074,7 @@ VCmpxLeI16Vop3::VCmpxLeI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10058,6 +10113,7 @@ VCmpxGtI16Vop3::VCmpxGtI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10096,6 +10152,7 @@ VCmpxNeI16Vop3::VCmpxNeI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10134,6 +10191,7 @@ VCmpxGeI16Vop3::VCmpxGeI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10172,6 +10230,7 @@ VCmpxTI16Vop3::VCmpxTI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10200,6 +10259,7 @@ VCmpxFU16Vop3::VCmpxFU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10228,6 +10288,7 @@ VCmpxLtU16Vop3::VCmpxLtU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10266,6 +10327,7 @@ VCmpxEqU16Vop3::VCmpxEqU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10304,6 +10366,7 @@ VCmpxLeU16Vop3::VCmpxLeU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10342,6 +10405,7 @@ VCmpxGtU16Vop3::VCmpxGtU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10380,6 +10444,7 @@ VCmpxNeU16Vop3::VCmpxNeU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10418,6 +10483,7 @@ VCmpxGeU16Vop3::VCmpxGeU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10456,6 +10522,7 @@ VCmpxTU16Vop3::VCmpxTU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10752,6 +10819,7 @@ VCmpxFI32Vop3::VCmpxFI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10780,6 +10848,7 @@ VCmpxLtI32Vop3::VCmpxLtI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10811,6 +10880,7 @@ VCmpxEqI32Vop3::VCmpxEqI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10842,6 +10912,7 @@ VCmpxLeI32Vop3::VCmpxLeI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10873,6 +10944,7 @@ VCmpxGtI32Vop3::VCmpxGtI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10904,6 +10976,7 @@ VCmpxNeI32Vop3::VCmpxNeI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10935,6 +11008,7 @@ VCmpxGeI32Vop3::VCmpxGeI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10966,6 +11040,7 @@ VCmpxTI32Vop3::VCmpxTI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10994,6 +11069,7 @@ VCmpxFU32Vop3::VCmpxFU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11022,6 +11098,7 @@ VCmpxLtU32Vop3::VCmpxLtU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11053,6 +11130,7 @@ VCmpxEqU32Vop3::VCmpxEqU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11084,6 +11162,7 @@ VCmpxLeU32Vop3::VCmpxLeU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11115,6 +11194,7 @@ VCmpxGtU32Vop3::VCmpxGtU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11146,6 +11226,7 @@ VCmpxNeU32Vop3::VCmpxNeU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11177,6 +11258,7 @@ VCmpxGeU32Vop3::VCmpxGeU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11208,6 +11290,7 @@ VCmpxTU32Vop3::VCmpxTU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11504,6 +11587,7 @@ VCmpxFI64Vop3::VCmpxFI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11532,6 +11616,7 @@ VCmpxLtI64Vop3::VCmpxLtI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11563,6 +11648,7 @@ VCmpxEqI64Vop3::VCmpxEqI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11594,6 +11680,7 @@ VCmpxLeI64Vop3::VCmpxLeI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11625,6 +11712,7 @@ VCmpxGtI64Vop3::VCmpxGtI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11656,6 +11744,7 @@ VCmpxNeI64Vop3::VCmpxNeI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11687,6 +11776,7 @@ VCmpxGeI64Vop3::VCmpxGeI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11718,6 +11808,7 @@ VCmpxTI64Vop3::VCmpxTI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11746,6 +11837,7 @@ VCmpxFU64Vop3::VCmpxFU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11774,6 +11866,7 @@ VCmpxLtU64Vop3::VCmpxLtU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11805,6 +11898,7 @@ VCmpxEqU64Vop3::VCmpxEqU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11836,6 +11930,7 @@ VCmpxLeU64Vop3::VCmpxLeU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11867,6 +11962,7 @@ VCmpxGtU64Vop3::VCmpxGtU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11898,6 +11994,7 @@ VCmpxNeU64Vop3::VCmpxNeU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11929,6 +12026,7 @@ VCmpxGeU64Vop3::VCmpxGeU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11960,6 +12058,7 @@ VCmpxTU64Vop3::VCmpxTU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vop3::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/vopc.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/vopc.cpp index f3423e7caf8b..ac00cf662dbd 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/vopc.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna2/vopc.cpp @@ -119,6 +119,7 @@ VCmpxClassF32Vopc::VCmpxClassF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -234,6 +235,7 @@ VCmpxClassF64Vopc::VCmpxClassF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_CLASS_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -377,6 +379,7 @@ VCmpxClassF16Vopc::VCmpxClassF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1491,6 +1494,7 @@ VCmpxFF16Vopc::VCmpxFF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1565,6 +1569,7 @@ VCmpxLtF16Vopc::VCmpxLtF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1644,6 +1649,7 @@ VCmpxEqF16Vopc::VCmpxEqF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1723,6 +1729,7 @@ VCmpxLeF16Vopc::VCmpxLeF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1802,6 +1809,7 @@ VCmpxGtF16Vopc::VCmpxGtF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1881,6 +1889,7 @@ VCmpxLgF16Vopc::VCmpxLgF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1960,6 +1969,7 @@ VCmpxGeF16Vopc::VCmpxGeF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2039,6 +2049,7 @@ VCmpxOF16Vopc::VCmpxOF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2118,6 +2129,7 @@ VCmpxUF16Vopc::VCmpxUF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2197,6 +2209,7 @@ VCmpxNgeF16Vopc::VCmpxNgeF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2276,6 +2289,7 @@ VCmpxNlgF16Vopc::VCmpxNlgF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2355,6 +2369,7 @@ VCmpxNgtF16Vopc::VCmpxNgtF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2434,6 +2449,7 @@ VCmpxNleF16Vopc::VCmpxNleF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2513,6 +2529,7 @@ VCmpxNeqF16Vopc::VCmpxNeqF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2592,6 +2609,7 @@ VCmpxNltF16Vopc::VCmpxNltF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2671,6 +2689,7 @@ VCmpxTruF16Vopc::VCmpxTruF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3736,6 +3755,7 @@ VCmpxFF32Vopc::VCmpxFF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3809,6 +3829,7 @@ VCmpxLtF32Vopc::VCmpxLtF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3885,6 +3906,7 @@ VCmpxEqF32Vopc::VCmpxEqF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3961,6 +3983,7 @@ VCmpxLeF32Vopc::VCmpxLeF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4037,6 +4060,7 @@ VCmpxGtF32Vopc::VCmpxGtF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4113,6 +4137,7 @@ VCmpxLgF32Vopc::VCmpxLgF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4189,6 +4214,7 @@ VCmpxGeF32Vopc::VCmpxGeF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4265,6 +4291,7 @@ VCmpxOF32Vopc::VCmpxOF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4341,6 +4368,7 @@ VCmpxUF32Vopc::VCmpxUF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4417,6 +4445,7 @@ VCmpxNgeF32Vopc::VCmpxNgeF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4493,6 +4522,7 @@ VCmpxNlgF32Vopc::VCmpxNlgF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4569,6 +4599,7 @@ VCmpxNgtF32Vopc::VCmpxNgtF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4645,6 +4676,7 @@ VCmpxNleF32Vopc::VCmpxNleF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4721,6 +4753,7 @@ VCmpxNeqF32Vopc::VCmpxNeqF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4797,6 +4830,7 @@ VCmpxNltF32Vopc::VCmpxNltF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4873,6 +4907,7 @@ VCmpxTruF32Vopc::VCmpxTruF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5382,6 +5417,7 @@ VCmpxFF64Vopc::VCmpxFF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5421,6 +5457,7 @@ VCmpxLtF64Vopc::VCmpxLtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5463,6 +5500,7 @@ VCmpxEqF64Vopc::VCmpxEqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5505,6 +5543,7 @@ VCmpxLeF64Vopc::VCmpxLeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5547,6 +5586,7 @@ VCmpxGtF64Vopc::VCmpxGtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5589,6 +5629,7 @@ VCmpxLgF64Vopc::VCmpxLgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LG_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5631,6 +5672,7 @@ VCmpxGeF64Vopc::VCmpxGeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5673,6 +5715,7 @@ VCmpxOF64Vopc::VCmpxOF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_O_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5715,6 +5758,7 @@ VCmpxUF64Vopc::VCmpxUF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_U_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5757,6 +5801,7 @@ VCmpxNgeF64Vopc::VCmpxNgeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5799,6 +5844,7 @@ VCmpxNlgF64Vopc::VCmpxNlgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLG_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5841,6 +5887,7 @@ VCmpxNgtF64Vopc::VCmpxNgtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5883,6 +5930,7 @@ VCmpxNleF64Vopc::VCmpxNleF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5925,6 +5973,7 @@ VCmpxNeqF64Vopc::VCmpxNeqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NEQ_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5967,6 +6016,7 @@ VCmpxNltF64Vopc::VCmpxNltF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6009,6 +6059,7 @@ VCmpxTruF64Vopc::VCmpxTruF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_TRU_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7069,6 +7120,7 @@ VCmpxFI16Vopc::VCmpxFI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7143,6 +7195,7 @@ VCmpxLtI16Vopc::VCmpxLtI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7220,6 +7273,7 @@ VCmpxEqI16Vopc::VCmpxEqI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7297,6 +7351,7 @@ VCmpxLeI16Vopc::VCmpxLeI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7374,6 +7429,7 @@ VCmpxGtI16Vopc::VCmpxGtI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7451,6 +7507,7 @@ VCmpxNeI16Vopc::VCmpxNeI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7528,6 +7585,7 @@ VCmpxGeI16Vopc::VCmpxGeI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7605,6 +7663,7 @@ VCmpxTI16Vopc::VCmpxTI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7679,6 +7738,7 @@ VCmpxFU16Vopc::VCmpxFU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7753,6 +7813,7 @@ VCmpxLtU16Vopc::VCmpxLtU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7830,6 +7891,7 @@ VCmpxEqU16Vopc::VCmpxEqU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7907,6 +7969,7 @@ VCmpxLeU16Vopc::VCmpxLeU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7984,6 +8047,7 @@ VCmpxGtU16Vopc::VCmpxGtU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8061,6 +8125,7 @@ VCmpxNeU16Vopc::VCmpxNeU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8138,6 +8203,7 @@ VCmpxGeU16Vopc::VCmpxGeU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8215,6 +8281,7 @@ VCmpxTU16Vopc::VCmpxTU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9280,6 +9347,7 @@ VCmpxFI32Vopc::VCmpxFI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9353,6 +9421,7 @@ VCmpxLtI32Vopc::VCmpxLtI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9429,6 +9498,7 @@ VCmpxEqI32Vopc::VCmpxEqI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9505,6 +9575,7 @@ VCmpxLeI32Vopc::VCmpxLeI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9581,6 +9652,7 @@ VCmpxGtI32Vopc::VCmpxGtI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9657,6 +9729,7 @@ VCmpxNeI32Vopc::VCmpxNeI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9733,6 +9806,7 @@ VCmpxGeI32Vopc::VCmpxGeI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9809,6 +9883,7 @@ VCmpxTI32Vopc::VCmpxTI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9882,6 +9957,7 @@ VCmpxFU32Vopc::VCmpxFU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9955,6 +10031,7 @@ VCmpxLtU32Vopc::VCmpxLtU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10031,6 +10108,7 @@ VCmpxEqU32Vopc::VCmpxEqU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10107,6 +10185,7 @@ VCmpxLeU32Vopc::VCmpxLeU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10183,6 +10262,7 @@ VCmpxGtU32Vopc::VCmpxGtU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10259,6 +10339,7 @@ VCmpxNeU32Vopc::VCmpxNeU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10335,6 +10416,7 @@ VCmpxGeU32Vopc::VCmpxGeU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10411,6 +10493,7 @@ VCmpxTU32Vopc::VCmpxTU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10886,6 +10969,7 @@ VCmpxFI64Vopc::VCmpxFI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10923,6 +11007,7 @@ VCmpxLtI64Vopc::VCmpxLtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10963,6 +11048,7 @@ VCmpxEqI64Vopc::VCmpxEqI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11003,6 +11089,7 @@ VCmpxLeI64Vopc::VCmpxLeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11043,6 +11130,7 @@ VCmpxGtI64Vopc::VCmpxGtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11083,6 +11171,7 @@ VCmpxNeI64Vopc::VCmpxNeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11123,6 +11212,7 @@ VCmpxGeI64Vopc::VCmpxGeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11163,6 +11253,7 @@ VCmpxTI64Vopc::VCmpxTI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11200,6 +11291,7 @@ VCmpxFU64Vopc::VCmpxFU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11237,6 +11329,7 @@ VCmpxLtU64Vopc::VCmpxLtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11277,6 +11370,7 @@ VCmpxEqU64Vopc::VCmpxEqU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11317,6 +11411,7 @@ VCmpxLeU64Vopc::VCmpxLeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11357,6 +11452,7 @@ VCmpxGtU64Vopc::VCmpxGtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11397,6 +11493,7 @@ VCmpxNeU64Vopc::VCmpxNeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11437,6 +11534,7 @@ VCmpxGeU64Vopc::VCmpxGeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11477,6 +11575,7 @@ VCmpxTU64Vopc::VCmpxTU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vopc::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/operand.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/operand.cpp index d623a5225159..e6d4350fdd28 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/operand.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/operand.cpp @@ -5,6 +5,7 @@ // See lib/python/amdisa/README.md for regeneration instructions. #include "rocjitsu/isa/arch/amdgpu/cdna3/operand.h" +#include "rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h" #include "rocjitsu/isa/isa_operand_simd_inl.h" #include "rocjitsu/vm/amdgpu/compute_unit.h" #include "rocjitsu/vm/amdgpu/register_access.h" @@ -52,6 +53,16 @@ std::optional Operand::literal64_value() const { return literal64_value_; } +std::optional Operand::const_value() const { + if (has_literal64_) + return literal64_value_; + if (is_immediate_type(opr_type_)) + return static_cast(static_cast(encoding_value_)); + if (to_register_ref()) + return std::nullopt; + return amdgpu::resolve_src_scalar_statically(encoding_value_); +} + std::string Operand::name() const { if (has_literal64_) return std::format("0x{:x}", literal64_value_); @@ -805,9 +816,17 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSdst::OPR_SDST_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_EXEC: { + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_M0: { @@ -828,6 +847,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSrc::OPR_SRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrc::OPR_SRC_VGPR_MIN && encoding_value_ <= OpSelSrc::OPR_SRC_VGPR_MAX) return RegisterRef{RegClass::VGPR, @@ -851,6 +874,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcNolds::OPR_SRC_NOLDS_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcNolds::OPR_SRC_NOLDS_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcNolds::OPR_SRC_NOLDS_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcNolds::OPR_SRC_NOLDS_VGPR_MIN && encoding_value_ <= OpSelSrcNolds::OPR_SRC_NOLDS_VGPR_MAX) return RegisterRef{ @@ -866,6 +893,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcNolit::OPR_SRC_NOLIT_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcNolit::OPR_SRC_NOLIT_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcNolit::OPR_SRC_NOLIT_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcNolit::OPR_SRC_NOLIT_VGPR_MIN && encoding_value_ <= OpSelSrcNolit::OPR_SRC_NOLIT_VGPR_MAX) return RegisterRef{ @@ -881,6 +912,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcSimple::OPR_SRC_SIMPLE_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcSimple::OPR_SRC_SIMPLE_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcSimple::OPR_SRC_SIMPLE_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcSimple::OPR_SRC_SIMPLE_VGPR_MIN && encoding_value_ <= OpSelSrcSimple::OPR_SRC_SIMPLE_VGPR_MAX) return RegisterRef{ @@ -957,6 +992,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrc::OPR_SSRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_LANESEL: { @@ -975,6 +1014,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrcNolit::OPR_SSRC_NOLIT_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrcNolit::OPR_SSRC_NOLIT_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrcNolit::OPR_SSRC_NOLIT_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_SPECIAL_SCC: { @@ -1023,242 +1066,7 @@ std::optional Operand::to_register_ref() const { namespace { -uint32_t resolve_src_scalar(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return static_cast(wf.scratch_base()); - if (ev == 103) - return static_cast(wf.scratch_base() >> 32); - if (ev <= 105) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 106) - return static_cast(wf.vcc()); - if (ev == 107) - return static_cast(wf.vcc() >> 32); - if (ev >= 108 && ev <= 123) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 124) - return wf.m0(); - if (ev == 126) - return static_cast(wf.exec()); - if (ev == 127) - return static_cast(wf.exec() >> 32); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(-(ev - 192))); - if (ev == 230) - return static_cast(wf.scratch_base()); // SRC_FLAT_SCRATCH_BASE_LO - if (ev == 231) - return static_cast(wf.scratch_base() >> 32); // SRC_FLAT_SCRATCH_BASE_HI - if (ev == 240) - return 0x3F000000u; // 0.5f - if (ev == 241) - return 0xBF000000u; // -0.5f - if (ev == 242) - return 0x3F800000u; // 1.0f - if (ev == 243) - return 0xBF800000u; // -1.0f - if (ev == 244) - return 0x40000000u; // 2.0f - if (ev == 245) - return 0xC0000000u; // -2.0f - if (ev == 246) - return 0x40800000u; // 4.0f - if (ev == 247) - return 0xC0800000u; // -4.0f - if (ev == 248) - return 0x3E22F983u; // 1/(2*pi) - if (ev == 235) - return static_cast(wf.shared_aperture_base() >> 32); // SRC_SHARED_BASE - if (ev == 236) - return static_cast(wf.shared_aperture_limit() >> 32); // SRC_SHARED_LIMIT - if (ev == 237) - return static_cast(wf.private_aperture_base() >> 32); // SRC_PRIVATE_BASE - if (ev == 238) - return static_cast(wf.private_aperture_limit() >> 32); // SRC_PRIVATE_LIMIT - if (ev == 249) - return 0u; // SRC_POPS_EXITING_WAVE_ID (not used in compute) - if (ev == 250) - return 0u; // NULL - if (ev == 251) - return (wf.vcc() & (wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL))) == 0 - ? 1u - : 0u; // VCCZ - if (ev == 252) { - uint64_t active = wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL); - return (wf.exec() & active) == 0 ? 1u : 0u; // EXECZ - } - if (ev == 253) - return wf.read_scc() ? 1u : 0u; // SCC - throw std::logic_error("Unsupported encoding value for scalar read: " + std::to_string(ev)); -} - -uint32_t resolve_src_scalar16(const amdgpu::Wavefront &wf, int ev) { - switch (ev) { - case 240: - return 0x3800u; // 0.5h - case 241: - return 0xB800u; // -0.5h - case 242: - return 0x3C00u; // 1.0h - case 243: - return 0xBC00u; // -1.0h - case 244: - return 0x4000u; // 2.0h - case 245: - return 0xC000u; // -2.0h - case 246: - return 0x4400u; // 4.0h - case 247: - return 0xC400u; // -4.0h - case 248: - return 0x3118u; // f16 1/(2*pi) - default: - return resolve_src_scalar(wf, ev); - } -} - -// Must stay in sync with resolve_src_scalar above — returns true for -// exactly the encoding values that resolve_src_scalar handles without -// throwing. Used by Isa::simd_capable_value() to keep the SIMD fast -// path off operands whose scalar broadcast would throw at runtime. -bool can_resolve_src_scalar(int ev) { - return (ev >= 0 && ev <= 107) || (ev >= 108 && ev <= 123) || ev == 124 || ev == 126 || - ev == 127 || (ev >= 128 && ev <= 208) || (ev >= 235 && ev <= 238) || - (ev >= 240 && ev <= 253); -} - -uint64_t resolve_src_scalar64(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return wf.scratch_base(); - if (ev <= 105) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 106) - return wf.vcc(); - if (ev >= 108 && ev <= 122) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 124) - return wf.m0(); - if (ev == 126) - return wf.exec(); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(static_cast(-(ev - 192)))); - if (ev == 230) - return wf.scratch_base(); // SRC_FLAT_SCRATCH_BASE - if (ev == 240) - return 0x3FE0000000000000ULL; // 0.5 - if (ev == 241) - return 0xBFE0000000000000ULL; // -0.5 - if (ev == 242) - return 0x3FF0000000000000ULL; // 1.0 - if (ev == 243) - return 0xBFF0000000000000ULL; // -1.0 - if (ev == 244) - return 0x4000000000000000ULL; // 2.0 - if (ev == 245) - return 0xC000000000000000ULL; // -2.0 - if (ev == 246) - return 0x4010000000000000ULL; // 4.0 - if (ev == 247) - return 0xC010000000000000ULL; // -4.0 - if (ev == 248) - return 0x3FC45F306DC9C883ULL; // 1/(2*pi) - if (ev == 235) - return wf.shared_aperture_base(); // SRC_SHARED_BASE - if (ev == 236) - return wf.shared_aperture_limit(); // SRC_SHARED_LIMIT - if (ev == 237) - return wf.private_aperture_base(); // SRC_PRIVATE_BASE - if (ev == 238) - return wf.private_aperture_limit(); // SRC_PRIVATE_LIMIT - throw std::logic_error("Unsupported encoding value for scalar64 read: " + std::to_string(ev)); -} - -void resolve_dst_write(amdgpu::Wavefront &wf, int ev, uint32_t val) { - if (ev == 102) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 103) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 106) { - wf.set_vcc((wf.vcc() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 107) { - wf.set_vcc((wf.vcc() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev >= 108 && ev <= 123) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 124) { - wf.set_m0(val); - return; - } - if (ev == 126) { - wf.set_exec((wf.exec() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 127) { - wf.set_exec((wf.exec() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - throw std::logic_error("Unsupported encoding value for scalar write: " + std::to_string(ev)); -} - -void resolve_dst_write64(amdgpu::Wavefront &wf, int ev, uint64_t val) { - if (ev == 102) { - wf.set_scratch_base(val); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 106) { - wf.set_vcc(val); - return; - } - if (ev >= 108 && ev <= 122) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 124) - return; - if (ev == 126) { - wf.set_exec(val); - return; - } - throw std::logic_error("Unsupported encoding value for scalar64 write: " + std::to_string(ev)); -} +constexpr int kM0EncodingValue = 124; bool is_vgpr_only_type(OperandType t) { return t == OperandType::OPR_VGPR || t == OperandType::OPR_VGPR_OR_ACCVGPR || @@ -1267,12 +1075,6 @@ bool is_vgpr_only_type(OperandType t) { t == OperandType::OPR_SRC_VGPR_OR_ACCVGPR; } -bool is_immediate_type(OperandType t) { - return t == OperandType::OPR_SIMM16 || t == OperandType::OPR_SIMM32 || - t == OperandType::OPR_SIMM4 || t == OperandType::OPR_SIMM8 || - t == OperandType::OPR_LABEL || t == OperandType::OPR_WAITCNT; -} - uint32_t vgpr_index(OperandType opr_type, int ev) { if (opr_type == OperandType::OPR_VGPR || opr_type == OperandType::OPR_VGPR_OR_ACCVGPR) { if (ev >= OpSelAccvgpr::OPR_ACCVGPR_ACC_MIN) @@ -1330,11 +1132,12 @@ std::optional Isa::resolved_vgpr_offset(OperandType opr_type, int ev) bool Isa::simd_capable_value(OperandType opr_type, int ev) { return resolved_vgpr_offset(opr_type, ev).has_value() || is_immediate_type(opr_type) || - can_resolve_src_scalar(ev); + amdgpu::can_resolve_src_scalar(ev, kM0EncodingValue); } uint32_t Isa::simd_broadcast_value(const amdgpu::Wavefront &wf, OperandType opr_type, int ev) { - return is_immediate_type(opr_type) ? static_cast(ev) : resolve_src_scalar(wf, ev); + return is_immediate_type(opr_type) ? static_cast(ev) + : amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { @@ -1350,7 +1153,7 @@ uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { return static_cast(literal64_value_); if (is_immediate_type(opr_type_)) return static_cast(encoding_value_); - return resolve_src_scalar(wf, encoding_value_); + return amdgpu::resolve_src_scalar(wf, encoding_value_, kM0EncodingValue); } uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { @@ -1370,8 +1173,8 @@ uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { if (is_immediate_type(opr_type_)) return static_cast(ev); if (size_bits_ == 16) - return resolve_src_scalar16(wf, ev); - return resolve_src_scalar(wf, ev); + return amdgpu::resolve_src_scalar16(wf, ev, kM0EncodingValue); + return amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { @@ -1381,7 +1184,7 @@ void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write(wf, encoding_value_, val); + amdgpu::resolve_dst_write(wf, encoding_value_, val, kM0EncodingValue); } void Operand::write_lane(amdgpu::Wavefront &wf, uint32_t lane, uint32_t val) const { @@ -1418,7 +1221,7 @@ uint64_t Operand::read_lane64(const amdgpu::Wavefront &wf, uint32_t lane) const return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, ev); - return resolve_src_scalar64(wf, ev); + return amdgpu::resolve_src_scalar64(wf, ev, kM0EncodingValue); } void Operand::write_lane64(amdgpu::Wavefront &wf, uint32_t lane, uint64_t val) const { @@ -1448,7 +1251,7 @@ uint64_t Operand::read_scalar64(const amdgpu::Wavefront &wf) const { return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, encoding_value_); - return resolve_src_scalar64(wf, encoding_value_); + return amdgpu::resolve_src_scalar64(wf, encoding_value_, kM0EncodingValue); } void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { @@ -1458,7 +1261,7 @@ void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write64(wf, encoding_value_, val); + amdgpu::resolve_dst_write64(wf, encoding_value_, val); } } // namespace cdna3 diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/operand.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/operand.h index 8b6bf61741c7..2dc96785fbda 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/operand.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/operand.h @@ -23,6 +23,7 @@ class Operand : public AmdgpuIsaOperand { Operand(int size_bits, OperandType opr_type, uint64_t literal64_value, bool is_literal64); std::string name() const override; std::optional literal64_value() const override; + std::optional const_value() const override; std::optional to_register_ref() const override; private: diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/operand_types.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/operand_types.h index 315e65f4ace0..3c65268757ce 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/operand_types.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/operand_types.h @@ -455,6 +455,20 @@ enum OpSelVgprOrLds { } } +[[nodiscard]] constexpr bool is_immediate_type(OperandType t) { + switch (t) { + case OperandType::OPR_SIMM4: + case OperandType::OPR_SIMM8: + case OperandType::OPR_SIMM16: + case OperandType::OPR_SIMM32: + case OperandType::OPR_LABEL: + case OperandType::OPR_WAITCNT: + return true; + default: + return false; + } +} + } // namespace cdna3 } // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/sop1.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/sop1.cpp index 9e9c62aa7599..81ca1728fb58 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/sop1.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/sop1.cpp @@ -32,6 +32,7 @@ SMovB32Sop1::SMovB32Sop1(const MachineInst *inst) ssrc0 = Operand( 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB32Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b32_sop1(*this, wf); } @@ -48,6 +49,7 @@ SMovB64Sop1::SMovB64Sop1(const MachineInst *inst) ssrc0 = Operand( 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB64Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b64_sop1(*this, wf); } @@ -673,6 +675,7 @@ SAndSaveexecB64Sop1::SAndSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -701,6 +704,8 @@ SOrSaveexecB64Sop1::SOrSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } void SOrSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -729,6 +734,7 @@ SXorSaveexecB64Sop1::SXorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -757,6 +763,7 @@ SAndn2SaveexecB64Sop1::SAndn2SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -785,6 +792,7 @@ SOrn2SaveexecB64Sop1::SOrn2SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn2SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -813,6 +821,7 @@ SNandSaveexecB64Sop1::SNandSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNandSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -841,6 +850,7 @@ SNorSaveexecB64Sop1::SNorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -869,6 +879,7 @@ SXnorSaveexecB64Sop1::SXnorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXnorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1132,6 +1143,7 @@ SAndn1SaveexecB64Sop1::SAndn1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1160,6 +1172,7 @@ SOrn1SaveexecB64Sop1::SOrn1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1188,6 +1201,7 @@ SAndn1WrexecB64Sop1::SAndn1WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1216,6 +1230,7 @@ SAndn2WrexecB64Sop1::SAndn2WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/sop2.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/sop2.cpp index 7b76046a2d7e..f16e7cbbf84a 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/sop2.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/sop2.cpp @@ -404,6 +404,7 @@ SOrB32Sop2::SOrB32Sop2(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB32Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b32_sop2(*this, wf); } @@ -429,6 +430,7 @@ SOrB64Sop2::SOrB64Sop2(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB64Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b64_sop2(*this, wf); } diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/sopp.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/sopp.cpp index 54e287535651..3cc943ec52e7 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/sopp.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/sopp.cpp @@ -43,6 +43,7 @@ SBranchSopp::SBranchSopp(const MachineInst *inst) num_src_ = 1; num_dst_ = 0; flags_ |= BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SBranchSopp::branch_offset_bytes() const { @@ -74,6 +75,7 @@ SCbranchScc0Sopp::SCbranchScc0Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc0Sopp::branch_offset_bytes() const { @@ -99,6 +101,7 @@ SCbranchScc1Sopp::SCbranchScc1Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc1Sopp::branch_offset_bytes() const { @@ -124,6 +127,7 @@ SCbranchVcczSopp::SCbranchVcczSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVcczSopp::branch_offset_bytes() const { @@ -151,6 +155,7 @@ SCbranchVccnzSopp::SCbranchVccnzSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVccnzSopp::branch_offset_bytes() const { @@ -178,6 +183,7 @@ SCbranchExeczSopp::SCbranchExeczSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExeczSopp::branch_offset_bytes() const { @@ -203,6 +209,7 @@ SCbranchExecnzSopp::SCbranchExecnzSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExecnzSopp::branch_offset_bytes() const { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/vop3.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/vop3.cpp index b510568249e8..521d631ca104 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/vop3.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/vop3.cpp @@ -6348,6 +6348,7 @@ VCmpxClassF32Vop3::VCmpxClassF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6423,6 +6424,7 @@ VCmpxClassF64Vop3::VCmpxClassF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6571,6 +6573,7 @@ VCmpxClassF16Vop3::VCmpxClassF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7328,6 +7331,7 @@ VCmpxFF16Vop3::VCmpxFF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7356,6 +7360,7 @@ VCmpxLtF16Vop3::VCmpxLtF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7398,6 +7403,7 @@ VCmpxEqF16Vop3::VCmpxEqF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7440,6 +7446,7 @@ VCmpxLeF16Vop3::VCmpxLeF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7482,6 +7489,7 @@ VCmpxGtF16Vop3::VCmpxGtF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7524,6 +7532,7 @@ VCmpxLgF16Vop3::VCmpxLgF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7566,6 +7575,7 @@ VCmpxGeF16Vop3::VCmpxGeF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7608,6 +7618,7 @@ VCmpxOF16Vop3::VCmpxOF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7650,6 +7661,7 @@ VCmpxUF16Vop3::VCmpxUF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7692,6 +7704,7 @@ VCmpxNgeF16Vop3::VCmpxNgeF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7734,6 +7747,7 @@ VCmpxNlgF16Vop3::VCmpxNlgF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7776,6 +7790,7 @@ VCmpxNgtF16Vop3::VCmpxNgtF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7818,6 +7833,7 @@ VCmpxNleF16Vop3::VCmpxNleF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7860,6 +7876,7 @@ VCmpxNeqF16Vop3::VCmpxNeqF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7902,6 +7919,7 @@ VCmpxNltF16Vop3::VCmpxNltF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7944,6 +7962,7 @@ VCmpxTruF16Vop3::VCmpxTruF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8241,6 +8260,7 @@ VCmpxFF32Vop3::VCmpxFF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8269,6 +8289,7 @@ VCmpxLtF32Vop3::VCmpxLtF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8308,6 +8329,7 @@ VCmpxEqF32Vop3::VCmpxEqF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8347,6 +8369,7 @@ VCmpxLeF32Vop3::VCmpxLeF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8386,6 +8409,7 @@ VCmpxGtF32Vop3::VCmpxGtF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8425,6 +8449,7 @@ VCmpxLgF32Vop3::VCmpxLgF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8464,6 +8489,7 @@ VCmpxGeF32Vop3::VCmpxGeF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8503,6 +8529,7 @@ VCmpxOF32Vop3::VCmpxOF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8542,6 +8569,7 @@ VCmpxUF32Vop3::VCmpxUF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8581,6 +8609,7 @@ VCmpxNgeF32Vop3::VCmpxNgeF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8620,6 +8649,7 @@ VCmpxNlgF32Vop3::VCmpxNlgF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8659,6 +8689,7 @@ VCmpxNgtF32Vop3::VCmpxNgtF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8698,6 +8729,7 @@ VCmpxNleF32Vop3::VCmpxNleF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8737,6 +8769,7 @@ VCmpxNeqF32Vop3::VCmpxNeqF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8776,6 +8809,7 @@ VCmpxNltF32Vop3::VCmpxNltF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8815,6 +8849,7 @@ VCmpxTruF32Vop3::VCmpxTruF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9112,6 +9147,7 @@ VCmpxFF64Vop3::VCmpxFF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9140,6 +9176,7 @@ VCmpxLtF64Vop3::VCmpxLtF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9179,6 +9216,7 @@ VCmpxEqF64Vop3::VCmpxEqF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9218,6 +9256,7 @@ VCmpxLeF64Vop3::VCmpxLeF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9257,6 +9296,7 @@ VCmpxGtF64Vop3::VCmpxGtF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9296,6 +9336,7 @@ VCmpxLgF64Vop3::VCmpxLgF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9335,6 +9376,7 @@ VCmpxGeF64Vop3::VCmpxGeF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9374,6 +9416,7 @@ VCmpxOF64Vop3::VCmpxOF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9413,6 +9456,7 @@ VCmpxUF64Vop3::VCmpxUF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9452,6 +9496,7 @@ VCmpxNgeF64Vop3::VCmpxNgeF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9491,6 +9536,7 @@ VCmpxNlgF64Vop3::VCmpxNlgF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9530,6 +9576,7 @@ VCmpxNgtF64Vop3::VCmpxNgtF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9569,6 +9616,7 @@ VCmpxNleF64Vop3::VCmpxNleF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9608,6 +9656,7 @@ VCmpxNeqF64Vop3::VCmpxNeqF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9647,6 +9696,7 @@ VCmpxNltF64Vop3::VCmpxNltF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9686,6 +9736,7 @@ VCmpxTruF64Vop3::VCmpxTruF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10158,6 +10209,7 @@ VCmpxFI16Vop3::VCmpxFI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10186,6 +10238,7 @@ VCmpxLtI16Vop3::VCmpxLtI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10224,6 +10277,7 @@ VCmpxEqI16Vop3::VCmpxEqI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10262,6 +10316,7 @@ VCmpxLeI16Vop3::VCmpxLeI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10300,6 +10355,7 @@ VCmpxGtI16Vop3::VCmpxGtI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10338,6 +10394,7 @@ VCmpxNeI16Vop3::VCmpxNeI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10376,6 +10433,7 @@ VCmpxGeI16Vop3::VCmpxGeI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10414,6 +10472,7 @@ VCmpxTI16Vop3::VCmpxTI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10442,6 +10501,7 @@ VCmpxFU16Vop3::VCmpxFU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10470,6 +10530,7 @@ VCmpxLtU16Vop3::VCmpxLtU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10508,6 +10569,7 @@ VCmpxEqU16Vop3::VCmpxEqU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10546,6 +10608,7 @@ VCmpxLeU16Vop3::VCmpxLeU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10584,6 +10647,7 @@ VCmpxGtU16Vop3::VCmpxGtU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10622,6 +10686,7 @@ VCmpxNeU16Vop3::VCmpxNeU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10660,6 +10725,7 @@ VCmpxGeU16Vop3::VCmpxGeU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10698,6 +10764,7 @@ VCmpxTU16Vop3::VCmpxTU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10994,6 +11061,7 @@ VCmpxFI32Vop3::VCmpxFI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11022,6 +11090,7 @@ VCmpxLtI32Vop3::VCmpxLtI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11053,6 +11122,7 @@ VCmpxEqI32Vop3::VCmpxEqI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11084,6 +11154,7 @@ VCmpxLeI32Vop3::VCmpxLeI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11115,6 +11186,7 @@ VCmpxGtI32Vop3::VCmpxGtI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11146,6 +11218,7 @@ VCmpxNeI32Vop3::VCmpxNeI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11177,6 +11250,7 @@ VCmpxGeI32Vop3::VCmpxGeI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11208,6 +11282,7 @@ VCmpxTI32Vop3::VCmpxTI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11236,6 +11311,7 @@ VCmpxFU32Vop3::VCmpxFU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11264,6 +11340,7 @@ VCmpxLtU32Vop3::VCmpxLtU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11295,6 +11372,7 @@ VCmpxEqU32Vop3::VCmpxEqU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11326,6 +11404,7 @@ VCmpxLeU32Vop3::VCmpxLeU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11357,6 +11436,7 @@ VCmpxGtU32Vop3::VCmpxGtU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11388,6 +11468,7 @@ VCmpxNeU32Vop3::VCmpxNeU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11419,6 +11500,7 @@ VCmpxGeU32Vop3::VCmpxGeU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11450,6 +11532,7 @@ VCmpxTU32Vop3::VCmpxTU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11746,6 +11829,7 @@ VCmpxFI64Vop3::VCmpxFI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11774,6 +11858,7 @@ VCmpxLtI64Vop3::VCmpxLtI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11805,6 +11890,7 @@ VCmpxEqI64Vop3::VCmpxEqI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11836,6 +11922,7 @@ VCmpxLeI64Vop3::VCmpxLeI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11867,6 +11954,7 @@ VCmpxGtI64Vop3::VCmpxGtI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11898,6 +11986,7 @@ VCmpxNeI64Vop3::VCmpxNeI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11929,6 +12018,7 @@ VCmpxGeI64Vop3::VCmpxGeI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11960,6 +12050,7 @@ VCmpxTI64Vop3::VCmpxTI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11988,6 +12079,7 @@ VCmpxFU64Vop3::VCmpxFU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12016,6 +12108,7 @@ VCmpxLtU64Vop3::VCmpxLtU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12047,6 +12140,7 @@ VCmpxEqU64Vop3::VCmpxEqU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12078,6 +12172,7 @@ VCmpxLeU64Vop3::VCmpxLeU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12109,6 +12204,7 @@ VCmpxGtU64Vop3::VCmpxGtU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12140,6 +12236,7 @@ VCmpxNeU64Vop3::VCmpxNeU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12171,6 +12268,7 @@ VCmpxGeU64Vop3::VCmpxGeU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12202,6 +12300,7 @@ VCmpxTU64Vop3::VCmpxTU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vop3::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/vopc.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/vopc.cpp index 116cbabadc33..a3f8cf741d7a 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/vopc.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna3/vopc.cpp @@ -119,6 +119,7 @@ VCmpxClassF32Vopc::VCmpxClassF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -234,6 +235,7 @@ VCmpxClassF64Vopc::VCmpxClassF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_CLASS_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -377,6 +379,7 @@ VCmpxClassF16Vopc::VCmpxClassF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1491,6 +1494,7 @@ VCmpxFF16Vopc::VCmpxFF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1565,6 +1569,7 @@ VCmpxLtF16Vopc::VCmpxLtF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1644,6 +1649,7 @@ VCmpxEqF16Vopc::VCmpxEqF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1723,6 +1729,7 @@ VCmpxLeF16Vopc::VCmpxLeF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1802,6 +1809,7 @@ VCmpxGtF16Vopc::VCmpxGtF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1881,6 +1889,7 @@ VCmpxLgF16Vopc::VCmpxLgF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1960,6 +1969,7 @@ VCmpxGeF16Vopc::VCmpxGeF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2039,6 +2049,7 @@ VCmpxOF16Vopc::VCmpxOF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2118,6 +2129,7 @@ VCmpxUF16Vopc::VCmpxUF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2197,6 +2209,7 @@ VCmpxNgeF16Vopc::VCmpxNgeF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2276,6 +2289,7 @@ VCmpxNlgF16Vopc::VCmpxNlgF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2355,6 +2369,7 @@ VCmpxNgtF16Vopc::VCmpxNgtF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2434,6 +2449,7 @@ VCmpxNleF16Vopc::VCmpxNleF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2513,6 +2529,7 @@ VCmpxNeqF16Vopc::VCmpxNeqF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2592,6 +2609,7 @@ VCmpxNltF16Vopc::VCmpxNltF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2671,6 +2689,7 @@ VCmpxTruF16Vopc::VCmpxTruF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3736,6 +3755,7 @@ VCmpxFF32Vopc::VCmpxFF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3809,6 +3829,7 @@ VCmpxLtF32Vopc::VCmpxLtF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3885,6 +3906,7 @@ VCmpxEqF32Vopc::VCmpxEqF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3961,6 +3983,7 @@ VCmpxLeF32Vopc::VCmpxLeF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4037,6 +4060,7 @@ VCmpxGtF32Vopc::VCmpxGtF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4113,6 +4137,7 @@ VCmpxLgF32Vopc::VCmpxLgF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4189,6 +4214,7 @@ VCmpxGeF32Vopc::VCmpxGeF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4265,6 +4291,7 @@ VCmpxOF32Vopc::VCmpxOF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4341,6 +4368,7 @@ VCmpxUF32Vopc::VCmpxUF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4417,6 +4445,7 @@ VCmpxNgeF32Vopc::VCmpxNgeF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4493,6 +4522,7 @@ VCmpxNlgF32Vopc::VCmpxNlgF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4569,6 +4599,7 @@ VCmpxNgtF32Vopc::VCmpxNgtF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4645,6 +4676,7 @@ VCmpxNleF32Vopc::VCmpxNleF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4721,6 +4753,7 @@ VCmpxNeqF32Vopc::VCmpxNeqF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4797,6 +4830,7 @@ VCmpxNltF32Vopc::VCmpxNltF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4873,6 +4907,7 @@ VCmpxTruF32Vopc::VCmpxTruF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5382,6 +5417,7 @@ VCmpxFF64Vopc::VCmpxFF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5421,6 +5457,7 @@ VCmpxLtF64Vopc::VCmpxLtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5463,6 +5500,7 @@ VCmpxEqF64Vopc::VCmpxEqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5505,6 +5543,7 @@ VCmpxLeF64Vopc::VCmpxLeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5547,6 +5586,7 @@ VCmpxGtF64Vopc::VCmpxGtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5589,6 +5629,7 @@ VCmpxLgF64Vopc::VCmpxLgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LG_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5631,6 +5672,7 @@ VCmpxGeF64Vopc::VCmpxGeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5673,6 +5715,7 @@ VCmpxOF64Vopc::VCmpxOF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_O_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5715,6 +5758,7 @@ VCmpxUF64Vopc::VCmpxUF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_U_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5757,6 +5801,7 @@ VCmpxNgeF64Vopc::VCmpxNgeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5799,6 +5844,7 @@ VCmpxNlgF64Vopc::VCmpxNlgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLG_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5841,6 +5887,7 @@ VCmpxNgtF64Vopc::VCmpxNgtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5883,6 +5930,7 @@ VCmpxNleF64Vopc::VCmpxNleF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5925,6 +5973,7 @@ VCmpxNeqF64Vopc::VCmpxNeqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NEQ_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5967,6 +6016,7 @@ VCmpxNltF64Vopc::VCmpxNltF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6009,6 +6059,7 @@ VCmpxTruF64Vopc::VCmpxTruF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_TRU_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7069,6 +7120,7 @@ VCmpxFI16Vopc::VCmpxFI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7143,6 +7195,7 @@ VCmpxLtI16Vopc::VCmpxLtI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7220,6 +7273,7 @@ VCmpxEqI16Vopc::VCmpxEqI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7297,6 +7351,7 @@ VCmpxLeI16Vopc::VCmpxLeI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7374,6 +7429,7 @@ VCmpxGtI16Vopc::VCmpxGtI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7451,6 +7507,7 @@ VCmpxNeI16Vopc::VCmpxNeI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7528,6 +7585,7 @@ VCmpxGeI16Vopc::VCmpxGeI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7605,6 +7663,7 @@ VCmpxTI16Vopc::VCmpxTI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7679,6 +7738,7 @@ VCmpxFU16Vopc::VCmpxFU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7753,6 +7813,7 @@ VCmpxLtU16Vopc::VCmpxLtU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7830,6 +7891,7 @@ VCmpxEqU16Vopc::VCmpxEqU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7907,6 +7969,7 @@ VCmpxLeU16Vopc::VCmpxLeU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7984,6 +8047,7 @@ VCmpxGtU16Vopc::VCmpxGtU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8061,6 +8125,7 @@ VCmpxNeU16Vopc::VCmpxNeU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8138,6 +8203,7 @@ VCmpxGeU16Vopc::VCmpxGeU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8215,6 +8281,7 @@ VCmpxTU16Vopc::VCmpxTU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9280,6 +9347,7 @@ VCmpxFI32Vopc::VCmpxFI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9353,6 +9421,7 @@ VCmpxLtI32Vopc::VCmpxLtI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9429,6 +9498,7 @@ VCmpxEqI32Vopc::VCmpxEqI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9505,6 +9575,7 @@ VCmpxLeI32Vopc::VCmpxLeI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9581,6 +9652,7 @@ VCmpxGtI32Vopc::VCmpxGtI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9657,6 +9729,7 @@ VCmpxNeI32Vopc::VCmpxNeI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9733,6 +9806,7 @@ VCmpxGeI32Vopc::VCmpxGeI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9809,6 +9883,7 @@ VCmpxTI32Vopc::VCmpxTI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9882,6 +9957,7 @@ VCmpxFU32Vopc::VCmpxFU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9955,6 +10031,7 @@ VCmpxLtU32Vopc::VCmpxLtU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10031,6 +10108,7 @@ VCmpxEqU32Vopc::VCmpxEqU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10107,6 +10185,7 @@ VCmpxLeU32Vopc::VCmpxLeU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10183,6 +10262,7 @@ VCmpxGtU32Vopc::VCmpxGtU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10259,6 +10339,7 @@ VCmpxNeU32Vopc::VCmpxNeU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10335,6 +10416,7 @@ VCmpxGeU32Vopc::VCmpxGeU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10411,6 +10493,7 @@ VCmpxTU32Vopc::VCmpxTU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10886,6 +10969,7 @@ VCmpxFI64Vopc::VCmpxFI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10923,6 +11007,7 @@ VCmpxLtI64Vopc::VCmpxLtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10963,6 +11048,7 @@ VCmpxEqI64Vopc::VCmpxEqI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11003,6 +11089,7 @@ VCmpxLeI64Vopc::VCmpxLeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11043,6 +11130,7 @@ VCmpxGtI64Vopc::VCmpxGtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11083,6 +11171,7 @@ VCmpxNeI64Vopc::VCmpxNeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11123,6 +11212,7 @@ VCmpxGeI64Vopc::VCmpxGeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11163,6 +11253,7 @@ VCmpxTI64Vopc::VCmpxTI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11200,6 +11291,7 @@ VCmpxFU64Vopc::VCmpxFU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11237,6 +11329,7 @@ VCmpxLtU64Vopc::VCmpxLtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11277,6 +11370,7 @@ VCmpxEqU64Vopc::VCmpxEqU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11317,6 +11411,7 @@ VCmpxLeU64Vopc::VCmpxLeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11357,6 +11452,7 @@ VCmpxGtU64Vopc::VCmpxGtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11397,6 +11493,7 @@ VCmpxNeU64Vopc::VCmpxNeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11437,6 +11534,7 @@ VCmpxGeU64Vopc::VCmpxGeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11477,6 +11575,7 @@ VCmpxTU64Vopc::VCmpxTU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vopc::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/operand.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/operand.cpp index 0e5fbbaafacb..3d47d57f7955 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/operand.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/operand.cpp @@ -5,6 +5,7 @@ // See lib/python/amdisa/README.md for regeneration instructions. #include "rocjitsu/isa/arch/amdgpu/cdna4/operand.h" +#include "rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h" #include "rocjitsu/isa/isa_operand_simd_inl.h" #include "rocjitsu/vm/amdgpu/compute_unit.h" #include "rocjitsu/vm/amdgpu/register_access.h" @@ -52,6 +53,16 @@ std::optional Operand::literal64_value() const { return literal64_value_; } +std::optional Operand::const_value() const { + if (has_literal64_) + return literal64_value_; + if (is_immediate_type(opr_type_)) + return static_cast(static_cast(encoding_value_)); + if (to_register_ref()) + return std::nullopt; + return amdgpu::resolve_src_scalar_statically(encoding_value_); +} + std::string Operand::name() const { if (has_literal64_) return std::format("0x{:x}", literal64_value_); @@ -1127,9 +1138,17 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSdst::OPR_SDST_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_EXEC: { + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_M0: { @@ -1150,6 +1169,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSrc::OPR_SRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrc::OPR_SRC_VGPR_MIN && encoding_value_ <= OpSelSrc::OPR_SRC_VGPR_MAX) return RegisterRef{RegClass::VGPR, @@ -1173,6 +1196,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcNolds::OPR_SRC_NOLDS_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcNolds::OPR_SRC_NOLDS_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcNolds::OPR_SRC_NOLDS_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcNolds::OPR_SRC_NOLDS_VGPR_MIN && encoding_value_ <= OpSelSrcNolds::OPR_SRC_NOLDS_VGPR_MAX) return RegisterRef{ @@ -1188,6 +1215,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcNolit::OPR_SRC_NOLIT_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcNolit::OPR_SRC_NOLIT_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcNolit::OPR_SRC_NOLIT_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcNolit::OPR_SRC_NOLIT_VGPR_MIN && encoding_value_ <= OpSelSrcNolit::OPR_SRC_NOLIT_VGPR_MAX) return RegisterRef{ @@ -1203,6 +1234,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcSimple::OPR_SRC_SIMPLE_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcSimple::OPR_SRC_SIMPLE_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcSimple::OPR_SRC_SIMPLE_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcSimple::OPR_SRC_SIMPLE_VGPR_MIN && encoding_value_ <= OpSelSrcSimple::OPR_SRC_SIMPLE_VGPR_MAX) return RegisterRef{ @@ -1279,6 +1314,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrc::OPR_SSRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_LANESEL: { @@ -1297,6 +1336,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrcNolit::OPR_SSRC_NOLIT_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrcNolit::OPR_SSRC_NOLIT_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrcNolit::OPR_SSRC_NOLIT_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_SPECIAL_SCC: { @@ -1345,242 +1388,7 @@ std::optional Operand::to_register_ref() const { namespace { -uint32_t resolve_src_scalar(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return static_cast(wf.scratch_base()); - if (ev == 103) - return static_cast(wf.scratch_base() >> 32); - if (ev <= 105) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 106) - return static_cast(wf.vcc()); - if (ev == 107) - return static_cast(wf.vcc() >> 32); - if (ev >= 108 && ev <= 123) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 124) - return wf.m0(); - if (ev == 126) - return static_cast(wf.exec()); - if (ev == 127) - return static_cast(wf.exec() >> 32); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(-(ev - 192))); - if (ev == 230) - return static_cast(wf.scratch_base()); // SRC_FLAT_SCRATCH_BASE_LO - if (ev == 231) - return static_cast(wf.scratch_base() >> 32); // SRC_FLAT_SCRATCH_BASE_HI - if (ev == 240) - return 0x3F000000u; // 0.5f - if (ev == 241) - return 0xBF000000u; // -0.5f - if (ev == 242) - return 0x3F800000u; // 1.0f - if (ev == 243) - return 0xBF800000u; // -1.0f - if (ev == 244) - return 0x40000000u; // 2.0f - if (ev == 245) - return 0xC0000000u; // -2.0f - if (ev == 246) - return 0x40800000u; // 4.0f - if (ev == 247) - return 0xC0800000u; // -4.0f - if (ev == 248) - return 0x3E22F983u; // 1/(2*pi) - if (ev == 235) - return static_cast(wf.shared_aperture_base() >> 32); // SRC_SHARED_BASE - if (ev == 236) - return static_cast(wf.shared_aperture_limit() >> 32); // SRC_SHARED_LIMIT - if (ev == 237) - return static_cast(wf.private_aperture_base() >> 32); // SRC_PRIVATE_BASE - if (ev == 238) - return static_cast(wf.private_aperture_limit() >> 32); // SRC_PRIVATE_LIMIT - if (ev == 249) - return 0u; // SRC_POPS_EXITING_WAVE_ID (not used in compute) - if (ev == 250) - return 0u; // NULL - if (ev == 251) - return (wf.vcc() & (wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL))) == 0 - ? 1u - : 0u; // VCCZ - if (ev == 252) { - uint64_t active = wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL); - return (wf.exec() & active) == 0 ? 1u : 0u; // EXECZ - } - if (ev == 253) - return wf.read_scc() ? 1u : 0u; // SCC - throw std::logic_error("Unsupported encoding value for scalar read: " + std::to_string(ev)); -} - -uint32_t resolve_src_scalar16(const amdgpu::Wavefront &wf, int ev) { - switch (ev) { - case 240: - return 0x3800u; // 0.5h - case 241: - return 0xB800u; // -0.5h - case 242: - return 0x3C00u; // 1.0h - case 243: - return 0xBC00u; // -1.0h - case 244: - return 0x4000u; // 2.0h - case 245: - return 0xC000u; // -2.0h - case 246: - return 0x4400u; // 4.0h - case 247: - return 0xC400u; // -4.0h - case 248: - return 0x3118u; // f16 1/(2*pi) - default: - return resolve_src_scalar(wf, ev); - } -} - -// Must stay in sync with resolve_src_scalar above — returns true for -// exactly the encoding values that resolve_src_scalar handles without -// throwing. Used by Isa::simd_capable_value() to keep the SIMD fast -// path off operands whose scalar broadcast would throw at runtime. -bool can_resolve_src_scalar(int ev) { - return (ev >= 0 && ev <= 107) || (ev >= 108 && ev <= 123) || ev == 124 || ev == 126 || - ev == 127 || (ev >= 128 && ev <= 208) || (ev >= 235 && ev <= 238) || - (ev >= 240 && ev <= 253); -} - -uint64_t resolve_src_scalar64(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return wf.scratch_base(); - if (ev <= 105) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 106) - return wf.vcc(); - if (ev >= 108 && ev <= 122) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 124) - return wf.m0(); - if (ev == 126) - return wf.exec(); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(static_cast(-(ev - 192)))); - if (ev == 230) - return wf.scratch_base(); // SRC_FLAT_SCRATCH_BASE - if (ev == 240) - return 0x3FE0000000000000ULL; // 0.5 - if (ev == 241) - return 0xBFE0000000000000ULL; // -0.5 - if (ev == 242) - return 0x3FF0000000000000ULL; // 1.0 - if (ev == 243) - return 0xBFF0000000000000ULL; // -1.0 - if (ev == 244) - return 0x4000000000000000ULL; // 2.0 - if (ev == 245) - return 0xC000000000000000ULL; // -2.0 - if (ev == 246) - return 0x4010000000000000ULL; // 4.0 - if (ev == 247) - return 0xC010000000000000ULL; // -4.0 - if (ev == 248) - return 0x3FC45F306DC9C883ULL; // 1/(2*pi) - if (ev == 235) - return wf.shared_aperture_base(); // SRC_SHARED_BASE - if (ev == 236) - return wf.shared_aperture_limit(); // SRC_SHARED_LIMIT - if (ev == 237) - return wf.private_aperture_base(); // SRC_PRIVATE_BASE - if (ev == 238) - return wf.private_aperture_limit(); // SRC_PRIVATE_LIMIT - throw std::logic_error("Unsupported encoding value for scalar64 read: " + std::to_string(ev)); -} - -void resolve_dst_write(amdgpu::Wavefront &wf, int ev, uint32_t val) { - if (ev == 102) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 103) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 106) { - wf.set_vcc((wf.vcc() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 107) { - wf.set_vcc((wf.vcc() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev >= 108 && ev <= 123) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 124) { - wf.set_m0(val); - return; - } - if (ev == 126) { - wf.set_exec((wf.exec() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 127) { - wf.set_exec((wf.exec() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - throw std::logic_error("Unsupported encoding value for scalar write: " + std::to_string(ev)); -} - -void resolve_dst_write64(amdgpu::Wavefront &wf, int ev, uint64_t val) { - if (ev == 102) { - wf.set_scratch_base(val); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 106) { - wf.set_vcc(val); - return; - } - if (ev >= 108 && ev <= 122) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 124) - return; - if (ev == 126) { - wf.set_exec(val); - return; - } - throw std::logic_error("Unsupported encoding value for scalar64 write: " + std::to_string(ev)); -} +constexpr int kM0EncodingValue = 124; bool is_vgpr_only_type(OperandType t) { return t == OperandType::OPR_VGPR || t == OperandType::OPR_VGPR_OR_ACCVGPR || @@ -1589,12 +1397,6 @@ bool is_vgpr_only_type(OperandType t) { t == OperandType::OPR_SRC_VGPR_OR_ACCVGPR; } -bool is_immediate_type(OperandType t) { - return t == OperandType::OPR_SIMM16 || t == OperandType::OPR_SIMM32 || - t == OperandType::OPR_SIMM4 || t == OperandType::OPR_SIMM8 || - t == OperandType::OPR_LABEL || t == OperandType::OPR_WAITCNT; -} - uint32_t vgpr_index(OperandType opr_type, int ev) { if (opr_type == OperandType::OPR_VGPR || opr_type == OperandType::OPR_VGPR_OR_ACCVGPR) { if (ev >= OpSelAccvgpr::OPR_ACCVGPR_ACC_MIN) @@ -1652,11 +1454,12 @@ std::optional Isa::resolved_vgpr_offset(OperandType opr_type, int ev) bool Isa::simd_capable_value(OperandType opr_type, int ev) { return resolved_vgpr_offset(opr_type, ev).has_value() || is_immediate_type(opr_type) || - can_resolve_src_scalar(ev); + amdgpu::can_resolve_src_scalar(ev, kM0EncodingValue); } uint32_t Isa::simd_broadcast_value(const amdgpu::Wavefront &wf, OperandType opr_type, int ev) { - return is_immediate_type(opr_type) ? static_cast(ev) : resolve_src_scalar(wf, ev); + return is_immediate_type(opr_type) ? static_cast(ev) + : amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { @@ -1672,7 +1475,7 @@ uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { return static_cast(literal64_value_); if (is_immediate_type(opr_type_)) return static_cast(encoding_value_); - return resolve_src_scalar(wf, encoding_value_); + return amdgpu::resolve_src_scalar(wf, encoding_value_, kM0EncodingValue); } uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { @@ -1692,8 +1495,8 @@ uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { if (is_immediate_type(opr_type_)) return static_cast(ev); if (size_bits_ == 16) - return resolve_src_scalar16(wf, ev); - return resolve_src_scalar(wf, ev); + return amdgpu::resolve_src_scalar16(wf, ev, kM0EncodingValue); + return amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { @@ -1703,7 +1506,7 @@ void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write(wf, encoding_value_, val); + amdgpu::resolve_dst_write(wf, encoding_value_, val, kM0EncodingValue); } void Operand::write_lane(amdgpu::Wavefront &wf, uint32_t lane, uint32_t val) const { @@ -1740,7 +1543,7 @@ uint64_t Operand::read_lane64(const amdgpu::Wavefront &wf, uint32_t lane) const return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, ev); - return resolve_src_scalar64(wf, ev); + return amdgpu::resolve_src_scalar64(wf, ev, kM0EncodingValue); } void Operand::write_lane64(amdgpu::Wavefront &wf, uint32_t lane, uint64_t val) const { @@ -1770,7 +1573,7 @@ uint64_t Operand::read_scalar64(const amdgpu::Wavefront &wf) const { return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, encoding_value_); - return resolve_src_scalar64(wf, encoding_value_); + return amdgpu::resolve_src_scalar64(wf, encoding_value_, kM0EncodingValue); } void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { @@ -1780,7 +1583,7 @@ void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write64(wf, encoding_value_, val); + amdgpu::resolve_dst_write64(wf, encoding_value_, val); } } // namespace cdna4 diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/operand.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/operand.h index 6320704f4886..4a9c8e926ffd 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/operand.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/operand.h @@ -23,6 +23,7 @@ class Operand : public AmdgpuIsaOperand { Operand(int size_bits, OperandType opr_type, uint64_t literal64_value, bool is_literal64); std::string name() const override; std::optional literal64_value() const override; + std::optional const_value() const override; std::optional to_register_ref() const override; private: diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/operand_types.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/operand_types.h index aa0affac72f8..9fdca459022a 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/operand_types.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/operand_types.h @@ -614,6 +614,20 @@ enum OpSelVgprOrLds { } } +[[nodiscard]] constexpr bool is_immediate_type(OperandType t) { + switch (t) { + case OperandType::OPR_SIMM4: + case OperandType::OPR_SIMM8: + case OperandType::OPR_SIMM16: + case OperandType::OPR_SIMM32: + case OperandType::OPR_LABEL: + case OperandType::OPR_WAITCNT: + return true; + default: + return false; + } +} + } // namespace cdna4 } // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/sop1.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/sop1.cpp index d9e2b80e7960..7beef1307fc8 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/sop1.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/sop1.cpp @@ -32,6 +32,7 @@ SMovB32Sop1::SMovB32Sop1(const MachineInst *inst) ssrc0 = Operand( 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB32Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b32_sop1(*this, wf); } @@ -48,6 +49,7 @@ SMovB64Sop1::SMovB64Sop1(const MachineInst *inst) ssrc0 = Operand( 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB64Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b64_sop1(*this, wf); } @@ -672,6 +674,7 @@ SAndSaveexecB64Sop1::SAndSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -700,6 +703,8 @@ SOrSaveexecB64Sop1::SOrSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } void SOrSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -728,6 +733,7 @@ SXorSaveexecB64Sop1::SXorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -756,6 +762,7 @@ SAndn2SaveexecB64Sop1::SAndn2SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -784,6 +791,7 @@ SOrn2SaveexecB64Sop1::SOrn2SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn2SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -812,6 +820,7 @@ SNandSaveexecB64Sop1::SNandSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNandSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -840,6 +849,7 @@ SNorSaveexecB64Sop1::SNorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -868,6 +878,7 @@ SXnorSaveexecB64Sop1::SXnorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXnorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1131,6 +1142,7 @@ SAndn1SaveexecB64Sop1::SAndn1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1159,6 +1171,7 @@ SOrn1SaveexecB64Sop1::SOrn1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1187,6 +1200,7 @@ SAndn1WrexecB64Sop1::SAndn1WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1215,6 +1229,7 @@ SAndn2WrexecB64Sop1::SAndn2WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/sop2.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/sop2.cpp index e0a82cfa9996..ef2e9340cb42 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/sop2.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/sop2.cpp @@ -404,6 +404,7 @@ SOrB32Sop2::SOrB32Sop2(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB32Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b32_sop2(*this, wf); } @@ -429,6 +430,7 @@ SOrB64Sop2::SOrB64Sop2(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB64Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b64_sop2(*this, wf); } diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/sopp.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/sopp.cpp index b0c36a2ee2c3..59e55b9877e1 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/sopp.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/sopp.cpp @@ -44,6 +44,7 @@ SBranchSopp::SBranchSopp(const MachineInst *inst) num_src_ = 1; num_dst_ = 0; flags_ |= BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SBranchSopp::branch_offset_bytes() const { @@ -75,6 +76,7 @@ SCbranchScc0Sopp::SCbranchScc0Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc0Sopp::branch_offset_bytes() const { @@ -100,6 +102,7 @@ SCbranchScc1Sopp::SCbranchScc1Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc1Sopp::branch_offset_bytes() const { @@ -125,6 +128,7 @@ SCbranchVcczSopp::SCbranchVcczSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVcczSopp::branch_offset_bytes() const { @@ -152,6 +156,7 @@ SCbranchVccnzSopp::SCbranchVccnzSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVccnzSopp::branch_offset_bytes() const { @@ -179,6 +184,7 @@ SCbranchExeczSopp::SCbranchExeczSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExeczSopp::branch_offset_bytes() const { @@ -204,6 +210,7 @@ SCbranchExecnzSopp::SCbranchExecnzSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExecnzSopp::branch_offset_bytes() const { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/vop3.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/vop3.cpp index a4a6ac4cce50..7a69f1eb5d85 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/vop3.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/vop3.cpp @@ -11043,6 +11043,12 @@ VWritelaneB32Vop3::VWritelaneB32Vop3(const MachineInst *inst) num_dst_ = 1; } +void VWritelaneB32Vop3::implicit_uses(RegisterSet &uses) const { + Vop3::implicit_uses(uses); + if (auto r = vdst.to_register_ref()) + uses.expand(*r); +} + void VWritelaneB32Vop3::execute_impl(amdgpu::Wavefront &wf) { uint32_t val = amdgpu::RegisterAccess(wf).read_scalar(src0); uint32_t lane = amdgpu::RegisterAccess(wf).read_scalar(src1); @@ -11713,6 +11719,7 @@ VCmpxClassF32Vop3::VCmpxClassF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11788,6 +11795,7 @@ VCmpxClassF64Vop3::VCmpxClassF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11936,6 +11944,7 @@ VCmpxClassF16Vop3::VCmpxClassF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12693,6 +12702,7 @@ VCmpxFF16Vop3::VCmpxFF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12721,6 +12731,7 @@ VCmpxLtF16Vop3::VCmpxLtF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12763,6 +12774,7 @@ VCmpxEqF16Vop3::VCmpxEqF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12805,6 +12817,7 @@ VCmpxLeF16Vop3::VCmpxLeF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12847,6 +12860,7 @@ VCmpxGtF16Vop3::VCmpxGtF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12889,6 +12903,7 @@ VCmpxLgF16Vop3::VCmpxLgF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12931,6 +12946,7 @@ VCmpxGeF16Vop3::VCmpxGeF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12973,6 +12989,7 @@ VCmpxOF16Vop3::VCmpxOF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13015,6 +13032,7 @@ VCmpxUF16Vop3::VCmpxUF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13057,6 +13075,7 @@ VCmpxNgeF16Vop3::VCmpxNgeF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13099,6 +13118,7 @@ VCmpxNlgF16Vop3::VCmpxNlgF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13141,6 +13161,7 @@ VCmpxNgtF16Vop3::VCmpxNgtF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13183,6 +13204,7 @@ VCmpxNleF16Vop3::VCmpxNleF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13225,6 +13247,7 @@ VCmpxNeqF16Vop3::VCmpxNeqF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13267,6 +13290,7 @@ VCmpxNltF16Vop3::VCmpxNltF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13309,6 +13333,7 @@ VCmpxTruF16Vop3::VCmpxTruF16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13606,6 +13631,7 @@ VCmpxFF32Vop3::VCmpxFF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13634,6 +13660,7 @@ VCmpxLtF32Vop3::VCmpxLtF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13673,6 +13700,7 @@ VCmpxEqF32Vop3::VCmpxEqF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13712,6 +13740,7 @@ VCmpxLeF32Vop3::VCmpxLeF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13751,6 +13780,7 @@ VCmpxGtF32Vop3::VCmpxGtF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13790,6 +13820,7 @@ VCmpxLgF32Vop3::VCmpxLgF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13829,6 +13860,7 @@ VCmpxGeF32Vop3::VCmpxGeF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13868,6 +13900,7 @@ VCmpxOF32Vop3::VCmpxOF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13907,6 +13940,7 @@ VCmpxUF32Vop3::VCmpxUF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13946,6 +13980,7 @@ VCmpxNgeF32Vop3::VCmpxNgeF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -13985,6 +14020,7 @@ VCmpxNlgF32Vop3::VCmpxNlgF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14024,6 +14060,7 @@ VCmpxNgtF32Vop3::VCmpxNgtF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14063,6 +14100,7 @@ VCmpxNleF32Vop3::VCmpxNleF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14102,6 +14140,7 @@ VCmpxNeqF32Vop3::VCmpxNeqF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14141,6 +14180,7 @@ VCmpxNltF32Vop3::VCmpxNltF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14180,6 +14220,7 @@ VCmpxTruF32Vop3::VCmpxTruF32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14477,6 +14518,7 @@ VCmpxFF64Vop3::VCmpxFF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14505,6 +14547,7 @@ VCmpxLtF64Vop3::VCmpxLtF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14544,6 +14587,7 @@ VCmpxEqF64Vop3::VCmpxEqF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14583,6 +14627,7 @@ VCmpxLeF64Vop3::VCmpxLeF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14622,6 +14667,7 @@ VCmpxGtF64Vop3::VCmpxGtF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14661,6 +14707,7 @@ VCmpxLgF64Vop3::VCmpxLgF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14700,6 +14747,7 @@ VCmpxGeF64Vop3::VCmpxGeF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14739,6 +14787,7 @@ VCmpxOF64Vop3::VCmpxOF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14778,6 +14827,7 @@ VCmpxUF64Vop3::VCmpxUF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14817,6 +14867,7 @@ VCmpxNgeF64Vop3::VCmpxNgeF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14856,6 +14907,7 @@ VCmpxNlgF64Vop3::VCmpxNlgF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14895,6 +14947,7 @@ VCmpxNgtF64Vop3::VCmpxNgtF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14934,6 +14987,7 @@ VCmpxNleF64Vop3::VCmpxNleF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -14973,6 +15027,7 @@ VCmpxNeqF64Vop3::VCmpxNeqF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15012,6 +15067,7 @@ VCmpxNltF64Vop3::VCmpxNltF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15051,6 +15107,7 @@ VCmpxTruF64Vop3::VCmpxTruF64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15523,6 +15580,7 @@ VCmpxFI16Vop3::VCmpxFI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15551,6 +15609,7 @@ VCmpxLtI16Vop3::VCmpxLtI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15589,6 +15648,7 @@ VCmpxEqI16Vop3::VCmpxEqI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15627,6 +15687,7 @@ VCmpxLeI16Vop3::VCmpxLeI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15665,6 +15726,7 @@ VCmpxGtI16Vop3::VCmpxGtI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15703,6 +15765,7 @@ VCmpxNeI16Vop3::VCmpxNeI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15741,6 +15804,7 @@ VCmpxGeI16Vop3::VCmpxGeI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15779,6 +15843,7 @@ VCmpxTI16Vop3::VCmpxTI16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15807,6 +15872,7 @@ VCmpxFU16Vop3::VCmpxFU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15835,6 +15901,7 @@ VCmpxLtU16Vop3::VCmpxLtU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15873,6 +15940,7 @@ VCmpxEqU16Vop3::VCmpxEqU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15911,6 +15979,7 @@ VCmpxLeU16Vop3::VCmpxLeU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15949,6 +16018,7 @@ VCmpxGtU16Vop3::VCmpxGtU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -15987,6 +16057,7 @@ VCmpxNeU16Vop3::VCmpxNeU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16025,6 +16096,7 @@ VCmpxGeU16Vop3::VCmpxGeU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16063,6 +16135,7 @@ VCmpxTU16Vop3::VCmpxTU16Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16359,6 +16432,7 @@ VCmpxFI32Vop3::VCmpxFI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16387,6 +16461,7 @@ VCmpxLtI32Vop3::VCmpxLtI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16418,6 +16493,7 @@ VCmpxEqI32Vop3::VCmpxEqI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16449,6 +16525,7 @@ VCmpxLeI32Vop3::VCmpxLeI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16480,6 +16557,7 @@ VCmpxGtI32Vop3::VCmpxGtI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16511,6 +16589,7 @@ VCmpxNeI32Vop3::VCmpxNeI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16542,6 +16621,7 @@ VCmpxGeI32Vop3::VCmpxGeI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16573,6 +16653,7 @@ VCmpxTI32Vop3::VCmpxTI32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16601,6 +16682,7 @@ VCmpxFU32Vop3::VCmpxFU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16629,6 +16711,7 @@ VCmpxLtU32Vop3::VCmpxLtU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16660,6 +16743,7 @@ VCmpxEqU32Vop3::VCmpxEqU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16691,6 +16775,7 @@ VCmpxLeU32Vop3::VCmpxLeU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16722,6 +16807,7 @@ VCmpxGtU32Vop3::VCmpxGtU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16753,6 +16839,7 @@ VCmpxNeU32Vop3::VCmpxNeU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16784,6 +16871,7 @@ VCmpxGeU32Vop3::VCmpxGeU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -16815,6 +16903,7 @@ VCmpxTU32Vop3::VCmpxTU32Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17111,6 +17200,7 @@ VCmpxFI64Vop3::VCmpxFI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17139,6 +17229,7 @@ VCmpxLtI64Vop3::VCmpxLtI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17170,6 +17261,7 @@ VCmpxEqI64Vop3::VCmpxEqI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17201,6 +17293,7 @@ VCmpxLeI64Vop3::VCmpxLeI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17232,6 +17325,7 @@ VCmpxGtI64Vop3::VCmpxGtI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17263,6 +17357,7 @@ VCmpxNeI64Vop3::VCmpxNeI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17294,6 +17389,7 @@ VCmpxGeI64Vop3::VCmpxGeI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17325,6 +17421,7 @@ VCmpxTI64Vop3::VCmpxTI64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17353,6 +17450,7 @@ VCmpxFU64Vop3::VCmpxFU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17381,6 +17479,7 @@ VCmpxLtU64Vop3::VCmpxLtU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17412,6 +17511,7 @@ VCmpxEqU64Vop3::VCmpxEqU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17443,6 +17543,7 @@ VCmpxLeU64Vop3::VCmpxLeU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17474,6 +17575,7 @@ VCmpxGtU64Vop3::VCmpxGtU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17505,6 +17607,7 @@ VCmpxNeU64Vop3::VCmpxNeU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17536,6 +17639,7 @@ VCmpxGeU64Vop3::VCmpxGeU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -17567,6 +17671,7 @@ VCmpxTU64Vop3::VCmpxTU64Vop3(const MachineInst *inst) num_src_ = 2; num_dst_ = 2; sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vop3::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/vop3.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/vop3.h index d746e6d72c7f..231211b3c70c 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/vop3.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/vop3.h @@ -2550,6 +2550,7 @@ class VWritelaneB32Vop3 : public Vop3 { public: VWritelaneB32Vop3(const MachineInst *inst); void execute_impl(amdgpu::Wavefront &wf); + void implicit_uses(RegisterSet &uses) const override; Operand vdst; Operand src0; Operand src1; diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/vopc.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/vopc.cpp index 68c22731a140..6af5df2facd0 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/vopc.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/cdna4/vopc.cpp @@ -119,6 +119,7 @@ VCmpxClassF32Vopc::VCmpxClassF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -234,6 +235,7 @@ VCmpxClassF64Vopc::VCmpxClassF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_CLASS_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -377,6 +379,7 @@ VCmpxClassF16Vopc::VCmpxClassF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1491,6 +1494,7 @@ VCmpxFF16Vopc::VCmpxFF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1565,6 +1569,7 @@ VCmpxLtF16Vopc::VCmpxLtF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1644,6 +1649,7 @@ VCmpxEqF16Vopc::VCmpxEqF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1723,6 +1729,7 @@ VCmpxLeF16Vopc::VCmpxLeF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1802,6 +1809,7 @@ VCmpxGtF16Vopc::VCmpxGtF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1881,6 +1889,7 @@ VCmpxLgF16Vopc::VCmpxLgF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1960,6 +1969,7 @@ VCmpxGeF16Vopc::VCmpxGeF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2039,6 +2049,7 @@ VCmpxOF16Vopc::VCmpxOF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2118,6 +2129,7 @@ VCmpxUF16Vopc::VCmpxUF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2197,6 +2209,7 @@ VCmpxNgeF16Vopc::VCmpxNgeF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2276,6 +2289,7 @@ VCmpxNlgF16Vopc::VCmpxNlgF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2355,6 +2369,7 @@ VCmpxNgtF16Vopc::VCmpxNgtF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2434,6 +2449,7 @@ VCmpxNleF16Vopc::VCmpxNleF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2513,6 +2529,7 @@ VCmpxNeqF16Vopc::VCmpxNeqF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2592,6 +2609,7 @@ VCmpxNltF16Vopc::VCmpxNltF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2671,6 +2689,7 @@ VCmpxTruF16Vopc::VCmpxTruF16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3736,6 +3755,7 @@ VCmpxFF32Vopc::VCmpxFF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3809,6 +3829,7 @@ VCmpxLtF32Vopc::VCmpxLtF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3885,6 +3906,7 @@ VCmpxEqF32Vopc::VCmpxEqF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3961,6 +3983,7 @@ VCmpxLeF32Vopc::VCmpxLeF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4037,6 +4060,7 @@ VCmpxGtF32Vopc::VCmpxGtF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4113,6 +4137,7 @@ VCmpxLgF32Vopc::VCmpxLgF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4189,6 +4214,7 @@ VCmpxGeF32Vopc::VCmpxGeF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4265,6 +4291,7 @@ VCmpxOF32Vopc::VCmpxOF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4341,6 +4368,7 @@ VCmpxUF32Vopc::VCmpxUF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4417,6 +4445,7 @@ VCmpxNgeF32Vopc::VCmpxNgeF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4493,6 +4522,7 @@ VCmpxNlgF32Vopc::VCmpxNlgF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4569,6 +4599,7 @@ VCmpxNgtF32Vopc::VCmpxNgtF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4645,6 +4676,7 @@ VCmpxNleF32Vopc::VCmpxNleF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4721,6 +4753,7 @@ VCmpxNeqF32Vopc::VCmpxNeqF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4797,6 +4830,7 @@ VCmpxNltF32Vopc::VCmpxNltF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4873,6 +4907,7 @@ VCmpxTruF32Vopc::VCmpxTruF32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5382,6 +5417,7 @@ VCmpxFF64Vopc::VCmpxFF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5421,6 +5457,7 @@ VCmpxLtF64Vopc::VCmpxLtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5463,6 +5500,7 @@ VCmpxEqF64Vopc::VCmpxEqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5505,6 +5543,7 @@ VCmpxLeF64Vopc::VCmpxLeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5547,6 +5586,7 @@ VCmpxGtF64Vopc::VCmpxGtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5589,6 +5629,7 @@ VCmpxLgF64Vopc::VCmpxLgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LG_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5631,6 +5672,7 @@ VCmpxGeF64Vopc::VCmpxGeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5673,6 +5715,7 @@ VCmpxOF64Vopc::VCmpxOF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_O_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5715,6 +5758,7 @@ VCmpxUF64Vopc::VCmpxUF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_U_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5757,6 +5801,7 @@ VCmpxNgeF64Vopc::VCmpxNgeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5799,6 +5844,7 @@ VCmpxNlgF64Vopc::VCmpxNlgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLG_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5841,6 +5887,7 @@ VCmpxNgtF64Vopc::VCmpxNgtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5883,6 +5930,7 @@ VCmpxNleF64Vopc::VCmpxNleF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLE_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5925,6 +5973,7 @@ VCmpxNeqF64Vopc::VCmpxNeqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NEQ_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5967,6 +6016,7 @@ VCmpxNltF64Vopc::VCmpxNltF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLT_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6009,6 +6059,7 @@ VCmpxTruF64Vopc::VCmpxTruF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_TRU_F64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7069,6 +7120,7 @@ VCmpxFI16Vopc::VCmpxFI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7143,6 +7195,7 @@ VCmpxLtI16Vopc::VCmpxLtI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7220,6 +7273,7 @@ VCmpxEqI16Vopc::VCmpxEqI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7297,6 +7351,7 @@ VCmpxLeI16Vopc::VCmpxLeI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7374,6 +7429,7 @@ VCmpxGtI16Vopc::VCmpxGtI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7451,6 +7507,7 @@ VCmpxNeI16Vopc::VCmpxNeI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7528,6 +7585,7 @@ VCmpxGeI16Vopc::VCmpxGeI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7605,6 +7663,7 @@ VCmpxTI16Vopc::VCmpxTI16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7679,6 +7738,7 @@ VCmpxFU16Vopc::VCmpxFU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7753,6 +7813,7 @@ VCmpxLtU16Vopc::VCmpxLtU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7830,6 +7891,7 @@ VCmpxEqU16Vopc::VCmpxEqU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7907,6 +7969,7 @@ VCmpxLeU16Vopc::VCmpxLeU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7984,6 +8047,7 @@ VCmpxGtU16Vopc::VCmpxGtU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8061,6 +8125,7 @@ VCmpxNeU16Vopc::VCmpxNeU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8138,6 +8203,7 @@ VCmpxGeU16Vopc::VCmpxGeU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8215,6 +8281,7 @@ VCmpxTU16Vopc::VCmpxTU16Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9280,6 +9347,7 @@ VCmpxFI32Vopc::VCmpxFI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9353,6 +9421,7 @@ VCmpxLtI32Vopc::VCmpxLtI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9429,6 +9498,7 @@ VCmpxEqI32Vopc::VCmpxEqI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9505,6 +9575,7 @@ VCmpxLeI32Vopc::VCmpxLeI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9581,6 +9652,7 @@ VCmpxGtI32Vopc::VCmpxGtI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9657,6 +9729,7 @@ VCmpxNeI32Vopc::VCmpxNeI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9733,6 +9806,7 @@ VCmpxGeI32Vopc::VCmpxGeI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9809,6 +9883,7 @@ VCmpxTI32Vopc::VCmpxTI32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9882,6 +9957,7 @@ VCmpxFU32Vopc::VCmpxFU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9955,6 +10031,7 @@ VCmpxLtU32Vopc::VCmpxLtU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10031,6 +10108,7 @@ VCmpxEqU32Vopc::VCmpxEqU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10107,6 +10185,7 @@ VCmpxLeU32Vopc::VCmpxLeU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10183,6 +10262,7 @@ VCmpxGtU32Vopc::VCmpxGtU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10259,6 +10339,7 @@ VCmpxNeU32Vopc::VCmpxNeU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10335,6 +10416,7 @@ VCmpxGeU32Vopc::VCmpxGeU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10411,6 +10493,7 @@ VCmpxTU32Vopc::VCmpxTU32Vopc(const MachineInst *inst) } vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10886,6 +10969,7 @@ VCmpxFI64Vopc::VCmpxFI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10923,6 +11007,7 @@ VCmpxLtI64Vopc::VCmpxLtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10963,6 +11048,7 @@ VCmpxEqI64Vopc::VCmpxEqI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11003,6 +11089,7 @@ VCmpxLeI64Vopc::VCmpxLeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11043,6 +11130,7 @@ VCmpxGtI64Vopc::VCmpxGtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11083,6 +11171,7 @@ VCmpxNeI64Vopc::VCmpxNeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11123,6 +11212,7 @@ VCmpxGeI64Vopc::VCmpxGeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11163,6 +11253,7 @@ VCmpxTI64Vopc::VCmpxTI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_I64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11200,6 +11291,7 @@ VCmpxFU64Vopc::VCmpxFU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11237,6 +11329,7 @@ VCmpxLtU64Vopc::VCmpxLtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11277,6 +11370,7 @@ VCmpxEqU64Vopc::VCmpxEqU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11317,6 +11411,7 @@ VCmpxLeU64Vopc::VCmpxLeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11357,6 +11452,7 @@ VCmpxGtU64Vopc::VCmpxGtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11397,6 +11493,7 @@ VCmpxNeU64Vopc::VCmpxNeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11437,6 +11534,7 @@ VCmpxGeU64Vopc::VCmpxGeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11477,6 +11575,7 @@ VCmpxTU64Vopc::VCmpxTU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_U64 does not support SDWA", ""); vcc.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vopc::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand.cpp index 729e081d2b56..5ebc60bb7110 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand.cpp @@ -5,6 +5,7 @@ // See lib/python/amdisa/README.md for regeneration instructions. #include "rocjitsu/isa/arch/amdgpu/gfx1250/operand.h" +#include "rocjitsu/isa/arch/amdgpu/shared/scalar_static_resolve.h" #include #include #include @@ -93,6 +94,16 @@ std::optional Operand::literal64_value() const { return literal64_value_; } +std::optional Operand::const_value() const { + if (has_literal64_) + return literal64_value_; + if (is_immediate_type(opr_type_)) + return static_cast(static_cast(encoding_value_)); + if (to_register_ref()) + return std::nullopt; + return amdgpu::resolve_src_scalar_statically(encoding_value_); +} + std::string Operand::name() const { if (has_literal64_) return std::format("0x{:x}", literal64_value_); @@ -874,6 +885,8 @@ std::optional Operand::to_register_ref() const { break; } case OperandType::OPR_EXEC: { + if (encoding_value_ == OpSelExec::OPR_EXEC_EXEC) + return RegisterRef{RegClass::EXEC, 0, reg_width}; break; } case OperandType::OPR_GPUMEM: { @@ -888,9 +901,17 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSdst::OPR_SDST_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_EXEC: { + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_M0: { @@ -928,6 +949,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSrc::OPR_SRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrc::OPR_SRC_VGPR_MIN && encoding_value_ <= OpSelSrc::OPR_SRC_VGPR_MAX) return RegisterRef{RegClass::VGPR, @@ -942,6 +967,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcNoinline::OPR_SRC_NOINLINE_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcNoinline::OPR_SRC_NOINLINE_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcNoinline::OPR_SRC_NOINLINE_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcNoinline::OPR_SRC_NOINLINE_VGPR_MIN && encoding_value_ <= OpSelSrcNoinline::OPR_SRC_NOINLINE_VGPR_MAX) return RegisterRef{ @@ -957,6 +986,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcSimple::OPR_SRC_SIMPLE_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcSimple::OPR_SRC_SIMPLE_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcSimple::OPR_SRC_SIMPLE_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcSimple::OPR_SRC_SIMPLE_VGPR_MIN && encoding_value_ <= OpSelSrcSimple::OPR_SRC_SIMPLE_VGPR_MAX) return RegisterRef{ @@ -1005,6 +1038,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrc::OPR_SSRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_BARRIER_ID: { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand.h index 993e54738a71..22fe2d30a119 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand.h @@ -27,6 +27,7 @@ class Operand : public IsaOperand { Operand(int size_bits, OperandType opr_type, uint64_t literal64_value, bool is_literal64); std::string name() const override; std::optional literal64_value() const override; + std::optional const_value() const override; std::optional to_register_ref() const override; /// @brief Return the immutable full-simulator operand table. static const void *full_execution_backend(); diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand_exec.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand_exec.cpp index 802d7970525a..a03149964a5c 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand_exec.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand_exec.cpp @@ -5,6 +5,7 @@ // See lib/python/amdisa/README.md for regeneration instructions. #include "rocjitsu/isa/arch/amdgpu/gfx1250/operand.h" +#include "rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h" #include "rocjitsu/isa/isa_operand_simd_inl.h" #include "rocjitsu/vm/amdgpu/compute_unit.h" #include "rocjitsu/vm/amdgpu/register_access.h" @@ -58,258 +59,12 @@ std::optional packed_16bit_vgpr_dst(bool packed_16bit_dst, i namespace { -uint32_t resolve_src_scalar(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return static_cast(wf.scratch_base()); - if (ev == 103) - return static_cast(wf.scratch_base() >> 32); - if (ev <= 105) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 106) - return static_cast(wf.vcc()); - if (ev == 107) - return static_cast(wf.vcc() >> 32); - if (ev >= 108 && ev <= 123) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 124) - return 0u; // NULL - if (ev == 125) - return wf.m0(); - if (ev == 126) - return static_cast(wf.exec()); - if (ev == 127) - return static_cast(wf.exec_raw() >> 32); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(-(ev - 192))); - if (ev == 230) - return static_cast(wf.scratch_base()); // SRC_FLAT_SCRATCH_BASE_LO - if (ev == 231) - return static_cast(wf.scratch_base() >> 32); // SRC_FLAT_SCRATCH_BASE_HI - if (ev == 240) - return 0x3F000000u; // 0.5f - if (ev == 241) - return 0xBF000000u; // -0.5f - if (ev == 242) - return 0x3F800000u; // 1.0f - if (ev == 243) - return 0xBF800000u; // -1.0f - if (ev == 244) - return 0x40000000u; // 2.0f - if (ev == 245) - return 0xC0000000u; // -2.0f - if (ev == 246) - return 0x40800000u; // 4.0f - if (ev == 247) - return 0xC0800000u; // -4.0f - if (ev == 248) - return 0x3E22F983u; // 1/(2*pi) - if (ev == 235) - return static_cast(wf.shared_aperture_base() >> 32); // SRC_SHARED_BASE - if (ev == 236) - return static_cast(wf.shared_aperture_limit() >> 32); // SRC_SHARED_LIMIT - if (ev == 237) - return static_cast(wf.private_aperture_base() >> 32); // SRC_PRIVATE_BASE - if (ev == 238) - return static_cast(wf.private_aperture_limit() >> 32); // SRC_PRIVATE_LIMIT - if (ev == 249) - return 0u; // SRC_POPS_EXITING_WAVE_ID (not used in compute) - if (ev == 250) - return 0u; // NULL - if (ev == 251) - return (wf.vcc() & (wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL))) == 0 - ? 1u - : 0u; // VCCZ - if (ev == 252) { - uint64_t active = wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL); - return (wf.exec() & active) == 0 ? 1u : 0u; // EXECZ - } - if (ev == 253) - return wf.read_scc() ? 1u : 0u; // SCC - throw std::logic_error("Unsupported encoding value for scalar read: " + std::to_string(ev)); -} - -uint32_t resolve_src_scalar16(const amdgpu::Wavefront &wf, int ev) { - switch (ev) { - case 240: - return 0x3800u; // 0.5h - case 241: - return 0xB800u; // -0.5h - case 242: - return 0x3C00u; // 1.0h - case 243: - return 0xBC00u; // -1.0h - case 244: - return 0x4000u; // 2.0h - case 245: - return 0xC000u; // -2.0h - case 246: - return 0x4400u; // 4.0h - case 247: - return 0xC400u; // -4.0h - case 248: - return 0x3118u; // f16 1/(2*pi) - default: - return resolve_src_scalar(wf, ev); - } -} - -// Must stay in sync with resolve_src_scalar above — returns true for -// exactly the encoding values that resolve_src_scalar handles without -// throwing. Used by Isa::simd_capable_value() to keep the SIMD fast -// path off operands whose scalar broadcast would throw at runtime. -bool can_resolve_src_scalar(int ev) { - return (ev >= 0 && ev <= 107) || (ev >= 108 && ev <= 123) || ev == 124 || ev == 125 || - ev == 126 || ev == 127 || (ev >= 128 && ev <= 208) || ev == 230 || ev == 231 || - (ev >= 235 && ev <= 238) || (ev >= 240 && ev <= 253); -} - -uint64_t resolve_src_scalar64(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return wf.scratch_base(); - if (ev <= 105) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 106) - return wf.vcc(); - if (ev >= 108 && ev <= 122) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 124) - return 0u; // NULL - if (ev == 125) - return wf.m0(); - if (ev == 126) - return wf.exec_raw(); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(static_cast(-(ev - 192)))); - if (ev == 230) - return wf.scratch_base(); // SRC_FLAT_SCRATCH_BASE - if (ev == 240) - return 0x3FE0000000000000ULL; // 0.5 - if (ev == 241) - return 0xBFE0000000000000ULL; // -0.5 - if (ev == 242) - return 0x3FF0000000000000ULL; // 1.0 - if (ev == 243) - return 0xBFF0000000000000ULL; // -1.0 - if (ev == 244) - return 0x4000000000000000ULL; // 2.0 - if (ev == 245) - return 0xC000000000000000ULL; // -2.0 - if (ev == 246) - return 0x4010000000000000ULL; // 4.0 - if (ev == 247) - return 0xC010000000000000ULL; // -4.0 - if (ev == 248) - return 0x3FC45F306DC9C883ULL; // 1/(2*pi) - if (ev == 235) - return wf.shared_aperture_base(); // SRC_SHARED_BASE - if (ev == 236) - return wf.shared_aperture_limit(); // SRC_SHARED_LIMIT - if (ev == 237) - return wf.private_aperture_base(); // SRC_PRIVATE_BASE - if (ev == 238) - return wf.private_aperture_limit(); // SRC_PRIVATE_LIMIT - throw std::logic_error("Unsupported encoding value for scalar64 read: " + std::to_string(ev)); -} - -void resolve_dst_write(amdgpu::Wavefront &wf, int ev, uint32_t val) { - if (ev == 102) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 103) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 106) { - wf.set_vcc((wf.vcc() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 107) { - wf.set_vcc((wf.vcc() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev >= 108 && ev <= 123) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 124) - return; - if (ev == 125) { - wf.set_m0(val); - return; - } - if (ev == 126) { - wf.set_exec((wf.exec() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 127) { - wf.set_exec_raw((wf.exec_raw() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - throw std::logic_error("Unsupported encoding value for scalar write: " + std::to_string(ev)); -} - -void resolve_dst_write64(amdgpu::Wavefront &wf, int ev, uint64_t val) { - if (ev == 102) { - wf.set_scratch_base(val); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 106) { - wf.set_vcc(val); - return; - } - if (ev >= 108 && ev <= 122) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 124) - return; - if (ev == 126) { - wf.set_exec_raw(val); - return; - } - throw std::logic_error("Unsupported encoding value for scalar64 write: " + std::to_string(ev)); -} +constexpr int kM0EncodingValue = 125; bool is_vgpr_only_type(OperandType t) { return t == OperandType::OPR_VGPR || t == OperandType::OPR_SRC_VGPR; } -bool is_immediate_type(OperandType t) { - return t == OperandType::OPR_SIMM16 || t == OperandType::OPR_SIMM32 || - t == OperandType::OPR_SIMM8 || t == OperandType::OPR_SIMM64 || t == OperandType::OPR_LABEL; -} - uint32_t vgpr_index(OperandType opr_type, int ev) { if (opr_type == OperandType::OPR_VGPR) return static_cast(ev); @@ -346,11 +101,12 @@ std::optional Isa::resolved_vgpr_offset(const amdgpu::Wavefront &wf, O bool Isa::simd_capable_value(OperandType opr_type, int ev) { return resolved_vgpr_offset(opr_type, ev).has_value() || is_immediate_type(opr_type) || - can_resolve_src_scalar(ev); + amdgpu::can_resolve_src_scalar(ev, kM0EncodingValue); } uint32_t Isa::simd_broadcast_value(const amdgpu::Wavefront &wf, OperandType opr_type, int ev) { - return is_immediate_type(opr_type) ? static_cast(ev) : resolve_src_scalar(wf, ev); + return is_immediate_type(opr_type) ? static_cast(ev) + : amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } bool Operand::simd_capable_exec() const { @@ -423,7 +179,7 @@ uint32_t Operand::read_scalar_exec(const amdgpu::Wavefront &wf) const { return static_cast(literal64_value_); if (is_immediate_type(opr_type_)) return static_cast(encoding_value_); - return resolve_src_scalar(wf, encoding_value_); + return amdgpu::resolve_src_scalar(wf, encoding_value_, kM0EncodingValue); } uint32_t Operand::read_lane_exec(const amdgpu::Wavefront &wf, uint32_t lane) const { @@ -452,8 +208,8 @@ uint32_t Operand::read_lane_exec(const amdgpu::Wavefront &wf, uint32_t lane) con if (is_immediate_type(opr_type_)) return static_cast(ev); if (size_bits_ == 16) - return resolve_src_scalar16(wf, ev); - return resolve_src_scalar(wf, ev); + return amdgpu::resolve_src_scalar16(wf, ev, kM0EncodingValue); + return amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } void Operand::write_scalar_exec(amdgpu::Wavefront &wf, uint32_t val) const { @@ -463,7 +219,7 @@ void Operand::write_scalar_exec(amdgpu::Wavefront &wf, uint32_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write(wf, encoding_value_, val); + amdgpu::resolve_dst_write(wf, encoding_value_, val, kM0EncodingValue); } void Operand::write_lane_exec(amdgpu::Wavefront &wf, uint32_t lane, uint32_t val) const { @@ -511,7 +267,7 @@ uint64_t Operand::read_lane64_exec(const amdgpu::Wavefront &wf, uint32_t lane) c return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, ev); - return resolve_src_scalar64(wf, ev); + return amdgpu::resolve_src_scalar64(wf, ev, kM0EncodingValue); } void Operand::write_lane64_exec(amdgpu::Wavefront &wf, uint32_t lane, uint64_t val) const { @@ -541,7 +297,7 @@ uint64_t Operand::read_scalar64_exec(const amdgpu::Wavefront &wf) const { return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, encoding_value_); - return resolve_src_scalar64(wf, encoding_value_); + return amdgpu::resolve_src_scalar64(wf, encoding_value_, kM0EncodingValue); } void Operand::write_scalar64_exec(amdgpu::Wavefront &wf, uint64_t val) const { @@ -551,7 +307,7 @@ void Operand::write_scalar64_exec(amdgpu::Wavefront &wf, uint64_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write64(wf, encoding_value_, val); + amdgpu::resolve_dst_write64(wf, encoding_value_, val); } std::optional Operand::simd_vgpr_base_exec(const amdgpu::Wavefront &wf) const { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand_types.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand_types.h index bc2953dd4aba..6780a15e6762 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand_types.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/operand_types.h @@ -465,6 +465,19 @@ enum OpSelVgpr { } } +[[nodiscard]] constexpr bool is_immediate_type(OperandType t) { + switch (t) { + case OperandType::OPR_SIMM8: + case OperandType::OPR_SIMM16: + case OperandType::OPR_SIMM32: + case OperandType::OPR_SIMM64: + case OperandType::OPR_LABEL: + return true; + default: + return false; + } +} + } // namespace gfx1250 } // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/sop1.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/sop1.cpp index 14def2b0646f..c0d9e554900c 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/sop1.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/sop1.cpp @@ -29,6 +29,7 @@ SMovB32Sop1::SMovB32Sop1(const MachineInst *inst) (static_cast(words[literal_word + 1]) << 32) | words[literal_word]; ssrc0 = Operand(32, OperandType::OPR_SIMM64, literal64, true); } + flags_ |= RESULT_COPY; } SMovB64Sop1::SMovB64Sop1(const MachineInst *inst) @@ -50,6 +51,7 @@ SMovB64Sop1::SMovB64Sop1(const MachineInst *inst) (static_cast(words[literal_word + 1]) << 32) | words[literal_word]; ssrc0 = Operand(64, OperandType::OPR_SIMM64, literal64, true); } + flags_ |= RESULT_COPY; } SCmovB32Sop1::SCmovB32Sop1(const MachineInst *inst) @@ -726,6 +728,7 @@ SAndSaveexecB32Sop1::SAndSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SAndSaveexecB64Sop1::SAndSaveexecB64Sop1(const MachineInst *inst) @@ -756,6 +759,7 @@ SAndSaveexecB64Sop1::SAndSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SOrSaveexecB32Sop1::SOrSaveexecB32Sop1(const MachineInst *inst) @@ -786,6 +790,8 @@ SOrSaveexecB32Sop1::SOrSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } SOrSaveexecB64Sop1::SOrSaveexecB64Sop1(const MachineInst *inst) @@ -816,6 +822,8 @@ SOrSaveexecB64Sop1::SOrSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } SXorSaveexecB32Sop1::SXorSaveexecB32Sop1(const MachineInst *inst) @@ -846,6 +854,7 @@ SXorSaveexecB32Sop1::SXorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SXorSaveexecB64Sop1::SXorSaveexecB64Sop1(const MachineInst *inst) @@ -876,6 +885,7 @@ SXorSaveexecB64Sop1::SXorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SNandSaveexecB32Sop1::SNandSaveexecB32Sop1(const MachineInst *inst) @@ -906,6 +916,7 @@ SNandSaveexecB32Sop1::SNandSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SNandSaveexecB64Sop1::SNandSaveexecB64Sop1(const MachineInst *inst) @@ -936,6 +947,7 @@ SNandSaveexecB64Sop1::SNandSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SNorSaveexecB32Sop1::SNorSaveexecB32Sop1(const MachineInst *inst) @@ -966,6 +978,7 @@ SNorSaveexecB32Sop1::SNorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SNorSaveexecB64Sop1::SNorSaveexecB64Sop1(const MachineInst *inst) @@ -996,6 +1009,7 @@ SNorSaveexecB64Sop1::SNorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SXnorSaveexecB32Sop1::SXnorSaveexecB32Sop1(const MachineInst *inst) @@ -1026,6 +1040,7 @@ SXnorSaveexecB32Sop1::SXnorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SXnorSaveexecB64Sop1::SXnorSaveexecB64Sop1(const MachineInst *inst) @@ -1056,6 +1071,7 @@ SXnorSaveexecB64Sop1::SXnorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SAndNot0SaveexecB32Sop1::SAndNot0SaveexecB32Sop1(const MachineInst *inst) @@ -1087,6 +1103,7 @@ SAndNot0SaveexecB32Sop1::SAndNot0SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SAndNot0SaveexecB64Sop1::SAndNot0SaveexecB64Sop1(const MachineInst *inst) @@ -1118,6 +1135,7 @@ SAndNot0SaveexecB64Sop1::SAndNot0SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SOrNot0SaveexecB32Sop1::SOrNot0SaveexecB32Sop1(const MachineInst *inst) @@ -1149,6 +1167,7 @@ SOrNot0SaveexecB32Sop1::SOrNot0SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SOrNot0SaveexecB64Sop1::SOrNot0SaveexecB64Sop1(const MachineInst *inst) @@ -1180,6 +1199,7 @@ SOrNot0SaveexecB64Sop1::SOrNot0SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SAndNot1SaveexecB32Sop1::SAndNot1SaveexecB32Sop1(const MachineInst *inst) @@ -1211,6 +1231,7 @@ SAndNot1SaveexecB32Sop1::SAndNot1SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SAndNot1SaveexecB64Sop1::SAndNot1SaveexecB64Sop1(const MachineInst *inst) @@ -1242,6 +1263,7 @@ SAndNot1SaveexecB64Sop1::SAndNot1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SOrNot1SaveexecB32Sop1::SOrNot1SaveexecB32Sop1(const MachineInst *inst) @@ -1273,6 +1295,7 @@ SOrNot1SaveexecB32Sop1::SOrNot1SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SOrNot1SaveexecB64Sop1::SOrNot1SaveexecB64Sop1(const MachineInst *inst) @@ -1304,6 +1327,7 @@ SOrNot1SaveexecB64Sop1::SOrNot1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SAndNot0WrexecB32Sop1::SAndNot0WrexecB32Sop1(const MachineInst *inst) @@ -1335,6 +1359,7 @@ SAndNot0WrexecB32Sop1::SAndNot0WrexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SAndNot0WrexecB64Sop1::SAndNot0WrexecB64Sop1(const MachineInst *inst) @@ -1366,6 +1391,7 @@ SAndNot0WrexecB64Sop1::SAndNot0WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SAndNot1WrexecB32Sop1::SAndNot1WrexecB32Sop1(const MachineInst *inst) @@ -1397,6 +1423,7 @@ SAndNot1WrexecB32Sop1::SAndNot1WrexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SAndNot1WrexecB64Sop1::SAndNot1WrexecB64Sop1(const MachineInst *inst) @@ -1428,6 +1455,7 @@ SAndNot1WrexecB64Sop1::SAndNot1WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } SMovrelsB32Sop1::SMovrelsB32Sop1(const MachineInst *inst) diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/sop2.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/sop2.cpp index 38e57847b2fb..7a09b901308c 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/sop2.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/sop2.cpp @@ -902,6 +902,7 @@ SOrB32Sop2::SOrB32Sop2(const MachineInst *inst) ssrc1 = Operand(32, OperandType::OPR_SIMM64, literal64, true); } scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } SOrB64Sop2::SOrB64Sop2(const MachineInst *inst) @@ -939,6 +940,7 @@ SOrB64Sop2::SOrB64Sop2(const MachineInst *inst) ssrc1 = Operand(64, OperandType::OPR_SIMM64, literal64, true); } scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } SXorB32Sop2::SXorB32Sop2(const MachineInst *inst) diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/sopp.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/sopp.cpp index cfdc6c4dfd68..bd0db45057b2 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/sopp.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/sopp.cpp @@ -138,6 +138,7 @@ SBranchSopp::SBranchSopp(const MachineInst *inst) num_src_ = 1; num_dst_ = 0; flags_ |= BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SBranchSopp::branch_offset_bytes() const { @@ -155,6 +156,7 @@ SCbranchScc0Sopp::SCbranchScc0Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc0Sopp::branch_offset_bytes() const { @@ -172,6 +174,7 @@ SCbranchScc1Sopp::SCbranchScc1Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc1Sopp::branch_offset_bytes() const { @@ -189,6 +192,7 @@ SCbranchVcczSopp::SCbranchVcczSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVcczSopp::branch_offset_bytes() const { @@ -206,6 +210,7 @@ SCbranchVccnzSopp::SCbranchVccnzSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVccnzSopp::branch_offset_bytes() const { @@ -223,6 +228,7 @@ SCbranchExeczSopp::SCbranchExeczSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExeczSopp::branch_offset_bytes() const { @@ -240,6 +246,7 @@ SCbranchExecnzSopp::SCbranchExecnzSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExecnzSopp::branch_offset_bytes() const { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vop3.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vop3.h index 4ce6f9562652..eda2ae7ddfe5 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vop3.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vop3.h @@ -3339,6 +3339,7 @@ class VWritelaneB32Vop3 : public Vop3 { public: VWritelaneB32Vop3(const MachineInst *inst); void execute_impl(amdgpu::Wavefront &wf); + void implicit_uses(RegisterSet &uses) const override; Operand vdst; Operand src0; Operand src1; diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vop3_cmp.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vop3_cmp.cpp index 77b692df92da..d009e55727a6 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vop3_cmp.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vop3_cmp.cpp @@ -4262,6 +4262,7 @@ VCmpxLtF16Vop3::VCmpxLtF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqF16Vop3::VCmpxEqF16Vop3(const MachineInst *inst) @@ -4326,6 +4327,7 @@ VCmpxEqF16Vop3::VCmpxEqF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeF16Vop3::VCmpxLeF16Vop3(const MachineInst *inst) @@ -4390,6 +4392,7 @@ VCmpxLeF16Vop3::VCmpxLeF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtF16Vop3::VCmpxGtF16Vop3(const MachineInst *inst) @@ -4454,6 +4457,7 @@ VCmpxGtF16Vop3::VCmpxGtF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLgF16Vop3::VCmpxLgF16Vop3(const MachineInst *inst) @@ -4518,6 +4522,7 @@ VCmpxLgF16Vop3::VCmpxLgF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeF16Vop3::VCmpxGeF16Vop3(const MachineInst *inst) @@ -4582,6 +4587,7 @@ VCmpxGeF16Vop3::VCmpxGeF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxOF16Vop3::VCmpxOF16Vop3(const MachineInst *inst) @@ -4646,6 +4652,7 @@ VCmpxOF16Vop3::VCmpxOF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxUF16Vop3::VCmpxUF16Vop3(const MachineInst *inst) @@ -4710,6 +4717,7 @@ VCmpxUF16Vop3::VCmpxUF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNgeF16Vop3::VCmpxNgeF16Vop3(const MachineInst *inst) @@ -4774,6 +4782,7 @@ VCmpxNgeF16Vop3::VCmpxNgeF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNlgF16Vop3::VCmpxNlgF16Vop3(const MachineInst *inst) @@ -4838,6 +4847,7 @@ VCmpxNlgF16Vop3::VCmpxNlgF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNgtF16Vop3::VCmpxNgtF16Vop3(const MachineInst *inst) @@ -4902,6 +4912,7 @@ VCmpxNgtF16Vop3::VCmpxNgtF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNleF16Vop3::VCmpxNleF16Vop3(const MachineInst *inst) @@ -4966,6 +4977,7 @@ VCmpxNleF16Vop3::VCmpxNleF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeqF16Vop3::VCmpxNeqF16Vop3(const MachineInst *inst) @@ -5030,6 +5042,7 @@ VCmpxNeqF16Vop3::VCmpxNeqF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNltF16Vop3::VCmpxNltF16Vop3(const MachineInst *inst) @@ -5094,6 +5107,7 @@ VCmpxNltF16Vop3::VCmpxNltF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtF32Vop3::VCmpxLtF32Vop3(const MachineInst *inst) @@ -5150,6 +5164,7 @@ VCmpxLtF32Vop3::VCmpxLtF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqF32Vop3::VCmpxEqF32Vop3(const MachineInst *inst) @@ -5206,6 +5221,7 @@ VCmpxEqF32Vop3::VCmpxEqF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeF32Vop3::VCmpxLeF32Vop3(const MachineInst *inst) @@ -5262,6 +5278,7 @@ VCmpxLeF32Vop3::VCmpxLeF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtF32Vop3::VCmpxGtF32Vop3(const MachineInst *inst) @@ -5318,6 +5335,7 @@ VCmpxGtF32Vop3::VCmpxGtF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLgF32Vop3::VCmpxLgF32Vop3(const MachineInst *inst) @@ -5374,6 +5392,7 @@ VCmpxLgF32Vop3::VCmpxLgF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeF32Vop3::VCmpxGeF32Vop3(const MachineInst *inst) @@ -5430,6 +5449,7 @@ VCmpxGeF32Vop3::VCmpxGeF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxOF32Vop3::VCmpxOF32Vop3(const MachineInst *inst) @@ -5486,6 +5506,7 @@ VCmpxOF32Vop3::VCmpxOF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxUF32Vop3::VCmpxUF32Vop3(const MachineInst *inst) @@ -5542,6 +5563,7 @@ VCmpxUF32Vop3::VCmpxUF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNgeF32Vop3::VCmpxNgeF32Vop3(const MachineInst *inst) @@ -5598,6 +5620,7 @@ VCmpxNgeF32Vop3::VCmpxNgeF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNlgF32Vop3::VCmpxNlgF32Vop3(const MachineInst *inst) @@ -5654,6 +5677,7 @@ VCmpxNlgF32Vop3::VCmpxNlgF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNgtF32Vop3::VCmpxNgtF32Vop3(const MachineInst *inst) @@ -5710,6 +5734,7 @@ VCmpxNgtF32Vop3::VCmpxNgtF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNleF32Vop3::VCmpxNleF32Vop3(const MachineInst *inst) @@ -5766,6 +5791,7 @@ VCmpxNleF32Vop3::VCmpxNleF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeqF32Vop3::VCmpxNeqF32Vop3(const MachineInst *inst) @@ -5822,6 +5848,7 @@ VCmpxNeqF32Vop3::VCmpxNeqF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNltF32Vop3::VCmpxNltF32Vop3(const MachineInst *inst) @@ -5878,6 +5905,7 @@ VCmpxNltF32Vop3::VCmpxNltF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtF64Vop3::VCmpxLtF64Vop3(const MachineInst *inst) @@ -5924,6 +5952,7 @@ VCmpxLtF64Vop3::VCmpxLtF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqF64Vop3::VCmpxEqF64Vop3(const MachineInst *inst) @@ -5970,6 +5999,7 @@ VCmpxEqF64Vop3::VCmpxEqF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeF64Vop3::VCmpxLeF64Vop3(const MachineInst *inst) @@ -6016,6 +6046,7 @@ VCmpxLeF64Vop3::VCmpxLeF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtF64Vop3::VCmpxGtF64Vop3(const MachineInst *inst) @@ -6062,6 +6093,7 @@ VCmpxGtF64Vop3::VCmpxGtF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLgF64Vop3::VCmpxLgF64Vop3(const MachineInst *inst) @@ -6108,6 +6140,7 @@ VCmpxLgF64Vop3::VCmpxLgF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeF64Vop3::VCmpxGeF64Vop3(const MachineInst *inst) @@ -6154,6 +6187,7 @@ VCmpxGeF64Vop3::VCmpxGeF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxOF64Vop3::VCmpxOF64Vop3(const MachineInst *inst) @@ -6200,6 +6234,7 @@ VCmpxOF64Vop3::VCmpxOF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxUF64Vop3::VCmpxUF64Vop3(const MachineInst *inst) @@ -6246,6 +6281,7 @@ VCmpxUF64Vop3::VCmpxUF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNgeF64Vop3::VCmpxNgeF64Vop3(const MachineInst *inst) @@ -6292,6 +6328,7 @@ VCmpxNgeF64Vop3::VCmpxNgeF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNlgF64Vop3::VCmpxNlgF64Vop3(const MachineInst *inst) @@ -6338,6 +6375,7 @@ VCmpxNlgF64Vop3::VCmpxNlgF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNgtF64Vop3::VCmpxNgtF64Vop3(const MachineInst *inst) @@ -6384,6 +6422,7 @@ VCmpxNgtF64Vop3::VCmpxNgtF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNleF64Vop3::VCmpxNleF64Vop3(const MachineInst *inst) @@ -6430,6 +6469,7 @@ VCmpxNleF64Vop3::VCmpxNleF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeqF64Vop3::VCmpxNeqF64Vop3(const MachineInst *inst) @@ -6476,6 +6516,7 @@ VCmpxNeqF64Vop3::VCmpxNeqF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNltF64Vop3::VCmpxNltF64Vop3(const MachineInst *inst) @@ -6522,6 +6563,7 @@ VCmpxNltF64Vop3::VCmpxNltF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtI16Vop3::VCmpxLtI16Vop3(const MachineInst *inst) @@ -6586,6 +6628,7 @@ VCmpxLtI16Vop3::VCmpxLtI16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqI16Vop3::VCmpxEqI16Vop3(const MachineInst *inst) @@ -6650,6 +6693,7 @@ VCmpxEqI16Vop3::VCmpxEqI16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeI16Vop3::VCmpxLeI16Vop3(const MachineInst *inst) @@ -6714,6 +6758,7 @@ VCmpxLeI16Vop3::VCmpxLeI16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtI16Vop3::VCmpxGtI16Vop3(const MachineInst *inst) @@ -6778,6 +6823,7 @@ VCmpxGtI16Vop3::VCmpxGtI16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeI16Vop3::VCmpxNeI16Vop3(const MachineInst *inst) @@ -6842,6 +6888,7 @@ VCmpxNeI16Vop3::VCmpxNeI16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeI16Vop3::VCmpxGeI16Vop3(const MachineInst *inst) @@ -6906,6 +6953,7 @@ VCmpxGeI16Vop3::VCmpxGeI16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtU16Vop3::VCmpxLtU16Vop3(const MachineInst *inst) @@ -6970,6 +7018,7 @@ VCmpxLtU16Vop3::VCmpxLtU16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqU16Vop3::VCmpxEqU16Vop3(const MachineInst *inst) @@ -7034,6 +7083,7 @@ VCmpxEqU16Vop3::VCmpxEqU16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeU16Vop3::VCmpxLeU16Vop3(const MachineInst *inst) @@ -7098,6 +7148,7 @@ VCmpxLeU16Vop3::VCmpxLeU16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtU16Vop3::VCmpxGtU16Vop3(const MachineInst *inst) @@ -7162,6 +7213,7 @@ VCmpxGtU16Vop3::VCmpxGtU16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeU16Vop3::VCmpxNeU16Vop3(const MachineInst *inst) @@ -7226,6 +7278,7 @@ VCmpxNeU16Vop3::VCmpxNeU16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeU16Vop3::VCmpxGeU16Vop3(const MachineInst *inst) @@ -7290,6 +7343,7 @@ VCmpxGeU16Vop3::VCmpxGeU16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtI32Vop3::VCmpxLtI32Vop3(const MachineInst *inst) @@ -7346,6 +7400,7 @@ VCmpxLtI32Vop3::VCmpxLtI32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqI32Vop3::VCmpxEqI32Vop3(const MachineInst *inst) @@ -7402,6 +7457,7 @@ VCmpxEqI32Vop3::VCmpxEqI32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeI32Vop3::VCmpxLeI32Vop3(const MachineInst *inst) @@ -7458,6 +7514,7 @@ VCmpxLeI32Vop3::VCmpxLeI32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtI32Vop3::VCmpxGtI32Vop3(const MachineInst *inst) @@ -7514,6 +7571,7 @@ VCmpxGtI32Vop3::VCmpxGtI32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeI32Vop3::VCmpxNeI32Vop3(const MachineInst *inst) @@ -7570,6 +7628,7 @@ VCmpxNeI32Vop3::VCmpxNeI32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeI32Vop3::VCmpxGeI32Vop3(const MachineInst *inst) @@ -7626,6 +7685,7 @@ VCmpxGeI32Vop3::VCmpxGeI32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtU32Vop3::VCmpxLtU32Vop3(const MachineInst *inst) @@ -7682,6 +7742,7 @@ VCmpxLtU32Vop3::VCmpxLtU32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqU32Vop3::VCmpxEqU32Vop3(const MachineInst *inst) @@ -7738,6 +7799,7 @@ VCmpxEqU32Vop3::VCmpxEqU32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeU32Vop3::VCmpxLeU32Vop3(const MachineInst *inst) @@ -7794,6 +7856,7 @@ VCmpxLeU32Vop3::VCmpxLeU32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtU32Vop3::VCmpxGtU32Vop3(const MachineInst *inst) @@ -7850,6 +7913,7 @@ VCmpxGtU32Vop3::VCmpxGtU32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeU32Vop3::VCmpxNeU32Vop3(const MachineInst *inst) @@ -7906,6 +7970,7 @@ VCmpxNeU32Vop3::VCmpxNeU32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeU32Vop3::VCmpxGeU32Vop3(const MachineInst *inst) @@ -7962,6 +8027,7 @@ VCmpxGeU32Vop3::VCmpxGeU32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtI64Vop3::VCmpxLtI64Vop3(const MachineInst *inst) @@ -8004,6 +8070,7 @@ VCmpxLtI64Vop3::VCmpxLtI64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqI64Vop3::VCmpxEqI64Vop3(const MachineInst *inst) @@ -8046,6 +8113,7 @@ VCmpxEqI64Vop3::VCmpxEqI64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeI64Vop3::VCmpxLeI64Vop3(const MachineInst *inst) @@ -8088,6 +8156,7 @@ VCmpxLeI64Vop3::VCmpxLeI64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtI64Vop3::VCmpxGtI64Vop3(const MachineInst *inst) @@ -8130,6 +8199,7 @@ VCmpxGtI64Vop3::VCmpxGtI64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeI64Vop3::VCmpxNeI64Vop3(const MachineInst *inst) @@ -8172,6 +8242,7 @@ VCmpxNeI64Vop3::VCmpxNeI64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeI64Vop3::VCmpxGeI64Vop3(const MachineInst *inst) @@ -8214,6 +8285,7 @@ VCmpxGeI64Vop3::VCmpxGeI64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtU64Vop3::VCmpxLtU64Vop3(const MachineInst *inst) @@ -8256,6 +8328,7 @@ VCmpxLtU64Vop3::VCmpxLtU64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqU64Vop3::VCmpxEqU64Vop3(const MachineInst *inst) @@ -8298,6 +8371,7 @@ VCmpxEqU64Vop3::VCmpxEqU64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeU64Vop3::VCmpxLeU64Vop3(const MachineInst *inst) @@ -8340,6 +8414,7 @@ VCmpxLeU64Vop3::VCmpxLeU64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtU64Vop3::VCmpxGtU64Vop3(const MachineInst *inst) @@ -8382,6 +8457,7 @@ VCmpxGtU64Vop3::VCmpxGtU64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeU64Vop3::VCmpxNeU64Vop3(const MachineInst *inst) @@ -8424,6 +8500,7 @@ VCmpxNeU64Vop3::VCmpxNeU64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeU64Vop3::VCmpxGeU64Vop3(const MachineInst *inst) @@ -8466,6 +8543,7 @@ VCmpxGeU64Vop3::VCmpxGeU64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxClassF16Vop3::VCmpxClassF16Vop3(const MachineInst *inst) @@ -8530,6 +8608,7 @@ VCmpxClassF16Vop3::VCmpxClassF16Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxClassF32Vop3::VCmpxClassF32Vop3(const MachineInst *inst) @@ -8586,6 +8665,7 @@ VCmpxClassF32Vop3::VCmpxClassF32Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxClassF64Vop3::VCmpxClassF64Vop3(const MachineInst *inst) @@ -8630,6 +8710,7 @@ VCmpxClassF64Vop3::VCmpxClassF64Vop3(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); src1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } } // namespace gfx1250 diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vop3_data.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vop3_data.cpp index 9a72a06cec2f..1cf89738fd31 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vop3_data.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vop3_data.cpp @@ -1452,5 +1452,11 @@ VWritelaneB32Vop3::VWritelaneB32Vop3(const MachineInst *inst) vdst.set_vgpr_msb_role(amdgpu::VgprMsbRole::Dst); } +void VWritelaneB32Vop3::implicit_uses(RegisterSet &uses) const { + Vop3::implicit_uses(uses); + if (auto r = vdst.to_register_ref()) + uses.expand(*r); +} + } // namespace gfx1250 } // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vopc_cmpx.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vopc_cmpx.cpp index 6ebfca81981a..b2aa91e6bbcb 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vopc_cmpx.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/gfx1250/vopc_cmpx.cpp @@ -58,6 +58,7 @@ VCmpxLtF16Vopc::VCmpxLtF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqF16Vopc::VCmpxEqF16Vopc(const MachineInst *inst) @@ -107,6 +108,7 @@ VCmpxEqF16Vopc::VCmpxEqF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeF16Vopc::VCmpxLeF16Vopc(const MachineInst *inst) @@ -156,6 +158,7 @@ VCmpxLeF16Vopc::VCmpxLeF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtF16Vopc::VCmpxGtF16Vopc(const MachineInst *inst) @@ -205,6 +208,7 @@ VCmpxGtF16Vopc::VCmpxGtF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLgF16Vopc::VCmpxLgF16Vopc(const MachineInst *inst) @@ -254,6 +258,7 @@ VCmpxLgF16Vopc::VCmpxLgF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeF16Vopc::VCmpxGeF16Vopc(const MachineInst *inst) @@ -303,6 +308,7 @@ VCmpxGeF16Vopc::VCmpxGeF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxOF16Vopc::VCmpxOF16Vopc(const MachineInst *inst) @@ -352,6 +358,7 @@ VCmpxOF16Vopc::VCmpxOF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxUF16Vopc::VCmpxUF16Vopc(const MachineInst *inst) @@ -401,6 +408,7 @@ VCmpxUF16Vopc::VCmpxUF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNgeF16Vopc::VCmpxNgeF16Vopc(const MachineInst *inst) @@ -450,6 +458,7 @@ VCmpxNgeF16Vopc::VCmpxNgeF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNlgF16Vopc::VCmpxNlgF16Vopc(const MachineInst *inst) @@ -499,6 +508,7 @@ VCmpxNlgF16Vopc::VCmpxNlgF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNgtF16Vopc::VCmpxNgtF16Vopc(const MachineInst *inst) @@ -548,6 +558,7 @@ VCmpxNgtF16Vopc::VCmpxNgtF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNleF16Vopc::VCmpxNleF16Vopc(const MachineInst *inst) @@ -597,6 +608,7 @@ VCmpxNleF16Vopc::VCmpxNleF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeqF16Vopc::VCmpxNeqF16Vopc(const MachineInst *inst) @@ -646,6 +658,7 @@ VCmpxNeqF16Vopc::VCmpxNeqF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNltF16Vopc::VCmpxNltF16Vopc(const MachineInst *inst) @@ -695,6 +708,7 @@ VCmpxNltF16Vopc::VCmpxNltF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtF32Vopc::VCmpxLtF32Vopc(const MachineInst *inst) @@ -741,6 +755,7 @@ VCmpxLtF32Vopc::VCmpxLtF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqF32Vopc::VCmpxEqF32Vopc(const MachineInst *inst) @@ -787,6 +802,7 @@ VCmpxEqF32Vopc::VCmpxEqF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeF32Vopc::VCmpxLeF32Vopc(const MachineInst *inst) @@ -833,6 +849,7 @@ VCmpxLeF32Vopc::VCmpxLeF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtF32Vopc::VCmpxGtF32Vopc(const MachineInst *inst) @@ -879,6 +896,7 @@ VCmpxGtF32Vopc::VCmpxGtF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLgF32Vopc::VCmpxLgF32Vopc(const MachineInst *inst) @@ -925,6 +943,7 @@ VCmpxLgF32Vopc::VCmpxLgF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeF32Vopc::VCmpxGeF32Vopc(const MachineInst *inst) @@ -971,6 +990,7 @@ VCmpxGeF32Vopc::VCmpxGeF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxOF32Vopc::VCmpxOF32Vopc(const MachineInst *inst) @@ -1017,6 +1037,7 @@ VCmpxOF32Vopc::VCmpxOF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxUF32Vopc::VCmpxUF32Vopc(const MachineInst *inst) @@ -1063,6 +1084,7 @@ VCmpxUF32Vopc::VCmpxUF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNgeF32Vopc::VCmpxNgeF32Vopc(const MachineInst *inst) @@ -1109,6 +1131,7 @@ VCmpxNgeF32Vopc::VCmpxNgeF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNlgF32Vopc::VCmpxNlgF32Vopc(const MachineInst *inst) @@ -1155,6 +1178,7 @@ VCmpxNlgF32Vopc::VCmpxNlgF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNgtF32Vopc::VCmpxNgtF32Vopc(const MachineInst *inst) @@ -1201,6 +1225,7 @@ VCmpxNgtF32Vopc::VCmpxNgtF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNleF32Vopc::VCmpxNleF32Vopc(const MachineInst *inst) @@ -1247,6 +1272,7 @@ VCmpxNleF32Vopc::VCmpxNleF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeqF32Vopc::VCmpxNeqF32Vopc(const MachineInst *inst) @@ -1293,6 +1319,7 @@ VCmpxNeqF32Vopc::VCmpxNeqF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNltF32Vopc::VCmpxNltF32Vopc(const MachineInst *inst) @@ -1339,6 +1366,7 @@ VCmpxNltF32Vopc::VCmpxNltF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtF64Vopc::VCmpxLtF64Vopc(const MachineInst *inst) @@ -1373,6 +1401,7 @@ VCmpxLtF64Vopc::VCmpxLtF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqF64Vopc::VCmpxEqF64Vopc(const MachineInst *inst) @@ -1407,6 +1436,7 @@ VCmpxEqF64Vopc::VCmpxEqF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeF64Vopc::VCmpxLeF64Vopc(const MachineInst *inst) @@ -1441,6 +1471,7 @@ VCmpxLeF64Vopc::VCmpxLeF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtF64Vopc::VCmpxGtF64Vopc(const MachineInst *inst) @@ -1475,6 +1506,7 @@ VCmpxGtF64Vopc::VCmpxGtF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLgF64Vopc::VCmpxLgF64Vopc(const MachineInst *inst) @@ -1509,6 +1541,7 @@ VCmpxLgF64Vopc::VCmpxLgF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeF64Vopc::VCmpxGeF64Vopc(const MachineInst *inst) @@ -1543,6 +1576,7 @@ VCmpxGeF64Vopc::VCmpxGeF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxOF64Vopc::VCmpxOF64Vopc(const MachineInst *inst) @@ -1577,6 +1611,7 @@ VCmpxOF64Vopc::VCmpxOF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxUF64Vopc::VCmpxUF64Vopc(const MachineInst *inst) @@ -1611,6 +1646,7 @@ VCmpxUF64Vopc::VCmpxUF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNgeF64Vopc::VCmpxNgeF64Vopc(const MachineInst *inst) @@ -1645,6 +1681,7 @@ VCmpxNgeF64Vopc::VCmpxNgeF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNlgF64Vopc::VCmpxNlgF64Vopc(const MachineInst *inst) @@ -1679,6 +1716,7 @@ VCmpxNlgF64Vopc::VCmpxNlgF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNgtF64Vopc::VCmpxNgtF64Vopc(const MachineInst *inst) @@ -1713,6 +1751,7 @@ VCmpxNgtF64Vopc::VCmpxNgtF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNleF64Vopc::VCmpxNleF64Vopc(const MachineInst *inst) @@ -1747,6 +1786,7 @@ VCmpxNleF64Vopc::VCmpxNleF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeqF64Vopc::VCmpxNeqF64Vopc(const MachineInst *inst) @@ -1781,6 +1821,7 @@ VCmpxNeqF64Vopc::VCmpxNeqF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNltF64Vopc::VCmpxNltF64Vopc(const MachineInst *inst) @@ -1815,6 +1856,7 @@ VCmpxNltF64Vopc::VCmpxNltF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtI16Vopc::VCmpxLtI16Vopc(const MachineInst *inst) @@ -1864,6 +1906,7 @@ VCmpxLtI16Vopc::VCmpxLtI16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqI16Vopc::VCmpxEqI16Vopc(const MachineInst *inst) @@ -1913,6 +1956,7 @@ VCmpxEqI16Vopc::VCmpxEqI16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeI16Vopc::VCmpxLeI16Vopc(const MachineInst *inst) @@ -1962,6 +2006,7 @@ VCmpxLeI16Vopc::VCmpxLeI16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtI16Vopc::VCmpxGtI16Vopc(const MachineInst *inst) @@ -2011,6 +2056,7 @@ VCmpxGtI16Vopc::VCmpxGtI16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeI16Vopc::VCmpxNeI16Vopc(const MachineInst *inst) @@ -2060,6 +2106,7 @@ VCmpxNeI16Vopc::VCmpxNeI16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeI16Vopc::VCmpxGeI16Vopc(const MachineInst *inst) @@ -2109,6 +2156,7 @@ VCmpxGeI16Vopc::VCmpxGeI16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtU16Vopc::VCmpxLtU16Vopc(const MachineInst *inst) @@ -2158,6 +2206,7 @@ VCmpxLtU16Vopc::VCmpxLtU16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqU16Vopc::VCmpxEqU16Vopc(const MachineInst *inst) @@ -2207,6 +2256,7 @@ VCmpxEqU16Vopc::VCmpxEqU16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeU16Vopc::VCmpxLeU16Vopc(const MachineInst *inst) @@ -2256,6 +2306,7 @@ VCmpxLeU16Vopc::VCmpxLeU16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtU16Vopc::VCmpxGtU16Vopc(const MachineInst *inst) @@ -2305,6 +2356,7 @@ VCmpxGtU16Vopc::VCmpxGtU16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeU16Vopc::VCmpxNeU16Vopc(const MachineInst *inst) @@ -2354,6 +2406,7 @@ VCmpxNeU16Vopc::VCmpxNeU16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeU16Vopc::VCmpxGeU16Vopc(const MachineInst *inst) @@ -2403,6 +2456,7 @@ VCmpxGeU16Vopc::VCmpxGeU16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtI32Vopc::VCmpxLtI32Vopc(const MachineInst *inst) @@ -2449,6 +2503,7 @@ VCmpxLtI32Vopc::VCmpxLtI32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqI32Vopc::VCmpxEqI32Vopc(const MachineInst *inst) @@ -2495,6 +2550,7 @@ VCmpxEqI32Vopc::VCmpxEqI32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeI32Vopc::VCmpxLeI32Vopc(const MachineInst *inst) @@ -2541,6 +2597,7 @@ VCmpxLeI32Vopc::VCmpxLeI32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtI32Vopc::VCmpxGtI32Vopc(const MachineInst *inst) @@ -2587,6 +2644,7 @@ VCmpxGtI32Vopc::VCmpxGtI32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeI32Vopc::VCmpxNeI32Vopc(const MachineInst *inst) @@ -2633,6 +2691,7 @@ VCmpxNeI32Vopc::VCmpxNeI32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeI32Vopc::VCmpxGeI32Vopc(const MachineInst *inst) @@ -2679,6 +2738,7 @@ VCmpxGeI32Vopc::VCmpxGeI32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtU32Vopc::VCmpxLtU32Vopc(const MachineInst *inst) @@ -2725,6 +2785,7 @@ VCmpxLtU32Vopc::VCmpxLtU32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqU32Vopc::VCmpxEqU32Vopc(const MachineInst *inst) @@ -2771,6 +2832,7 @@ VCmpxEqU32Vopc::VCmpxEqU32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeU32Vopc::VCmpxLeU32Vopc(const MachineInst *inst) @@ -2817,6 +2879,7 @@ VCmpxLeU32Vopc::VCmpxLeU32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtU32Vopc::VCmpxGtU32Vopc(const MachineInst *inst) @@ -2863,6 +2926,7 @@ VCmpxGtU32Vopc::VCmpxGtU32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeU32Vopc::VCmpxNeU32Vopc(const MachineInst *inst) @@ -2909,6 +2973,7 @@ VCmpxNeU32Vopc::VCmpxNeU32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeU32Vopc::VCmpxGeU32Vopc(const MachineInst *inst) @@ -2955,6 +3020,7 @@ VCmpxGeU32Vopc::VCmpxGeU32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtI64Vopc::VCmpxLtI64Vopc(const MachineInst *inst) @@ -2987,6 +3053,7 @@ VCmpxLtI64Vopc::VCmpxLtI64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqI64Vopc::VCmpxEqI64Vopc(const MachineInst *inst) @@ -3019,6 +3086,7 @@ VCmpxEqI64Vopc::VCmpxEqI64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeI64Vopc::VCmpxLeI64Vopc(const MachineInst *inst) @@ -3051,6 +3119,7 @@ VCmpxLeI64Vopc::VCmpxLeI64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtI64Vopc::VCmpxGtI64Vopc(const MachineInst *inst) @@ -3083,6 +3152,7 @@ VCmpxGtI64Vopc::VCmpxGtI64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeI64Vopc::VCmpxNeI64Vopc(const MachineInst *inst) @@ -3115,6 +3185,7 @@ VCmpxNeI64Vopc::VCmpxNeI64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeI64Vopc::VCmpxGeI64Vopc(const MachineInst *inst) @@ -3147,6 +3218,7 @@ VCmpxGeI64Vopc::VCmpxGeI64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLtU64Vopc::VCmpxLtU64Vopc(const MachineInst *inst) @@ -3179,6 +3251,7 @@ VCmpxLtU64Vopc::VCmpxLtU64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxEqU64Vopc::VCmpxEqU64Vopc(const MachineInst *inst) @@ -3211,6 +3284,7 @@ VCmpxEqU64Vopc::VCmpxEqU64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxLeU64Vopc::VCmpxLeU64Vopc(const MachineInst *inst) @@ -3243,6 +3317,7 @@ VCmpxLeU64Vopc::VCmpxLeU64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGtU64Vopc::VCmpxGtU64Vopc(const MachineInst *inst) @@ -3275,6 +3350,7 @@ VCmpxGtU64Vopc::VCmpxGtU64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxNeU64Vopc::VCmpxNeU64Vopc(const MachineInst *inst) @@ -3307,6 +3383,7 @@ VCmpxNeU64Vopc::VCmpxNeU64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxGeU64Vopc::VCmpxGeU64Vopc(const MachineInst *inst) @@ -3339,6 +3416,7 @@ VCmpxGeU64Vopc::VCmpxGeU64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxClassF16Vopc::VCmpxClassF16Vopc(const MachineInst *inst) @@ -3389,6 +3467,7 @@ VCmpxClassF16Vopc::VCmpxClassF16Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxClassF32Vopc::VCmpxClassF32Vopc(const MachineInst *inst) @@ -3436,6 +3515,7 @@ VCmpxClassF32Vopc::VCmpxClassF32Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } VCmpxClassF64Vopc::VCmpxClassF64Vopc(const MachineInst *inst) @@ -3471,6 +3551,7 @@ VCmpxClassF64Vopc::VCmpxClassF64Vopc(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); src0.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src0); vsrc1.set_vgpr_msb_role(amdgpu::VgprMsbRole::Src1); + flags_ |= WRITES_EXEC; } } // namespace gfx1250 diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/operand.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/operand.cpp index 1b5dc9b8b41d..679282fcec2e 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/operand.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/operand.cpp @@ -5,6 +5,7 @@ // See lib/python/amdisa/README.md for regeneration instructions. #include "rocjitsu/isa/arch/amdgpu/rdna1/operand.h" +#include "rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h" #include "rocjitsu/isa/isa_operand_simd_inl.h" #include "rocjitsu/vm/amdgpu/compute_unit.h" #include "rocjitsu/vm/amdgpu/register_access.h" @@ -52,6 +53,16 @@ std::optional Operand::literal64_value() const { return literal64_value_; } +std::optional Operand::const_value() const { + if (has_literal64_) + return literal64_value_; + if (is_immediate_type(opr_type_)) + return static_cast(static_cast(encoding_value_)); + if (to_register_ref()) + return std::nullopt; + return amdgpu::resolve_src_scalar_statically(encoding_value_); +} + std::string Operand::name() const { if (has_literal64_) return std::format("0x{:x}", literal64_value_); @@ -956,6 +967,8 @@ std::optional Operand::to_register_ref() const { break; } case OperandType::OPR_EXEC: { + if (encoding_value_ == OpSelExec::OPR_EXEC_EXEC) + return RegisterRef{RegClass::EXEC, 0, reg_width}; break; } case OperandType::OPR_FLAT_SCRATCH: { @@ -973,9 +986,17 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSdst::OPR_SDST_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_EXEC: { + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_M0: { @@ -999,6 +1020,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSrc::OPR_SRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrc::OPR_SRC_VGPR_MIN && encoding_value_ <= OpSelSrc::OPR_SRC_VGPR_MAX) return RegisterRef{RegClass::VGPR, @@ -1013,6 +1038,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcNolds::OPR_SRC_NOLDS_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcNolds::OPR_SRC_NOLDS_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcNolds::OPR_SRC_NOLDS_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcNolds::OPR_SRC_NOLDS_VGPR_MIN && encoding_value_ <= OpSelSrcNolds::OPR_SRC_NOLDS_VGPR_MAX) return RegisterRef{ @@ -1028,6 +1057,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcSimple::OPR_SRC_SIMPLE_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcSimple::OPR_SRC_SIMPLE_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcSimple::OPR_SRC_SIMPLE_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcSimple::OPR_SRC_SIMPLE_VGPR_MIN && encoding_value_ <= OpSelSrcSimple::OPR_SRC_SIMPLE_VGPR_MAX) return RegisterRef{ @@ -1076,6 +1109,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrc::OPR_SSRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_LANESEL: { @@ -1094,6 +1131,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrcNolds::OPR_SSRC_NOLDS_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrcNolds::OPR_SSRC_NOLDS_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrcNolds::OPR_SSRC_NOLDS_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_SPECIAL_SCC: { @@ -1130,254 +1171,13 @@ std::optional Operand::to_register_ref() const { namespace { -uint32_t resolve_src_scalar(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return static_cast(wf.scratch_base()); - if (ev == 103) - return static_cast(wf.scratch_base() >> 32); - if (ev <= 105) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 106) - return static_cast(wf.vcc()); - if (ev == 107) - return static_cast(wf.vcc() >> 32); - if (ev >= 108 && ev <= 123) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 124) - return wf.m0(); - if (ev == 126) - return static_cast(wf.exec()); - if (ev == 127) - return static_cast(wf.exec_raw() >> 32); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(-(ev - 192))); - if (ev == 230) - return static_cast(wf.scratch_base()); // SRC_FLAT_SCRATCH_BASE_LO - if (ev == 231) - return static_cast(wf.scratch_base() >> 32); // SRC_FLAT_SCRATCH_BASE_HI - if (ev == 240) - return 0x3F000000u; // 0.5f - if (ev == 241) - return 0xBF000000u; // -0.5f - if (ev == 242) - return 0x3F800000u; // 1.0f - if (ev == 243) - return 0xBF800000u; // -1.0f - if (ev == 244) - return 0x40000000u; // 2.0f - if (ev == 245) - return 0xC0000000u; // -2.0f - if (ev == 246) - return 0x40800000u; // 4.0f - if (ev == 247) - return 0xC0800000u; // -4.0f - if (ev == 248) - return 0x3E22F983u; // 1/(2*pi) - if (ev == 235) - return static_cast(wf.shared_aperture_base() >> 32); // SRC_SHARED_BASE - if (ev == 236) - return static_cast(wf.shared_aperture_limit() >> 32); // SRC_SHARED_LIMIT - if (ev == 237) - return static_cast(wf.private_aperture_base() >> 32); // SRC_PRIVATE_BASE - if (ev == 238) - return static_cast(wf.private_aperture_limit() >> 32); // SRC_PRIVATE_LIMIT - if (ev == 249) - return 0u; // SRC_POPS_EXITING_WAVE_ID (not used in compute) - if (ev == 250) - return 0u; // NULL - if (ev == 251) - return (wf.vcc() & (wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL))) == 0 - ? 1u - : 0u; // VCCZ - if (ev == 252) { - uint64_t active = wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL); - return (wf.exec() & active) == 0 ? 1u : 0u; // EXECZ - } - if (ev == 253) - return wf.read_scc() ? 1u : 0u; // SCC - throw std::logic_error("Unsupported encoding value for scalar read: " + std::to_string(ev)); -} - -uint32_t resolve_src_scalar16(const amdgpu::Wavefront &wf, int ev) { - switch (ev) { - case 240: - return 0x3800u; // 0.5h - case 241: - return 0xB800u; // -0.5h - case 242: - return 0x3C00u; // 1.0h - case 243: - return 0xBC00u; // -1.0h - case 244: - return 0x4000u; // 2.0h - case 245: - return 0xC000u; // -2.0h - case 246: - return 0x4400u; // 4.0h - case 247: - return 0xC400u; // -4.0h - case 248: - return 0x3118u; // f16 1/(2*pi) - default: - return resolve_src_scalar(wf, ev); - } -} - -// Must stay in sync with resolve_src_scalar above — returns true for -// exactly the encoding values that resolve_src_scalar handles without -// throwing. Used by Isa::simd_capable_value() to keep the SIMD fast -// path off operands whose scalar broadcast would throw at runtime. -bool can_resolve_src_scalar(int ev) { - return (ev >= 0 && ev <= 107) || (ev >= 108 && ev <= 123) || ev == 124 || ev == 126 || - ev == 127 || (ev >= 128 && ev <= 208) || (ev >= 235 && ev <= 238) || - (ev >= 240 && ev <= 253); -} - -uint64_t resolve_src_scalar64(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return wf.scratch_base(); - if (ev <= 105) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 106) - return wf.vcc(); - if (ev >= 108 && ev <= 122) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 124) - return wf.m0(); - if (ev == 126) - return wf.exec_raw(); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(static_cast(-(ev - 192)))); - if (ev == 230) - return wf.scratch_base(); // SRC_FLAT_SCRATCH_BASE - if (ev == 240) - return 0x3FE0000000000000ULL; // 0.5 - if (ev == 241) - return 0xBFE0000000000000ULL; // -0.5 - if (ev == 242) - return 0x3FF0000000000000ULL; // 1.0 - if (ev == 243) - return 0xBFF0000000000000ULL; // -1.0 - if (ev == 244) - return 0x4000000000000000ULL; // 2.0 - if (ev == 245) - return 0xC000000000000000ULL; // -2.0 - if (ev == 246) - return 0x4010000000000000ULL; // 4.0 - if (ev == 247) - return 0xC010000000000000ULL; // -4.0 - if (ev == 248) - return 0x3FC45F306DC9C883ULL; // 1/(2*pi) - if (ev == 235) - return wf.shared_aperture_base(); // SRC_SHARED_BASE - if (ev == 236) - return wf.shared_aperture_limit(); // SRC_SHARED_LIMIT - if (ev == 237) - return wf.private_aperture_base(); // SRC_PRIVATE_BASE - if (ev == 238) - return wf.private_aperture_limit(); // SRC_PRIVATE_LIMIT - throw std::logic_error("Unsupported encoding value for scalar64 read: " + std::to_string(ev)); -} - -void resolve_dst_write(amdgpu::Wavefront &wf, int ev, uint32_t val) { - if (ev == 102) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 103) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 106) { - wf.set_vcc((wf.vcc() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 107) { - wf.set_vcc((wf.vcc() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev >= 108 && ev <= 123) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 124) { - wf.set_m0(val); - return; - } - if (ev == 126) { - wf.set_exec((wf.exec() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 127) { - wf.set_exec_raw((wf.exec_raw() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - throw std::logic_error("Unsupported encoding value for scalar write: " + std::to_string(ev)); -} - -void resolve_dst_write64(amdgpu::Wavefront &wf, int ev, uint64_t val) { - if (ev == 102) { - wf.set_scratch_base(val); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 106) { - wf.set_vcc(val); - return; - } - if (ev >= 108 && ev <= 122) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 124) - return; - if (ev == 126) { - wf.set_exec_raw(val); - return; - } - throw std::logic_error("Unsupported encoding value for scalar64 write: " + std::to_string(ev)); -} +constexpr int kM0EncodingValue = 124; bool is_vgpr_only_type(OperandType t) { return t == OperandType::OPR_VGPR || t == OperandType::OPR_VGPR_OR_LDS || t == OperandType::OPR_SRC_VGPR; } -bool is_immediate_type(OperandType t) { - return t == OperandType::OPR_SIMM16 || t == OperandType::OPR_SIMM32 || - t == OperandType::OPR_SIMM8 || t == OperandType::OPR_LABEL || - t == OperandType::OPR_WAITCNT; -} - uint32_t vgpr_index(OperandType opr_type, int ev) { if (opr_type == OperandType::OPR_VGPR) return static_cast(ev); @@ -1406,11 +1206,12 @@ std::optional Isa::resolved_vgpr_offset(OperandType opr_type, int ev) bool Isa::simd_capable_value(OperandType opr_type, int ev) { return resolved_vgpr_offset(opr_type, ev).has_value() || is_immediate_type(opr_type) || - can_resolve_src_scalar(ev); + amdgpu::can_resolve_src_scalar(ev, kM0EncodingValue); } uint32_t Isa::simd_broadcast_value(const amdgpu::Wavefront &wf, OperandType opr_type, int ev) { - return is_immediate_type(opr_type) ? static_cast(ev) : resolve_src_scalar(wf, ev); + return is_immediate_type(opr_type) ? static_cast(ev) + : amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { @@ -1426,7 +1227,7 @@ uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { return static_cast(literal64_value_); if (is_immediate_type(opr_type_)) return static_cast(encoding_value_); - return resolve_src_scalar(wf, encoding_value_); + return amdgpu::resolve_src_scalar(wf, encoding_value_, kM0EncodingValue); } uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { @@ -1446,8 +1247,8 @@ uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { if (is_immediate_type(opr_type_)) return static_cast(ev); if (size_bits_ == 16) - return resolve_src_scalar16(wf, ev); - return resolve_src_scalar(wf, ev); + return amdgpu::resolve_src_scalar16(wf, ev, kM0EncodingValue); + return amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { @@ -1457,7 +1258,7 @@ void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write(wf, encoding_value_, val); + amdgpu::resolve_dst_write(wf, encoding_value_, val, kM0EncodingValue); } void Operand::write_lane(amdgpu::Wavefront &wf, uint32_t lane, uint32_t val) const { @@ -1494,7 +1295,7 @@ uint64_t Operand::read_lane64(const amdgpu::Wavefront &wf, uint32_t lane) const return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, ev); - return resolve_src_scalar64(wf, ev); + return amdgpu::resolve_src_scalar64(wf, ev, kM0EncodingValue); } void Operand::write_lane64(amdgpu::Wavefront &wf, uint32_t lane, uint64_t val) const { @@ -1524,7 +1325,7 @@ uint64_t Operand::read_scalar64(const amdgpu::Wavefront &wf) const { return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, encoding_value_); - return resolve_src_scalar64(wf, encoding_value_); + return amdgpu::resolve_src_scalar64(wf, encoding_value_, kM0EncodingValue); } void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { @@ -1534,7 +1335,7 @@ void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write64(wf, encoding_value_, val); + amdgpu::resolve_dst_write64(wf, encoding_value_, val); } } // namespace rdna1 diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/operand.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/operand.h index f1c05f87dd28..c3d8ce7df2ac 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/operand.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/operand.h @@ -23,6 +23,7 @@ class Operand : public AmdgpuIsaOperand { Operand(int size_bits, OperandType opr_type, uint64_t literal64_value, bool is_literal64); std::string name() const override; std::optional literal64_value() const override; + std::optional const_value() const override; std::optional to_register_ref() const override; private: diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/operand_types.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/operand_types.h index e5ae6af84e53..120130988b78 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/operand_types.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/operand_types.h @@ -542,6 +542,19 @@ enum OpSelVgprOrLds { } } +[[nodiscard]] constexpr bool is_immediate_type(OperandType t) { + switch (t) { + case OperandType::OPR_SIMM8: + case OperandType::OPR_SIMM16: + case OperandType::OPR_SIMM32: + case OperandType::OPR_LABEL: + case OperandType::OPR_WAITCNT: + return true; + default: + return false; + } +} + } // namespace rdna1 } // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/sop1.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/sop1.cpp index 5d8ab9a93560..a0f549de2dc4 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/sop1.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/sop1.cpp @@ -32,6 +32,7 @@ SMovB32Sop1::SMovB32Sop1(const MachineInst *inst) ssrc0 = Operand( 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB32Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b32_sop1(*this, wf); } @@ -48,6 +49,7 @@ SMovB64Sop1::SMovB64Sop1(const MachineInst *inst) ssrc0 = Operand( 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB64Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b64_sop1(*this, wf); } @@ -673,6 +675,7 @@ SAndSaveexecB64Sop1::SAndSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -701,6 +704,8 @@ SOrSaveexecB64Sop1::SOrSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } void SOrSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -729,6 +734,7 @@ SXorSaveexecB64Sop1::SXorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -757,6 +763,7 @@ SAndn2SaveexecB64Sop1::SAndn2SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -785,6 +792,7 @@ SOrn2SaveexecB64Sop1::SOrn2SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn2SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -813,6 +821,7 @@ SNandSaveexecB64Sop1::SNandSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNandSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -841,6 +850,7 @@ SNorSaveexecB64Sop1::SNorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -869,6 +879,7 @@ SXnorSaveexecB64Sop1::SXnorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXnorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1088,6 +1099,7 @@ SAndn1SaveexecB64Sop1::SAndn1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1116,6 +1128,7 @@ SOrn1SaveexecB64Sop1::SOrn1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1144,6 +1157,7 @@ SAndn1WrexecB64Sop1::SAndn1WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1172,6 +1186,7 @@ SAndn2WrexecB64Sop1::SAndn2WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1219,6 +1234,7 @@ SAndSaveexecB32Sop1::SAndSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1247,6 +1263,8 @@ SOrSaveexecB32Sop1::SOrSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } void SOrSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1275,6 +1293,7 @@ SXorSaveexecB32Sop1::SXorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1303,6 +1322,7 @@ SAndn2SaveexecB32Sop1::SAndn2SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1331,6 +1351,7 @@ SOrn2SaveexecB32Sop1::SOrn2SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn2SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1359,6 +1380,7 @@ SNandSaveexecB32Sop1::SNandSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNandSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1387,6 +1409,7 @@ SNorSaveexecB32Sop1::SNorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1415,6 +1438,7 @@ SXnorSaveexecB32Sop1::SXnorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXnorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1443,6 +1467,7 @@ SAndn1SaveexecB32Sop1::SAndn1SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1471,6 +1496,7 @@ SOrn1SaveexecB32Sop1::SOrn1SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn1SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1499,6 +1525,7 @@ SAndn1WrexecB32Sop1::SAndn1WrexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1WrexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1527,6 +1554,7 @@ SAndn2WrexecB32Sop1::SAndn2WrexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2WrexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/sop2.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/sop2.cpp index 13f141dfa404..5e9bf5f5d1f2 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/sop2.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/sop2.cpp @@ -404,6 +404,7 @@ SOrB32Sop2::SOrB32Sop2(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB32Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b32_sop2(*this, wf); } @@ -429,6 +430,7 @@ SOrB64Sop2::SOrB64Sop2(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB64Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b64_sop2(*this, wf); } diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/sopp.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/sopp.cpp index 9848b9b186cf..70f3ccd5df38 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/sopp.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/sopp.cpp @@ -43,6 +43,7 @@ SBranchSopp::SBranchSopp(const MachineInst *inst) num_src_ = 1; num_dst_ = 0; flags_ |= BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SBranchSopp::branch_offset_bytes() const { @@ -74,6 +75,7 @@ SCbranchScc0Sopp::SCbranchScc0Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc0Sopp::branch_offset_bytes() const { @@ -99,6 +101,7 @@ SCbranchScc1Sopp::SCbranchScc1Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc1Sopp::branch_offset_bytes() const { @@ -124,6 +127,7 @@ SCbranchVcczSopp::SCbranchVcczSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVcczSopp::branch_offset_bytes() const { @@ -151,6 +155,7 @@ SCbranchVccnzSopp::SCbranchVccnzSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVccnzSopp::branch_offset_bytes() const { @@ -178,6 +183,7 @@ SCbranchExeczSopp::SCbranchExeczSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExeczSopp::branch_offset_bytes() const { @@ -203,6 +209,7 @@ SCbranchExecnzSopp::SCbranchExecnzSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExecnzSopp::branch_offset_bytes() const { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/vop3.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/vop3.cpp index 1c23189e739a..ba897231b55f 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/vop3.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/vop3.cpp @@ -6559,6 +6559,7 @@ VCmpxFF32Vop3::VCmpxFF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6594,6 +6595,7 @@ VCmpxLtF32Vop3::VCmpxLtF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6640,6 +6642,7 @@ VCmpxEqF32Vop3::VCmpxEqF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6686,6 +6689,7 @@ VCmpxLeF32Vop3::VCmpxLeF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6732,6 +6736,7 @@ VCmpxGtF32Vop3::VCmpxGtF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6778,6 +6783,7 @@ VCmpxLgF32Vop3::VCmpxLgF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6824,6 +6830,7 @@ VCmpxGeF32Vop3::VCmpxGeF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6870,6 +6877,7 @@ VCmpxOF32Vop3::VCmpxOF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6916,6 +6924,7 @@ VCmpxUF32Vop3::VCmpxUF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6962,6 +6971,7 @@ VCmpxNgeF32Vop3::VCmpxNgeF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7008,6 +7018,7 @@ VCmpxNlgF32Vop3::VCmpxNlgF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7054,6 +7065,7 @@ VCmpxNgtF32Vop3::VCmpxNgtF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7100,6 +7112,7 @@ VCmpxNleF32Vop3::VCmpxNleF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7146,6 +7159,7 @@ VCmpxNeqF32Vop3::VCmpxNeqF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7192,6 +7206,7 @@ VCmpxNltF32Vop3::VCmpxNltF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7238,6 +7253,7 @@ VCmpxTruF32Vop3::VCmpxTruF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7738,6 +7754,7 @@ VCmpxFF64Vop3::VCmpxFF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7777,6 +7794,7 @@ VCmpxLtF64Vop3::VCmpxLtF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7827,6 +7845,7 @@ VCmpxEqF64Vop3::VCmpxEqF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7877,6 +7896,7 @@ VCmpxLeF64Vop3::VCmpxLeF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7927,6 +7947,7 @@ VCmpxGtF64Vop3::VCmpxGtF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7977,6 +7998,7 @@ VCmpxLgF64Vop3::VCmpxLgF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8027,6 +8049,7 @@ VCmpxGeF64Vop3::VCmpxGeF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8077,6 +8100,7 @@ VCmpxOF64Vop3::VCmpxOF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8127,6 +8151,7 @@ VCmpxUF64Vop3::VCmpxUF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8177,6 +8202,7 @@ VCmpxNgeF64Vop3::VCmpxNgeF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8227,6 +8253,7 @@ VCmpxNlgF64Vop3::VCmpxNlgF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8277,6 +8304,7 @@ VCmpxNgtF64Vop3::VCmpxNgtF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8327,6 +8355,7 @@ VCmpxNleF64Vop3::VCmpxNleF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8377,6 +8406,7 @@ VCmpxNeqF64Vop3::VCmpxNeqF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8427,6 +8457,7 @@ VCmpxNltF64Vop3::VCmpxNltF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8477,6 +8508,7 @@ VCmpxTruF64Vop3::VCmpxTruF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8924,6 +8956,7 @@ VCmpxFI32Vop3::VCmpxFI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8959,6 +8992,7 @@ VCmpxLtI32Vop3::VCmpxLtI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8997,6 +9031,7 @@ VCmpxEqI32Vop3::VCmpxEqI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9035,6 +9070,7 @@ VCmpxLeI32Vop3::VCmpxLeI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9073,6 +9109,7 @@ VCmpxGtI32Vop3::VCmpxGtI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9111,6 +9148,7 @@ VCmpxNeI32Vop3::VCmpxNeI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9149,6 +9187,7 @@ VCmpxGeI32Vop3::VCmpxGeI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9187,6 +9226,7 @@ VCmpxTI32Vop3::VCmpxTI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9222,6 +9262,7 @@ VCmpxClassF32Vop3::VCmpxClassF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9289,6 +9330,7 @@ VCmpxLtI16Vop3::VCmpxLtI16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9336,6 +9378,7 @@ VCmpxEqI16Vop3::VCmpxEqI16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9383,6 +9426,7 @@ VCmpxLeI16Vop3::VCmpxLeI16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9430,6 +9474,7 @@ VCmpxGtI16Vop3::VCmpxGtI16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9477,6 +9522,7 @@ VCmpxNeI16Vop3::VCmpxNeI16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9524,6 +9570,7 @@ VCmpxGeI16Vop3::VCmpxGeI16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9571,6 +9618,7 @@ VCmpxClassF16Vop3::VCmpxClassF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10031,6 +10079,7 @@ VCmpxFI64Vop3::VCmpxFI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10066,6 +10115,7 @@ VCmpxLtI64Vop3::VCmpxLtI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10104,6 +10154,7 @@ VCmpxEqI64Vop3::VCmpxEqI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10142,6 +10193,7 @@ VCmpxLeI64Vop3::VCmpxLeI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10180,6 +10232,7 @@ VCmpxGtI64Vop3::VCmpxGtI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10218,6 +10271,7 @@ VCmpxNeI64Vop3::VCmpxNeI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10256,6 +10310,7 @@ VCmpxGeI64Vop3::VCmpxGeI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10294,6 +10349,7 @@ VCmpxTI64Vop3::VCmpxTI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10331,6 +10387,7 @@ VCmpxClassF64Vop3::VCmpxClassF64Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10400,6 +10457,7 @@ VCmpxLtU16Vop3::VCmpxLtU16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10447,6 +10505,7 @@ VCmpxEqU16Vop3::VCmpxEqU16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10494,6 +10553,7 @@ VCmpxLeU16Vop3::VCmpxLeU16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10541,6 +10601,7 @@ VCmpxGtU16Vop3::VCmpxGtU16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10588,6 +10649,7 @@ VCmpxNeU16Vop3::VCmpxNeU16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10635,6 +10697,7 @@ VCmpxGeU16Vop3::VCmpxGeU16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11092,6 +11155,7 @@ VCmpxFU32Vop3::VCmpxFU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11127,6 +11191,7 @@ VCmpxLtU32Vop3::VCmpxLtU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11165,6 +11230,7 @@ VCmpxEqU32Vop3::VCmpxEqU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11203,6 +11269,7 @@ VCmpxLeU32Vop3::VCmpxLeU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11241,6 +11308,7 @@ VCmpxGtU32Vop3::VCmpxGtU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11279,6 +11347,7 @@ VCmpxNeU32Vop3::VCmpxNeU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11317,6 +11386,7 @@ VCmpxGeU32Vop3::VCmpxGeU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11355,6 +11425,7 @@ VCmpxTU32Vop3::VCmpxTU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11392,6 +11463,7 @@ VCmpxFF16Vop3::VCmpxFF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11429,6 +11501,7 @@ VCmpxLtF16Vop3::VCmpxLtF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11480,6 +11553,7 @@ VCmpxEqF16Vop3::VCmpxEqF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11531,6 +11605,7 @@ VCmpxLeF16Vop3::VCmpxLeF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11582,6 +11657,7 @@ VCmpxGtF16Vop3::VCmpxGtF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11633,6 +11709,7 @@ VCmpxLgF16Vop3::VCmpxLgF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11684,6 +11761,7 @@ VCmpxGeF16Vop3::VCmpxGeF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11735,6 +11813,7 @@ VCmpxOF16Vop3::VCmpxOF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12197,6 +12276,7 @@ VCmpxFU64Vop3::VCmpxFU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12232,6 +12312,7 @@ VCmpxLtU64Vop3::VCmpxLtU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12270,6 +12351,7 @@ VCmpxEqU64Vop3::VCmpxEqU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12308,6 +12390,7 @@ VCmpxLeU64Vop3::VCmpxLeU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12346,6 +12429,7 @@ VCmpxGtU64Vop3::VCmpxGtU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12384,6 +12468,7 @@ VCmpxNeU64Vop3::VCmpxNeU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12422,6 +12507,7 @@ VCmpxGeU64Vop3::VCmpxGeU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12460,6 +12546,7 @@ VCmpxTU64Vop3::VCmpxTU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12497,6 +12584,7 @@ VCmpxUF16Vop3::VCmpxUF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12548,6 +12636,7 @@ VCmpxNgeF16Vop3::VCmpxNgeF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12599,6 +12688,7 @@ VCmpxNlgF16Vop3::VCmpxNlgF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12650,6 +12740,7 @@ VCmpxNgtF16Vop3::VCmpxNgtF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12701,6 +12792,7 @@ VCmpxNleF16Vop3::VCmpxNleF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12752,6 +12844,7 @@ VCmpxNeqF16Vop3::VCmpxNeqF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12803,6 +12896,7 @@ VCmpxNltF16Vop3::VCmpxNltF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12854,6 +12948,7 @@ VCmpxTruF16Vop3::VCmpxTruF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF16Vop3::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/vopc.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/vopc.cpp index 672edfd6d634..1fa0869bc2be 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/vopc.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna1/vopc.cpp @@ -1066,6 +1066,7 @@ VCmpxFF32Vopc::VCmpxFF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1139,6 +1140,7 @@ VCmpxLtF32Vopc::VCmpxLtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1215,6 +1217,7 @@ VCmpxEqF32Vopc::VCmpxEqF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1291,6 +1294,7 @@ VCmpxLeF32Vopc::VCmpxLeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1367,6 +1371,7 @@ VCmpxGtF32Vopc::VCmpxGtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1443,6 +1448,7 @@ VCmpxLgF32Vopc::VCmpxLgF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1519,6 +1525,7 @@ VCmpxGeF32Vopc::VCmpxGeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1595,6 +1602,7 @@ VCmpxOF32Vopc::VCmpxOF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1671,6 +1679,7 @@ VCmpxUF32Vopc::VCmpxUF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1747,6 +1756,7 @@ VCmpxNgeF32Vopc::VCmpxNgeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1823,6 +1833,7 @@ VCmpxNlgF32Vopc::VCmpxNlgF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1899,6 +1910,7 @@ VCmpxNgtF32Vopc::VCmpxNgtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1975,6 +1987,7 @@ VCmpxNleF32Vopc::VCmpxNleF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2051,6 +2064,7 @@ VCmpxNeqF32Vopc::VCmpxNeqF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2127,6 +2141,7 @@ VCmpxNltF32Vopc::VCmpxNltF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2203,6 +2218,7 @@ VCmpxTruF32Vopc::VCmpxTruF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2728,6 +2744,7 @@ VCmpxFF64Vopc::VCmpxFF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2767,6 +2784,7 @@ VCmpxLtF64Vopc::VCmpxLtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2809,6 +2827,7 @@ VCmpxEqF64Vopc::VCmpxEqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2851,6 +2870,7 @@ VCmpxLeF64Vopc::VCmpxLeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2893,6 +2913,7 @@ VCmpxGtF64Vopc::VCmpxGtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2935,6 +2956,7 @@ VCmpxLgF64Vopc::VCmpxLgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LG_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2977,6 +2999,7 @@ VCmpxGeF64Vopc::VCmpxGeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3019,6 +3042,7 @@ VCmpxOF64Vopc::VCmpxOF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_O_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3061,6 +3085,7 @@ VCmpxUF64Vopc::VCmpxUF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_U_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3103,6 +3128,7 @@ VCmpxNgeF64Vopc::VCmpxNgeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGE_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3145,6 +3171,7 @@ VCmpxNlgF64Vopc::VCmpxNlgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLG_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3187,6 +3214,7 @@ VCmpxNgtF64Vopc::VCmpxNgtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGT_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3229,6 +3257,7 @@ VCmpxNleF64Vopc::VCmpxNleF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLE_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3271,6 +3300,7 @@ VCmpxNeqF64Vopc::VCmpxNeqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NEQ_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3313,6 +3343,7 @@ VCmpxNltF64Vopc::VCmpxNltF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLT_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3355,6 +3386,7 @@ VCmpxTruF64Vopc::VCmpxTruF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_TRU_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4421,6 +4453,7 @@ VCmpxFI32Vopc::VCmpxFI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4494,6 +4527,7 @@ VCmpxLtI32Vopc::VCmpxLtI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4570,6 +4604,7 @@ VCmpxEqI32Vopc::VCmpxEqI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4646,6 +4681,7 @@ VCmpxLeI32Vopc::VCmpxLeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4722,6 +4758,7 @@ VCmpxGtI32Vopc::VCmpxGtI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4798,6 +4835,7 @@ VCmpxNeI32Vopc::VCmpxNeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4874,6 +4912,7 @@ VCmpxGeI32Vopc::VCmpxGeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4950,6 +4989,7 @@ VCmpxTI32Vopc::VCmpxTI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5023,6 +5063,7 @@ VCmpxClassF32Vopc::VCmpxClassF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5123,6 +5164,7 @@ VCmpxLtI16Vopc::VCmpxLtI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5200,6 +5242,7 @@ VCmpxEqI16Vopc::VCmpxEqI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5277,6 +5320,7 @@ VCmpxLeI16Vopc::VCmpxLeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5354,6 +5398,7 @@ VCmpxGtI16Vopc::VCmpxGtI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5431,6 +5476,7 @@ VCmpxNeI16Vopc::VCmpxNeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5508,6 +5554,7 @@ VCmpxGeI16Vopc::VCmpxGeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5585,6 +5632,7 @@ VCmpxClassF16Vopc::VCmpxClassF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6305,6 +6353,7 @@ VCmpxFI64Vopc::VCmpxFI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6342,6 +6391,7 @@ VCmpxLtI64Vopc::VCmpxLtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6382,6 +6432,7 @@ VCmpxEqI64Vopc::VCmpxEqI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6422,6 +6473,7 @@ VCmpxLeI64Vopc::VCmpxLeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6462,6 +6514,7 @@ VCmpxGtI64Vopc::VCmpxGtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6502,6 +6555,7 @@ VCmpxNeI64Vopc::VCmpxNeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6542,6 +6596,7 @@ VCmpxGeI64Vopc::VCmpxGeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6582,6 +6637,7 @@ VCmpxTI64Vopc::VCmpxTI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6621,6 +6677,7 @@ VCmpxClassF64Vopc::VCmpxClassF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_CLASS_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6701,6 +6758,7 @@ VCmpxLtU16Vopc::VCmpxLtU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6778,6 +6836,7 @@ VCmpxEqU16Vopc::VCmpxEqU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6855,6 +6914,7 @@ VCmpxLeU16Vopc::VCmpxLeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6932,6 +6992,7 @@ VCmpxGtU16Vopc::VCmpxGtU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7009,6 +7070,7 @@ VCmpxNeU16Vopc::VCmpxNeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7086,6 +7148,7 @@ VCmpxGeU16Vopc::VCmpxGeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8178,6 +8241,7 @@ VCmpxFU32Vopc::VCmpxFU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8251,6 +8315,7 @@ VCmpxLtU32Vopc::VCmpxLtU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8327,6 +8392,7 @@ VCmpxEqU32Vopc::VCmpxEqU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8403,6 +8469,7 @@ VCmpxLeU32Vopc::VCmpxLeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8479,6 +8546,7 @@ VCmpxGtU32Vopc::VCmpxGtU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8555,6 +8623,7 @@ VCmpxNeU32Vopc::VCmpxNeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8631,6 +8700,7 @@ VCmpxGeU32Vopc::VCmpxGeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8707,6 +8777,7 @@ VCmpxTU32Vopc::VCmpxTU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8781,6 +8852,7 @@ VCmpxFF16Vopc::VCmpxFF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8855,6 +8927,7 @@ VCmpxLtF16Vopc::VCmpxLtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8934,6 +9007,7 @@ VCmpxEqF16Vopc::VCmpxEqF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9013,6 +9087,7 @@ VCmpxLeF16Vopc::VCmpxLeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9092,6 +9167,7 @@ VCmpxGtF16Vopc::VCmpxGtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9171,6 +9247,7 @@ VCmpxLgF16Vopc::VCmpxLgF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9250,6 +9327,7 @@ VCmpxGeF16Vopc::VCmpxGeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9329,6 +9407,7 @@ VCmpxOF16Vopc::VCmpxOF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10121,6 +10200,7 @@ VCmpxFU64Vopc::VCmpxFU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10158,6 +10238,7 @@ VCmpxLtU64Vopc::VCmpxLtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10198,6 +10279,7 @@ VCmpxEqU64Vopc::VCmpxEqU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10238,6 +10320,7 @@ VCmpxLeU64Vopc::VCmpxLeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10278,6 +10361,7 @@ VCmpxGtU64Vopc::VCmpxGtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10318,6 +10402,7 @@ VCmpxNeU64Vopc::VCmpxNeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10358,6 +10443,7 @@ VCmpxGeU64Vopc::VCmpxGeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10398,6 +10484,7 @@ VCmpxTU64Vopc::VCmpxTU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10450,6 +10537,7 @@ VCmpxUF16Vopc::VCmpxUF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10529,6 +10617,7 @@ VCmpxNgeF16Vopc::VCmpxNgeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10608,6 +10697,7 @@ VCmpxNlgF16Vopc::VCmpxNlgF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10687,6 +10777,7 @@ VCmpxNgtF16Vopc::VCmpxNgtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10766,6 +10857,7 @@ VCmpxNleF16Vopc::VCmpxNleF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10845,6 +10937,7 @@ VCmpxNeqF16Vopc::VCmpxNeqF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10924,6 +11017,7 @@ VCmpxNltF16Vopc::VCmpxNltF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11003,6 +11097,7 @@ VCmpxTruF16Vopc::VCmpxTruF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF16Vopc::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/operand.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/operand.cpp index ef7ed688e3c8..691c78169e75 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/operand.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/operand.cpp @@ -5,6 +5,7 @@ // See lib/python/amdisa/README.md for regeneration instructions. #include "rocjitsu/isa/arch/amdgpu/rdna2/operand.h" +#include "rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h" #include "rocjitsu/isa/isa_operand_simd_inl.h" #include "rocjitsu/vm/amdgpu/compute_unit.h" #include "rocjitsu/vm/amdgpu/register_access.h" @@ -52,6 +53,16 @@ std::optional Operand::literal64_value() const { return literal64_value_; } +std::optional Operand::const_value() const { + if (has_literal64_) + return literal64_value_; + if (is_immediate_type(opr_type_)) + return static_cast(static_cast(encoding_value_)); + if (to_register_ref()) + return std::nullopt; + return amdgpu::resolve_src_scalar_statically(encoding_value_); +} + std::string Operand::name() const { if (has_literal64_) return std::format("0x{:x}", literal64_value_); @@ -803,6 +814,8 @@ std::optional Operand::to_register_ref() const { break; } case OperandType::OPR_EXEC: { + if (encoding_value_ == OpSelExec::OPR_EXEC_EXEC) + return RegisterRef{RegClass::EXEC, 0, reg_width}; break; } case OperandType::OPR_FLAT_SCRATCH: { @@ -820,9 +833,17 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSdst::OPR_SDST_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_EXEC: { + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_M0: { @@ -843,6 +864,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSrc::OPR_SRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrc::OPR_SRC_VGPR_MIN && encoding_value_ <= OpSelSrc::OPR_SRC_VGPR_MAX) return RegisterRef{RegClass::VGPR, @@ -857,6 +882,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcNolds::OPR_SRC_NOLDS_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcNolds::OPR_SRC_NOLDS_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcNolds::OPR_SRC_NOLDS_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcNolds::OPR_SRC_NOLDS_VGPR_MIN && encoding_value_ <= OpSelSrcNolds::OPR_SRC_NOLDS_VGPR_MAX) return RegisterRef{ @@ -872,6 +901,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSrcSimple::OPR_SRC_SIMPLE_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrcSimple::OPR_SRC_SIMPLE_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrcSimple::OPR_SRC_SIMPLE_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrcSimple::OPR_SRC_SIMPLE_VGPR_MIN && encoding_value_ <= OpSelSrcSimple::OPR_SRC_SIMPLE_VGPR_MAX) return RegisterRef{ @@ -920,6 +953,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrc::OPR_SSRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_LANESEL: { @@ -938,6 +975,10 @@ std::optional Operand::to_register_ref() const { RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrcNolds::OPR_SSRC_NOLDS_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrcNolds::OPR_SSRC_NOLDS_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrcNolds::OPR_SSRC_NOLDS_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_SPECIAL_SCC: { @@ -974,253 +1015,13 @@ std::optional Operand::to_register_ref() const { namespace { -uint32_t resolve_src_scalar(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return static_cast(wf.scratch_base()); - if (ev == 103) - return static_cast(wf.scratch_base() >> 32); - if (ev <= 105) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 106) - return static_cast(wf.vcc()); - if (ev == 107) - return static_cast(wf.vcc() >> 32); - if (ev >= 108 && ev <= 123) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 124) - return wf.m0(); - if (ev == 126) - return static_cast(wf.exec()); - if (ev == 127) - return static_cast(wf.exec_raw() >> 32); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(-(ev - 192))); - if (ev == 230) - return static_cast(wf.scratch_base()); // SRC_FLAT_SCRATCH_BASE_LO - if (ev == 231) - return static_cast(wf.scratch_base() >> 32); // SRC_FLAT_SCRATCH_BASE_HI - if (ev == 240) - return 0x3F000000u; // 0.5f - if (ev == 241) - return 0xBF000000u; // -0.5f - if (ev == 242) - return 0x3F800000u; // 1.0f - if (ev == 243) - return 0xBF800000u; // -1.0f - if (ev == 244) - return 0x40000000u; // 2.0f - if (ev == 245) - return 0xC0000000u; // -2.0f - if (ev == 246) - return 0x40800000u; // 4.0f - if (ev == 247) - return 0xC0800000u; // -4.0f - if (ev == 248) - return 0x3E22F983u; // 1/(2*pi) - if (ev == 235) - return static_cast(wf.shared_aperture_base() >> 32); // SRC_SHARED_BASE - if (ev == 236) - return static_cast(wf.shared_aperture_limit() >> 32); // SRC_SHARED_LIMIT - if (ev == 237) - return static_cast(wf.private_aperture_base() >> 32); // SRC_PRIVATE_BASE - if (ev == 238) - return static_cast(wf.private_aperture_limit() >> 32); // SRC_PRIVATE_LIMIT - if (ev == 249) - return 0u; // SRC_POPS_EXITING_WAVE_ID (not used in compute) - if (ev == 250) - return 0u; // NULL - if (ev == 251) - return (wf.vcc() & (wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL))) == 0 - ? 1u - : 0u; // VCCZ - if (ev == 252) { - uint64_t active = wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL); - return (wf.exec() & active) == 0 ? 1u : 0u; // EXECZ - } - if (ev == 253) - return wf.read_scc() ? 1u : 0u; // SCC - throw std::logic_error("Unsupported encoding value for scalar read: " + std::to_string(ev)); -} - -uint32_t resolve_src_scalar16(const amdgpu::Wavefront &wf, int ev) { - switch (ev) { - case 240: - return 0x3800u; // 0.5h - case 241: - return 0xB800u; // -0.5h - case 242: - return 0x3C00u; // 1.0h - case 243: - return 0xBC00u; // -1.0h - case 244: - return 0x4000u; // 2.0h - case 245: - return 0xC000u; // -2.0h - case 246: - return 0x4400u; // 4.0h - case 247: - return 0xC400u; // -4.0h - case 248: - return 0x3118u; // f16 1/(2*pi) - default: - return resolve_src_scalar(wf, ev); - } -} - -// Must stay in sync with resolve_src_scalar above — returns true for -// exactly the encoding values that resolve_src_scalar handles without -// throwing. Used by Isa::simd_capable_value() to keep the SIMD fast -// path off operands whose scalar broadcast would throw at runtime. -bool can_resolve_src_scalar(int ev) { - return (ev >= 0 && ev <= 107) || (ev >= 108 && ev <= 123) || ev == 124 || ev == 126 || - ev == 127 || (ev >= 128 && ev <= 208) || (ev >= 235 && ev <= 238) || - (ev >= 240 && ev <= 253); -} - -uint64_t resolve_src_scalar64(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return wf.scratch_base(); - if (ev <= 105) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 106) - return wf.vcc(); - if (ev >= 108 && ev <= 122) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 124) - return wf.m0(); - if (ev == 126) - return wf.exec_raw(); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(static_cast(-(ev - 192)))); - if (ev == 230) - return wf.scratch_base(); // SRC_FLAT_SCRATCH_BASE - if (ev == 240) - return 0x3FE0000000000000ULL; // 0.5 - if (ev == 241) - return 0xBFE0000000000000ULL; // -0.5 - if (ev == 242) - return 0x3FF0000000000000ULL; // 1.0 - if (ev == 243) - return 0xBFF0000000000000ULL; // -1.0 - if (ev == 244) - return 0x4000000000000000ULL; // 2.0 - if (ev == 245) - return 0xC000000000000000ULL; // -2.0 - if (ev == 246) - return 0x4010000000000000ULL; // 4.0 - if (ev == 247) - return 0xC010000000000000ULL; // -4.0 - if (ev == 248) - return 0x3FC45F306DC9C883ULL; // 1/(2*pi) - if (ev == 235) - return wf.shared_aperture_base(); // SRC_SHARED_BASE - if (ev == 236) - return wf.shared_aperture_limit(); // SRC_SHARED_LIMIT - if (ev == 237) - return wf.private_aperture_base(); // SRC_PRIVATE_BASE - if (ev == 238) - return wf.private_aperture_limit(); // SRC_PRIVATE_LIMIT - throw std::logic_error("Unsupported encoding value for scalar64 read: " + std::to_string(ev)); -} - -void resolve_dst_write(amdgpu::Wavefront &wf, int ev, uint32_t val) { - if (ev == 102) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 103) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 106) { - wf.set_vcc((wf.vcc() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 107) { - wf.set_vcc((wf.vcc() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev >= 108 && ev <= 123) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 124) { - wf.set_m0(val); - return; - } - if (ev == 126) { - wf.set_exec((wf.exec() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 127) { - wf.set_exec_raw((wf.exec_raw() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - throw std::logic_error("Unsupported encoding value for scalar write: " + std::to_string(ev)); -} - -void resolve_dst_write64(amdgpu::Wavefront &wf, int ev, uint64_t val) { - if (ev == 102) { - wf.set_scratch_base(val); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 106) { - wf.set_vcc(val); - return; - } - if (ev >= 108 && ev <= 122) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 124) - return; - if (ev == 126) { - wf.set_exec_raw(val); - return; - } - throw std::logic_error("Unsupported encoding value for scalar64 write: " + std::to_string(ev)); -} +constexpr int kM0EncodingValue = 124; bool is_vgpr_only_type(OperandType t) { return t == OperandType::OPR_VGPR || t == OperandType::OPR_VGPR_OR_LDS || t == OperandType::OPR_SRC_VGPR; } -bool is_immediate_type(OperandType t) { - return t == OperandType::OPR_SIMM16 || t == OperandType::OPR_SIMM32 || - t == OperandType::OPR_LABEL || t == OperandType::OPR_WAITCNT; -} - uint32_t vgpr_index(OperandType opr_type, int ev) { if (opr_type == OperandType::OPR_VGPR) return static_cast(ev); @@ -1249,11 +1050,12 @@ std::optional Isa::resolved_vgpr_offset(OperandType opr_type, int ev) bool Isa::simd_capable_value(OperandType opr_type, int ev) { return resolved_vgpr_offset(opr_type, ev).has_value() || is_immediate_type(opr_type) || - can_resolve_src_scalar(ev); + amdgpu::can_resolve_src_scalar(ev, kM0EncodingValue); } uint32_t Isa::simd_broadcast_value(const amdgpu::Wavefront &wf, OperandType opr_type, int ev) { - return is_immediate_type(opr_type) ? static_cast(ev) : resolve_src_scalar(wf, ev); + return is_immediate_type(opr_type) ? static_cast(ev) + : amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { @@ -1269,7 +1071,7 @@ uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { return static_cast(literal64_value_); if (is_immediate_type(opr_type_)) return static_cast(encoding_value_); - return resolve_src_scalar(wf, encoding_value_); + return amdgpu::resolve_src_scalar(wf, encoding_value_, kM0EncodingValue); } uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { @@ -1289,8 +1091,8 @@ uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { if (is_immediate_type(opr_type_)) return static_cast(ev); if (size_bits_ == 16) - return resolve_src_scalar16(wf, ev); - return resolve_src_scalar(wf, ev); + return amdgpu::resolve_src_scalar16(wf, ev, kM0EncodingValue); + return amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { @@ -1300,7 +1102,7 @@ void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write(wf, encoding_value_, val); + amdgpu::resolve_dst_write(wf, encoding_value_, val, kM0EncodingValue); } void Operand::write_lane(amdgpu::Wavefront &wf, uint32_t lane, uint32_t val) const { @@ -1337,7 +1139,7 @@ uint64_t Operand::read_lane64(const amdgpu::Wavefront &wf, uint32_t lane) const return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, ev); - return resolve_src_scalar64(wf, ev); + return amdgpu::resolve_src_scalar64(wf, ev, kM0EncodingValue); } void Operand::write_lane64(amdgpu::Wavefront &wf, uint32_t lane, uint64_t val) const { @@ -1367,7 +1169,7 @@ uint64_t Operand::read_scalar64(const amdgpu::Wavefront &wf) const { return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, encoding_value_); - return resolve_src_scalar64(wf, encoding_value_); + return amdgpu::resolve_src_scalar64(wf, encoding_value_, kM0EncodingValue); } void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { @@ -1377,7 +1179,7 @@ void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write64(wf, encoding_value_, val); + amdgpu::resolve_dst_write64(wf, encoding_value_, val); } } // namespace rdna2 diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/operand.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/operand.h index 69f244e20e01..19aebc2424e2 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/operand.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/operand.h @@ -23,6 +23,7 @@ class Operand : public AmdgpuIsaOperand { Operand(int size_bits, OperandType opr_type, uint64_t literal64_value, bool is_literal64); std::string name() const override; std::optional literal64_value() const override; + std::optional const_value() const override; std::optional to_register_ref() const override; private: diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/operand_types.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/operand_types.h index 8e153c7c31c2..edddab335f09 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/operand_types.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/operand_types.h @@ -463,6 +463,18 @@ enum OpSelVgprOrLds { } } +[[nodiscard]] constexpr bool is_immediate_type(OperandType t) { + switch (t) { + case OperandType::OPR_SIMM16: + case OperandType::OPR_SIMM32: + case OperandType::OPR_LABEL: + case OperandType::OPR_WAITCNT: + return true; + default: + return false; + } +} + } // namespace rdna2 } // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/sop1.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/sop1.cpp index df7492c5548e..9fff82712b64 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/sop1.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/sop1.cpp @@ -32,6 +32,7 @@ SMovB32Sop1::SMovB32Sop1(const MachineInst *inst) ssrc0 = Operand( 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB32Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b32_sop1(*this, wf); } @@ -48,6 +49,7 @@ SMovB64Sop1::SMovB64Sop1(const MachineInst *inst) ssrc0 = Operand( 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB64Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b64_sop1(*this, wf); } @@ -673,6 +675,7 @@ SAndSaveexecB64Sop1::SAndSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -701,6 +704,8 @@ SOrSaveexecB64Sop1::SOrSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } void SOrSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -729,6 +734,7 @@ SXorSaveexecB64Sop1::SXorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -757,6 +763,7 @@ SAndn2SaveexecB64Sop1::SAndn2SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -785,6 +792,7 @@ SOrn2SaveexecB64Sop1::SOrn2SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn2SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -813,6 +821,7 @@ SNandSaveexecB64Sop1::SNandSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNandSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -841,6 +850,7 @@ SNorSaveexecB64Sop1::SNorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -869,6 +879,7 @@ SXnorSaveexecB64Sop1::SXnorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXnorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1088,6 +1099,7 @@ SAndn1SaveexecB64Sop1::SAndn1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1116,6 +1128,7 @@ SOrn1SaveexecB64Sop1::SOrn1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1144,6 +1157,7 @@ SAndn1WrexecB64Sop1::SAndn1WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1172,6 +1186,7 @@ SAndn2WrexecB64Sop1::SAndn2WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1219,6 +1234,7 @@ SAndSaveexecB32Sop1::SAndSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1247,6 +1263,8 @@ SOrSaveexecB32Sop1::SOrSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } void SOrSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1275,6 +1293,7 @@ SXorSaveexecB32Sop1::SXorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1303,6 +1322,7 @@ SAndn2SaveexecB32Sop1::SAndn2SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1331,6 +1351,7 @@ SOrn2SaveexecB32Sop1::SOrn2SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn2SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1359,6 +1380,7 @@ SNandSaveexecB32Sop1::SNandSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNandSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1387,6 +1409,7 @@ SNorSaveexecB32Sop1::SNorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1415,6 +1438,7 @@ SXnorSaveexecB32Sop1::SXnorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXnorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1443,6 +1467,7 @@ SAndn1SaveexecB32Sop1::SAndn1SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1471,6 +1496,7 @@ SOrn1SaveexecB32Sop1::SOrn1SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrn1SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1499,6 +1525,7 @@ SAndn1WrexecB32Sop1::SAndn1WrexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn1WrexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1527,6 +1554,7 @@ SAndn2WrexecB32Sop1::SAndn2WrexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndn2WrexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/sop2.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/sop2.cpp index b91994b6c5c3..76bba8c0cc3e 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/sop2.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/sop2.cpp @@ -404,6 +404,7 @@ SOrB32Sop2::SOrB32Sop2(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB32Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b32_sop2(*this, wf); } @@ -429,6 +430,7 @@ SOrB64Sop2::SOrB64Sop2(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB64Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b64_sop2(*this, wf); } diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/sopp.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/sopp.cpp index 4863226f4082..4e929338778b 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/sopp.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/sopp.cpp @@ -43,6 +43,7 @@ SBranchSopp::SBranchSopp(const MachineInst *inst) num_src_ = 1; num_dst_ = 0; flags_ |= BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SBranchSopp::branch_offset_bytes() const { @@ -74,6 +75,7 @@ SCbranchScc0Sopp::SCbranchScc0Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc0Sopp::branch_offset_bytes() const { @@ -99,6 +101,7 @@ SCbranchScc1Sopp::SCbranchScc1Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc1Sopp::branch_offset_bytes() const { @@ -124,6 +127,7 @@ SCbranchVcczSopp::SCbranchVcczSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVcczSopp::branch_offset_bytes() const { @@ -151,6 +155,7 @@ SCbranchVccnzSopp::SCbranchVccnzSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVccnzSopp::branch_offset_bytes() const { @@ -178,6 +183,7 @@ SCbranchExeczSopp::SCbranchExeczSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExeczSopp::branch_offset_bytes() const { @@ -203,6 +209,7 @@ SCbranchExecnzSopp::SCbranchExecnzSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExecnzSopp::branch_offset_bytes() const { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/vop3.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/vop3.cpp index 1449393c75e0..697ae2b8cbb0 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/vop3.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/vop3.cpp @@ -6499,6 +6499,7 @@ VCmpxFF32Vop3::VCmpxFF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6534,6 +6535,7 @@ VCmpxLtF32Vop3::VCmpxLtF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6580,6 +6582,7 @@ VCmpxEqF32Vop3::VCmpxEqF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6626,6 +6629,7 @@ VCmpxLeF32Vop3::VCmpxLeF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6672,6 +6676,7 @@ VCmpxGtF32Vop3::VCmpxGtF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6718,6 +6723,7 @@ VCmpxLgF32Vop3::VCmpxLgF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6764,6 +6770,7 @@ VCmpxGeF32Vop3::VCmpxGeF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6810,6 +6817,7 @@ VCmpxOF32Vop3::VCmpxOF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6856,6 +6864,7 @@ VCmpxUF32Vop3::VCmpxUF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6902,6 +6911,7 @@ VCmpxNgeF32Vop3::VCmpxNgeF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6948,6 +6958,7 @@ VCmpxNlgF32Vop3::VCmpxNlgF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -6994,6 +7005,7 @@ VCmpxNgtF32Vop3::VCmpxNgtF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7040,6 +7052,7 @@ VCmpxNleF32Vop3::VCmpxNleF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7086,6 +7099,7 @@ VCmpxNeqF32Vop3::VCmpxNeqF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7132,6 +7146,7 @@ VCmpxNltF32Vop3::VCmpxNltF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7178,6 +7193,7 @@ VCmpxTruF32Vop3::VCmpxTruF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7678,6 +7694,7 @@ VCmpxFF64Vop3::VCmpxFF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7717,6 +7734,7 @@ VCmpxLtF64Vop3::VCmpxLtF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7767,6 +7785,7 @@ VCmpxEqF64Vop3::VCmpxEqF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7817,6 +7836,7 @@ VCmpxLeF64Vop3::VCmpxLeF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7867,6 +7887,7 @@ VCmpxGtF64Vop3::VCmpxGtF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7917,6 +7938,7 @@ VCmpxLgF64Vop3::VCmpxLgF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -7967,6 +7989,7 @@ VCmpxGeF64Vop3::VCmpxGeF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8017,6 +8040,7 @@ VCmpxOF64Vop3::VCmpxOF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8067,6 +8091,7 @@ VCmpxUF64Vop3::VCmpxUF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8117,6 +8142,7 @@ VCmpxNgeF64Vop3::VCmpxNgeF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8167,6 +8193,7 @@ VCmpxNlgF64Vop3::VCmpxNlgF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8217,6 +8244,7 @@ VCmpxNgtF64Vop3::VCmpxNgtF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8267,6 +8295,7 @@ VCmpxNleF64Vop3::VCmpxNleF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8317,6 +8346,7 @@ VCmpxNeqF64Vop3::VCmpxNeqF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8367,6 +8397,7 @@ VCmpxNltF64Vop3::VCmpxNltF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8417,6 +8448,7 @@ VCmpxTruF64Vop3::VCmpxTruF64Vop3(const MachineInst *inst) << 32), true); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8864,6 +8896,7 @@ VCmpxFI32Vop3::VCmpxFI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8899,6 +8932,7 @@ VCmpxLtI32Vop3::VCmpxLtI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8937,6 +8971,7 @@ VCmpxEqI32Vop3::VCmpxEqI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -8975,6 +9010,7 @@ VCmpxLeI32Vop3::VCmpxLeI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9013,6 +9049,7 @@ VCmpxGtI32Vop3::VCmpxGtI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9051,6 +9088,7 @@ VCmpxNeI32Vop3::VCmpxNeI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9089,6 +9127,7 @@ VCmpxGeI32Vop3::VCmpxGeI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9127,6 +9166,7 @@ VCmpxTI32Vop3::VCmpxTI32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9162,6 +9202,7 @@ VCmpxClassF32Vop3::VCmpxClassF32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9229,6 +9270,7 @@ VCmpxLtI16Vop3::VCmpxLtI16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9276,6 +9318,7 @@ VCmpxEqI16Vop3::VCmpxEqI16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9323,6 +9366,7 @@ VCmpxLeI16Vop3::VCmpxLeI16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9370,6 +9414,7 @@ VCmpxGtI16Vop3::VCmpxGtI16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9417,6 +9462,7 @@ VCmpxNeI16Vop3::VCmpxNeI16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9464,6 +9510,7 @@ VCmpxGeI16Vop3::VCmpxGeI16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9511,6 +9558,7 @@ VCmpxClassF16Vop3::VCmpxClassF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -9971,6 +10019,7 @@ VCmpxFI64Vop3::VCmpxFI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10006,6 +10055,7 @@ VCmpxLtI64Vop3::VCmpxLtI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10044,6 +10094,7 @@ VCmpxEqI64Vop3::VCmpxEqI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10082,6 +10133,7 @@ VCmpxLeI64Vop3::VCmpxLeI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10120,6 +10172,7 @@ VCmpxGtI64Vop3::VCmpxGtI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10158,6 +10211,7 @@ VCmpxNeI64Vop3::VCmpxNeI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10196,6 +10250,7 @@ VCmpxGeI64Vop3::VCmpxGeI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10234,6 +10289,7 @@ VCmpxTI64Vop3::VCmpxTI64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10271,6 +10327,7 @@ VCmpxClassF64Vop3::VCmpxClassF64Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10340,6 +10397,7 @@ VCmpxLtU16Vop3::VCmpxLtU16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10387,6 +10445,7 @@ VCmpxEqU16Vop3::VCmpxEqU16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10434,6 +10493,7 @@ VCmpxLeU16Vop3::VCmpxLeU16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10481,6 +10541,7 @@ VCmpxGtU16Vop3::VCmpxGtU16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10528,6 +10589,7 @@ VCmpxNeU16Vop3::VCmpxNeU16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -10575,6 +10637,7 @@ VCmpxGeU16Vop3::VCmpxGeU16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11032,6 +11095,7 @@ VCmpxFU32Vop3::VCmpxFU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11067,6 +11131,7 @@ VCmpxLtU32Vop3::VCmpxLtU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11105,6 +11170,7 @@ VCmpxEqU32Vop3::VCmpxEqU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11143,6 +11209,7 @@ VCmpxLeU32Vop3::VCmpxLeU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11181,6 +11248,7 @@ VCmpxGtU32Vop3::VCmpxGtU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11219,6 +11287,7 @@ VCmpxNeU32Vop3::VCmpxNeU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11257,6 +11326,7 @@ VCmpxGeU32Vop3::VCmpxGeU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11295,6 +11365,7 @@ VCmpxTU32Vop3::VCmpxTU32Vop3(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11332,6 +11403,7 @@ VCmpxFF16Vop3::VCmpxFF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11369,6 +11441,7 @@ VCmpxLtF16Vop3::VCmpxLtF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11420,6 +11493,7 @@ VCmpxEqF16Vop3::VCmpxEqF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11471,6 +11545,7 @@ VCmpxLeF16Vop3::VCmpxLeF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11522,6 +11597,7 @@ VCmpxGtF16Vop3::VCmpxGtF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11573,6 +11649,7 @@ VCmpxLgF16Vop3::VCmpxLgF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11624,6 +11701,7 @@ VCmpxGeF16Vop3::VCmpxGeF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -11675,6 +11753,7 @@ VCmpxOF16Vop3::VCmpxOF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12137,6 +12216,7 @@ VCmpxFU64Vop3::VCmpxFU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12172,6 +12252,7 @@ VCmpxLtU64Vop3::VCmpxLtU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12210,6 +12291,7 @@ VCmpxEqU64Vop3::VCmpxEqU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12248,6 +12330,7 @@ VCmpxLeU64Vop3::VCmpxLeU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12286,6 +12369,7 @@ VCmpxGtU64Vop3::VCmpxGtU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12324,6 +12408,7 @@ VCmpxNeU64Vop3::VCmpxNeU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12362,6 +12447,7 @@ VCmpxGeU64Vop3::VCmpxGeU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12400,6 +12486,7 @@ VCmpxTU64Vop3::VCmpxTU64Vop3(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12437,6 +12524,7 @@ VCmpxUF16Vop3::VCmpxUF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12488,6 +12576,7 @@ VCmpxNgeF16Vop3::VCmpxNgeF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12539,6 +12628,7 @@ VCmpxNlgF16Vop3::VCmpxNlgF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12590,6 +12680,7 @@ VCmpxNgtF16Vop3::VCmpxNgtF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12641,6 +12732,7 @@ VCmpxNleF16Vop3::VCmpxNleF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12692,6 +12784,7 @@ VCmpxNeqF16Vop3::VCmpxNeqF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12743,6 +12836,7 @@ VCmpxNltF16Vop3::VCmpxNltF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -12794,6 +12888,7 @@ VCmpxTruF16Vop3::VCmpxTruF16Vop3(const MachineInst *inst) static_cast(( reinterpret_cast(inst)->simm32 & 0xFFFFu))); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF16Vop3::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/vopc.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/vopc.cpp index 79d6e2c32a1b..41eab38fb926 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/vopc.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna2/vopc.cpp @@ -1066,6 +1066,7 @@ VCmpxFF32Vopc::VCmpxFF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1139,6 +1140,7 @@ VCmpxLtF32Vopc::VCmpxLtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1215,6 +1217,7 @@ VCmpxEqF32Vopc::VCmpxEqF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1291,6 +1294,7 @@ VCmpxLeF32Vopc::VCmpxLeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1367,6 +1371,7 @@ VCmpxGtF32Vopc::VCmpxGtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1443,6 +1448,7 @@ VCmpxLgF32Vopc::VCmpxLgF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1519,6 +1525,7 @@ VCmpxGeF32Vopc::VCmpxGeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1595,6 +1602,7 @@ VCmpxOF32Vopc::VCmpxOF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1671,6 +1679,7 @@ VCmpxUF32Vopc::VCmpxUF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1747,6 +1756,7 @@ VCmpxNgeF32Vopc::VCmpxNgeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1823,6 +1833,7 @@ VCmpxNlgF32Vopc::VCmpxNlgF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1899,6 +1910,7 @@ VCmpxNgtF32Vopc::VCmpxNgtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -1975,6 +1987,7 @@ VCmpxNleF32Vopc::VCmpxNleF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2051,6 +2064,7 @@ VCmpxNeqF32Vopc::VCmpxNeqF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2127,6 +2141,7 @@ VCmpxNltF32Vopc::VCmpxNltF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2203,6 +2218,7 @@ VCmpxTruF32Vopc::VCmpxTruF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2728,6 +2744,7 @@ VCmpxFF64Vopc::VCmpxFF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2767,6 +2784,7 @@ VCmpxLtF64Vopc::VCmpxLtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2809,6 +2827,7 @@ VCmpxEqF64Vopc::VCmpxEqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2851,6 +2870,7 @@ VCmpxLeF64Vopc::VCmpxLeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2893,6 +2913,7 @@ VCmpxGtF64Vopc::VCmpxGtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2935,6 +2956,7 @@ VCmpxLgF64Vopc::VCmpxLgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LG_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -2977,6 +2999,7 @@ VCmpxGeF64Vopc::VCmpxGeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3019,6 +3042,7 @@ VCmpxOF64Vopc::VCmpxOF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_O_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3061,6 +3085,7 @@ VCmpxUF64Vopc::VCmpxUF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_U_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3103,6 +3128,7 @@ VCmpxNgeF64Vopc::VCmpxNgeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGE_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3145,6 +3171,7 @@ VCmpxNlgF64Vopc::VCmpxNlgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLG_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3187,6 +3214,7 @@ VCmpxNgtF64Vopc::VCmpxNgtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGT_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3229,6 +3257,7 @@ VCmpxNleF64Vopc::VCmpxNleF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLE_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3271,6 +3300,7 @@ VCmpxNeqF64Vopc::VCmpxNeqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NEQ_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3313,6 +3343,7 @@ VCmpxNltF64Vopc::VCmpxNltF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLT_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -3355,6 +3386,7 @@ VCmpxTruF64Vopc::VCmpxTruF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_TRU_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4421,6 +4453,7 @@ VCmpxFI32Vopc::VCmpxFI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4494,6 +4527,7 @@ VCmpxLtI32Vopc::VCmpxLtI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4570,6 +4604,7 @@ VCmpxEqI32Vopc::VCmpxEqI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4646,6 +4681,7 @@ VCmpxLeI32Vopc::VCmpxLeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4722,6 +4758,7 @@ VCmpxGtI32Vopc::VCmpxGtI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4798,6 +4835,7 @@ VCmpxNeI32Vopc::VCmpxNeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4874,6 +4912,7 @@ VCmpxGeI32Vopc::VCmpxGeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4950,6 +4989,7 @@ VCmpxTI32Vopc::VCmpxTI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5023,6 +5063,7 @@ VCmpxClassF32Vopc::VCmpxClassF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5123,6 +5164,7 @@ VCmpxLtI16Vopc::VCmpxLtI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5200,6 +5242,7 @@ VCmpxEqI16Vopc::VCmpxEqI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5277,6 +5320,7 @@ VCmpxLeI16Vopc::VCmpxLeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5354,6 +5398,7 @@ VCmpxGtI16Vopc::VCmpxGtI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5431,6 +5476,7 @@ VCmpxNeI16Vopc::VCmpxNeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5508,6 +5554,7 @@ VCmpxGeI16Vopc::VCmpxGeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5585,6 +5632,7 @@ VCmpxClassF16Vopc::VCmpxClassF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6305,6 +6353,7 @@ VCmpxFI64Vopc::VCmpxFI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6342,6 +6391,7 @@ VCmpxLtI64Vopc::VCmpxLtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6382,6 +6432,7 @@ VCmpxEqI64Vopc::VCmpxEqI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6422,6 +6473,7 @@ VCmpxLeI64Vopc::VCmpxLeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6462,6 +6514,7 @@ VCmpxGtI64Vopc::VCmpxGtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6502,6 +6555,7 @@ VCmpxNeI64Vopc::VCmpxNeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6542,6 +6596,7 @@ VCmpxGeI64Vopc::VCmpxGeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6582,6 +6637,7 @@ VCmpxTI64Vopc::VCmpxTI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_I64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6621,6 +6677,7 @@ VCmpxClassF64Vopc::VCmpxClassF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_CLASS_F64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6701,6 +6758,7 @@ VCmpxLtU16Vopc::VCmpxLtU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6778,6 +6836,7 @@ VCmpxEqU16Vopc::VCmpxEqU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6855,6 +6914,7 @@ VCmpxLeU16Vopc::VCmpxLeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6932,6 +6992,7 @@ VCmpxGtU16Vopc::VCmpxGtU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7009,6 +7070,7 @@ VCmpxNeU16Vopc::VCmpxNeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7086,6 +7148,7 @@ VCmpxGeU16Vopc::VCmpxGeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8178,6 +8241,7 @@ VCmpxFU32Vopc::VCmpxFU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8251,6 +8315,7 @@ VCmpxLtU32Vopc::VCmpxLtU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8327,6 +8392,7 @@ VCmpxEqU32Vopc::VCmpxEqU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8403,6 +8469,7 @@ VCmpxLeU32Vopc::VCmpxLeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8479,6 +8546,7 @@ VCmpxGtU32Vopc::VCmpxGtU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8555,6 +8623,7 @@ VCmpxNeU32Vopc::VCmpxNeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8631,6 +8700,7 @@ VCmpxGeU32Vopc::VCmpxGeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8707,6 +8777,7 @@ VCmpxTU32Vopc::VCmpxTU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8781,6 +8852,7 @@ VCmpxFF16Vopc::VCmpxFF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8855,6 +8927,7 @@ VCmpxLtF16Vopc::VCmpxLtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8934,6 +9007,7 @@ VCmpxEqF16Vopc::VCmpxEqF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9013,6 +9087,7 @@ VCmpxLeF16Vopc::VCmpxLeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9092,6 +9167,7 @@ VCmpxGtF16Vopc::VCmpxGtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9171,6 +9247,7 @@ VCmpxLgF16Vopc::VCmpxLgF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9250,6 +9327,7 @@ VCmpxGeF16Vopc::VCmpxGeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9329,6 +9407,7 @@ VCmpxOF16Vopc::VCmpxOF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10121,6 +10200,7 @@ VCmpxFU64Vopc::VCmpxFU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10158,6 +10238,7 @@ VCmpxLtU64Vopc::VCmpxLtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10198,6 +10279,7 @@ VCmpxEqU64Vopc::VCmpxEqU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10238,6 +10320,7 @@ VCmpxLeU64Vopc::VCmpxLeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10278,6 +10361,7 @@ VCmpxGtU64Vopc::VCmpxGtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10318,6 +10402,7 @@ VCmpxNeU64Vopc::VCmpxNeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10358,6 +10443,7 @@ VCmpxGeU64Vopc::VCmpxGeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10398,6 +10484,7 @@ VCmpxTU64Vopc::VCmpxTU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_U64 does not support SDWA", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10450,6 +10537,7 @@ VCmpxUF16Vopc::VCmpxUF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10529,6 +10617,7 @@ VCmpxNgeF16Vopc::VCmpxNgeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10608,6 +10697,7 @@ VCmpxNlgF16Vopc::VCmpxNlgF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10687,6 +10777,7 @@ VCmpxNgtF16Vopc::VCmpxNgtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10766,6 +10857,7 @@ VCmpxNleF16Vopc::VCmpxNleF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10845,6 +10937,7 @@ VCmpxNeqF16Vopc::VCmpxNeqF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10924,6 +11017,7 @@ VCmpxNltF16Vopc::VCmpxNltF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -11003,6 +11097,7 @@ VCmpxTruF16Vopc::VCmpxTruF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTruF16Vopc::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/operand.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/operand.cpp index 71d620019aca..dcf8d00c0e0b 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/operand.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/operand.cpp @@ -5,6 +5,7 @@ // See lib/python/amdisa/README.md for regeneration instructions. #include "rocjitsu/isa/arch/amdgpu/rdna3/operand.h" +#include "rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h" #include "rocjitsu/isa/isa_operand_simd_inl.h" #include "rocjitsu/vm/amdgpu/compute_unit.h" #include "rocjitsu/vm/amdgpu/register_access.h" @@ -94,6 +95,16 @@ std::optional Operand::literal64_value() const { return literal64_value_; } +std::optional Operand::const_value() const { + if (has_literal64_) + return literal64_value_; + if (is_immediate_type(opr_type_)) + return static_cast(static_cast(encoding_value_)); + if (to_register_ref()) + return std::nullopt; + return amdgpu::resolve_src_scalar_statically(encoding_value_); +} + std::string Operand::name() const { if (has_literal64_) return std::format("0x{:x}", literal64_value_); @@ -593,6 +604,8 @@ std::optional Operand::to_register_ref() const { break; } case OperandType::OPR_EXEC: { + if (encoding_value_ == OpSelExec::OPR_EXEC_EXEC) + return RegisterRef{RegClass::EXEC, 0, reg_width}; break; } case OperandType::OPR_FLAT_SCRATCH: { @@ -607,9 +620,17 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSdst::OPR_SDST_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_EXEC: { + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_M0: { @@ -633,6 +654,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSrc::OPR_SRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrc::OPR_SRC_VGPR_MIN && encoding_value_ <= OpSelSrc::OPR_SRC_VGPR_MAX) return RegisterRef{RegClass::VGPR, @@ -681,6 +706,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrc::OPR_SSRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_LANESEL: { @@ -717,258 +746,12 @@ std::optional Operand::to_register_ref() const { namespace { -uint32_t resolve_src_scalar(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return static_cast(wf.scratch_base()); - if (ev == 103) - return static_cast(wf.scratch_base() >> 32); - if (ev <= 105) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 106) - return static_cast(wf.vcc()); - if (ev == 107) - return static_cast(wf.vcc() >> 32); - if (ev >= 108 && ev <= 123) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 124) - return 0u; // NULL - if (ev == 125) - return wf.m0(); - if (ev == 126) - return static_cast(wf.exec()); - if (ev == 127) - return static_cast(wf.exec_raw() >> 32); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(-(ev - 192))); - if (ev == 230) - return static_cast(wf.scratch_base()); // SRC_FLAT_SCRATCH_BASE_LO - if (ev == 231) - return static_cast(wf.scratch_base() >> 32); // SRC_FLAT_SCRATCH_BASE_HI - if (ev == 240) - return 0x3F000000u; // 0.5f - if (ev == 241) - return 0xBF000000u; // -0.5f - if (ev == 242) - return 0x3F800000u; // 1.0f - if (ev == 243) - return 0xBF800000u; // -1.0f - if (ev == 244) - return 0x40000000u; // 2.0f - if (ev == 245) - return 0xC0000000u; // -2.0f - if (ev == 246) - return 0x40800000u; // 4.0f - if (ev == 247) - return 0xC0800000u; // -4.0f - if (ev == 248) - return 0x3E22F983u; // 1/(2*pi) - if (ev == 235) - return static_cast(wf.shared_aperture_base() >> 32); // SRC_SHARED_BASE - if (ev == 236) - return static_cast(wf.shared_aperture_limit() >> 32); // SRC_SHARED_LIMIT - if (ev == 237) - return static_cast(wf.private_aperture_base() >> 32); // SRC_PRIVATE_BASE - if (ev == 238) - return static_cast(wf.private_aperture_limit() >> 32); // SRC_PRIVATE_LIMIT - if (ev == 249) - return 0u; // SRC_POPS_EXITING_WAVE_ID (not used in compute) - if (ev == 250) - return 0u; // NULL - if (ev == 251) - return (wf.vcc() & (wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL))) == 0 - ? 1u - : 0u; // VCCZ - if (ev == 252) { - uint64_t active = wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL); - return (wf.exec() & active) == 0 ? 1u : 0u; // EXECZ - } - if (ev == 253) - return wf.read_scc() ? 1u : 0u; // SCC - throw std::logic_error("Unsupported encoding value for scalar read: " + std::to_string(ev)); -} - -uint32_t resolve_src_scalar16(const amdgpu::Wavefront &wf, int ev) { - switch (ev) { - case 240: - return 0x3800u; // 0.5h - case 241: - return 0xB800u; // -0.5h - case 242: - return 0x3C00u; // 1.0h - case 243: - return 0xBC00u; // -1.0h - case 244: - return 0x4000u; // 2.0h - case 245: - return 0xC000u; // -2.0h - case 246: - return 0x4400u; // 4.0h - case 247: - return 0xC400u; // -4.0h - case 248: - return 0x3118u; // f16 1/(2*pi) - default: - return resolve_src_scalar(wf, ev); - } -} - -// Must stay in sync with resolve_src_scalar above — returns true for -// exactly the encoding values that resolve_src_scalar handles without -// throwing. Used by Isa::simd_capable_value() to keep the SIMD fast -// path off operands whose scalar broadcast would throw at runtime. -bool can_resolve_src_scalar(int ev) { - return (ev >= 0 && ev <= 107) || (ev >= 108 && ev <= 123) || ev == 124 || ev == 125 || - ev == 126 || ev == 127 || (ev >= 128 && ev <= 208) || ev == 230 || ev == 231 || - (ev >= 235 && ev <= 238) || (ev >= 240 && ev <= 253); -} - -uint64_t resolve_src_scalar64(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return wf.scratch_base(); - if (ev <= 105) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 106) - return wf.vcc(); - if (ev >= 108 && ev <= 122) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 124) - return 0u; // NULL - if (ev == 125) - return wf.m0(); - if (ev == 126) - return wf.exec_raw(); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(static_cast(-(ev - 192)))); - if (ev == 230) - return wf.scratch_base(); // SRC_FLAT_SCRATCH_BASE - if (ev == 240) - return 0x3FE0000000000000ULL; // 0.5 - if (ev == 241) - return 0xBFE0000000000000ULL; // -0.5 - if (ev == 242) - return 0x3FF0000000000000ULL; // 1.0 - if (ev == 243) - return 0xBFF0000000000000ULL; // -1.0 - if (ev == 244) - return 0x4000000000000000ULL; // 2.0 - if (ev == 245) - return 0xC000000000000000ULL; // -2.0 - if (ev == 246) - return 0x4010000000000000ULL; // 4.0 - if (ev == 247) - return 0xC010000000000000ULL; // -4.0 - if (ev == 248) - return 0x3FC45F306DC9C883ULL; // 1/(2*pi) - if (ev == 235) - return wf.shared_aperture_base(); // SRC_SHARED_BASE - if (ev == 236) - return wf.shared_aperture_limit(); // SRC_SHARED_LIMIT - if (ev == 237) - return wf.private_aperture_base(); // SRC_PRIVATE_BASE - if (ev == 238) - return wf.private_aperture_limit(); // SRC_PRIVATE_LIMIT - throw std::logic_error("Unsupported encoding value for scalar64 read: " + std::to_string(ev)); -} - -void resolve_dst_write(amdgpu::Wavefront &wf, int ev, uint32_t val) { - if (ev == 102) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 103) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 106) { - wf.set_vcc((wf.vcc() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 107) { - wf.set_vcc((wf.vcc() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev >= 108 && ev <= 123) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 124) - return; - if (ev == 125) { - wf.set_m0(val); - return; - } - if (ev == 126) { - wf.set_exec((wf.exec() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 127) { - wf.set_exec_raw((wf.exec_raw() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - throw std::logic_error("Unsupported encoding value for scalar write: " + std::to_string(ev)); -} - -void resolve_dst_write64(amdgpu::Wavefront &wf, int ev, uint64_t val) { - if (ev == 102) { - wf.set_scratch_base(val); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 106) { - wf.set_vcc(val); - return; - } - if (ev >= 108 && ev <= 122) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 124) - return; - if (ev == 126) { - wf.set_exec_raw(val); - return; - } - throw std::logic_error("Unsupported encoding value for scalar64 write: " + std::to_string(ev)); -} +constexpr int kM0EncodingValue = 125; bool is_vgpr_only_type(OperandType t) { return t == OperandType::OPR_VGPR || t == OperandType::OPR_SRC_VGPR; } -bool is_immediate_type(OperandType t) { - return t == OperandType::OPR_SIMM16 || t == OperandType::OPR_SIMM32 || - t == OperandType::OPR_LABEL || t == OperandType::OPR_WAITCNT; -} - uint32_t vgpr_index(OperandType opr_type, int ev) { if (opr_type == OperandType::OPR_VGPR) return static_cast(ev); @@ -997,11 +780,12 @@ std::optional Isa::resolved_vgpr_offset(OperandType opr_type, int ev) bool Isa::simd_capable_value(OperandType opr_type, int ev) { return resolved_vgpr_offset(opr_type, ev).has_value() || is_immediate_type(opr_type) || - can_resolve_src_scalar(ev); + amdgpu::can_resolve_src_scalar(ev, kM0EncodingValue); } uint32_t Isa::simd_broadcast_value(const amdgpu::Wavefront &wf, OperandType opr_type, int ev) { - return is_immediate_type(opr_type) ? static_cast(ev) : resolve_src_scalar(wf, ev); + return is_immediate_type(opr_type) ? static_cast(ev) + : amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } bool Operand::simd_capable() const { @@ -1058,7 +842,7 @@ uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { return static_cast(literal64_value_); if (is_immediate_type(opr_type_)) return static_cast(encoding_value_); - return resolve_src_scalar(wf, encoding_value_); + return amdgpu::resolve_src_scalar(wf, encoding_value_, kM0EncodingValue); } uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { @@ -1087,8 +871,8 @@ uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { if (is_immediate_type(opr_type_)) return static_cast(ev); if (size_bits_ == 16) - return resolve_src_scalar16(wf, ev); - return resolve_src_scalar(wf, ev); + return amdgpu::resolve_src_scalar16(wf, ev, kM0EncodingValue); + return amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { @@ -1098,7 +882,7 @@ void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write(wf, encoding_value_, val); + amdgpu::resolve_dst_write(wf, encoding_value_, val, kM0EncodingValue); } void Operand::write_lane(amdgpu::Wavefront &wf, uint32_t lane, uint32_t val) const { @@ -1146,7 +930,7 @@ uint64_t Operand::read_lane64(const amdgpu::Wavefront &wf, uint32_t lane) const return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, ev); - return resolve_src_scalar64(wf, ev); + return amdgpu::resolve_src_scalar64(wf, ev, kM0EncodingValue); } void Operand::write_lane64(amdgpu::Wavefront &wf, uint32_t lane, uint64_t val) const { @@ -1176,7 +960,7 @@ uint64_t Operand::read_scalar64(const amdgpu::Wavefront &wf) const { return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, encoding_value_); - return resolve_src_scalar64(wf, encoding_value_); + return amdgpu::resolve_src_scalar64(wf, encoding_value_, kM0EncodingValue); } void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { @@ -1186,7 +970,7 @@ void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write64(wf, encoding_value_, val); + amdgpu::resolve_dst_write64(wf, encoding_value_, val); } } // namespace rdna3 diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/operand.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/operand.h index 3f44fb8de607..cd708ae429a5 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/operand.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/operand.h @@ -26,6 +26,7 @@ class Operand : public AmdgpuIsaOperand { Operand(int size_bits, OperandType opr_type, uint64_t literal64_value, bool is_literal64); std::string name() const override; std::optional literal64_value() const override; + std::optional const_value() const override; std::optional to_register_ref() const override; bool simd_capable() const override; diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/operand_types.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/operand_types.h index a1ce5fa12ac7..52d7438d58ec 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/operand_types.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/operand_types.h @@ -313,6 +313,18 @@ enum OpSelVgpr { } } +[[nodiscard]] constexpr bool is_immediate_type(OperandType t) { + switch (t) { + case OperandType::OPR_SIMM16: + case OperandType::OPR_SIMM32: + case OperandType::OPR_LABEL: + case OperandType::OPR_WAITCNT: + return true; + default: + return false; + } +} + } // namespace rdna3 } // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/sop1.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/sop1.cpp index e266a37d0b9e..892c036ae53a 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/sop1.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/sop1.cpp @@ -33,6 +33,7 @@ SMovB32Sop1::SMovB32Sop1(const MachineInst *inst) ssrc0 = Operand( 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB32Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b32_sop1(*this, wf); } @@ -49,6 +50,7 @@ SMovB64Sop1::SMovB64Sop1(const MachineInst *inst) ssrc0 = Operand( 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB64Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b64_sop1(*this, wf); } @@ -634,6 +636,7 @@ SAndSaveexecB32Sop1::SAndSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -662,6 +665,7 @@ SAndSaveexecB64Sop1::SAndSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -690,6 +694,8 @@ SOrSaveexecB32Sop1::SOrSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } void SOrSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -718,6 +724,8 @@ SOrSaveexecB64Sop1::SOrSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } void SOrSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -746,6 +754,7 @@ SXorSaveexecB32Sop1::SXorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -774,6 +783,7 @@ SXorSaveexecB64Sop1::SXorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -802,6 +812,7 @@ SNandSaveexecB32Sop1::SNandSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNandSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -830,6 +841,7 @@ SNandSaveexecB64Sop1::SNandSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNandSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -858,6 +870,7 @@ SNorSaveexecB32Sop1::SNorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -886,6 +899,7 @@ SNorSaveexecB64Sop1::SNorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -914,6 +928,7 @@ SXnorSaveexecB32Sop1::SXnorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXnorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -942,6 +957,7 @@ SXnorSaveexecB64Sop1::SXnorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXnorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -970,6 +986,7 @@ SAndNot0SaveexecB32Sop1::SAndNot0SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot0SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -998,6 +1015,7 @@ SAndNot0SaveexecB64Sop1::SAndNot0SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot0SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1026,6 +1044,7 @@ SOrNot0SaveexecB32Sop1::SOrNot0SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrNot0SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1054,6 +1073,7 @@ SOrNot0SaveexecB64Sop1::SOrNot0SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrNot0SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1082,6 +1102,7 @@ SAndNot1SaveexecB32Sop1::SAndNot1SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot1SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1110,6 +1131,7 @@ SAndNot1SaveexecB64Sop1::SAndNot1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1138,6 +1160,7 @@ SOrNot1SaveexecB32Sop1::SOrNot1SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrNot1SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1166,6 +1189,7 @@ SOrNot1SaveexecB64Sop1::SOrNot1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrNot1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1194,6 +1218,7 @@ SAndNot0WrexecB32Sop1::SAndNot0WrexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot0WrexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1222,6 +1247,7 @@ SAndNot0WrexecB64Sop1::SAndNot0WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot0WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1250,6 +1276,7 @@ SAndNot1WrexecB32Sop1::SAndNot1WrexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot1WrexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1278,6 +1305,7 @@ SAndNot1WrexecB64Sop1::SAndNot1WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot1WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/sop2.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/sop2.cpp index eacc5a1e486a..01ca6c04cb54 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/sop2.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/sop2.cpp @@ -650,6 +650,7 @@ SOrB32Sop2::SOrB32Sop2(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB32Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b32_sop2(*this, wf); } @@ -675,6 +676,7 @@ SOrB64Sop2::SOrB64Sop2(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB64Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b64_sop2(*this, wf); } diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/sopp.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/sopp.cpp index e15e10895131..00c189ca3f83 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/sopp.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/sopp.cpp @@ -206,6 +206,7 @@ SBranchSopp::SBranchSopp(const MachineInst *inst) num_src_ = 1; num_dst_ = 0; flags_ |= BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SBranchSopp::branch_offset_bytes() const { @@ -229,6 +230,7 @@ SCbranchScc0Sopp::SCbranchScc0Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc0Sopp::branch_offset_bytes() const { @@ -254,6 +256,7 @@ SCbranchScc1Sopp::SCbranchScc1Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc1Sopp::branch_offset_bytes() const { @@ -279,6 +282,7 @@ SCbranchVcczSopp::SCbranchVcczSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVcczSopp::branch_offset_bytes() const { @@ -306,6 +310,7 @@ SCbranchVccnzSopp::SCbranchVccnzSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVccnzSopp::branch_offset_bytes() const { @@ -333,6 +338,7 @@ SCbranchExeczSopp::SCbranchExeczSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExeczSopp::branch_offset_bytes() const { @@ -358,6 +364,7 @@ SCbranchExecnzSopp::SCbranchExecnzSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExecnzSopp::branch_offset_bytes() const { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/vop3.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/vop3.cpp index 4ee75f15bb36..bc446ccb3aeb 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/vop3.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/vop3.cpp @@ -18854,6 +18854,7 @@ VCmpxFF16Vop3::VCmpxFF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -18923,6 +18924,7 @@ VCmpxLtF16Vop3::VCmpxLtF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19006,6 +19008,7 @@ VCmpxEqF16Vop3::VCmpxEqF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19089,6 +19092,7 @@ VCmpxLeF16Vop3::VCmpxLeF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19172,6 +19176,7 @@ VCmpxGtF16Vop3::VCmpxGtF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19255,6 +19260,7 @@ VCmpxLgF16Vop3::VCmpxLgF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19338,6 +19344,7 @@ VCmpxGeF16Vop3::VCmpxGeF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19421,6 +19428,7 @@ VCmpxOF16Vop3::VCmpxOF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19504,6 +19512,7 @@ VCmpxUF16Vop3::VCmpxUF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19587,6 +19596,7 @@ VCmpxNgeF16Vop3::VCmpxNgeF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19670,6 +19680,7 @@ VCmpxNlgF16Vop3::VCmpxNlgF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19753,6 +19764,7 @@ VCmpxNgtF16Vop3::VCmpxNgtF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19836,6 +19848,7 @@ VCmpxNleF16Vop3::VCmpxNleF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19919,6 +19932,7 @@ VCmpxNeqF16Vop3::VCmpxNeqF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20002,6 +20016,7 @@ VCmpxNltF16Vop3::VCmpxNltF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20085,6 +20100,7 @@ VCmpxTF16Vop3::VCmpxTF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20146,6 +20162,7 @@ VCmpxFF32Vop3::VCmpxFF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20205,6 +20222,7 @@ VCmpxLtF32Vop3::VCmpxLtF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20275,6 +20293,7 @@ VCmpxEqF32Vop3::VCmpxEqF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20345,6 +20364,7 @@ VCmpxLeF32Vop3::VCmpxLeF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20415,6 +20435,7 @@ VCmpxGtF32Vop3::VCmpxGtF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20485,6 +20506,7 @@ VCmpxLgF32Vop3::VCmpxLgF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20555,6 +20577,7 @@ VCmpxGeF32Vop3::VCmpxGeF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20625,6 +20648,7 @@ VCmpxOF32Vop3::VCmpxOF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20695,6 +20719,7 @@ VCmpxUF32Vop3::VCmpxUF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20765,6 +20790,7 @@ VCmpxNgeF32Vop3::VCmpxNgeF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20835,6 +20861,7 @@ VCmpxNlgF32Vop3::VCmpxNlgF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20905,6 +20932,7 @@ VCmpxNgtF32Vop3::VCmpxNgtF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20975,6 +21003,7 @@ VCmpxNleF32Vop3::VCmpxNleF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21045,6 +21074,7 @@ VCmpxNeqF32Vop3::VCmpxNeqF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21115,6 +21145,7 @@ VCmpxNltF32Vop3::VCmpxNltF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21185,6 +21216,7 @@ VCmpxTF32Vop3::VCmpxTF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21234,6 +21266,7 @@ VCmpxFF64Vop3::VCmpxFF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_F_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21276,6 +21309,7 @@ VCmpxLtF64Vop3::VCmpxLtF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LT_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21329,6 +21363,7 @@ VCmpxEqF64Vop3::VCmpxEqF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_EQ_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21382,6 +21417,7 @@ VCmpxLeF64Vop3::VCmpxLeF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LE_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21435,6 +21471,7 @@ VCmpxGtF64Vop3::VCmpxGtF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GT_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21488,6 +21525,7 @@ VCmpxLgF64Vop3::VCmpxLgF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LG_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21541,6 +21579,7 @@ VCmpxGeF64Vop3::VCmpxGeF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GE_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21594,6 +21633,7 @@ VCmpxOF64Vop3::VCmpxOF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_O_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21647,6 +21687,7 @@ VCmpxUF64Vop3::VCmpxUF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_U_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21700,6 +21741,7 @@ VCmpxNgeF64Vop3::VCmpxNgeF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NGE_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21753,6 +21795,7 @@ VCmpxNlgF64Vop3::VCmpxNlgF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NLG_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21806,6 +21849,7 @@ VCmpxNgtF64Vop3::VCmpxNgtF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NGT_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21859,6 +21903,7 @@ VCmpxNleF64Vop3::VCmpxNleF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NLE_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21912,6 +21957,7 @@ VCmpxNeqF64Vop3::VCmpxNeqF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NEQ_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21965,6 +22011,7 @@ VCmpxNltF64Vop3::VCmpxNltF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NLT_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22018,6 +22065,7 @@ VCmpxTF64Vop3::VCmpxTF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_T_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22078,6 +22126,7 @@ VCmpxLtI16Vop3::VCmpxLtI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22157,6 +22206,7 @@ VCmpxEqI16Vop3::VCmpxEqI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22236,6 +22286,7 @@ VCmpxLeI16Vop3::VCmpxLeI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22315,6 +22366,7 @@ VCmpxGtI16Vop3::VCmpxGtI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22394,6 +22446,7 @@ VCmpxNeI16Vop3::VCmpxNeI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22473,6 +22526,7 @@ VCmpxGeI16Vop3::VCmpxGeI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22552,6 +22606,7 @@ VCmpxLtU16Vop3::VCmpxLtU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22631,6 +22686,7 @@ VCmpxEqU16Vop3::VCmpxEqU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22710,6 +22766,7 @@ VCmpxLeU16Vop3::VCmpxLeU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22789,6 +22846,7 @@ VCmpxGtU16Vop3::VCmpxGtU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22868,6 +22926,7 @@ VCmpxNeU16Vop3::VCmpxNeU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22947,6 +23006,7 @@ VCmpxGeU16Vop3::VCmpxGeU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23018,6 +23078,7 @@ VCmpxFI32Vop3::VCmpxFI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23077,6 +23138,7 @@ VCmpxLtI32Vop3::VCmpxLtI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23139,6 +23201,7 @@ VCmpxEqI32Vop3::VCmpxEqI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23201,6 +23264,7 @@ VCmpxLeI32Vop3::VCmpxLeI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23263,6 +23327,7 @@ VCmpxGtI32Vop3::VCmpxGtI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23325,6 +23390,7 @@ VCmpxNeI32Vop3::VCmpxNeI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23387,6 +23453,7 @@ VCmpxGeI32Vop3::VCmpxGeI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23449,6 +23516,7 @@ VCmpxTI32Vop3::VCmpxTI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23508,6 +23576,7 @@ VCmpxFU32Vop3::VCmpxFU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23567,6 +23636,7 @@ VCmpxLtU32Vop3::VCmpxLtU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23629,6 +23699,7 @@ VCmpxEqU32Vop3::VCmpxEqU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23691,6 +23762,7 @@ VCmpxLeU32Vop3::VCmpxLeU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23753,6 +23825,7 @@ VCmpxGtU32Vop3::VCmpxGtU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23815,6 +23888,7 @@ VCmpxNeU32Vop3::VCmpxNeU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23877,6 +23951,7 @@ VCmpxGeU32Vop3::VCmpxGeU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23939,6 +24014,7 @@ VCmpxTU32Vop3::VCmpxTU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23984,6 +24060,7 @@ VCmpxFI64Vop3::VCmpxFI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_F_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24022,6 +24099,7 @@ VCmpxLtI64Vop3::VCmpxLtI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LT_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24063,6 +24141,7 @@ VCmpxEqI64Vop3::VCmpxEqI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_EQ_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24104,6 +24183,7 @@ VCmpxLeI64Vop3::VCmpxLeI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LE_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24145,6 +24225,7 @@ VCmpxGtI64Vop3::VCmpxGtI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GT_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24186,6 +24267,7 @@ VCmpxNeI64Vop3::VCmpxNeI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NE_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24227,6 +24309,7 @@ VCmpxGeI64Vop3::VCmpxGeI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GE_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24268,6 +24351,7 @@ VCmpxTI64Vop3::VCmpxTI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_T_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24306,6 +24390,7 @@ VCmpxFU64Vop3::VCmpxFU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_F_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24344,6 +24429,7 @@ VCmpxLtU64Vop3::VCmpxLtU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LT_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24385,6 +24471,7 @@ VCmpxEqU64Vop3::VCmpxEqU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_EQ_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24426,6 +24513,7 @@ VCmpxLeU64Vop3::VCmpxLeU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LE_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24467,6 +24555,7 @@ VCmpxGtU64Vop3::VCmpxGtU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GT_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24508,6 +24597,7 @@ VCmpxNeU64Vop3::VCmpxNeU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NE_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24549,6 +24639,7 @@ VCmpxGeU64Vop3::VCmpxGeU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GE_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24590,6 +24681,7 @@ VCmpxTU64Vop3::VCmpxTU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_T_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24650,6 +24742,7 @@ VCmpxClassF16Vop3::VCmpxClassF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24749,6 +24842,7 @@ VCmpxClassF32Vop3::VCmpxClassF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24826,6 +24920,7 @@ VCmpxClassF64Vop3::VCmpxClassF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_CLASS_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vop3::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/vopc.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/vopc.cpp index d34f6308c053..a4e652499ffc 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/vopc.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3/vopc.cpp @@ -4539,6 +4539,7 @@ VCmpxFF16Vopc::VCmpxFF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4613,6 +4614,7 @@ VCmpxLtF16Vopc::VCmpxLtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4692,6 +4694,7 @@ VCmpxEqF16Vopc::VCmpxEqF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4771,6 +4774,7 @@ VCmpxLeF16Vopc::VCmpxLeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4850,6 +4854,7 @@ VCmpxGtF16Vopc::VCmpxGtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4929,6 +4934,7 @@ VCmpxLgF16Vopc::VCmpxLgF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5008,6 +5014,7 @@ VCmpxGeF16Vopc::VCmpxGeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5087,6 +5094,7 @@ VCmpxOF16Vopc::VCmpxOF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5166,6 +5174,7 @@ VCmpxUF16Vopc::VCmpxUF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5245,6 +5254,7 @@ VCmpxNgeF16Vopc::VCmpxNgeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5324,6 +5334,7 @@ VCmpxNlgF16Vopc::VCmpxNlgF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5403,6 +5414,7 @@ VCmpxNgtF16Vopc::VCmpxNgtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5482,6 +5494,7 @@ VCmpxNleF16Vopc::VCmpxNleF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5561,6 +5574,7 @@ VCmpxNeqF16Vopc::VCmpxNeqF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5640,6 +5654,7 @@ VCmpxNltF16Vopc::VCmpxNltF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5719,6 +5734,7 @@ VCmpxTF16Vopc::VCmpxTF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5790,6 +5806,7 @@ VCmpxFF32Vopc::VCmpxFF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5861,6 +5878,7 @@ VCmpxLtF32Vopc::VCmpxLtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5935,6 +5953,7 @@ VCmpxEqF32Vopc::VCmpxEqF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6009,6 +6028,7 @@ VCmpxLeF32Vopc::VCmpxLeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6083,6 +6103,7 @@ VCmpxGtF32Vopc::VCmpxGtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6157,6 +6178,7 @@ VCmpxLgF32Vopc::VCmpxLgF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6231,6 +6253,7 @@ VCmpxGeF32Vopc::VCmpxGeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6305,6 +6328,7 @@ VCmpxOF32Vopc::VCmpxOF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6379,6 +6403,7 @@ VCmpxUF32Vopc::VCmpxUF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6453,6 +6478,7 @@ VCmpxNgeF32Vopc::VCmpxNgeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6527,6 +6553,7 @@ VCmpxNlgF32Vopc::VCmpxNlgF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6601,6 +6628,7 @@ VCmpxNgtF32Vopc::VCmpxNgtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6675,6 +6703,7 @@ VCmpxNleF32Vopc::VCmpxNleF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6749,6 +6778,7 @@ VCmpxNeqF32Vopc::VCmpxNeqF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6823,6 +6853,7 @@ VCmpxNltF32Vopc::VCmpxNltF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6897,6 +6928,7 @@ VCmpxTF32Vopc::VCmpxTF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6956,6 +6988,7 @@ VCmpxFF64Vopc::VCmpxFF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6993,6 +7026,7 @@ VCmpxLtF64Vopc::VCmpxLtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7033,6 +7067,7 @@ VCmpxEqF64Vopc::VCmpxEqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7073,6 +7108,7 @@ VCmpxLeF64Vopc::VCmpxLeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7113,6 +7149,7 @@ VCmpxGtF64Vopc::VCmpxGtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7153,6 +7190,7 @@ VCmpxLgF64Vopc::VCmpxLgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LG_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7193,6 +7231,7 @@ VCmpxGeF64Vopc::VCmpxGeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7233,6 +7272,7 @@ VCmpxOF64Vopc::VCmpxOF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_O_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7273,6 +7313,7 @@ VCmpxUF64Vopc::VCmpxUF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_U_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7313,6 +7354,7 @@ VCmpxNgeF64Vopc::VCmpxNgeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGE_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7353,6 +7395,7 @@ VCmpxNlgF64Vopc::VCmpxNlgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLG_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7393,6 +7436,7 @@ VCmpxNgtF64Vopc::VCmpxNgtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGT_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7433,6 +7477,7 @@ VCmpxNleF64Vopc::VCmpxNleF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLE_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7473,6 +7518,7 @@ VCmpxNeqF64Vopc::VCmpxNeqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NEQ_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7513,6 +7559,7 @@ VCmpxNltF64Vopc::VCmpxNltF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLT_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7553,6 +7600,7 @@ VCmpxTF64Vopc::VCmpxTF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7605,6 +7653,7 @@ VCmpxLtI16Vopc::VCmpxLtI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7682,6 +7731,7 @@ VCmpxEqI16Vopc::VCmpxEqI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7759,6 +7809,7 @@ VCmpxLeI16Vopc::VCmpxLeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7836,6 +7887,7 @@ VCmpxGtI16Vopc::VCmpxGtI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7913,6 +7965,7 @@ VCmpxNeI16Vopc::VCmpxNeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7990,6 +8043,7 @@ VCmpxGeI16Vopc::VCmpxGeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8067,6 +8121,7 @@ VCmpxLtU16Vopc::VCmpxLtU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8144,6 +8199,7 @@ VCmpxEqU16Vopc::VCmpxEqU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8221,6 +8277,7 @@ VCmpxLeU16Vopc::VCmpxLeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8298,6 +8355,7 @@ VCmpxGtU16Vopc::VCmpxGtU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8375,6 +8433,7 @@ VCmpxNeU16Vopc::VCmpxNeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8452,6 +8511,7 @@ VCmpxGeU16Vopc::VCmpxGeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8526,6 +8586,7 @@ VCmpxFI32Vopc::VCmpxFI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8597,6 +8658,7 @@ VCmpxLtI32Vopc::VCmpxLtI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8671,6 +8733,7 @@ VCmpxEqI32Vopc::VCmpxEqI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8745,6 +8808,7 @@ VCmpxLeI32Vopc::VCmpxLeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8819,6 +8883,7 @@ VCmpxGtI32Vopc::VCmpxGtI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8893,6 +8958,7 @@ VCmpxNeI32Vopc::VCmpxNeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8967,6 +9033,7 @@ VCmpxGeI32Vopc::VCmpxGeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9041,6 +9108,7 @@ VCmpxTI32Vopc::VCmpxTI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9112,6 +9180,7 @@ VCmpxFU32Vopc::VCmpxFU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9183,6 +9252,7 @@ VCmpxLtU32Vopc::VCmpxLtU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9257,6 +9327,7 @@ VCmpxEqU32Vopc::VCmpxEqU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9331,6 +9402,7 @@ VCmpxLeU32Vopc::VCmpxLeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9405,6 +9477,7 @@ VCmpxGtU32Vopc::VCmpxGtU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9479,6 +9552,7 @@ VCmpxNeU32Vopc::VCmpxNeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9553,6 +9627,7 @@ VCmpxGeU32Vopc::VCmpxGeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9627,6 +9702,7 @@ VCmpxTU32Vopc::VCmpxTU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9684,6 +9760,7 @@ VCmpxFI64Vopc::VCmpxFI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9719,6 +9796,7 @@ VCmpxLtI64Vopc::VCmpxLtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9757,6 +9835,7 @@ VCmpxEqI64Vopc::VCmpxEqI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9795,6 +9874,7 @@ VCmpxLeI64Vopc::VCmpxLeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9833,6 +9913,7 @@ VCmpxGtI64Vopc::VCmpxGtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9871,6 +9952,7 @@ VCmpxNeI64Vopc::VCmpxNeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9909,6 +9991,7 @@ VCmpxGeI64Vopc::VCmpxGeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9947,6 +10030,7 @@ VCmpxTI64Vopc::VCmpxTI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9982,6 +10066,7 @@ VCmpxFU64Vopc::VCmpxFU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10017,6 +10102,7 @@ VCmpxLtU64Vopc::VCmpxLtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10055,6 +10141,7 @@ VCmpxEqU64Vopc::VCmpxEqU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10093,6 +10180,7 @@ VCmpxLeU64Vopc::VCmpxLeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10131,6 +10219,7 @@ VCmpxGtU64Vopc::VCmpxGtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10169,6 +10258,7 @@ VCmpxNeU64Vopc::VCmpxNeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10207,6 +10297,7 @@ VCmpxGeU64Vopc::VCmpxGeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10245,6 +10336,7 @@ VCmpxTU64Vopc::VCmpxTU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10297,6 +10389,7 @@ VCmpxClassF16Vopc::VCmpxClassF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10400,6 +10493,7 @@ VCmpxClassF32Vopc::VCmpxClassF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10485,6 +10579,7 @@ VCmpxClassF64Vopc::VCmpxClassF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_CLASS_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vopc::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/operand.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/operand.cpp index a5302b368f93..457df73657a3 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/operand.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/operand.cpp @@ -5,6 +5,7 @@ // See lib/python/amdisa/README.md for regeneration instructions. #include "rocjitsu/isa/arch/amdgpu/rdna3_5/operand.h" +#include "rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h" #include "rocjitsu/isa/isa_operand_simd_inl.h" #include "rocjitsu/vm/amdgpu/compute_unit.h" #include "rocjitsu/vm/amdgpu/register_access.h" @@ -94,6 +95,16 @@ std::optional Operand::literal64_value() const { return literal64_value_; } +std::optional Operand::const_value() const { + if (has_literal64_) + return literal64_value_; + if (is_immediate_type(opr_type_)) + return static_cast(static_cast(encoding_value_)); + if (to_register_ref()) + return std::nullopt; + return amdgpu::resolve_src_scalar_statically(encoding_value_); +} + std::string Operand::name() const { if (has_literal64_) return std::format("0x{:x}", literal64_value_); @@ -599,6 +610,8 @@ std::optional Operand::to_register_ref() const { break; } case OperandType::OPR_EXEC: { + if (encoding_value_ == OpSelExec::OPR_EXEC_EXEC) + return RegisterRef{RegClass::EXEC, 0, reg_width}; break; } case OperandType::OPR_FLAT_SCRATCH: { @@ -613,9 +626,17 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSdst::OPR_SDST_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_EXEC: { + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_M0: { @@ -639,6 +660,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSrc::OPR_SRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrc::OPR_SRC_VGPR_MIN && encoding_value_ <= OpSelSrc::OPR_SRC_VGPR_MAX) return RegisterRef{RegClass::VGPR, @@ -687,6 +712,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrc::OPR_SSRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_LANESEL: { @@ -723,259 +752,12 @@ std::optional Operand::to_register_ref() const { namespace { -uint32_t resolve_src_scalar(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return static_cast(wf.scratch_base()); - if (ev == 103) - return static_cast(wf.scratch_base() >> 32); - if (ev <= 105) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 106) - return static_cast(wf.vcc()); - if (ev == 107) - return static_cast(wf.vcc() >> 32); - if (ev >= 108 && ev <= 123) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 124) - return 0u; // NULL - if (ev == 125) - return wf.m0(); - if (ev == 126) - return static_cast(wf.exec()); - if (ev == 127) - return static_cast(wf.exec_raw() >> 32); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(-(ev - 192))); - if (ev == 230) - return static_cast(wf.scratch_base()); // SRC_FLAT_SCRATCH_BASE_LO - if (ev == 231) - return static_cast(wf.scratch_base() >> 32); // SRC_FLAT_SCRATCH_BASE_HI - if (ev == 240) - return 0x3F000000u; // 0.5f - if (ev == 241) - return 0xBF000000u; // -0.5f - if (ev == 242) - return 0x3F800000u; // 1.0f - if (ev == 243) - return 0xBF800000u; // -1.0f - if (ev == 244) - return 0x40000000u; // 2.0f - if (ev == 245) - return 0xC0000000u; // -2.0f - if (ev == 246) - return 0x40800000u; // 4.0f - if (ev == 247) - return 0xC0800000u; // -4.0f - if (ev == 248) - return 0x3E22F983u; // 1/(2*pi) - if (ev == 235) - return static_cast(wf.shared_aperture_base() >> 32); // SRC_SHARED_BASE - if (ev == 236) - return static_cast(wf.shared_aperture_limit() >> 32); // SRC_SHARED_LIMIT - if (ev == 237) - return static_cast(wf.private_aperture_base() >> 32); // SRC_PRIVATE_BASE - if (ev == 238) - return static_cast(wf.private_aperture_limit() >> 32); // SRC_PRIVATE_LIMIT - if (ev == 249) - return 0u; // SRC_POPS_EXITING_WAVE_ID (not used in compute) - if (ev == 250) - return 0u; // NULL - if (ev == 251) - return (wf.vcc() & (wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL))) == 0 - ? 1u - : 0u; // VCCZ - if (ev == 252) { - uint64_t active = wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL); - return (wf.exec() & active) == 0 ? 1u : 0u; // EXECZ - } - if (ev == 253) - return wf.read_scc() ? 1u : 0u; // SCC - throw std::logic_error("Unsupported encoding value for scalar read: " + std::to_string(ev)); -} - -uint32_t resolve_src_scalar16(const amdgpu::Wavefront &wf, int ev) { - switch (ev) { - case 240: - return 0x3800u; // 0.5h - case 241: - return 0xB800u; // -0.5h - case 242: - return 0x3C00u; // 1.0h - case 243: - return 0xBC00u; // -1.0h - case 244: - return 0x4000u; // 2.0h - case 245: - return 0xC000u; // -2.0h - case 246: - return 0x4400u; // 4.0h - case 247: - return 0xC400u; // -4.0h - case 248: - return 0x3118u; // f16 1/(2*pi) - default: - return resolve_src_scalar(wf, ev); - } -} - -// Must stay in sync with resolve_src_scalar above — returns true for -// exactly the encoding values that resolve_src_scalar handles without -// throwing. Used by Isa::simd_capable_value() to keep the SIMD fast -// path off operands whose scalar broadcast would throw at runtime. -bool can_resolve_src_scalar(int ev) { - return (ev >= 0 && ev <= 107) || (ev >= 108 && ev <= 123) || ev == 124 || ev == 125 || - ev == 126 || ev == 127 || (ev >= 128 && ev <= 208) || ev == 230 || ev == 231 || - (ev >= 235 && ev <= 238) || (ev >= 240 && ev <= 253); -} - -uint64_t resolve_src_scalar64(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return wf.scratch_base(); - if (ev <= 105) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 106) - return wf.vcc(); - if (ev >= 108 && ev <= 122) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 124) - return 0u; // NULL - if (ev == 125) - return wf.m0(); - if (ev == 126) - return wf.exec_raw(); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(static_cast(-(ev - 192)))); - if (ev == 230) - return wf.scratch_base(); // SRC_FLAT_SCRATCH_BASE - if (ev == 240) - return 0x3FE0000000000000ULL; // 0.5 - if (ev == 241) - return 0xBFE0000000000000ULL; // -0.5 - if (ev == 242) - return 0x3FF0000000000000ULL; // 1.0 - if (ev == 243) - return 0xBFF0000000000000ULL; // -1.0 - if (ev == 244) - return 0x4000000000000000ULL; // 2.0 - if (ev == 245) - return 0xC000000000000000ULL; // -2.0 - if (ev == 246) - return 0x4010000000000000ULL; // 4.0 - if (ev == 247) - return 0xC010000000000000ULL; // -4.0 - if (ev == 248) - return 0x3FC45F306DC9C883ULL; // 1/(2*pi) - if (ev == 235) - return wf.shared_aperture_base(); // SRC_SHARED_BASE - if (ev == 236) - return wf.shared_aperture_limit(); // SRC_SHARED_LIMIT - if (ev == 237) - return wf.private_aperture_base(); // SRC_PRIVATE_BASE - if (ev == 238) - return wf.private_aperture_limit(); // SRC_PRIVATE_LIMIT - throw std::logic_error("Unsupported encoding value for scalar64 read: " + std::to_string(ev)); -} - -void resolve_dst_write(amdgpu::Wavefront &wf, int ev, uint32_t val) { - if (ev == 102) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 103) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 106) { - wf.set_vcc((wf.vcc() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 107) { - wf.set_vcc((wf.vcc() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev >= 108 && ev <= 123) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 124) - return; - if (ev == 125) { - wf.set_m0(val); - return; - } - if (ev == 126) { - wf.set_exec((wf.exec() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 127) { - wf.set_exec_raw((wf.exec_raw() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - throw std::logic_error("Unsupported encoding value for scalar write: " + std::to_string(ev)); -} - -void resolve_dst_write64(amdgpu::Wavefront &wf, int ev, uint64_t val) { - if (ev == 102) { - wf.set_scratch_base(val); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 106) { - wf.set_vcc(val); - return; - } - if (ev >= 108 && ev <= 122) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 124) - return; - if (ev == 126) { - wf.set_exec_raw(val); - return; - } - throw std::logic_error("Unsupported encoding value for scalar64 write: " + std::to_string(ev)); -} +constexpr int kM0EncodingValue = 125; bool is_vgpr_only_type(OperandType t) { return t == OperandType::OPR_VGPR || t == OperandType::OPR_SRC_VGPR; } -bool is_immediate_type(OperandType t) { - return t == OperandType::OPR_SIMM16 || t == OperandType::OPR_SIMM32 || - t == OperandType::OPR_SIMM8 || t == OperandType::OPR_LABEL || - t == OperandType::OPR_WAITCNT; -} - uint32_t vgpr_index(OperandType opr_type, int ev) { if (opr_type == OperandType::OPR_VGPR) return static_cast(ev); @@ -1004,11 +786,12 @@ std::optional Isa::resolved_vgpr_offset(OperandType opr_type, int ev) bool Isa::simd_capable_value(OperandType opr_type, int ev) { return resolved_vgpr_offset(opr_type, ev).has_value() || is_immediate_type(opr_type) || - can_resolve_src_scalar(ev); + amdgpu::can_resolve_src_scalar(ev, kM0EncodingValue); } uint32_t Isa::simd_broadcast_value(const amdgpu::Wavefront &wf, OperandType opr_type, int ev) { - return is_immediate_type(opr_type) ? static_cast(ev) : resolve_src_scalar(wf, ev); + return is_immediate_type(opr_type) ? static_cast(ev) + : amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } bool Operand::simd_capable() const { @@ -1065,7 +848,7 @@ uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { return static_cast(literal64_value_); if (is_immediate_type(opr_type_)) return static_cast(encoding_value_); - return resolve_src_scalar(wf, encoding_value_); + return amdgpu::resolve_src_scalar(wf, encoding_value_, kM0EncodingValue); } uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { @@ -1094,8 +877,8 @@ uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { if (is_immediate_type(opr_type_)) return static_cast(ev); if (size_bits_ == 16) - return resolve_src_scalar16(wf, ev); - return resolve_src_scalar(wf, ev); + return amdgpu::resolve_src_scalar16(wf, ev, kM0EncodingValue); + return amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { @@ -1105,7 +888,7 @@ void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write(wf, encoding_value_, val); + amdgpu::resolve_dst_write(wf, encoding_value_, val, kM0EncodingValue); } void Operand::write_lane(amdgpu::Wavefront &wf, uint32_t lane, uint32_t val) const { @@ -1153,7 +936,7 @@ uint64_t Operand::read_lane64(const amdgpu::Wavefront &wf, uint32_t lane) const return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, ev); - return resolve_src_scalar64(wf, ev); + return amdgpu::resolve_src_scalar64(wf, ev, kM0EncodingValue); } void Operand::write_lane64(amdgpu::Wavefront &wf, uint32_t lane, uint64_t val) const { @@ -1183,7 +966,7 @@ uint64_t Operand::read_scalar64(const amdgpu::Wavefront &wf) const { return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, encoding_value_); - return resolve_src_scalar64(wf, encoding_value_); + return amdgpu::resolve_src_scalar64(wf, encoding_value_, kM0EncodingValue); } void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { @@ -1193,7 +976,7 @@ void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write64(wf, encoding_value_, val); + amdgpu::resolve_dst_write64(wf, encoding_value_, val); } } // namespace rdna3_5 diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/operand.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/operand.h index 4ef1042dffef..808e7f919734 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/operand.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/operand.h @@ -26,6 +26,7 @@ class Operand : public AmdgpuIsaOperand { Operand(int size_bits, OperandType opr_type, uint64_t literal64_value, bool is_literal64); std::string name() const override; std::optional literal64_value() const override; + std::optional const_value() const override; std::optional to_register_ref() const override; bool simd_capable() const override; diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/operand_types.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/operand_types.h index e6c63d0d1300..228e8a64d567 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/operand_types.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/operand_types.h @@ -316,6 +316,19 @@ enum OpSelVgpr { } } +[[nodiscard]] constexpr bool is_immediate_type(OperandType t) { + switch (t) { + case OperandType::OPR_SIMM8: + case OperandType::OPR_SIMM16: + case OperandType::OPR_SIMM32: + case OperandType::OPR_LABEL: + case OperandType::OPR_WAITCNT: + return true; + default: + return false; + } +} + } // namespace rdna3_5 } // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/sop1.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/sop1.cpp index 9bad910f80b0..792dcb73efe1 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/sop1.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/sop1.cpp @@ -33,6 +33,7 @@ SMovB32Sop1::SMovB32Sop1(const MachineInst *inst) ssrc0 = Operand( 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB32Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b32_sop1(*this, wf); } @@ -49,6 +50,7 @@ SMovB64Sop1::SMovB64Sop1(const MachineInst *inst) ssrc0 = Operand( 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB64Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b64_sop1(*this, wf); } @@ -634,6 +636,7 @@ SAndSaveexecB32Sop1::SAndSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -662,6 +665,7 @@ SAndSaveexecB64Sop1::SAndSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -690,6 +694,8 @@ SOrSaveexecB32Sop1::SOrSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } void SOrSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -718,6 +724,8 @@ SOrSaveexecB64Sop1::SOrSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } void SOrSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -746,6 +754,7 @@ SXorSaveexecB32Sop1::SXorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -774,6 +783,7 @@ SXorSaveexecB64Sop1::SXorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -802,6 +812,7 @@ SNandSaveexecB32Sop1::SNandSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNandSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -830,6 +841,7 @@ SNandSaveexecB64Sop1::SNandSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNandSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -858,6 +870,7 @@ SNorSaveexecB32Sop1::SNorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -886,6 +899,7 @@ SNorSaveexecB64Sop1::SNorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -914,6 +928,7 @@ SXnorSaveexecB32Sop1::SXnorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXnorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -942,6 +957,7 @@ SXnorSaveexecB64Sop1::SXnorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXnorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -970,6 +986,7 @@ SAndNot0SaveexecB32Sop1::SAndNot0SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot0SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -998,6 +1015,7 @@ SAndNot0SaveexecB64Sop1::SAndNot0SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot0SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1026,6 +1044,7 @@ SOrNot0SaveexecB32Sop1::SOrNot0SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrNot0SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1054,6 +1073,7 @@ SOrNot0SaveexecB64Sop1::SOrNot0SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrNot0SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1082,6 +1102,7 @@ SAndNot1SaveexecB32Sop1::SAndNot1SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot1SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1110,6 +1131,7 @@ SAndNot1SaveexecB64Sop1::SAndNot1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1138,6 +1160,7 @@ SOrNot1SaveexecB32Sop1::SOrNot1SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrNot1SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1166,6 +1189,7 @@ SOrNot1SaveexecB64Sop1::SOrNot1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrNot1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1194,6 +1218,7 @@ SAndNot0WrexecB32Sop1::SAndNot0WrexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot0WrexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1222,6 +1247,7 @@ SAndNot0WrexecB64Sop1::SAndNot0WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot0WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1250,6 +1276,7 @@ SAndNot1WrexecB32Sop1::SAndNot1WrexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot1WrexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1278,6 +1305,7 @@ SAndNot1WrexecB64Sop1::SAndNot1WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot1WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/sop2.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/sop2.cpp index 55e51a00c5d5..1655543a940c 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/sop2.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/sop2.cpp @@ -651,6 +651,7 @@ SOrB32Sop2::SOrB32Sop2(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB32Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b32_sop2(*this, wf); } @@ -676,6 +677,7 @@ SOrB64Sop2::SOrB64Sop2(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB64Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b64_sop2(*this, wf); } diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/sopp.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/sopp.cpp index 3a3797f00077..74f4d7f2673e 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/sopp.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/sopp.cpp @@ -208,6 +208,7 @@ SBranchSopp::SBranchSopp(const MachineInst *inst) num_src_ = 1; num_dst_ = 0; flags_ |= BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SBranchSopp::branch_offset_bytes() const { @@ -231,6 +232,7 @@ SCbranchScc0Sopp::SCbranchScc0Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc0Sopp::branch_offset_bytes() const { @@ -256,6 +258,7 @@ SCbranchScc1Sopp::SCbranchScc1Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc1Sopp::branch_offset_bytes() const { @@ -281,6 +284,7 @@ SCbranchVcczSopp::SCbranchVcczSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVcczSopp::branch_offset_bytes() const { @@ -308,6 +312,7 @@ SCbranchVccnzSopp::SCbranchVccnzSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVccnzSopp::branch_offset_bytes() const { @@ -335,6 +340,7 @@ SCbranchExeczSopp::SCbranchExeczSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExeczSopp::branch_offset_bytes() const { @@ -360,6 +366,7 @@ SCbranchExecnzSopp::SCbranchExecnzSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExecnzSopp::branch_offset_bytes() const { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/vop3.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/vop3.cpp index 32e20d556d4f..9b3aa507a72a 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/vop3.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/vop3.cpp @@ -18854,6 +18854,7 @@ VCmpxFF16Vop3::VCmpxFF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -18923,6 +18924,7 @@ VCmpxLtF16Vop3::VCmpxLtF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19006,6 +19008,7 @@ VCmpxEqF16Vop3::VCmpxEqF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19089,6 +19092,7 @@ VCmpxLeF16Vop3::VCmpxLeF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19172,6 +19176,7 @@ VCmpxGtF16Vop3::VCmpxGtF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19255,6 +19260,7 @@ VCmpxLgF16Vop3::VCmpxLgF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19338,6 +19344,7 @@ VCmpxGeF16Vop3::VCmpxGeF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19421,6 +19428,7 @@ VCmpxOF16Vop3::VCmpxOF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19504,6 +19512,7 @@ VCmpxUF16Vop3::VCmpxUF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19587,6 +19596,7 @@ VCmpxNgeF16Vop3::VCmpxNgeF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19670,6 +19680,7 @@ VCmpxNlgF16Vop3::VCmpxNlgF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19753,6 +19764,7 @@ VCmpxNgtF16Vop3::VCmpxNgtF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19836,6 +19848,7 @@ VCmpxNleF16Vop3::VCmpxNleF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -19919,6 +19932,7 @@ VCmpxNeqF16Vop3::VCmpxNeqF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20002,6 +20016,7 @@ VCmpxNltF16Vop3::VCmpxNltF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20085,6 +20100,7 @@ VCmpxTF16Vop3::VCmpxTF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20146,6 +20162,7 @@ VCmpxFF32Vop3::VCmpxFF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20205,6 +20222,7 @@ VCmpxLtF32Vop3::VCmpxLtF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20275,6 +20293,7 @@ VCmpxEqF32Vop3::VCmpxEqF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20345,6 +20364,7 @@ VCmpxLeF32Vop3::VCmpxLeF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20415,6 +20435,7 @@ VCmpxGtF32Vop3::VCmpxGtF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20485,6 +20506,7 @@ VCmpxLgF32Vop3::VCmpxLgF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20555,6 +20577,7 @@ VCmpxGeF32Vop3::VCmpxGeF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20625,6 +20648,7 @@ VCmpxOF32Vop3::VCmpxOF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20695,6 +20719,7 @@ VCmpxUF32Vop3::VCmpxUF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20765,6 +20790,7 @@ VCmpxNgeF32Vop3::VCmpxNgeF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20835,6 +20861,7 @@ VCmpxNlgF32Vop3::VCmpxNlgF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20905,6 +20932,7 @@ VCmpxNgtF32Vop3::VCmpxNgtF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20975,6 +21003,7 @@ VCmpxNleF32Vop3::VCmpxNleF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21045,6 +21074,7 @@ VCmpxNeqF32Vop3::VCmpxNeqF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21115,6 +21145,7 @@ VCmpxNltF32Vop3::VCmpxNltF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21185,6 +21216,7 @@ VCmpxTF32Vop3::VCmpxTF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21234,6 +21266,7 @@ VCmpxFF64Vop3::VCmpxFF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_F_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21276,6 +21309,7 @@ VCmpxLtF64Vop3::VCmpxLtF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LT_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21329,6 +21363,7 @@ VCmpxEqF64Vop3::VCmpxEqF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_EQ_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21382,6 +21417,7 @@ VCmpxLeF64Vop3::VCmpxLeF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LE_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21435,6 +21471,7 @@ VCmpxGtF64Vop3::VCmpxGtF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GT_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21488,6 +21525,7 @@ VCmpxLgF64Vop3::VCmpxLgF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LG_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21541,6 +21579,7 @@ VCmpxGeF64Vop3::VCmpxGeF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GE_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21594,6 +21633,7 @@ VCmpxOF64Vop3::VCmpxOF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_O_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21647,6 +21687,7 @@ VCmpxUF64Vop3::VCmpxUF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_U_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21700,6 +21741,7 @@ VCmpxNgeF64Vop3::VCmpxNgeF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NGE_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21753,6 +21795,7 @@ VCmpxNlgF64Vop3::VCmpxNlgF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NLG_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21806,6 +21849,7 @@ VCmpxNgtF64Vop3::VCmpxNgtF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NGT_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21859,6 +21903,7 @@ VCmpxNleF64Vop3::VCmpxNleF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NLE_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21912,6 +21957,7 @@ VCmpxNeqF64Vop3::VCmpxNeqF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NEQ_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21965,6 +22011,7 @@ VCmpxNltF64Vop3::VCmpxNltF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NLT_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22018,6 +22065,7 @@ VCmpxTF64Vop3::VCmpxTF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_T_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22078,6 +22126,7 @@ VCmpxLtI16Vop3::VCmpxLtI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22157,6 +22206,7 @@ VCmpxEqI16Vop3::VCmpxEqI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22236,6 +22286,7 @@ VCmpxLeI16Vop3::VCmpxLeI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22315,6 +22366,7 @@ VCmpxGtI16Vop3::VCmpxGtI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22394,6 +22446,7 @@ VCmpxNeI16Vop3::VCmpxNeI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22473,6 +22526,7 @@ VCmpxGeI16Vop3::VCmpxGeI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22552,6 +22606,7 @@ VCmpxLtU16Vop3::VCmpxLtU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22631,6 +22686,7 @@ VCmpxEqU16Vop3::VCmpxEqU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22710,6 +22766,7 @@ VCmpxLeU16Vop3::VCmpxLeU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22789,6 +22846,7 @@ VCmpxGtU16Vop3::VCmpxGtU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22868,6 +22926,7 @@ VCmpxNeU16Vop3::VCmpxNeU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22947,6 +23006,7 @@ VCmpxGeU16Vop3::VCmpxGeU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23018,6 +23078,7 @@ VCmpxFI32Vop3::VCmpxFI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23077,6 +23138,7 @@ VCmpxLtI32Vop3::VCmpxLtI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23139,6 +23201,7 @@ VCmpxEqI32Vop3::VCmpxEqI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23201,6 +23264,7 @@ VCmpxLeI32Vop3::VCmpxLeI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23263,6 +23327,7 @@ VCmpxGtI32Vop3::VCmpxGtI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23325,6 +23390,7 @@ VCmpxNeI32Vop3::VCmpxNeI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23387,6 +23453,7 @@ VCmpxGeI32Vop3::VCmpxGeI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23449,6 +23516,7 @@ VCmpxTI32Vop3::VCmpxTI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23508,6 +23576,7 @@ VCmpxFU32Vop3::VCmpxFU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23567,6 +23636,7 @@ VCmpxLtU32Vop3::VCmpxLtU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23629,6 +23699,7 @@ VCmpxEqU32Vop3::VCmpxEqU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23691,6 +23762,7 @@ VCmpxLeU32Vop3::VCmpxLeU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23753,6 +23825,7 @@ VCmpxGtU32Vop3::VCmpxGtU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23815,6 +23888,7 @@ VCmpxNeU32Vop3::VCmpxNeU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23877,6 +23951,7 @@ VCmpxGeU32Vop3::VCmpxGeU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23939,6 +24014,7 @@ VCmpxTU32Vop3::VCmpxTU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23984,6 +24060,7 @@ VCmpxFI64Vop3::VCmpxFI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_F_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24022,6 +24099,7 @@ VCmpxLtI64Vop3::VCmpxLtI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LT_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24063,6 +24141,7 @@ VCmpxEqI64Vop3::VCmpxEqI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_EQ_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24104,6 +24183,7 @@ VCmpxLeI64Vop3::VCmpxLeI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LE_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24145,6 +24225,7 @@ VCmpxGtI64Vop3::VCmpxGtI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GT_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24186,6 +24267,7 @@ VCmpxNeI64Vop3::VCmpxNeI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NE_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24227,6 +24309,7 @@ VCmpxGeI64Vop3::VCmpxGeI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GE_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24268,6 +24351,7 @@ VCmpxTI64Vop3::VCmpxTI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_T_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24306,6 +24390,7 @@ VCmpxFU64Vop3::VCmpxFU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_F_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24344,6 +24429,7 @@ VCmpxLtU64Vop3::VCmpxLtU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LT_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24385,6 +24471,7 @@ VCmpxEqU64Vop3::VCmpxEqU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_EQ_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24426,6 +24513,7 @@ VCmpxLeU64Vop3::VCmpxLeU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LE_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24467,6 +24555,7 @@ VCmpxGtU64Vop3::VCmpxGtU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GT_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24508,6 +24597,7 @@ VCmpxNeU64Vop3::VCmpxNeU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NE_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24549,6 +24639,7 @@ VCmpxGeU64Vop3::VCmpxGeU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GE_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24590,6 +24681,7 @@ VCmpxTU64Vop3::VCmpxTU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_T_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24650,6 +24742,7 @@ VCmpxClassF16Vop3::VCmpxClassF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24749,6 +24842,7 @@ VCmpxClassF32Vop3::VCmpxClassF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24826,6 +24920,7 @@ VCmpxClassF64Vop3::VCmpxClassF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_CLASS_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vop3::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/vopc.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/vopc.cpp index 8f45f4edb8b7..c87cdd284fcc 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/vopc.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna3_5/vopc.cpp @@ -4539,6 +4539,7 @@ VCmpxFF16Vopc::VCmpxFF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4613,6 +4614,7 @@ VCmpxLtF16Vopc::VCmpxLtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4692,6 +4694,7 @@ VCmpxEqF16Vopc::VCmpxEqF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4771,6 +4774,7 @@ VCmpxLeF16Vopc::VCmpxLeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4850,6 +4854,7 @@ VCmpxGtF16Vopc::VCmpxGtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4929,6 +4934,7 @@ VCmpxLgF16Vopc::VCmpxLgF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5008,6 +5014,7 @@ VCmpxGeF16Vopc::VCmpxGeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5087,6 +5094,7 @@ VCmpxOF16Vopc::VCmpxOF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5166,6 +5174,7 @@ VCmpxUF16Vopc::VCmpxUF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5245,6 +5254,7 @@ VCmpxNgeF16Vopc::VCmpxNgeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5324,6 +5334,7 @@ VCmpxNlgF16Vopc::VCmpxNlgF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5403,6 +5414,7 @@ VCmpxNgtF16Vopc::VCmpxNgtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5482,6 +5494,7 @@ VCmpxNleF16Vopc::VCmpxNleF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5561,6 +5574,7 @@ VCmpxNeqF16Vopc::VCmpxNeqF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5640,6 +5654,7 @@ VCmpxNltF16Vopc::VCmpxNltF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5719,6 +5734,7 @@ VCmpxTF16Vopc::VCmpxTF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5790,6 +5806,7 @@ VCmpxFF32Vopc::VCmpxFF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5861,6 +5878,7 @@ VCmpxLtF32Vopc::VCmpxLtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5935,6 +5953,7 @@ VCmpxEqF32Vopc::VCmpxEqF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6009,6 +6028,7 @@ VCmpxLeF32Vopc::VCmpxLeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6083,6 +6103,7 @@ VCmpxGtF32Vopc::VCmpxGtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6157,6 +6178,7 @@ VCmpxLgF32Vopc::VCmpxLgF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6231,6 +6253,7 @@ VCmpxGeF32Vopc::VCmpxGeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6305,6 +6328,7 @@ VCmpxOF32Vopc::VCmpxOF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6379,6 +6403,7 @@ VCmpxUF32Vopc::VCmpxUF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6453,6 +6478,7 @@ VCmpxNgeF32Vopc::VCmpxNgeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6527,6 +6553,7 @@ VCmpxNlgF32Vopc::VCmpxNlgF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6601,6 +6628,7 @@ VCmpxNgtF32Vopc::VCmpxNgtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6675,6 +6703,7 @@ VCmpxNleF32Vopc::VCmpxNleF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6749,6 +6778,7 @@ VCmpxNeqF32Vopc::VCmpxNeqF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6823,6 +6853,7 @@ VCmpxNltF32Vopc::VCmpxNltF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6897,6 +6928,7 @@ VCmpxTF32Vopc::VCmpxTF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6956,6 +6988,7 @@ VCmpxFF64Vopc::VCmpxFF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6993,6 +7026,7 @@ VCmpxLtF64Vopc::VCmpxLtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7033,6 +7067,7 @@ VCmpxEqF64Vopc::VCmpxEqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7073,6 +7108,7 @@ VCmpxLeF64Vopc::VCmpxLeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7113,6 +7149,7 @@ VCmpxGtF64Vopc::VCmpxGtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7153,6 +7190,7 @@ VCmpxLgF64Vopc::VCmpxLgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LG_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7193,6 +7231,7 @@ VCmpxGeF64Vopc::VCmpxGeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7233,6 +7272,7 @@ VCmpxOF64Vopc::VCmpxOF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_O_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7273,6 +7313,7 @@ VCmpxUF64Vopc::VCmpxUF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_U_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7313,6 +7354,7 @@ VCmpxNgeF64Vopc::VCmpxNgeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGE_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7353,6 +7395,7 @@ VCmpxNlgF64Vopc::VCmpxNlgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLG_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7393,6 +7436,7 @@ VCmpxNgtF64Vopc::VCmpxNgtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGT_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7433,6 +7477,7 @@ VCmpxNleF64Vopc::VCmpxNleF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLE_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7473,6 +7518,7 @@ VCmpxNeqF64Vopc::VCmpxNeqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NEQ_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7513,6 +7559,7 @@ VCmpxNltF64Vopc::VCmpxNltF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLT_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7553,6 +7600,7 @@ VCmpxTF64Vopc::VCmpxTF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7605,6 +7653,7 @@ VCmpxLtI16Vopc::VCmpxLtI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7682,6 +7731,7 @@ VCmpxEqI16Vopc::VCmpxEqI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7759,6 +7809,7 @@ VCmpxLeI16Vopc::VCmpxLeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7836,6 +7887,7 @@ VCmpxGtI16Vopc::VCmpxGtI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7913,6 +7965,7 @@ VCmpxNeI16Vopc::VCmpxNeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7990,6 +8043,7 @@ VCmpxGeI16Vopc::VCmpxGeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8067,6 +8121,7 @@ VCmpxLtU16Vopc::VCmpxLtU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8144,6 +8199,7 @@ VCmpxEqU16Vopc::VCmpxEqU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8221,6 +8277,7 @@ VCmpxLeU16Vopc::VCmpxLeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8298,6 +8355,7 @@ VCmpxGtU16Vopc::VCmpxGtU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8375,6 +8433,7 @@ VCmpxNeU16Vopc::VCmpxNeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8452,6 +8511,7 @@ VCmpxGeU16Vopc::VCmpxGeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8526,6 +8586,7 @@ VCmpxFI32Vopc::VCmpxFI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8597,6 +8658,7 @@ VCmpxLtI32Vopc::VCmpxLtI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8671,6 +8733,7 @@ VCmpxEqI32Vopc::VCmpxEqI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8745,6 +8808,7 @@ VCmpxLeI32Vopc::VCmpxLeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8819,6 +8883,7 @@ VCmpxGtI32Vopc::VCmpxGtI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8893,6 +8958,7 @@ VCmpxNeI32Vopc::VCmpxNeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8967,6 +9033,7 @@ VCmpxGeI32Vopc::VCmpxGeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9041,6 +9108,7 @@ VCmpxTI32Vopc::VCmpxTI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9112,6 +9180,7 @@ VCmpxFU32Vopc::VCmpxFU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9183,6 +9252,7 @@ VCmpxLtU32Vopc::VCmpxLtU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9257,6 +9327,7 @@ VCmpxEqU32Vopc::VCmpxEqU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9331,6 +9402,7 @@ VCmpxLeU32Vopc::VCmpxLeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9405,6 +9477,7 @@ VCmpxGtU32Vopc::VCmpxGtU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9479,6 +9552,7 @@ VCmpxNeU32Vopc::VCmpxNeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9553,6 +9627,7 @@ VCmpxGeU32Vopc::VCmpxGeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9627,6 +9702,7 @@ VCmpxTU32Vopc::VCmpxTU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9684,6 +9760,7 @@ VCmpxFI64Vopc::VCmpxFI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9719,6 +9796,7 @@ VCmpxLtI64Vopc::VCmpxLtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9757,6 +9835,7 @@ VCmpxEqI64Vopc::VCmpxEqI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9795,6 +9874,7 @@ VCmpxLeI64Vopc::VCmpxLeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9833,6 +9913,7 @@ VCmpxGtI64Vopc::VCmpxGtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9871,6 +9952,7 @@ VCmpxNeI64Vopc::VCmpxNeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9909,6 +9991,7 @@ VCmpxGeI64Vopc::VCmpxGeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9947,6 +10030,7 @@ VCmpxTI64Vopc::VCmpxTI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9982,6 +10066,7 @@ VCmpxFU64Vopc::VCmpxFU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_F_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxFU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10017,6 +10102,7 @@ VCmpxLtU64Vopc::VCmpxLtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10055,6 +10141,7 @@ VCmpxEqU64Vopc::VCmpxEqU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10093,6 +10180,7 @@ VCmpxLeU64Vopc::VCmpxLeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10131,6 +10219,7 @@ VCmpxGtU64Vopc::VCmpxGtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10169,6 +10258,7 @@ VCmpxNeU64Vopc::VCmpxNeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10207,6 +10297,7 @@ VCmpxGeU64Vopc::VCmpxGeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10245,6 +10336,7 @@ VCmpxTU64Vopc::VCmpxTU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_T_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxTU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10297,6 +10389,7 @@ VCmpxClassF16Vopc::VCmpxClassF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10400,6 +10493,7 @@ VCmpxClassF32Vopc::VCmpxClassF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -10485,6 +10579,7 @@ VCmpxClassF64Vopc::VCmpxClassF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_CLASS_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vopc::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/operand.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/operand.cpp index 069050526d03..fcb13687c840 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/operand.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/operand.cpp @@ -5,6 +5,7 @@ // See lib/python/amdisa/README.md for regeneration instructions. #include "rocjitsu/isa/arch/amdgpu/rdna4/operand.h" +#include "rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h" #include "rocjitsu/isa/isa_operand_simd_inl.h" #include "rocjitsu/vm/amdgpu/compute_unit.h" #include "rocjitsu/vm/amdgpu/register_access.h" @@ -94,6 +95,16 @@ std::optional Operand::literal64_value() const { return literal64_value_; } +std::optional Operand::const_value() const { + if (has_literal64_) + return literal64_value_; + if (is_immediate_type(opr_type_)) + return static_cast(static_cast(encoding_value_)); + if (to_register_ref()) + return std::nullopt; + return amdgpu::resolve_src_scalar_statically(encoding_value_); +} + std::string Operand::name() const { if (has_literal64_) return std::format("0x{:x}", literal64_value_); @@ -622,6 +633,8 @@ std::optional Operand::to_register_ref() const { break; } case OperandType::OPR_EXEC: { + if (encoding_value_ == OpSelExec::OPR_EXEC_EXEC) + return RegisterRef{RegClass::EXEC, 0, reg_width}; break; } case OperandType::OPR_GPUMEM: { @@ -636,9 +649,17 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSdst::OPR_SDST_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdst::OPR_SDST_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_EXEC: { + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSdstExec::OPR_SDST_EXEC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SDST_M0: { @@ -668,6 +689,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSrc::OPR_SRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSrc::OPR_SRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; if (encoding_value_ >= OpSelSrc::OPR_SRC_VGPR_MIN && encoding_value_ <= OpSelSrc::OPR_SRC_VGPR_MAX) return RegisterRef{RegClass::VGPR, @@ -724,6 +749,10 @@ std::optional Operand::to_register_ref() const { return RegisterRef{RegClass::SGPR, static_cast(encoding_value_ - OpSelSsrc::OPR_SSRC_SGPR_MIN), reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_LO) + return RegisterRef{RegClass::EXEC, 0, reg_width}; + if (encoding_value_ == OpSelSsrc::OPR_SSRC_EXEC_HI) + return RegisterRef{RegClass::EXEC, 1, reg_width}; break; } case OperandType::OPR_SSRC_BARRIER_ID: { @@ -763,259 +792,12 @@ std::optional Operand::to_register_ref() const { namespace { -uint32_t resolve_src_scalar(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return static_cast(wf.scratch_base()); - if (ev == 103) - return static_cast(wf.scratch_base() >> 32); - if (ev <= 105) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 106) - return static_cast(wf.vcc()); - if (ev == 107) - return static_cast(wf.vcc() >> 32); - if (ev >= 108 && ev <= 123) - return amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - if (ev == 124) - return 0u; // NULL - if (ev == 125) - return wf.m0(); - if (ev == 126) - return static_cast(wf.exec()); - if (ev == 127) - return static_cast(wf.exec_raw() >> 32); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(-(ev - 192))); - if (ev == 230) - return static_cast(wf.scratch_base()); // SRC_FLAT_SCRATCH_BASE_LO - if (ev == 231) - return static_cast(wf.scratch_base() >> 32); // SRC_FLAT_SCRATCH_BASE_HI - if (ev == 240) - return 0x3F000000u; // 0.5f - if (ev == 241) - return 0xBF000000u; // -0.5f - if (ev == 242) - return 0x3F800000u; // 1.0f - if (ev == 243) - return 0xBF800000u; // -1.0f - if (ev == 244) - return 0x40000000u; // 2.0f - if (ev == 245) - return 0xC0000000u; // -2.0f - if (ev == 246) - return 0x40800000u; // 4.0f - if (ev == 247) - return 0xC0800000u; // -4.0f - if (ev == 248) - return 0x3E22F983u; // 1/(2*pi) - if (ev == 235) - return static_cast(wf.shared_aperture_base() >> 32); // SRC_SHARED_BASE - if (ev == 236) - return static_cast(wf.shared_aperture_limit() >> 32); // SRC_SHARED_LIMIT - if (ev == 237) - return static_cast(wf.private_aperture_base() >> 32); // SRC_PRIVATE_BASE - if (ev == 238) - return static_cast(wf.private_aperture_limit() >> 32); // SRC_PRIVATE_LIMIT - if (ev == 249) - return 0u; // SRC_POPS_EXITING_WAVE_ID (not used in compute) - if (ev == 250) - return 0u; // NULL - if (ev == 251) - return (wf.vcc() & (wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL))) == 0 - ? 1u - : 0u; // VCCZ - if (ev == 252) { - uint64_t active = wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL); - return (wf.exec() & active) == 0 ? 1u : 0u; // EXECZ - } - if (ev == 253) - return wf.read_scc() ? 1u : 0u; // SCC - throw std::logic_error("Unsupported encoding value for scalar read: " + std::to_string(ev)); -} - -uint32_t resolve_src_scalar16(const amdgpu::Wavefront &wf, int ev) { - switch (ev) { - case 240: - return 0x3800u; // 0.5h - case 241: - return 0xB800u; // -0.5h - case 242: - return 0x3C00u; // 1.0h - case 243: - return 0xBC00u; // -1.0h - case 244: - return 0x4000u; // 2.0h - case 245: - return 0xC000u; // -2.0h - case 246: - return 0x4400u; // 4.0h - case 247: - return 0xC400u; // -4.0h - case 248: - return 0x3118u; // f16 1/(2*pi) - default: - return resolve_src_scalar(wf, ev); - } -} - -// Must stay in sync with resolve_src_scalar above — returns true for -// exactly the encoding values that resolve_src_scalar handles without -// throwing. Used by Isa::simd_capable_value() to keep the SIMD fast -// path off operands whose scalar broadcast would throw at runtime. -bool can_resolve_src_scalar(int ev) { - return (ev >= 0 && ev <= 107) || (ev >= 108 && ev <= 123) || ev == 124 || ev == 125 || - ev == 126 || ev == 127 || (ev >= 128 && ev <= 208) || ev == 230 || ev == 231 || - (ev >= 235 && ev <= 238) || (ev >= 240 && ev <= 253); -} - -uint64_t resolve_src_scalar64(const amdgpu::Wavefront &wf, int ev) { - if (ev == 102) - return wf.scratch_base(); - if (ev <= 105) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 106) - return wf.vcc(); - if (ev >= 108 && ev <= 122) { - uint32_t lo = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); - uint32_t hi = - amdgpu::RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); - return static_cast(hi) << 32 | lo; - } - if (ev == 124) - return 0u; // NULL - if (ev == 125) - return wf.m0(); - if (ev == 126) - return wf.exec_raw(); - if (ev >= 128 && ev <= 192) - return static_cast(ev - 128); - if (ev >= 193 && ev <= 208) - return static_cast(static_cast(static_cast(-(ev - 192)))); - if (ev == 230) - return wf.scratch_base(); // SRC_FLAT_SCRATCH_BASE - if (ev == 240) - return 0x3FE0000000000000ULL; // 0.5 - if (ev == 241) - return 0xBFE0000000000000ULL; // -0.5 - if (ev == 242) - return 0x3FF0000000000000ULL; // 1.0 - if (ev == 243) - return 0xBFF0000000000000ULL; // -1.0 - if (ev == 244) - return 0x4000000000000000ULL; // 2.0 - if (ev == 245) - return 0xC000000000000000ULL; // -2.0 - if (ev == 246) - return 0x4010000000000000ULL; // 4.0 - if (ev == 247) - return 0xC010000000000000ULL; // -4.0 - if (ev == 248) - return 0x3FC45F306DC9C883ULL; // 1/(2*pi) - if (ev == 235) - return wf.shared_aperture_base(); // SRC_SHARED_BASE - if (ev == 236) - return wf.shared_aperture_limit(); // SRC_SHARED_LIMIT - if (ev == 237) - return wf.private_aperture_base(); // SRC_PRIVATE_BASE - if (ev == 238) - return wf.private_aperture_limit(); // SRC_PRIVATE_LIMIT - throw std::logic_error("Unsupported encoding value for scalar64 read: " + std::to_string(ev)); -} - -void resolve_dst_write(amdgpu::Wavefront &wf, int ev, uint32_t val) { - if (ev == 102) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 103) { - uint64_t sb = wf.scratch_base(); - wf.set_scratch_base((sb & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 106) { - wf.set_vcc((wf.vcc() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 107) { - wf.set_vcc((wf.vcc() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - if (ev >= 108 && ev <= 123) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); - return; - } - if (ev == 124) - return; - if (ev == 125) { - wf.set_m0(val); - return; - } - if (ev == 126) { - wf.set_exec((wf.exec() & 0xFFFFFFFF00000000ULL) | val); - return; - } - if (ev == 127) { - wf.set_exec_raw((wf.exec_raw() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); - return; - } - throw std::logic_error("Unsupported encoding value for scalar write: " + std::to_string(ev)); -} - -void resolve_dst_write64(amdgpu::Wavefront &wf, int ev, uint64_t val) { - if (ev == 102) { - wf.set_scratch_base(val); - return; - } - if (ev <= 105) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 106) { - wf.set_vcc(val); - return; - } - if (ev >= 108 && ev <= 122) { - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), - static_cast(val)); - amdgpu::RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), - static_cast(val >> 32)); - return; - } - if (ev == 124) - return; - if (ev == 126) { - wf.set_exec_raw(val); - return; - } - throw std::logic_error("Unsupported encoding value for scalar64 write: " + std::to_string(ev)); -} +constexpr int kM0EncodingValue = 125; bool is_vgpr_only_type(OperandType t) { return t == OperandType::OPR_VGPR || t == OperandType::OPR_SRC_VGPR; } -bool is_immediate_type(OperandType t) { - return t == OperandType::OPR_SIMM16 || t == OperandType::OPR_SIMM32 || - t == OperandType::OPR_SIMM8 || t == OperandType::OPR_LABEL || - t == OperandType::OPR_WAITCNT; -} - uint32_t vgpr_index(OperandType opr_type, int ev) { if (opr_type == OperandType::OPR_VGPR) return static_cast(ev); @@ -1044,11 +826,12 @@ std::optional Isa::resolved_vgpr_offset(OperandType opr_type, int ev) bool Isa::simd_capable_value(OperandType opr_type, int ev) { return resolved_vgpr_offset(opr_type, ev).has_value() || is_immediate_type(opr_type) || - can_resolve_src_scalar(ev); + amdgpu::can_resolve_src_scalar(ev, kM0EncodingValue); } uint32_t Isa::simd_broadcast_value(const amdgpu::Wavefront &wf, OperandType opr_type, int ev) { - return is_immediate_type(opr_type) ? static_cast(ev) : resolve_src_scalar(wf, ev); + return is_immediate_type(opr_type) ? static_cast(ev) + : amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } bool Operand::simd_capable() const { @@ -1105,7 +888,7 @@ uint32_t Operand::read_scalar(const amdgpu::Wavefront &wf) const { return static_cast(literal64_value_); if (is_immediate_type(opr_type_)) return static_cast(encoding_value_); - return resolve_src_scalar(wf, encoding_value_); + return amdgpu::resolve_src_scalar(wf, encoding_value_, kM0EncodingValue); } uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { @@ -1134,8 +917,8 @@ uint32_t Operand::read_lane(const amdgpu::Wavefront &wf, uint32_t lane) const { if (is_immediate_type(opr_type_)) return static_cast(ev); if (size_bits_ == 16) - return resolve_src_scalar16(wf, ev); - return resolve_src_scalar(wf, ev); + return amdgpu::resolve_src_scalar16(wf, ev, kM0EncodingValue); + return amdgpu::resolve_src_scalar(wf, ev, kM0EncodingValue); } void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { @@ -1145,7 +928,7 @@ void Operand::write_scalar(amdgpu::Wavefront &wf, uint32_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write(wf, encoding_value_, val); + amdgpu::resolve_dst_write(wf, encoding_value_, val, kM0EncodingValue); } void Operand::write_lane(amdgpu::Wavefront &wf, uint32_t lane, uint32_t val) const { @@ -1193,7 +976,7 @@ uint64_t Operand::read_lane64(const amdgpu::Wavefront &wf, uint32_t lane) const return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, ev); - return resolve_src_scalar64(wf, ev); + return amdgpu::resolve_src_scalar64(wf, ev, kM0EncodingValue); } void Operand::write_lane64(amdgpu::Wavefront &wf, uint32_t lane, uint64_t val) const { @@ -1223,7 +1006,7 @@ uint64_t Operand::read_scalar64(const amdgpu::Wavefront &wf) const { return literal64_value_; if (is_immediate_type(opr_type_)) return read_immediate64(opr_type_, encoding_value_); - return resolve_src_scalar64(wf, encoding_value_); + return amdgpu::resolve_src_scalar64(wf, encoding_value_, kM0EncodingValue); } void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { @@ -1233,7 +1016,7 @@ void Operand::write_scalar64(amdgpu::Wavefront &wf, uint64_t val) const { // via apply_fieldless_caps() (see fieldless_policy.py). if (!is_writable()) return; - resolve_dst_write64(wf, encoding_value_, val); + amdgpu::resolve_dst_write64(wf, encoding_value_, val); } } // namespace rdna4 diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/operand.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/operand.h index 2c46f826fdec..9cd14acb7cb4 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/operand.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/operand.h @@ -26,6 +26,7 @@ class Operand : public AmdgpuIsaOperand { Operand(int size_bits, OperandType opr_type, uint64_t literal64_value, bool is_literal64); std::string name() const override; std::optional literal64_value() const override; + std::optional const_value() const override; std::optional to_register_ref() const override; bool simd_capable() const override; diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/operand_types.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/operand_types.h index fc520ff8d643..00f531499e7d 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/operand_types.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/operand_types.h @@ -333,6 +333,19 @@ enum OpSelVgpr { } } +[[nodiscard]] constexpr bool is_immediate_type(OperandType t) { + switch (t) { + case OperandType::OPR_SIMM8: + case OperandType::OPR_SIMM16: + case OperandType::OPR_SIMM32: + case OperandType::OPR_LABEL: + case OperandType::OPR_WAITCNT: + return true; + default: + return false; + } +} + } // namespace rdna4 } // namespace rocjitsu diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/sop1.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/sop1.cpp index 13d8bd8ea915..55e9e84cd172 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/sop1.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/sop1.cpp @@ -33,6 +33,7 @@ SMovB32Sop1::SMovB32Sop1(const MachineInst *inst) ssrc0 = Operand( 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB32Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b32_sop1(*this, wf); } @@ -49,6 +50,7 @@ SMovB64Sop1::SMovB64Sop1(const MachineInst *inst) ssrc0 = Operand( 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); + flags_ |= RESULT_COPY; } void SMovB64Sop1::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_mov_b64_sop1(*this, wf); } @@ -634,6 +636,7 @@ SAndSaveexecB32Sop1::SAndSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -662,6 +665,7 @@ SAndSaveexecB64Sop1::SAndSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -690,6 +694,8 @@ SOrSaveexecB32Sop1::SOrSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } void SOrSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -718,6 +724,8 @@ SOrSaveexecB64Sop1::SOrSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; + flags_ |= RESULT_OR; } void SOrSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -746,6 +754,7 @@ SXorSaveexecB32Sop1::SXorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -774,6 +783,7 @@ SXorSaveexecB64Sop1::SXorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -802,6 +812,7 @@ SNandSaveexecB32Sop1::SNandSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNandSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -830,6 +841,7 @@ SNandSaveexecB64Sop1::SNandSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNandSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -858,6 +870,7 @@ SNorSaveexecB32Sop1::SNorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -886,6 +899,7 @@ SNorSaveexecB64Sop1::SNorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SNorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -914,6 +928,7 @@ SXnorSaveexecB32Sop1::SXnorSaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXnorSaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -942,6 +957,7 @@ SXnorSaveexecB64Sop1::SXnorSaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SXnorSaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -970,6 +986,7 @@ SAndNot0SaveexecB32Sop1::SAndNot0SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot0SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -998,6 +1015,7 @@ SAndNot0SaveexecB64Sop1::SAndNot0SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot0SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1026,6 +1044,7 @@ SOrNot0SaveexecB32Sop1::SOrNot0SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrNot0SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1054,6 +1073,7 @@ SOrNot0SaveexecB64Sop1::SOrNot0SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrNot0SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1082,6 +1102,7 @@ SAndNot1SaveexecB32Sop1::SAndNot1SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot1SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1110,6 +1131,7 @@ SAndNot1SaveexecB64Sop1::SAndNot1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1138,6 +1160,7 @@ SOrNot1SaveexecB32Sop1::SOrNot1SaveexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrNot1SaveexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1166,6 +1189,7 @@ SOrNot1SaveexecB64Sop1::SOrNot1SaveexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SOrNot1SaveexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1194,6 +1218,7 @@ SAndNot0WrexecB32Sop1::SAndNot0WrexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot0WrexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1222,6 +1247,7 @@ SAndNot0WrexecB64Sop1::SAndNot0WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot0WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1250,6 +1276,7 @@ SAndNot1WrexecB32Sop1::SAndNot1WrexecB32Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot1WrexecB32Sop1::execute_impl(amdgpu::Wavefront &wf) { @@ -1278,6 +1305,7 @@ SAndNot1WrexecB64Sop1::SAndNot1WrexecB64Sop1(const MachineInst *inst) sdst_exec.apply_fieldless_caps(false, false, false); scc.apply_fieldless_caps(false, false, false); sdst_exec_in.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void SAndNot1WrexecB64Sop1::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/sop2.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/sop2.cpp index 3bf77d8e9930..297b44112a3a 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/sop2.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/sop2.cpp @@ -664,6 +664,7 @@ SOrB32Sop2::SOrB32Sop2(const MachineInst *inst) 32, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB32Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b32_sop2(*this, wf); } @@ -689,6 +690,7 @@ SOrB64Sop2::SOrB64Sop2(const MachineInst *inst) 64, OperandType::OPR_SIMM32, static_cast(reinterpret_cast(inst)->simm32)); scc.apply_fieldless_caps(false, false, false); + flags_ |= RESULT_OR; } void SOrB64Sop2::execute_impl(amdgpu::Wavefront &wf) { amdgpu::execute_s_or_b64_sop2(*this, wf); } diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/sopp.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/sopp.cpp index 915d12f8d04b..8152f5fb9e7f 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/sopp.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/sopp.cpp @@ -207,6 +207,7 @@ SBranchSopp::SBranchSopp(const MachineInst *inst) num_src_ = 1; num_dst_ = 0; flags_ |= BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SBranchSopp::branch_offset_bytes() const { @@ -230,6 +231,7 @@ SCbranchScc0Sopp::SCbranchScc0Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc0Sopp::branch_offset_bytes() const { @@ -255,6 +257,7 @@ SCbranchScc1Sopp::SCbranchScc1Sopp(const MachineInst *inst) num_dst_ = 0; scc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchScc1Sopp::branch_offset_bytes() const { @@ -280,6 +283,7 @@ SCbranchVcczSopp::SCbranchVcczSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVcczSopp::branch_offset_bytes() const { @@ -307,6 +311,7 @@ SCbranchVccnzSopp::SCbranchVccnzSopp(const MachineInst *inst) num_dst_ = 0; vcc.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchVccnzSopp::branch_offset_bytes() const { @@ -334,6 +339,7 @@ SCbranchExeczSopp::SCbranchExeczSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExeczSopp::branch_offset_bytes() const { @@ -359,6 +365,7 @@ SCbranchExecnzSopp::SCbranchExecnzSopp(const MachineInst *inst) num_dst_ = 0; sdst_exec.apply_fieldless_caps(false, false, false); flags_ |= COND_BRANCH; + flags_ |= IGNORES_EXEC; } std::optional SCbranchExecnzSopp::branch_offset_bytes() const { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/vop3.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/vop3.cpp index d738d20638f1..bbb4aa13b4a2 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/vop3.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/vop3.cpp @@ -20233,6 +20233,7 @@ VCmpxLtF16Vop3::VCmpxLtF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20316,6 +20317,7 @@ VCmpxEqF16Vop3::VCmpxEqF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20399,6 +20401,7 @@ VCmpxLeF16Vop3::VCmpxLeF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20482,6 +20485,7 @@ VCmpxGtF16Vop3::VCmpxGtF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20565,6 +20569,7 @@ VCmpxLgF16Vop3::VCmpxLgF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20648,6 +20653,7 @@ VCmpxGeF16Vop3::VCmpxGeF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20731,6 +20737,7 @@ VCmpxOF16Vop3::VCmpxOF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20814,6 +20821,7 @@ VCmpxUF16Vop3::VCmpxUF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20897,6 +20905,7 @@ VCmpxNgeF16Vop3::VCmpxNgeF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -20980,6 +20989,7 @@ VCmpxNlgF16Vop3::VCmpxNlgF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21063,6 +21073,7 @@ VCmpxNgtF16Vop3::VCmpxNgtF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21146,6 +21157,7 @@ VCmpxNleF16Vop3::VCmpxNleF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21229,6 +21241,7 @@ VCmpxNeqF16Vop3::VCmpxNeqF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21312,6 +21325,7 @@ VCmpxNltF16Vop3::VCmpxNltF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21387,6 +21401,7 @@ VCmpxLtF32Vop3::VCmpxLtF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21457,6 +21472,7 @@ VCmpxEqF32Vop3::VCmpxEqF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21527,6 +21543,7 @@ VCmpxLeF32Vop3::VCmpxLeF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21597,6 +21614,7 @@ VCmpxGtF32Vop3::VCmpxGtF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21667,6 +21685,7 @@ VCmpxLgF32Vop3::VCmpxLgF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21737,6 +21756,7 @@ VCmpxGeF32Vop3::VCmpxGeF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21807,6 +21827,7 @@ VCmpxOF32Vop3::VCmpxOF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21877,6 +21898,7 @@ VCmpxUF32Vop3::VCmpxUF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -21947,6 +21969,7 @@ VCmpxNgeF32Vop3::VCmpxNgeF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22017,6 +22040,7 @@ VCmpxNlgF32Vop3::VCmpxNlgF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22087,6 +22111,7 @@ VCmpxNgtF32Vop3::VCmpxNgtF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22157,6 +22182,7 @@ VCmpxNleF32Vop3::VCmpxNleF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22227,6 +22253,7 @@ VCmpxNeqF32Vop3::VCmpxNeqF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22297,6 +22324,7 @@ VCmpxNltF32Vop3::VCmpxNltF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22357,6 +22385,7 @@ VCmpxLtF64Vop3::VCmpxLtF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LT_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22410,6 +22439,7 @@ VCmpxEqF64Vop3::VCmpxEqF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_EQ_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22463,6 +22493,7 @@ VCmpxLeF64Vop3::VCmpxLeF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LE_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22516,6 +22547,7 @@ VCmpxGtF64Vop3::VCmpxGtF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GT_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22569,6 +22601,7 @@ VCmpxLgF64Vop3::VCmpxLgF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LG_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22622,6 +22655,7 @@ VCmpxGeF64Vop3::VCmpxGeF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GE_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22675,6 +22709,7 @@ VCmpxOF64Vop3::VCmpxOF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_O_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22728,6 +22763,7 @@ VCmpxUF64Vop3::VCmpxUF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_U_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22781,6 +22817,7 @@ VCmpxNgeF64Vop3::VCmpxNgeF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NGE_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22834,6 +22871,7 @@ VCmpxNlgF64Vop3::VCmpxNlgF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NLG_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22887,6 +22925,7 @@ VCmpxNgtF64Vop3::VCmpxNgtF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NGT_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22940,6 +22979,7 @@ VCmpxNleF64Vop3::VCmpxNleF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NLE_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -22993,6 +23033,7 @@ VCmpxNeqF64Vop3::VCmpxNeqF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NEQ_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23046,6 +23087,7 @@ VCmpxNltF64Vop3::VCmpxNltF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NLT_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23117,6 +23159,7 @@ VCmpxLtI16Vop3::VCmpxLtI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23196,6 +23239,7 @@ VCmpxEqI16Vop3::VCmpxEqI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23275,6 +23319,7 @@ VCmpxLeI16Vop3::VCmpxLeI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23354,6 +23399,7 @@ VCmpxGtI16Vop3::VCmpxGtI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23433,6 +23479,7 @@ VCmpxNeI16Vop3::VCmpxNeI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23512,6 +23559,7 @@ VCmpxGeI16Vop3::VCmpxGeI16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23591,6 +23639,7 @@ VCmpxLtU16Vop3::VCmpxLtU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23670,6 +23719,7 @@ VCmpxEqU16Vop3::VCmpxEqU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23749,6 +23799,7 @@ VCmpxLeU16Vop3::VCmpxLeU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23828,6 +23879,7 @@ VCmpxGtU16Vop3::VCmpxGtU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23907,6 +23959,7 @@ VCmpxNeU16Vop3::VCmpxNeU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -23986,6 +24039,7 @@ VCmpxGeU16Vop3::VCmpxGeU16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24057,6 +24111,7 @@ VCmpxLtI32Vop3::VCmpxLtI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24119,6 +24174,7 @@ VCmpxEqI32Vop3::VCmpxEqI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24181,6 +24237,7 @@ VCmpxLeI32Vop3::VCmpxLeI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24243,6 +24300,7 @@ VCmpxGtI32Vop3::VCmpxGtI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24305,6 +24363,7 @@ VCmpxNeI32Vop3::VCmpxNeI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24367,6 +24426,7 @@ VCmpxGeI32Vop3::VCmpxGeI32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24429,6 +24489,7 @@ VCmpxLtU32Vop3::VCmpxLtU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24491,6 +24552,7 @@ VCmpxEqU32Vop3::VCmpxEqU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24553,6 +24615,7 @@ VCmpxLeU32Vop3::VCmpxLeU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24615,6 +24678,7 @@ VCmpxGtU32Vop3::VCmpxGtU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24677,6 +24741,7 @@ VCmpxNeU32Vop3::VCmpxNeU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24739,6 +24804,7 @@ VCmpxGeU32Vop3::VCmpxGeU32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24787,6 +24853,7 @@ VCmpxLtI64Vop3::VCmpxLtI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LT_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24828,6 +24895,7 @@ VCmpxEqI64Vop3::VCmpxEqI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_EQ_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24869,6 +24937,7 @@ VCmpxLeI64Vop3::VCmpxLeI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LE_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24910,6 +24979,7 @@ VCmpxGtI64Vop3::VCmpxGtI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GT_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24951,6 +25021,7 @@ VCmpxNeI64Vop3::VCmpxNeI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NE_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -24992,6 +25063,7 @@ VCmpxGeI64Vop3::VCmpxGeI64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GE_I64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -25033,6 +25105,7 @@ VCmpxLtU64Vop3::VCmpxLtU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LT_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -25074,6 +25147,7 @@ VCmpxEqU64Vop3::VCmpxEqU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_EQ_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -25115,6 +25189,7 @@ VCmpxLeU64Vop3::VCmpxLeU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_LE_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -25156,6 +25231,7 @@ VCmpxGtU64Vop3::VCmpxGtU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GT_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -25197,6 +25273,7 @@ VCmpxNeU64Vop3::VCmpxNeU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_NE_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -25238,6 +25315,7 @@ VCmpxGeU64Vop3::VCmpxGeU64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_GE_U64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -25301,6 +25379,7 @@ VCmpxClassF16Vop3::VCmpxClassF16Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -25400,6 +25479,7 @@ VCmpxClassF32Vop3::VCmpxClassF32Vop3(const MachineInst *inst) dpp_fi_ = dp->fi; } sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vop3::execute_impl(amdgpu::Wavefront &wf) { @@ -25477,6 +25557,7 @@ VCmpxClassF64Vop3::VCmpxClassF64Vop3(const MachineInst *inst) amdgpu::dpp::is_src_dpp8(reinterpret_cast(inst)->src0)) throw util::InvalidInst("V_CMPX_CLASS_F64 does not support DPP", ""); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vop3::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/vopc.cpp b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/vopc.cpp index 40e60fa7532a..d6b8e7f69eba 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/vopc.cpp +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/rdna4/vopc.cpp @@ -3923,6 +3923,7 @@ VCmpxLtF16Vopc::VCmpxLtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4002,6 +4003,7 @@ VCmpxEqF16Vopc::VCmpxEqF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4081,6 +4083,7 @@ VCmpxLeF16Vopc::VCmpxLeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4160,6 +4163,7 @@ VCmpxGtF16Vopc::VCmpxGtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4239,6 +4243,7 @@ VCmpxLgF16Vopc::VCmpxLgF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4318,6 +4323,7 @@ VCmpxGeF16Vopc::VCmpxGeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4397,6 +4403,7 @@ VCmpxOF16Vopc::VCmpxOF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4476,6 +4483,7 @@ VCmpxUF16Vopc::VCmpxUF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4555,6 +4563,7 @@ VCmpxNgeF16Vopc::VCmpxNgeF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4634,6 +4643,7 @@ VCmpxNlgF16Vopc::VCmpxNlgF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4713,6 +4723,7 @@ VCmpxNgtF16Vopc::VCmpxNgtF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4792,6 +4803,7 @@ VCmpxNleF16Vopc::VCmpxNleF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4871,6 +4883,7 @@ VCmpxNeqF16Vopc::VCmpxNeqF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -4950,6 +4963,7 @@ VCmpxNltF16Vopc::VCmpxNltF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5026,6 +5040,7 @@ VCmpxLtF32Vopc::VCmpxLtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5100,6 +5115,7 @@ VCmpxEqF32Vopc::VCmpxEqF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5174,6 +5190,7 @@ VCmpxLeF32Vopc::VCmpxLeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5248,6 +5265,7 @@ VCmpxGtF32Vopc::VCmpxGtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5322,6 +5340,7 @@ VCmpxLgF32Vopc::VCmpxLgF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5396,6 +5415,7 @@ VCmpxGeF32Vopc::VCmpxGeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5470,6 +5490,7 @@ VCmpxOF32Vopc::VCmpxOF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5544,6 +5565,7 @@ VCmpxUF32Vopc::VCmpxUF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5618,6 +5640,7 @@ VCmpxNgeF32Vopc::VCmpxNgeF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5692,6 +5715,7 @@ VCmpxNlgF32Vopc::VCmpxNlgF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5766,6 +5790,7 @@ VCmpxNgtF32Vopc::VCmpxNgtF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5840,6 +5865,7 @@ VCmpxNleF32Vopc::VCmpxNleF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5914,6 +5940,7 @@ VCmpxNeqF32Vopc::VCmpxNeqF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -5988,6 +6015,7 @@ VCmpxNltF32Vopc::VCmpxNltF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6050,6 +6078,7 @@ VCmpxLtF64Vopc::VCmpxLtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6090,6 +6119,7 @@ VCmpxEqF64Vopc::VCmpxEqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6130,6 +6160,7 @@ VCmpxLeF64Vopc::VCmpxLeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6170,6 +6201,7 @@ VCmpxGtF64Vopc::VCmpxGtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6210,6 +6242,7 @@ VCmpxLgF64Vopc::VCmpxLgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LG_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6250,6 +6283,7 @@ VCmpxGeF64Vopc::VCmpxGeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6290,6 +6324,7 @@ VCmpxOF64Vopc::VCmpxOF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_O_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxOF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6330,6 +6365,7 @@ VCmpxUF64Vopc::VCmpxUF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_U_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxUF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6370,6 +6406,7 @@ VCmpxNgeF64Vopc::VCmpxNgeF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGE_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgeF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6410,6 +6447,7 @@ VCmpxNlgF64Vopc::VCmpxNlgF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLG_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNlgF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6450,6 +6488,7 @@ VCmpxNgtF64Vopc::VCmpxNgtF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NGT_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNgtF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6490,6 +6529,7 @@ VCmpxNleF64Vopc::VCmpxNleF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLE_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNleF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6530,6 +6570,7 @@ VCmpxNeqF64Vopc::VCmpxNeqF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NEQ_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeqF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6570,6 +6611,7 @@ VCmpxNltF64Vopc::VCmpxNltF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NLT_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNltF64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6625,6 +6667,7 @@ VCmpxLtI16Vopc::VCmpxLtI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6702,6 +6745,7 @@ VCmpxEqI16Vopc::VCmpxEqI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6779,6 +6823,7 @@ VCmpxLeI16Vopc::VCmpxLeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6856,6 +6901,7 @@ VCmpxGtI16Vopc::VCmpxGtI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -6933,6 +6979,7 @@ VCmpxNeI16Vopc::VCmpxNeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7010,6 +7057,7 @@ VCmpxGeI16Vopc::VCmpxGeI16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7087,6 +7135,7 @@ VCmpxLtU16Vopc::VCmpxLtU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7164,6 +7213,7 @@ VCmpxEqU16Vopc::VCmpxEqU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7241,6 +7291,7 @@ VCmpxLeU16Vopc::VCmpxLeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7318,6 +7369,7 @@ VCmpxGtU16Vopc::VCmpxGtU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7395,6 +7447,7 @@ VCmpxNeU16Vopc::VCmpxNeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7472,6 +7525,7 @@ VCmpxGeU16Vopc::VCmpxGeU16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7546,6 +7600,7 @@ VCmpxLtI32Vopc::VCmpxLtI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7620,6 +7675,7 @@ VCmpxEqI32Vopc::VCmpxEqI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7694,6 +7750,7 @@ VCmpxLeI32Vopc::VCmpxLeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7768,6 +7825,7 @@ VCmpxGtI32Vopc::VCmpxGtI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7842,6 +7900,7 @@ VCmpxNeI32Vopc::VCmpxNeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7916,6 +7975,7 @@ VCmpxGeI32Vopc::VCmpxGeI32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -7990,6 +8050,7 @@ VCmpxLtU32Vopc::VCmpxLtU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8064,6 +8125,7 @@ VCmpxEqU32Vopc::VCmpxEqU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8138,6 +8200,7 @@ VCmpxLeU32Vopc::VCmpxLeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8212,6 +8275,7 @@ VCmpxGtU32Vopc::VCmpxGtU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8286,6 +8350,7 @@ VCmpxNeU32Vopc::VCmpxNeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8360,6 +8425,7 @@ VCmpxGeU32Vopc::VCmpxGeU32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8420,6 +8486,7 @@ VCmpxLtI64Vopc::VCmpxLtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8458,6 +8525,7 @@ VCmpxEqI64Vopc::VCmpxEqI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8496,6 +8564,7 @@ VCmpxLeI64Vopc::VCmpxLeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8534,6 +8603,7 @@ VCmpxGtI64Vopc::VCmpxGtI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8572,6 +8642,7 @@ VCmpxNeI64Vopc::VCmpxNeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8610,6 +8681,7 @@ VCmpxGeI64Vopc::VCmpxGeI64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_I64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeI64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8648,6 +8720,7 @@ VCmpxLtU64Vopc::VCmpxLtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LT_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8686,6 +8759,7 @@ VCmpxEqU64Vopc::VCmpxEqU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_EQ_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxEqU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8724,6 +8798,7 @@ VCmpxLeU64Vopc::VCmpxLeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_LE_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxLeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8762,6 +8837,7 @@ VCmpxGtU64Vopc::VCmpxGtU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GT_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGtU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8800,6 +8876,7 @@ VCmpxNeU64Vopc::VCmpxNeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_NE_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxNeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8838,6 +8915,7 @@ VCmpxGeU64Vopc::VCmpxGeU64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_GE_U64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxGeU64Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8893,6 +8971,7 @@ VCmpxClassF16Vopc::VCmpxClassF16Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF16Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -8996,6 +9075,7 @@ VCmpxClassF32Vopc::VCmpxClassF32Vopc(const MachineInst *inst) } exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF32Vopc::execute_impl(amdgpu::Wavefront &wf) { @@ -9081,6 +9161,7 @@ VCmpxClassF64Vopc::VCmpxClassF64Vopc(const MachineInst *inst) throw util::InvalidInst("V_CMPX_CLASS_F64 does not support DPP", ""); exec.apply_fieldless_caps(false, false, false); sdst_exec.apply_fieldless_caps(false, false, false); + flags_ |= WRITES_EXEC; } void VCmpxClassF64Vopc::execute_impl(amdgpu::Wavefront &wf) { diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h new file mode 100644 index 000000000000..d1aba9f13a47 --- /dev/null +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/shared/scalar_operand_resolve.h @@ -0,0 +1,278 @@ +// Copyright (c) 2025-2026 Advanced Micro Devices, Inc. +// SPDX-License-Identifier: MIT + +#ifndef ROCJITSU_ISA_AMDGPU_SHARED_SCALAR_OPERAND_RESOLVE_H_ +#define ROCJITSU_ISA_AMDGPU_SHARED_SCALAR_OPERAND_RESOLVE_H_ + +#include "rocjitsu/isa/arch/amdgpu/shared/scalar_static_resolve.h" +#include "rocjitsu/vm/amdgpu/compute_unit.h" +#include "rocjitsu/vm/amdgpu/register_access.h" +#include "rocjitsu/vm/amdgpu/wavefront.h" +#include +#include +#include +#include + +namespace rocjitsu { +namespace amdgpu { + +// resolve_src_scalar_statically() (the wavefront-free inline-constant subset) is +// defined in scalar_static_resolve.h, included above, so model-side code can use +// it without depending on the vm/ simulator layer. Keep the encoding-value +// handling in resolve_src_scalar() below in sync with it. + +// The value of a scalar source operand resolvable from wavefront state alone +// (SGPR/VCC/EXEC/M0 reads plus inline constants). `m0_ev` is the M0 encoding +// value for this arch (124 on most arches; 125 on RDNA 3 / RDNA 3.5 / RDNA4 +// / GFX1250, where 124 is the NULL slot). +inline uint32_t resolve_src_scalar(const Wavefront &wf, int ev, int m0_ev) { + if (ev == 102) + return static_cast(wf.scratch_base()); + if (ev == 103) + return static_cast(wf.scratch_base() >> 32); + if (ev <= 105) + return RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); + if (ev == 106) + return static_cast(wf.vcc()); + if (ev == 107) + return static_cast(wf.vcc() >> 32); + if (ev >= 108 && ev <= 123) + return RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); + if (m0_ev == 125 && ev == 124) + return 0u; // NULL + if (ev == m0_ev) + return wf.m0(); + if (ev == 126) + return static_cast(wf.exec()); + if (ev == 127) + return static_cast(wf.exec_raw() >> 32); + if (ev >= 128 && ev <= 192) + return static_cast(ev - 128); + if (ev >= 193 && ev <= 208) + return static_cast(static_cast(-(ev - 192))); + if (ev == 230) + return static_cast(wf.scratch_base()); // SRC_FLAT_SCRATCH_BASE_LO + if (ev == 231) + return static_cast(wf.scratch_base() >> 32); // SRC_FLAT_SCRATCH_BASE_HI + if (ev == 240) + return 0x3F000000u; // 0.5f + if (ev == 241) + return 0xBF000000u; // -0.5f + if (ev == 242) + return 0x3F800000u; // 1.0f + if (ev == 243) + return 0xBF800000u; // -1.0f + if (ev == 244) + return 0x40000000u; // 2.0f + if (ev == 245) + return 0xC0000000u; // -2.0f + if (ev == 246) + return 0x40800000u; // 4.0f + if (ev == 247) + return 0xC0800000u; // -4.0f + if (ev == 248) + return 0x3E22F983u; // 1/(2*pi) + if (ev == 235) + return static_cast(wf.shared_aperture_base() >> 32); // SRC_SHARED_BASE + if (ev == 236) + return static_cast(wf.shared_aperture_limit() >> 32); // SRC_SHARED_LIMIT + if (ev == 237) + return static_cast(wf.private_aperture_base() >> 32); // SRC_PRIVATE_BASE + if (ev == 238) + return static_cast(wf.private_aperture_limit() >> 32); // SRC_PRIVATE_LIMIT + if (ev == 249) + return 0u; // SRC_POPS_EXITING_WAVE_ID (not used in compute) + if (ev == 250) + return 0u; // NULL + if (ev == 251) + return (wf.vcc() & (wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL))) == 0 + ? 1u + : 0u; // VCCZ + if (ev == 252) { + uint64_t active = wf.wf_size() >= 64 ? ~0ULL : ((1ULL << wf.wf_size()) - 1ULL); + return (wf.exec() & active) == 0 ? 1u : 0u; // EXECZ + } + if (ev == 253) + return wf.read_scc() ? 1u : 0u; // SCC + throw std::logic_error("Unsupported encoding value for scalar read: " + std::to_string(ev)); +} + +// 16-bit reads of the inline float constants use the half-precision bit +// patterns rather than the single-precision ones; every other encoding value +// resolves identically to the 32-bit path. +inline uint32_t resolve_src_scalar16(const Wavefront &wf, int ev, int m0_ev) { + switch (ev) { + case 240: + return 0x3800u; // 0.5h + case 241: + return 0xB800u; // -0.5h + case 242: + return 0x3C00u; // 1.0h + case 243: + return 0xBC00u; // -1.0h + case 244: + return 0x4000u; // 2.0h + case 245: + return 0xC000u; // -2.0h + case 246: + return 0x4400u; // 4.0h + case 247: + return 0xC400u; // -4.0h + case 248: + return 0x3118u; // f16 1/(2*pi) + default: + return resolve_src_scalar(wf, ev, m0_ev); + } +} + +// Must stay in sync with resolve_src_scalar above -- returns true for exactly +// the encoding values that resolve_src_scalar handles without throwing. Used by +// Isa::simd_capable_value() to keep the SIMD fast path off operands whose +// scalar broadcast would throw at runtime. +inline bool can_resolve_src_scalar(int ev, int m0_ev) { + bool ok = (ev >= 0 && ev <= 107) || (ev >= 108 && ev <= 123) || ev == 124 || ev == 126 || + ev == 127 || (ev >= 128 && ev <= 208) || (ev >= 235 && ev <= 238) || + (ev >= 240 && ev <= 253); + if (m0_ev == 125) + ok = ok || ev == 125 || ev == 230 || ev == 231; + return ok; +} + +inline uint64_t resolve_src_scalar64(const Wavefront &wf, int ev, int m0_ev) { + if (ev == 102) + return wf.scratch_base(); + if (ev <= 105) { + uint32_t lo = RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); + uint32_t hi = + RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); + return static_cast(hi) << 32 | lo; + } + if (ev == 106) + return wf.vcc(); + if (ev >= 108 && ev <= 122) { + uint32_t lo = RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev)); + uint32_t hi = + RegisterAccess(wf).read_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1)); + return static_cast(hi) << 32 | lo; + } + if (m0_ev == 125 && ev == 124) + return 0u; // NULL + if (ev == m0_ev) + return wf.m0(); + if (ev == 126) + return wf.exec_raw(); + if (ev >= 128 && ev <= 192) + return static_cast(ev - 128); + if (ev >= 193 && ev <= 208) + return static_cast(static_cast(static_cast(-(ev - 192)))); + if (ev == 230) + return wf.scratch_base(); // SRC_FLAT_SCRATCH_BASE + if (ev == 240) + return 0x3FE0000000000000ULL; // 0.5 + if (ev == 241) + return 0xBFE0000000000000ULL; // -0.5 + if (ev == 242) + return 0x3FF0000000000000ULL; // 1.0 + if (ev == 243) + return 0xBFF0000000000000ULL; // -1.0 + if (ev == 244) + return 0x4000000000000000ULL; // 2.0 + if (ev == 245) + return 0xC000000000000000ULL; // -2.0 + if (ev == 246) + return 0x4010000000000000ULL; // 4.0 + if (ev == 247) + return 0xC010000000000000ULL; // -4.0 + if (ev == 248) + return 0x3FC45F306DC9C883ULL; // 1/(2*pi) + if (ev == 235) + return wf.shared_aperture_base(); // SRC_SHARED_BASE + if (ev == 236) + return wf.shared_aperture_limit(); // SRC_SHARED_LIMIT + if (ev == 237) + return wf.private_aperture_base(); // SRC_PRIVATE_BASE + if (ev == 238) + return wf.private_aperture_limit(); // SRC_PRIVATE_LIMIT + throw std::logic_error("Unsupported encoding value for scalar64 read: " + std::to_string(ev)); +} + +inline void resolve_dst_write(Wavefront &wf, int ev, uint32_t val, int m0_ev) { + if (ev == 102) { + uint64_t sb = wf.scratch_base(); + wf.set_scratch_base((sb & 0xFFFFFFFF00000000ULL) | val); + return; + } + if (ev == 103) { + uint64_t sb = wf.scratch_base(); + wf.set_scratch_base((sb & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); + return; + } + if (ev <= 105) { + RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); + return; + } + if (ev == 106) { + wf.set_vcc((wf.vcc() & 0xFFFFFFFF00000000ULL) | val); + return; + } + if (ev == 107) { + wf.set_vcc((wf.vcc() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); + return; + } + if (ev >= 108 && ev <= 123) { + RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), val); + return; + } + if (m0_ev == 125 && ev == 124) + return; // NULL + if (ev == m0_ev) { + wf.set_m0(val); + return; + } + if (ev == 126) { + wf.set_exec((wf.exec() & 0xFFFFFFFF00000000ULL) | val); + return; + } + if (ev == 127) { + wf.set_exec_raw((wf.exec_raw() & 0x00000000FFFFFFFFULL) | (static_cast(val) << 32)); + return; + } + throw std::logic_error("Unsupported encoding value for scalar write: " + std::to_string(ev)); +} + +inline void resolve_dst_write64(Wavefront &wf, int ev, uint64_t val) { + if (ev == 102) { + wf.set_scratch_base(val); + return; + } + if (ev <= 105) { + RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), + static_cast(val)); + RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), + static_cast(val >> 32)); + return; + } + if (ev == 106) { + wf.set_vcc(val); + return; + } + if (ev >= 108 && ev <= 122) { + RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev), + static_cast(val)); + RegisterAccess(wf).write_sgpr(wf.sgpr_alloc().base + static_cast(ev + 1), + static_cast(val >> 32)); + return; + } + if (ev == 124) + return; + if (ev == 126) { + wf.set_exec_raw(val); + return; + } + throw std::logic_error("Unsupported encoding value for scalar64 write: " + std::to_string(ev)); +} + +} // namespace amdgpu +} // namespace rocjitsu + +#endif // ROCJITSU_ISA_AMDGPU_SHARED_SCALAR_OPERAND_RESOLVE_H_ diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/shared/scalar_static_resolve.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/shared/scalar_static_resolve.h new file mode 100644 index 000000000000..539cc5445aef --- /dev/null +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/arch/amdgpu/shared/scalar_static_resolve.h @@ -0,0 +1,51 @@ +// Copyright (c) 2025-2026 Advanced Micro Devices, Inc. +// SPDX-License-Identifier: MIT + +#ifndef ROCJITSU_ISA_AMDGPU_SHARED_SCALAR_STATIC_RESOLVE_H_ +#define ROCJITSU_ISA_AMDGPU_SHARED_SCALAR_STATIC_RESOLVE_H_ + +#include +#include + +namespace rocjitsu { +namespace amdgpu { + +// Wavefront-free subset of resolve_src_scalar: the value of an inline constant +// (small integers 0..64 / -1..-16 and the inline float constants), or nullopt +// for any other encoding value. Negative inline integers are sign-extended to +// 64 bits so 64-bit consumers see all-ones. +// +// This header is intentionally free of any rocjitsu/vm/ dependency so that +// model-side code (e.g. Operand::const_value) can use it without pulling in the +// simulator/execution layer. Keep the encoding-value handling here in sync with +// resolve_src_scalar() in scalar_operand_resolve.h, which includes this header. +inline std::optional resolve_src_scalar_statically(int ev) { + if (ev >= 128 && ev <= 192) + return static_cast(ev - 128); + if (ev >= 193 && ev <= 208) + return static_cast(static_cast(-(ev - 192))); + if (ev == 240) + return static_cast(0x3F000000u); // 0.5f + if (ev == 241) + return static_cast(0xBF000000u); // -0.5f + if (ev == 242) + return static_cast(0x3F800000u); // 1.0f + if (ev == 243) + return static_cast(0xBF800000u); // -1.0f + if (ev == 244) + return static_cast(0x40000000u); // 2.0f + if (ev == 245) + return static_cast(0xC0000000u); // -2.0f + if (ev == 246) + return static_cast(0x40800000u); // 4.0f + if (ev == 247) + return static_cast(0xC0800000u); // -4.0f + if (ev == 248) + return static_cast(0x3E22F983u); // 1/(2*pi) + return std::nullopt; +} + +} // namespace amdgpu +} // namespace rocjitsu + +#endif // ROCJITSU_ISA_AMDGPU_SHARED_SCALAR_STATIC_RESOLVE_H_ diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/instruction.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/instruction.h index c8b98677d248..ddedac185311 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/instruction.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/instruction.h @@ -47,7 +47,19 @@ enum InstFlags : uint64_t { /// @brief AccVGPR move instruction (v_accvgpr_write, v_accvgpr_read, v_accvgpr_mov). ACCVGPR = (1ULL << 10), /// @brief Destination update is conditional and must not kill the old value. - PREDICATED_DEF = (1ULL << 11) + PREDICATED_DEF = (1ULL << 11), + /// @brief Executes regardless of the EXEC mask (e.g. branches). + IGNORES_EXEC = (1ULL << 12), + /// @brief Writes the EXEC mask regardless of DST operands. + WRITES_EXEC = (1ULL << 13), + /// @brief The destination value is a scalar plain copy of a single source operand + /// (e.g. s_mov). Lets EXEC-state analysis prove an all-ones EXEC write from an + /// all-ones source. + RESULT_COPY = (1ULL << 14), + /// @brief The destination value is the scalar bitwise pure OR of the source operands + /// (e.g. s_or, s_or_saveexec). Pure OR with an all-ones operand is all-ones + /// regardless of the others. + RESULT_OR = (1ULL << 15) }; class BasicBlock; diff --git a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/operand.h b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/operand.h index 5c2e2018826d..ef081c9d6233 100644 --- a/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/operand.h +++ b/emulation/rocjitsu/lib/rocjitsu/src/rocjitsu/isa/operand.h @@ -101,6 +101,18 @@ class Operand { /// @brief Full 64-bit literal value when this operand came from a literal64 encoding. [[nodiscard]] virtual std::optional literal64_value() const { return std::nullopt; } + /// @brief Compile-time constant value of this operand, resolved without any + /// register/wavefront state, or nullopt for registers and other non-constant + /// operands. + /// + /// @details Unlike `literal64_value()` (which only reports the literal64 + /// encoding), this also resolves inline constants — small integers and the + /// inline float constants whose value is implied by the encoding. The base + /// default covers only the literal case; ISA subclasses override it to add + /// inline-constant resolution. Useful for static analysis (e.g. detecting + /// `s_mov exec, -1`) where no wavefront is available. + [[nodiscard]] virtual std::optional const_value() const { return literal64_value(); } + /// @brief Operand width in bits. int size_bits() const { return size_bits_; } diff --git a/emulation/rocjitsu/tests/analysis/liveness_test.cpp b/emulation/rocjitsu/tests/analysis/liveness_test.cpp index 7489997a3f3b..5b1ba6dd5279 100644 --- a/emulation/rocjitsu/tests/analysis/liveness_test.cpp +++ b/emulation/rocjitsu/tests/analysis/liveness_test.cpp @@ -2,6 +2,7 @@ // SPDX-License-Identifier: MIT #include "rocjitsu/analysis/def_use_chain.h" +#include "rocjitsu/analysis/exec_state.h" #include "rocjitsu/analysis/indirect_branch_discovery.h" #include "rocjitsu/analysis/liveness.h" #include "rocjitsu/code/basic_block.h" @@ -54,17 +55,42 @@ class TestOperand : public Operand { TestOperand(RegisterRef ref, int size_bits) : Operand(size_bits, ref.index), ref_(ref) {} std::optional to_register_ref() const override { return ref_; } + std::optional literal64_value() const override { return lit_; } + std::optional const_value() const override { + return const_.has_value() ? const_ : literal64_value(); + } + + // Turn this into a 64-bit literal source operand (no register ref). Models the + // literal64 path: both literal64_value() and const_value() report it. + void set_literal(uint64_t v) { + lit_ = v; + size_bits_ = 64; + } + + // Turn this into an inline-constant source operand: const_value() reports it + // but literal64_value() stays empty (mirrors how inline constants behave). + void set_inline_const(uint64_t v) { + const_ = v; + size_bits_ = 64; + } private: std::optional ref_; + std::optional lit_; + std::optional const_; }; class TestInstruction : public Instruction { public: + // `literal_src`, when set, appends one literal source operand carrying the + // given value via literal64_value() — models an instruction's literal64 + // (SIMM) immediate, e.g. the all-ones source of `s_mov_b64 exec, `. TestInstruction(std::string_view mnemonic, std::initializer_list defs = {}, std::initializer_list uses = {}, uint64_t flags = 0, std::optional branch_delta = std::nullopt, - std::initializer_list implicit_uses = {}, int def_size_bits = 0) + std::initializer_list implicit_uses = {}, + std::optional literal_src = std::nullopt, + std::optional inline_const_src = std::nullopt, int def_size_bits = 0) : Instruction(mnemonic, nullptr), implicit_uses_(implicit_uses), branch_delta_(branch_delta) { size_ = 4; flags_ = flags; @@ -82,6 +108,16 @@ class TestInstruction : public Instruction { src_operands_[num_src_] = &src_storage_[num_src_]; ++num_src_; } + if (literal_src) { + src_storage_[num_src_].set_literal(*literal_src); + src_operands_[num_src_] = &src_storage_[num_src_]; + ++num_src_; + } + if (inline_const_src) { + src_storage_[num_src_].set_inline_const(*inline_const_src); + src_operands_[num_src_] = &src_storage_[num_src_]; + ++num_src_; + } } std::optional branch_offset_bytes() const override { return branch_delta_; } @@ -152,7 +188,15 @@ enum class TestOpcode : uint32_t { CBranchToElseAfterTwo = 14, IndirectCall = 15, IndirectBranch = 16, - PartialDefSgpr4 = 17, + WriteExecFull = 17, + WriteExecNarrow = 18, + WriteExecFullInline = 19, + WriteExecOrAllOnes = 20, + WriteExecAndSaveexec = 21, + WriteExecLoHalf = 22, + WriteExecHiHalf = 23, + WriteExecHiHalfZero = 25, + PartialDefSgpr4 = 24, }; class TestDecoder : public Decoder { @@ -195,10 +239,49 @@ class TestDecoder : public Decoder { return new TestInstruction("test_indirect_call", {}, {}, INDIRECT_CALL); case TestOpcode::IndirectBranch: return new TestInstruction("test_indirect_branch", {}, {}, INDIRECT_BRANCH); + case TestOpcode::WriteExecFull: + // s_mov exec, : COPY of a single all-ones source. + return new TestInstruction("test_write_exec_full", {{RegClass::EXEC, 0, 2}}, {}, RESULT_COPY, + std::nullopt, {}, ~0ULL); + case TestOpcode::WriteExecNarrow: + // exec <- sgpr (non-constant): writes EXEC but not provably all-ones. + return new TestInstruction("test_write_exec_narrow", {{RegClass::EXEC, 0, 2}}, + {{RegClass::SGPR, 0, 1}}, RESULT_COPY); + case TestOpcode::WriteExecFullInline: + // s_mov exec, -1: COPY of an inline-constant all-ones source (reports + // const_value() but not literal64_value()). + return new TestInstruction("test_write_exec_full_inline", {{RegClass::EXEC, 0, 2}}, {}, + RESULT_COPY, std::nullopt, {}, std::nullopt, ~0ULL); + case TestOpcode::WriteExecOrAllOnes: + // s_or_b64 exec, exec, -1: OR of a (non-constant) source and an all-ones + // inline constant -> all-ones regardless of the other operand. + return new TestInstruction("test_write_exec_or_allones", {{RegClass::EXEC, 0, 2}}, + {{RegClass::SGPR, 0, 1}}, RESULT_OR, std::nullopt, {}, + std::nullopt, ~0ULL); + case TestOpcode::WriteExecAndSaveexec: + // s_and_saveexec exec, -1: writes EXEC (flag), single all-ones source, but + // exec = exec & -1 = exec -> NOT all-ones. No RESULT_* -> must stay Unknown. + return new TestInstruction("test_write_exec_and_saveexec", {{RegClass::SGPR, 0, 2}}, {}, + WRITES_EXEC, std::nullopt, {}, std::nullopt, ~0ULL); + case TestOpcode::WriteExecLoHalf: + // s_mov_b32 exec_lo, -1: a 32-bit COPY of all-ones into only the low half + // of EXEC. Full on Wave32; a partial write on Wave64. + return new TestInstruction("test_write_exec_lo_half", {{RegClass::EXEC, 0, 1}}, {}, + RESULT_COPY, std::nullopt, {}, std::nullopt, ~0ULL); + case TestOpcode::WriteExecHiHalf: + // s_mov_b32 exec_hi, -1: a 32-bit COPY of all-ones into only the high half + // of EXEC. Never covers the active lanes, so it can never establish Full. + return new TestInstruction("test_write_exec_hi_half", {{RegClass::EXEC, 1, 1}}, {}, + RESULT_COPY, std::nullopt, {}, std::nullopt, ~0ULL); + case TestOpcode::WriteExecHiHalfZero: + // s_mov_b32 exec_hi, 0: a 32-bit COPY of zero into only the high half of EXEC. + return new TestInstruction("test_write_exec_hi_half_zero", {{RegClass::EXEC, 1, 1}}, {}, + RESULT_COPY, std::nullopt, {}, std::nullopt, 0ULL); case TestOpcode::PartialDefSgpr4: // 16-bit write to s4: defines only part of the lane, so it also reads s4. return new TestInstruction("test_partial_def_s4", {{RegClass::SGPR, 4, 1}}, {}, 0, - std::nullopt, {}, /*def_size_bits=*/16); + std::nullopt, {}, std::nullopt, std::nullopt, + /*def_size_bits=*/16); } return new TestInstruction("test_end", {}, {}, PROGRAM_TERMINATOR); } @@ -253,7 +336,18 @@ std::span text_span(const CodeObject &co) { LivenessAnalysis analyze_scope(const std::vector> &blocks) { auto scope = block_scope(blocks); - return LivenessAnalysis(KernelBlockScope(scope)); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + return LivenessAnalysis(KernelBlockScope(scope), std::make_unique(exec)); +} + +// Wire the same scoped call/return edges into BOTH analyses, as BinaryTranslator +// does; feeding them to only one makes the two disagree around calls and returns. +LivenessAnalysis analyze_scope_with_edges(const std::vector> &blocks, + std::span extra_edges) { + auto scope = block_scope(blocks); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64, extra_edges); + return LivenessAnalysis(KernelBlockScope(scope), std::make_unique(exec), + /*options=*/{}, extra_edges); } // CFG/liveness tests care about decoded register effects, not the physical @@ -2872,7 +2966,9 @@ TEST(LivenessAnalysis, Gfx1250VgprMsbResolvesPhysicalRegisterBank) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -2908,7 +3004,9 @@ TEST(LivenessAnalysis, Gfx1250ImplicitVgprUseResolvesDestinationBank) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -2941,7 +3039,9 @@ TEST(LivenessAnalysis, Gfx1250ImplicitVgprUseResolvesDespiteExplicitBank0Alias) options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -2972,7 +3072,9 @@ TEST(LivenessAnalysis, Gfx1250SwapImplicitReadsResolvePerRole) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -3023,7 +3125,9 @@ TEST(LivenessAnalysis, Gfx1250DppPreserveReadResolvesToDstBank) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -3055,7 +3159,9 @@ TEST(LivenessAnalysis, Gfx1250ImplicitVgprUseUnknownBankReadsEveryCandidate) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -3087,7 +3193,9 @@ TEST(LivenessAnalysis, Gfx1250UnknownBankDefMakesEveryCandidateGloballyUsed) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -3124,7 +3232,9 @@ TEST(LivenessAnalysis, Gfx1250RelativeVgprAccessDisablesGlobalUnusedQuery) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); const Instruction &instruction = *blocks.front()->instructions().begin(); EXPECT_EQ(liveness.find_globally_unused_vgpr_run(&instruction, 1, 1, 1, 2), std::nullopt); @@ -3145,7 +3255,9 @@ TEST(LivenessAnalysis, Gfx1250SwaprelDisablesGlobalUnusedQuery) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); const Instruction &instruction = *blocks.front()->instructions().begin(); EXPECT_EQ(liveness.find_globally_unused_vgpr_run(&instruction, 1, 1, 1, 2), std::nullopt); @@ -3171,7 +3283,9 @@ TEST(LivenessAnalysis, Gfx1250GprIndexModeWriteDisablesGlobalUnusedQuery) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -3200,7 +3314,9 @@ TEST(LivenessAnalysis, Gfx1250ImmediateGprIndexModeWriteUsesLiteralValue) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -3230,7 +3346,9 @@ TEST(LivenessAnalysis, Cdna4DynamicGprIndexModeWriteDisablesGlobalUnusedQuery) { LivenessAnalysisOptions options; options.arch = ROCJITSU_CODE_ARCH_CDNA4; options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -3258,7 +3376,9 @@ TEST(LivenessAnalysis, Cdna4ImmediateGprIndexModeWriteUsesLiteralValue) { LivenessAnalysisOptions options; options.arch = ROCJITSU_CODE_ARCH_CDNA4; options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -3289,7 +3409,9 @@ TEST(LivenessAnalysis, Gfx1250DynamicModeWriteConservativelyUsesEveryBank) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -3322,7 +3444,9 @@ TEST(LivenessAnalysis, Gfx1250FullLiteralModeWriteRecoversKnownBank) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); std::advance(instruction, 2); @@ -3363,7 +3487,9 @@ TEST(LivenessAnalysis, Gfx1250TruncatedLiteralModeWriteMarksBanksAmbiguous) { // literal at offset 8. const auto full = text_span(co); options.text = full.subspan(0, 8); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); std::advance(instruction, 2); @@ -3392,7 +3518,9 @@ TEST(LivenessAnalysis, Gfx1250PartialLiteralModeWriteUsesUnmaskedVgprFields) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); std::advance(instruction, 2); @@ -3424,7 +3552,9 @@ TEST(LivenessAnalysis, Gfx1250ImmediateModeWriteRecoversBanksOutsideRequestedSli options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); std::advance(instruction, 2); @@ -3451,7 +3581,9 @@ TEST(LivenessAnalysis, Gfx1250LiteralModeWriteTracksEveryRole) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -3479,7 +3611,9 @@ TEST(LivenessAnalysis, Gfx1250ImmediateNonModeWriteDoesNotChangeBanks) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -3510,7 +3644,9 @@ TEST(LivenessAnalysis, Gfx1250VgprMsbCfgJoinRequiresPredecessorsToAgree) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); const Instruction &joined_move = *join->instructions().begin(); EXPECT_EQ(liveness.vgpr_msb_bank_before(joined_move, amdgpu::VgprMsbRole::Src0), std::nullopt); @@ -3538,7 +3674,9 @@ TEST(LivenessAnalysis, Gfx1250VgprMsbCfgJoinPreservesAgreeingBank) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); const Instruction &joined_move = *join->instructions().begin(); EXPECT_EQ(liveness.vgpr_msb_bank_before(joined_move, amdgpu::VgprMsbRole::Src0), 2); @@ -3575,7 +3713,9 @@ TEST(LivenessAnalysis, Gfx1250VgprMsbJoinExcludesUnreachablePredecessor) { options.arch = ROCJITSU_CODE_ARCH_GFX1250; options.entry_block = scope.front(); options.text = text_span(co); - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); const Instruction *joined_move = nullptr; for (const auto &block : blocks) { @@ -3589,6 +3729,442 @@ TEST(LivenessAnalysis, Gfx1250VgprMsbJoinExcludesUnreachablePredecessor) { EXPECT_TRUE(liveness.is_live_before(*joined_move, {RegClass::VGPR, 513, 1})); } +// Collect a block's instructions in order for index-based assertions. +std::vector insts_of(BasicBlock &block) { + std::vector out; + for (const auto &inst : block.instructions()) + out.push_back(&inst); + return out; +} + +// Decode real CDNA4 instruction words into a CFG with the production decoder. +std::vector> build_cdna4_blocks(std::vector words) { + TestCodeObject co(std::move(words)); + auto decoder = Decoder::create(ROCJITSU_CODE_ARCH_CDNA4); + return BasicBlock::build(co, *decoder, ROCJITSU_CODE_ARCH_CDNA4); +} + +// Full end-to-end on real decoded instructions: `s_mov_b64 exec, -1` makes EXEC +// provably all-ones, so the following EXEC-masked VGPR def overwrites every lane +// and becomes a real kill — the defined VGPR is dead immediately before it. This +// exercises the whole chain: decode -> to_register_ref (EXEC dest) + const_value +// (-1 -> all-ones) -> ExecMaskAnalysis (Full) -> liveness kill. +TEST(ExecFlagsRealDecode, Cdna4SMovExecAllOnesPromotesVgprDefToKill) { + // s_mov_b64 exec, -1 ; v_mov_b32 v0, s0 ; v_mov_b32 v2, v0 ; s_endpgm + auto blocks = build_cdna4_blocks({0xBEFE01C1u, 0x7E000200u, 0x7E040300u, 0xBF810000u}); + ASSERT_FALSE(blocks.empty()); + auto insts = insts_of(*blocks[0]); + ASSERT_GE(insts.size(), 3u); + + // Sanity-check the decode so an encoding typo fails loudly. + EXPECT_EQ(insts[0]->mnemonic(), "s_mov_b64"); + const Instruction &def = *insts[1]; + EXPECT_TRUE(def.mnemonic().starts_with("v_mov_b32")); + ASSERT_NE(def.dst_operand(0), nullptr); + auto def_ref = def.dst_operand(0)->to_register_ref(); + ASSERT_TRUE(def_ref.has_value()); + EXPECT_EQ(*def_ref, (RegisterRef{RegClass::VGPR, 0, 1})); + + // Proving EXEC=Full from `s_mov exec, -1` needs the s_mov to carry RESULT_COPY, + // which only exists once the ISA is regenerated with the combinator metadata. + ASSERT_TRUE(insts[0]->flags() & RESULT_COPY) + << "s_mov lacks RESULT_COPY; regenerate ISA to enable EXEC-Full tracking"; + + // EXEC is provably full at the def, so its vector write is a real kill. + auto scope = block_scope(blocks); + ExecMaskAnalysis exec{KernelBlockScope(scope), 64}; + EXPECT_EQ(exec.before(def), ExecState::Full); + + LivenessAnalysis liveness = analyze_scope(blocks); + EXPECT_FALSE(liveness.is_live_before(def, {RegClass::VGPR, 0, 1})); +} + +// Contrast: without the all-ones EXEC write, EXEC stays Unknown at the def, so +// the same vector def is not promoted to a kill and the VGPR remains live. +TEST(ExecFlagsRealDecode, Cdna4VgprDefStaysLiveWithoutFullExec) { + // v_mov_b32 v0, s0 ; v_mov_b32 v2, v0 ; s_endpgm + auto blocks = build_cdna4_blocks({0x7E000200u, 0x7E040300u, 0xBF810000u}); + ASSERT_FALSE(blocks.empty()); + auto insts = insts_of(*blocks[0]); + ASSERT_GE(insts.size(), 2u); + const Instruction &def = *insts[0]; + EXPECT_TRUE(def.mnemonic().starts_with("v_mov_b32")); + + auto scope = block_scope(blocks); + ExecMaskAnalysis exec{KernelBlockScope(scope), 64}; + EXPECT_EQ(exec.before(def), ExecState::Unknown); + + LivenessAnalysis liveness = analyze_scope(blocks); + EXPECT_TRUE(liveness.is_live_before(def, {RegClass::VGPR, 0, 1})); +} + +// v_writelane_b32 writes a single lane, so even under Full EXEC it is a +// read-modify-write of its destination and must not be promoted to a kill. +TEST(ExecFlagsRealDecode, Cdna4WritelaneDestStaysLiveUnderFullExec) { + // s_mov_b64 exec, -1 ; v_writelane_b32 v5, s4, s2 ; v_mov_b32 v2, v5 ; s_endpgm + auto blocks = + build_cdna4_blocks({0xBEFE01C1u, 0xD28A0005u, 0x00000404u, 0x7E040305u, 0xBF810000u}); + ASSERT_FALSE(blocks.empty()); + auto insts = insts_of(*blocks[0]); + ASSERT_GE(insts.size(), 3u); + + // Sanity-check the decode so an encoding typo fails loudly. + EXPECT_EQ(insts[0]->mnemonic(), "s_mov_b64"); + const Instruction &writelane = *insts[1]; + EXPECT_EQ(writelane.mnemonic(), "v_writelane_b32"); + ASSERT_NE(writelane.dst_operand(0), nullptr); + auto dst_ref = writelane.dst_operand(0)->to_register_ref(); + ASSERT_TRUE(dst_ref.has_value()); + EXPECT_EQ(*dst_ref, (RegisterRef{RegClass::VGPR, 5, 1})); + + // Full-EXEC tracking needs the regenerated s_mov RESULT_COPY metadata. + ASSERT_TRUE(insts[0]->flags() & RESULT_COPY) + << "s_mov lacks RESULT_COPY; regenerate ISA to enable EXEC-Full tracking"; + + auto scope = block_scope(blocks); + ExecMaskAnalysis exec{KernelBlockScope(scope), 64}; + EXPECT_EQ(exec.before(writelane), ExecState::Full); + + // Contrast Cdna4SMovExecAllOnesPromotesVgprDefToKill: the RMW dst stays live. + LivenessAnalysis liveness = analyze_scope(blocks); + EXPECT_TRUE(liveness.is_live_before(writelane, {RegClass::VGPR, 5, 1})); +} + +TEST(ExecMaskAnalysis, EntryIsUnknownAllOnesIsFullNarrowingIsUnknown) { + // exec=all-ones; v0=...; exec=narrow; v0=...; end + auto blocks = + build_test_blocks({TestOpcode::WriteExecFull, TestOpcode::DefVgpr0, + TestOpcode::WriteExecNarrow, TestOpcode::DefVgpr0, TestOpcode::End}); + auto scope = block_scope(blocks); + ExecMaskAnalysis exec{KernelBlockScope(scope), 64}; + + auto insts = insts_of(*blocks[0]); + ASSERT_EQ(insts.size(), 5u); + EXPECT_EQ(exec.before(*insts[0]), ExecState::Unknown); // kernel entry + EXPECT_EQ(exec.before(*insts[1]), ExecState::Full); // after exec=all-ones + EXPECT_EQ(exec.before(*insts[2]), ExecState::Full); // narrowing not yet applied + EXPECT_EQ(exec.before(*insts[3]), ExecState::Unknown); // after narrowing write +} + +TEST(ExecMaskAnalysis, LoopHeaderEntryWithBackedgeIsPinnedUnknown) { + // block0 @0: End -- a predecessor-less natural entry, so the scope-leader + // fallback does not fire. block1 @4: a self-looping "kernel entry" that writes + // EXEC all-ones and conditionally branches back to itself; its only in-scope + // predecessor is that backedge. Without pinning it, the forward meet carries + // the backedge's Full state into the header and wrongly derives Full there. + auto blocks = build_test_blocks({TestOpcode::End, TestOpcode::WriteExecFull, + TestOpcode::CBranchBackToUseSgpr4, TestOpcode::End}); + auto scope = block_scope(blocks); + BasicBlock *header = block_starting_at(blocks, 4); + ASSERT_NE(header, nullptr); + ASSERT_TRUE(has_predecessor(*header, header)) << "header must have its own backedge"; + const Instruction &header_first = *insts_of(*header).front(); + EXPECT_TRUE(header_first.mnemonic().starts_with("test_write_exec_full")); + + // Without pinning, the backedge makes the header wrongly Full. + ExecMaskAnalysis unpinned{KernelBlockScope(scope), 64}; + EXPECT_EQ(unpinned.before(header_first), ExecState::Full); + + // Pinning the real entry keeps it Unknown, as at any kernel entry. + const BasicBlock *const entries[] = {header}; + ExecMaskAnalysis pinned{KernelBlockScope(scope), 64, /*extra_edges=*/{}, entries}; + EXPECT_EQ(pinned.before(header_first), ExecState::Unknown); +} + +TEST(ExecMaskAnalysis, SecondHardwareEntryReachedAfterFullIsPinnedUnknown) { + // Models a kernel with two hardware entries (descriptor entry + kernarg-preload + // firmware entry): block0 @0 establishes Full and falls through to block1 @4, a + // second entry (forced to be a leader). block1 is reachable with Full via the + // ordinary path, but hardware may enter it directly with unknown EXEC, so both + // entries must be seeded -- unlike the single-entry tests above. + const uint64_t firmware_leader[] = {4}; + auto blocks = build_test_blocks( + {TestOpcode::WriteExecFull, TestOpcode::DefVgpr0, TestOpcode::End}, firmware_leader); + auto scope = block_scope(blocks); + BasicBlock *firmware = block_starting_at(blocks, 4); + ASSERT_NE(firmware, nullptr); + ASSERT_TRUE(has_predecessor(*firmware, blocks.front().get())); + const Instruction &firmware_first = *insts_of(*firmware).front(); + + // Without pinning, the ordinary fallthrough carries Full into the second entry. + ExecMaskAnalysis unpinned{KernelBlockScope(scope), 64}; + EXPECT_EQ(unpinned.before(firmware_first), ExecState::Full); + + // Seeding both entries keeps the second Unknown despite the incoming Full. + const BasicBlock *const entries[] = {blocks.front().get(), firmware}; + ExecMaskAnalysis pinned{KernelBlockScope(scope), 64, /*extra_edges=*/{}, entries}; + EXPECT_EQ(pinned.before(firmware_first), ExecState::Unknown); +} + +TEST(ExecMaskAnalysis, OrWithAllOnesConstantIsFull) { + // exec = exec | -1 -> all-ones regardless of the prior EXEC (RESULT_OR with an + // all-ones source operand). + auto blocks = + build_test_blocks({TestOpcode::WriteExecOrAllOnes, TestOpcode::DefVgpr0, TestOpcode::End}); + auto scope = block_scope(blocks); + ExecMaskAnalysis exec{KernelBlockScope(scope), 64}; + + auto insts = insts_of(*blocks[0]); + ASSERT_GE(insts.size(), 2u); + EXPECT_EQ(exec.before(*insts[0]), ExecState::Unknown); // entry + EXPECT_EQ(exec.before(*insts[1]), ExecState::Full); // after exec = exec | -1 +} + +TEST(ExecMaskAnalysis, AndSaveexecWithAllOnesStaysUnknown) { + // s_and_saveexec exec, -1: exec = exec & -1 = exec, NOT all-ones. The all-ones + // source must not be mistaken for an all-ones result (regression guard). + auto blocks = + build_test_blocks({TestOpcode::WriteExecAndSaveexec, TestOpcode::DefVgpr0, TestOpcode::End}); + auto scope = block_scope(blocks); + ExecMaskAnalysis exec{KernelBlockScope(scope), 64}; + + auto insts = insts_of(*blocks[0]); + ASSERT_GE(insts.size(), 2u); + EXPECT_EQ(exec.before(*insts[1]), ExecState::Unknown); // after and-saveexec +} + +TEST(ExecMaskAnalysis, PartialAllOnesWritePreservesButDoesNotEstablishFull) { + // s_mov_b32 exec_lo, -1 on Wave64 sets only the low half to all-ones. + // Keeps an already-Full mask Full + { + auto blocks = build_test_blocks({TestOpcode::WriteExecFull, TestOpcode::WriteExecLoHalf, + TestOpcode::DefVgpr0, TestOpcode::End}); + auto scope = block_scope(blocks); + ExecMaskAnalysis exec{KernelBlockScope(scope), 64}; + auto insts = insts_of(*blocks[0]); + ASSERT_GE(insts.size(), 3u); + EXPECT_EQ(exec.before(*insts[1]), ExecState::Full); // entering the half write + EXPECT_EQ(exec.before(*insts[2]), ExecState::Full); // half all-ones preserved Full + } + // ...Cannot establish Full from Unknown (exec_hi stays unknown). + { + auto blocks = + build_test_blocks({TestOpcode::WriteExecLoHalf, TestOpcode::DefVgpr0, TestOpcode::End}); + auto scope = block_scope(blocks); + ExecMaskAnalysis exec{KernelBlockScope(scope), 64}; + auto insts = insts_of(*blocks[0]); + ASSERT_GE(insts.size(), 2u); + EXPECT_EQ(exec.before(*insts[1]), ExecState::Unknown); + } +} + +TEST(ExecMaskAnalysis, Wave32ExecLoWriteCoversFullMask) { + // On Wave32, exec_lo is the entire EXEC, so an all-ones exec_lo write is Full. + auto blocks = + build_test_blocks({TestOpcode::WriteExecLoHalf, TestOpcode::DefVgpr0, TestOpcode::End}); + auto scope = block_scope(blocks); + ExecMaskAnalysis exec{KernelBlockScope(scope), 32}; + auto insts = insts_of(*blocks[0]); + ASSERT_GE(insts.size(), 2u); + EXPECT_EQ(exec.before(*insts[1]), ExecState::Full); +} + +TEST(ExecMaskAnalysis, ExecHiWriteNeverEstablishesFull) { + // s_mov_b32 exec_hi, -1 writes bits [32,64), which never cover the active + // lanes. It must not establish Full from Unknown on either wave size — on + // Wave32 the written bits lie entirely outside the mask, on Wave64 they are a + // partial upper half. + for (uint8_t wave_size : {uint8_t{32}, uint8_t{64}}) { + auto blocks = + build_test_blocks({TestOpcode::WriteExecHiHalf, TestOpcode::DefVgpr0, TestOpcode::End}); + auto scope = block_scope(blocks); + ExecMaskAnalysis exec{KernelBlockScope(scope), wave_size}; + auto insts = insts_of(*blocks[0]); + ASSERT_GE(insts.size(), 2u); + EXPECT_EQ(exec.before(*insts[1]), ExecState::Unknown); + } +} + +TEST(ExecMaskAnalysis, ExecHiWritePreservesButDoesNotNarrowFull) { + // From an already-Full mask, an all-ones exec_hi write keeps Full (it only + // rewrites in-range or upper bits with ones), the same as an exec_lo half. + auto blocks = build_test_blocks({TestOpcode::WriteExecFull, TestOpcode::WriteExecHiHalf, + TestOpcode::DefVgpr0, TestOpcode::End}); + auto scope = block_scope(blocks); + ExecMaskAnalysis exec{KernelBlockScope(scope), 64}; + auto insts = insts_of(*blocks[0]); + ASSERT_GE(insts.size(), 3u); + EXPECT_EQ(exec.before(*insts[1]), ExecState::Full); // entering the hi write + EXPECT_EQ(exec.before(*insts[2]), ExecState::Full); // hi all-ones preserved Full +} + +TEST(ExecMaskAnalysis, Wave32ExecHiZeroWritePreservesFull) { + // On Wave32 exec_hi lies outside the active mask, so an exec_hi write preserves + // the current state even for a non-all-ones value like `s_mov_b32 exec_hi, 0` + // (which previously narrowed an established Full to Unknown). + auto blocks = build_test_blocks({TestOpcode::WriteExecFull, TestOpcode::WriteExecHiHalfZero, + TestOpcode::DefVgpr0, TestOpcode::UseVgpr0, TestOpcode::End}); + auto scope = block_scope(blocks); + ExecMaskAnalysis exec{KernelBlockScope(scope), 32}; + auto insts = insts_of(*blocks[0]); + ASSERT_GE(insts.size(), 4u); + EXPECT_EQ(exec.before(*insts[1]), ExecState::Full); // entering the exec_hi=0 write + EXPECT_EQ(exec.before(*insts[2]), ExecState::Full); // exec_hi=0 preserved Full + + const ExecMaskAnalysis exec_for_liveness{KernelBlockScope(scope), /*wave_size=*/32}; + const LivenessAnalysis liveness{KernelBlockScope(scope), + std::make_unique(exec_for_liveness)}; + EXPECT_FALSE(liveness.is_live_before(*insts[2], {RegClass::VGPR, 0, 1})); +} + +TEST(LivenessAnalysis, ExecFullPromotesVgprDefToKill) { + // exec=all-ones; def v0; use v0; end. Under full EXEC the def overwrites every + // lane, so v0 is dead immediately before the def. + auto blocks = build_test_blocks( + {TestOpcode::WriteExecFull, TestOpcode::DefVgpr0, TestOpcode::UseVgpr0, TestOpcode::End}); + LivenessAnalysis liveness = analyze_scope(blocks); + + const Instruction &def = *insts_of(*blocks[0])[1]; + EXPECT_FALSE(liveness.is_live_before(def, {RegClass::VGPR, 0, 1})); + EXPECT_EQ(liveness.find_free_run(&def, 1), 0u); +} + +TEST(LivenessAnalysis, ExecFullViaInlineConstantPromotesVgprDefToKill) { + // The all-ones source here is an inline constant (`s_mov exec, -1` style): + // it exposes const_value() but not literal64_value(), so this exercises the + // const_value() path the analysis relies on. + auto blocks = build_test_blocks({TestOpcode::WriteExecFullInline, TestOpcode::DefVgpr0, + TestOpcode::UseVgpr0, TestOpcode::End}); + LivenessAnalysis liveness = analyze_scope(blocks); + + const Instruction &def = *insts_of(*blocks[0])[1]; + EXPECT_FALSE(liveness.is_live_before(def, {RegClass::VGPR, 0, 1})); + EXPECT_EQ(liveness.find_free_run(&def, 1), 0u); +} + +TEST(LivenessAnalysis, NarrowingExecWriteDoesNotPromoteVgprDefToKill) { + // Same shape but EXEC is only narrowed (unknown), so the def stays a + // non-kill and v0 remains live before it. + auto blocks = build_test_blocks( + {TestOpcode::WriteExecNarrow, TestOpcode::DefVgpr0, TestOpcode::UseVgpr0, TestOpcode::End}); + LivenessAnalysis liveness = analyze_scope(blocks); + + const Instruction &def = *insts_of(*blocks[0])[1]; + EXPECT_TRUE(liveness.is_live_before(def, {RegClass::VGPR, 0, 1})); + + auto free_vgpr = liveness.find_free_run(&def, 1); + ASSERT_TRUE(free_vgpr.has_value()); + EXPECT_NE(*free_vgpr, 0u); +} + +TEST(ExecMaskAnalysis, CfgJoinMeetsToUnknownUnlessAllPredecessorsFull) { + // Branch byte layout (4 bytes/inst); target = block-end + delta: + // 0: WriteExecFull + // 4: CBranchToElse (delta +4; block ends at 8 -> target 12, skips block@8) + // 8: WriteExecNarrow (fallthrough block) + // 12: DefVgpr0 (join: reached from the Full branch path and the + // 16: UseVgpr0 Unknown fallthrough path -> meet is Unknown, so the + // 20: End def must not be promoted to a kill) + auto blocks = build_test_blocks({TestOpcode::WriteExecFull, TestOpcode::CBranchToElse, + TestOpcode::WriteExecNarrow, TestOpcode::DefVgpr0, + TestOpcode::UseVgpr0, TestOpcode::End}); + auto scope = block_scope(blocks); + ExecMaskAnalysis exec{KernelBlockScope(scope), 64}; + + BasicBlock *join = block_starting_at(blocks, 12); + ASSERT_NE(join, nullptr); + const Instruction &def = *join->instructions().begin(); + EXPECT_EQ(exec.before(def), ExecState::Unknown); + + LivenessAnalysis liveness = analyze_scope(blocks); + EXPECT_TRUE(liveness.is_live_before(def, {RegClass::VGPR, 0, 1})); +} + +// Regression: EXEC must flow across the scoped caller->callee edge like liveness +// does. Without the edge the callee looks like a scope entry (Unknown) and its +// vector def is wrongly left a non-kill; with it EXEC is Full and the def kills. +TEST(ExecMaskAnalysis, CallEdgeFlowsExecFullIntoCallee) { + // Caller: exec=all-ones; end. Callee: def v0; use v0; end. The caller's End + // splits the callee into its own block, reachable only via the scoped edge. + auto blocks = build_test_blocks({TestOpcode::WriteExecFull, TestOpcode::End, TestOpcode::DefVgpr0, + TestOpcode::UseVgpr0, TestOpcode::End}); + ASSERT_EQ(blocks.size(), 2u); + BasicBlock *caller = blocks[0].get(); + BasicBlock *callee = blocks[1].get(); + const Instruction &def = *callee->instructions().begin(); + + const std::array edges{ScopedCfgEdge{.from = caller, .to = callee}}; + auto scope = block_scope(blocks); + + // No edge: callee is a scope entry, EXEC Unknown, def stays live. + { + ExecMaskAnalysis exec{KernelBlockScope(scope), 64}; + EXPECT_EQ(exec.before(def), ExecState::Unknown); + LivenessAnalysis liveness = analyze_scope(blocks); + EXPECT_TRUE(liveness.is_live_before(def, {RegClass::VGPR, 0, 1})); + } + + // Same edge in both: EXEC Full at the def, so it overwrites every lane and kills v0. + { + ExecMaskAnalysis exec{KernelBlockScope(scope), 64, edges}; + EXPECT_EQ(exec.before(def), ExecState::Full); + LivenessAnalysis liveness = analyze_scope_with_edges(blocks, edges); + EXPECT_FALSE(liveness.is_live_before(def, {RegClass::VGPR, 0, 1})); + } +} + +// Regression: a scoped return->continuation edge must pull the continuation to +// Unknown when the returning path narrowed EXEC. Omitting it from exec leaves the +// continuation looking Full (from its local branch pred) and unsoundly kills. +TEST(ExecMaskAnalysis, ReturnEdgeToContinuationMeetsToUnknown) { + // 0: WriteExecFull (P0) + // 4: CBranchToElseAfterTwo (delta +8 -> branch target 16) + // 8: WriteExecNarrow (P1) return block: narrows EXEC + // 12: End P1 terminates -> reaches cont only via the edge + // 16: DefVgpr0 (cont) branch target of P0; 20: UseVgpr0; 24: End + auto blocks = build_test_blocks({TestOpcode::WriteExecFull, TestOpcode::CBranchToElseAfterTwo, + TestOpcode::WriteExecNarrow, TestOpcode::End, + TestOpcode::DefVgpr0, TestOpcode::UseVgpr0, TestOpcode::End}); + BasicBlock *ret_block = block_starting_at(blocks, 8); + BasicBlock *cont = block_starting_at(blocks, 16); + ASSERT_NE(ret_block, nullptr); + ASSERT_NE(cont, nullptr); + const Instruction &def = *cont->instructions().begin(); + + const std::array edges{ScopedCfgEdge{.from = ret_block, .to = cont}}; + auto scope = block_scope(blocks); + + // No edge: cont sees only its Full branch pred, so EXEC looks Full and def kills. + { + ExecMaskAnalysis exec{KernelBlockScope(scope), 64}; + EXPECT_EQ(exec.before(def), ExecState::Full); + LivenessAnalysis liveness = analyze_scope(blocks); + EXPECT_FALSE(liveness.is_live_before(def, {RegClass::VGPR, 0, 1})); + } + + // With edge: meet of the Full branch and the narrowed return path is Unknown, + // so the def is not a kill and v0 stays live. + { + ExecMaskAnalysis exec{KernelBlockScope(scope), 64, edges}; + EXPECT_EQ(exec.before(def), ExecState::Unknown); + LivenessAnalysis liveness = analyze_scope_with_edges(blocks, edges); + EXPECT_TRUE(liveness.is_live_before(def, {RegClass::VGPR, 0, 1})); + } +} + +// Regression: a back-edge into the scope entry gives block 0 a predecessor, but +// EXEC at kernel entry is set by dispatch and must stay Unknown -- the loop +// back-edge must not let interior blocks' optimistic `Full` seed leak in. Guards +// the `i == 0` pin in the predecessor-based entry detection. +TEST(ExecMaskAnalysis, BackEdgeIntoScopeEntryStaysUnknown) { + // 0: CBranchToElse (+4) header/entry: loop or exit at 8 + // 4: BranchBackToStart(-8) latch: unconditional back-edge to offset 0 + // 8: End loop exit + auto blocks = build_test_blocks( + {TestOpcode::CBranchToElse, TestOpcode::BranchBackToStart, TestOpcode::End}); + BasicBlock *entry = blocks[0].get(); + BasicBlock *latch = block_starting_at(blocks, 4); + ASSERT_NE(latch, nullptr); + + // The latch back-edges into the entry, so it is not caught by the empty-pred + // case -- only the i==0 pin keeps it an entry. + EXPECT_TRUE(has_predecessor(*entry, latch)); + + auto scope = block_scope(blocks); + ExecMaskAnalysis exec{KernelBlockScope(scope), 64}; + EXPECT_EQ(exec.before(*entry->instructions().begin()), ExecState::Unknown); +} + TEST(LivenessAnalysis, FindsDeadSgprAfterLiveSgpr) { auto blocks = build_test_blocks({TestOpcode::UseSgpr4, TestOpcode::End}); LivenessAnalysis liveness = analyze_scope(blocks); @@ -3630,7 +4206,9 @@ TEST(LivenessAnalysis, MinFreeVgprForcesScratchAllocationAboveFloor) { LivenessAnalysisOptions options; options.min_free_vgpr = 4; - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); const Instruction &use = *blocks[0]->instructions().begin(); EXPECT_FALSE(liveness.is_live_before(use, {RegClass::VGPR, 0, 4})); @@ -3644,7 +4222,9 @@ TEST(LivenessAnalysis, GloballyUnusedRunHonorsMinFreeVgprFloor) { auto scope = block_scope(blocks); LivenessAnalysisOptions options; options.min_free_vgpr = 4; - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); const Instruction &use = *blocks[0]->instructions().begin(); EXPECT_EQ(liveness.find_globally_unused_vgpr_run(&use, 1, 0, 1, 8), 4); @@ -3655,7 +4235,9 @@ TEST(LivenessAnalysis, GloballyUnusedRunHonorsMinFreeVgprFloor) { TEST(LivenessAnalysis, FindsGloballyUnusedRunBeforeSiteDeadFallback) { auto blocks = build_test_blocks({TestOpcode::UseVgpr0, TestOpcode::Nop, TestOpcode::End}); auto scope = block_scope(blocks); - const LivenessAnalysis liveness{KernelBlockScope(scope)}; + const ExecMaskAnalysis exec{KernelBlockScope(scope), /*wave_size=*/64}; + const LivenessAnalysis liveness{KernelBlockScope(scope), + std::make_unique(exec)}; auto instruction = blocks.front()->instructions().begin(); ++instruction; @@ -3679,16 +4261,19 @@ TEST(LivenessAnalysis, FreeVgprAllocationHonorsDestinationLimit) { auto blocks = build_test_blocks({TestOpcode::UseSgpr4, TestOpcode::End}); auto scope = block_scope(blocks); const Instruction &use = *blocks[0]->instructions().begin(); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); LivenessAnalysisOptions limited_options; limited_options.min_free_vgpr = 256; - LivenessAnalysis limited(KernelBlockScope(scope), limited_options); + LivenessAnalysis limited(KernelBlockScope(scope), std::make_unique(exec), + limited_options); EXPECT_EQ(limited.find_free_run(&use, 1), std::nullopt); LivenessAnalysisOptions gfx1250_options; gfx1250_options.min_free_vgpr = 256; gfx1250_options.max_free_vgpr = 1024; - LivenessAnalysis gfx1250(KernelBlockScope(scope), gfx1250_options); + LivenessAnalysis gfx1250(KernelBlockScope(scope), std::make_unique(exec), + gfx1250_options); EXPECT_EQ(gfx1250.find_free_run(&use, 1), 256); } @@ -3699,7 +4284,9 @@ TEST(LivenessAnalysis, FindFreeRunHonorsBaseAlignment) { LivenessAnalysisOptions options; options.min_free_vgpr = 93; - LivenessAnalysis liveness(KernelBlockScope(scope), options); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(KernelBlockScope(scope), std::make_unique(exec), + options); const Instruction &use = *blocks[0]->instructions().begin(); EXPECT_EQ(liveness.find_free_run(&use, 4, 0, 2), 94); @@ -3812,7 +4399,9 @@ TEST(LivenessAnalysis, ExplicitBlockSubsetIgnoresOutsideSuccessors) { EXPECT_TRUE(all_decoded_liveness.is_live_before(def, {RegClass::VGPR, 0, 1})); std::vector kernel_blocks{kernel0}; - LivenessAnalysis kernel_liveness{KernelBlockScope(kernel_blocks)}; + const ExecMaskAnalysis kernel_exec(KernelBlockScope(kernel_blocks), /*wave_size=*/64); + LivenessAnalysis kernel_liveness{KernelBlockScope(kernel_blocks), + std::make_unique(kernel_exec)}; EXPECT_FALSE(kernel_liveness.is_live_before(def, {RegClass::VGPR, 0, 1})); } @@ -3837,7 +4426,8 @@ TEST(InstDefUse, RWSgpr) { TEST(InstDefUse, PartialDefIsAlsoUse) { const TestInstruction test_inst("test_partial_def_s4", {{RegClass::SGPR, 4, 1}}, {}, 0, - std::nullopt, {}, /*def_size_bits=*/16); + std::nullopt, {}, std::nullopt, std::nullopt, + /*def_size_bits=*/16); InstDefUse idu(test_inst); EXPECT_TRUE(idu.defs.contains({RegClass::SGPR, 4, 1})); EXPECT_TRUE(idu.uses.contains({RegClass::SGPR, 4, 1})); @@ -3845,7 +4435,7 @@ TEST(InstDefUse, PartialDefIsAlsoUse) { TEST(InstDefUse, FullWidthDefIsNotUse) { const TestInstruction test_inst("test_def_s4", {{RegClass::SGPR, 4, 1}}, {}, 0, std::nullopt, {}, - /*def_size_bits=*/32); + std::nullopt, std::nullopt, /*def_size_bits=*/32); InstDefUse idu(test_inst); EXPECT_TRUE(idu.defs.contains({RegClass::SGPR, 4, 1})); EXPECT_FALSE(idu.uses.contains({RegClass::SGPR, 4, 1})); @@ -4186,5 +4776,32 @@ TEST(GeneratedInstDefUse, Vop3SdstEncDppPartialRowMaskReadsOnlyVgprResult) { EXPECT_FALSE(idu.uses.contains({RegClass::SGPR, 8, 2})); } +// v_writelane_b32 writes one lane and preserves the rest of vdst, so it reads +// the old value. On CDNA4/gfx1250 (XML marks vdst output-only) that read is +// surfaced via implicit_uses. word0 = VOP3 writelane opcode, vdst=5; word1 = +// src0=s4, src1=s2 (2 << 9). +TEST(GeneratedInstDefUse, WritelaneReadsDestinationCdna4) { + auto inst = decode_cdna4({0xD28A0005U, 0x00000404U}); // v_writelane_b32 v5, s4, s2 + ASSERT_NE(inst, nullptr); + ASSERT_EQ(std::string_view(inst->mnemonic()), "v_writelane_b32"); + + InstDefUse idu(*inst); + EXPECT_TRUE(idu.defs.contains({RegClass::VGPR, 5, 1})); + EXPECT_TRUE(idu.uses.contains({RegClass::VGPR, 5, 1})); +} + +TEST(GeneratedInstDefUse, WritelaneReadsDestinationGfx1250) { + auto decoder = Decoder::create(ROCJITSU_CODE_ARCH_GFX1250); + ASSERT_NE(decoder, nullptr); + std::array words{0xD7610005U, 0x00000404U, 0U, 0U}; + std::unique_ptr inst(decoder->decode(words.data())); + ASSERT_NE(inst, nullptr); + ASSERT_EQ(std::string_view(inst->mnemonic()), "v_writelane_b32"); + + InstDefUse idu(*inst); + EXPECT_TRUE(idu.defs.contains({RegClass::VGPR, 5, 1})); + EXPECT_TRUE(idu.uses.contains({RegClass::VGPR, 5, 1})); +} + } // namespace } // namespace rocjitsu diff --git a/emulation/rocjitsu/tests/code/amdgpu_code_object_test.cpp b/emulation/rocjitsu/tests/code/amdgpu_code_object_test.cpp index cb90b3d58b14..47d4ba384911 100644 --- a/emulation/rocjitsu/tests/code/amdgpu_code_object_test.cpp +++ b/emulation/rocjitsu/tests/code/amdgpu_code_object_test.cpp @@ -16,10 +16,12 @@ #include +#include #include #include #include #include +#include #include #include #include @@ -43,11 +45,16 @@ uint64_t align_up(uint64_t value, uint64_t alignment) { } // A 64-byte kernel descriptor whose wavefront SGPR granulation field is -// `granulated`; everything else zero. -KD make_kd(uint32_t granulated) { +// `granulated` and whose ENABLE_WAVEFRONT_SIZE32 bit is set iff `wave32`; +// everything else zero. +KD make_kd(uint32_t granulated, bool wave32 = false) { KD desc{}; AMDHSA_BITS_SET(desc.compute_pgm_rsrc1, kd::COMPUTE_PGM_RSRC1_GRANULATED_WAVEFRONT_SGPR_COUNT, granulated); + if (wave32) { + AMDHSA_BITS_SET(desc.kernel_code_properties, kd::KERNEL_CODE_PROPERTY_ENABLE_WAVEFRONT_SIZE32, + 1); + } return desc; } @@ -57,10 +64,14 @@ KD make_kd(uint32_t granulated) { // sh_addr, and each .kd symbol's st_value is that descriptor's virtual address, // so min_kernel_sgpr_count() can locate and decode them via Section::vaddr(). // Sections: [1]=.text [2]=.rodata [3]=.strtab [4]=.symtab [5]=.shstrtab. -std::vector -make_elf_with_kds(const std::vector> &kernels) { +std::vector make_elf_with_kds(const std::vector> &kernels, + bool wave32 = false, + std::span unreadable = {}) { constexpr uint64_t kTextAddr = 0x1000; constexpr uint64_t kRodataAddr = 0x2000; + // A vaddr covered by no section, so kernel_wavefront_size() cannot decode a + // descriptor placed here and must treat it as unreadable. + constexpr uint64_t kUnreadableAddr = 0xF000; std::vector shstrtab{'\0'}; const uint32_t text_name = add_elf_name(shstrtab, ".text"); @@ -75,13 +86,14 @@ make_elf_with_kds(const std::vector> &kernels) std::vector strtab{'\0'}; std::vector syms(1); // mandatory null symbol for (size_t i = 0; i < kernels.size(); ++i) { - const KD desc = make_kd(kernels[i].second); + const KD desc = make_kd(kernels[i].second, wave32); std::memcpy(rodata.data() + i * sizeof(KD), &desc, sizeof(KD)); + const bool is_unreadable = std::ranges::find(unreadable, i) != unreadable.end(); Elf64_Sym sym{}; sym.st_name = add_elf_name(strtab, kernels[i].first + ".kd"); sym.st_info = static_cast((1u << 4) | kElfSymbolTypeObject); // global object sym.st_shndx = 2; // .rodata - sym.st_value = kRodataAddr + i * sizeof(KD); + sym.st_value = is_unreadable ? kUnreadableAddr : kRodataAddr + i * sizeof(KD); sym.st_size = sizeof(KD); syms.push_back(sym); } @@ -209,5 +221,41 @@ TEST(AmdGpuCodeObjectSgpr, NoKernelDescriptorReturnsNullopt) { EXPECT_FALSE(obj.min_kernel_sgpr_count(ROCJITSU_CODE_ARCH_CDNA2).has_value()); } +// CDNA is always Wave64 regardless of the descriptor's Wave32 bit. +TEST(AmdGpuCodeObjectWavefront, CdnaIsAlwaysWave64) { + const auto image = make_elf_with_kds({{"k", 0}}, /*wave32=*/true); + AmdGpuCodeObject obj(image.data(), image.size()); + ASSERT_TRUE(obj.is_valid()); + EXPECT_EQ(obj.kernel_wavefront_size(ROCJITSU_CODE_ARCH_CDNA2), 64u); +} + +// RDNA: Wave32 only when every kernel descriptor is readable and opts in. +TEST(AmdGpuCodeObjectWavefront, RdnaAllReadableWave32IsWave32) { + const auto image = make_elf_with_kds({{"a", 0}, {"b", 0}}, /*wave32=*/true); + AmdGpuCodeObject obj(image.data(), image.size()); + ASSERT_TRUE(obj.is_valid()); + EXPECT_EQ(obj.kernel_wavefront_size(ROCJITSU_CODE_ARCH_RDNA4), 32u); +} + +// RDNA: a cleared Wave32 bit means Wave64. +TEST(AmdGpuCodeObjectWavefront, RdnaWave32BitClearIsWave64) { + const auto image = make_elf_with_kds({{"k", 0}}, /*wave32=*/false); + AmdGpuCodeObject obj(image.data(), image.size()); + ASSERT_TRUE(obj.is_valid()); + EXPECT_EQ(obj.kernel_wavefront_size(ROCJITSU_CODE_ARCH_RDNA4), 64u); +} + +// RDNA regression: an unreadable descriptor must not let readable Wave32 kernels +// claim the whole object is Wave32 -- the unreadable one could be Wave64, so the +// conservative answer is 64. +TEST(AmdGpuCodeObjectWavefront, RdnaUnreadableDescriptorFallsBackToWave64) { + const std::array unreadable{1}; + const auto image = make_elf_with_kds({{"readable_wave32", 0}, {"unreadable", 0}}, + /*wave32=*/true, unreadable); + AmdGpuCodeObject obj(image.data(), image.size()); + ASSERT_TRUE(obj.is_valid()); + EXPECT_EQ(obj.kernel_wavefront_size(ROCJITSU_CODE_ARCH_RDNA4), 64u); +} + } // namespace } // namespace rocjitsu diff --git a/emulation/rocjitsu/tests/dbt/semantic_scratch_test.cpp b/emulation/rocjitsu/tests/dbt/semantic_scratch_test.cpp index c592db8951a9..1df4495e7e55 100644 --- a/emulation/rocjitsu/tests/dbt/semantic_scratch_test.cpp +++ b/emulation/rocjitsu/tests/dbt/semantic_scratch_test.cpp @@ -1,6 +1,7 @@ // Copyright (c) 2026 Advanced Micro Devices, Inc. // SPDX-License-Identifier: MIT +#include "rocjitsu/analysis/exec_state.h" #include "rocjitsu/analysis/liveness.h" #include "rocjitsu/code/basic_block.h" #include "rocjitsu/code/code_object.h" @@ -139,7 +140,8 @@ TEST(SemanticScratchAllocator, FallsBackToNonForbiddenSpillVictim) { // registers, which deliberately drives the allocator through its spill tier. Instruction inst("scratch_test", nullptr); std::vector blocks; - LivenessAnalysis liveness(blocks); + const ExecMaskAnalysis exec(KernelBlockScope(blocks), /*wave_size=*/64); + LivenessAnalysis liveness(blocks, std::make_unique(exec)); TranslationContext context(/*vgprs=*/8, /*agprs=*/0, /*accum_base=*/0, /*sgprs=*/8, /*private_bytes=*/20); SemanticScratchAllocator allocator(inst, liveness, context, @@ -162,7 +164,9 @@ TEST(SemanticScratchAllocator, FallsBackToNonForbiddenSpillVictim) { TEST(SemanticScratchAllocator, PrefersKernelUnusedOverSiteDeadVgpr) { auto blocks = build_scratch_test_blocks(); auto scope = scratch_test_scope(blocks); - const LivenessAnalysis liveness{KernelBlockScope(scope)}; + const ExecMaskAnalysis exec{KernelBlockScope(scope), /*wave_size=*/64}; + const LivenessAnalysis liveness{KernelBlockScope(scope), + std::make_unique(exec)}; auto site = blocks.front()->instructions().begin(); ++site; ASSERT_NE(site, blocks.front()->instructions().end()); @@ -185,7 +189,9 @@ TEST(SemanticScratchAllocator, PrefersKernelUnusedOverSiteDeadVgpr) { TEST(SemanticScratchAllocator, KernelUnusedSearchSkipsForbiddenWindow) { auto blocks = build_scratch_test_blocks(); auto scope = scratch_test_scope(blocks); - const LivenessAnalysis liveness{KernelBlockScope(scope)}; + const ExecMaskAnalysis exec{KernelBlockScope(scope), /*wave_size=*/64}; + const LivenessAnalysis liveness{KernelBlockScope(scope), + std::make_unique(exec)}; auto site = blocks.front()->instructions().begin(); ++site; ASSERT_NE(site, blocks.front()->instructions().end()); @@ -222,7 +228,9 @@ TEST(SemanticScratchAllocator, GprIndexModeWriteBypassesKernelUnusedTier) { LivenessAnalysisOptions options; options.arch = ROCJITSU_CODE_ARCH_CDNA4; options.text = scratch_test_text(code); - const LivenessAnalysis liveness{KernelBlockScope(scope), options}; + const ExecMaskAnalysis exec{KernelBlockScope(scope), /*wave_size=*/64}; + const LivenessAnalysis liveness{KernelBlockScope(scope), std::make_unique(exec), + options}; auto site = blocks.front()->instructions().begin(); std::advance(site, 2); ASSERT_NE(site, blocks.front()->instructions().end()); @@ -246,7 +254,9 @@ TEST(SemanticScratchAllocator, GprIndexModeWriteBypassesKernelUnusedTier) { TEST(SemanticScratchAllocator, SiteDeadTierCanGrowDescriptor) { auto blocks = build_scratch_test_blocks(); auto scope = scratch_test_scope(blocks); - const LivenessAnalysis liveness{KernelBlockScope(scope)}; + const ExecMaskAnalysis exec{KernelBlockScope(scope), /*wave_size=*/64}; + const LivenessAnalysis liveness{KernelBlockScope(scope), + std::make_unique(exec)}; const Instruction &site = *blocks.front()->instructions().begin(); // The sole descriptor-allocated register v0 is read at this site, so the @@ -271,7 +281,8 @@ TEST(SemanticScratchAllocator, SiteDeadTierCanGrowDescriptor) { TEST(SemanticScratchAllocator, ReportsTargetSpillOffsetLimit) { Instruction inst("scratch_test", nullptr); std::vector blocks; - LivenessAnalysis liveness(blocks); + const ExecMaskAnalysis exec(KernelBlockScope(blocks), /*wave_size=*/64); + LivenessAnalysis liveness(blocks, std::make_unique(exec)); TranslationContext context(/*vgprs=*/8, /*agprs=*/0, /*accum_base=*/0, /*sgprs=*/8, /*private_bytes=*/32); SemanticScratchAllocator allocator( @@ -290,7 +301,8 @@ TEST(SemanticScratchAllocator, ReportsTargetSpillOffsetLimit) { TEST(SemanticScratchAllocator, RejectsSpillVictimInDynamicStackKernel) { Instruction inst("scratch_test", nullptr); std::vector blocks; - LivenessAnalysis liveness(blocks); + const ExecMaskAnalysis exec(KernelBlockScope(blocks), /*wave_size=*/64); + LivenessAnalysis liveness(blocks, std::make_unique(exec)); // With no live-before snapshot, no register window is proven free, so the // allocator must borrow a victim and exercise the spill policy. ASSERT_FALSE(liveness.has_live_before(inst)); @@ -315,7 +327,8 @@ TEST(SemanticScratchAllocator, AllowsFreeWindowInDynamicStackKernel) { for (const auto &block : blocks) scope.push_back(block.get()); const Instruction &inst = *blocks.front()->instructions().begin(); - LivenessAnalysis liveness(scope); + const ExecMaskAnalysis exec(KernelBlockScope(scope), /*wave_size=*/64); + LivenessAnalysis liveness(scope, std::make_unique(exec)); TranslationContext context(/*vgprs=*/8, /*agprs=*/0, /*accum_base=*/0, /*sgprs=*/8, /*private_bytes=*/32); context.uses_dynamic_stack = true; diff --git a/emulation/rocjitsu/tests/dbt/translate_test.cpp b/emulation/rocjitsu/tests/dbt/translate_test.cpp index 9aa8baae63e6..226b19a827ab 100644 --- a/emulation/rocjitsu/tests/dbt/translate_test.cpp +++ b/emulation/rocjitsu/tests/dbt/translate_test.cpp @@ -8440,6 +8440,79 @@ TEST(BinaryTranslatorE2E, SkipFailedVirtualLdsSidecarStubsOversizedNormalDescrip EXPECT_EQ(rocjitsu::find_section(translated, rocjitsu::kVirtualLdsMetadataSectionName), nullptr); } +TEST(BinaryTranslatorE2E, Cdna4ToCdna3KernargPreloadFirmwareEntryKeepsMaskedDefLive) { + using namespace rocr::llvm::amdhsa; + constexpr uint16_t kScratchFloor = 120; + + auto image = rocjitsu::make_large_amdgpu_elf_with_waitcnt_entry(); + rocjitsu::AmdGpuCodeObject layout(image.data(), image.size()); + ASSERT_TRUE(layout.is_valid()); + const auto *rodata = rocjitsu::find_section(layout, ".rodata"); + ASSERT_NE(rodata, nullptr); + ASSERT_FALSE(layout.text_sections().empty()); + + auto source_kd = + rocjitsu::read_kernel_descriptor_for_test(image.data() + rodata->sectionOffset()); + AMDHSA_BITS_SET(source_kd.kernarg_preload, KERNARG_PRELOAD_SPEC_LENGTH, 1); + // Declare a small VGPR file so the globally-unused search is exhausted at the + // scratch floor, forcing the allocator onto the per-point find_free_run path + // (the only path the firmware EXEC pin can influence). + AMDHSA_BITS_SET(source_kd.compute_pgm_rsrc1, COMPUTE_PGM_RSRC1_GRANULATED_WORKITEM_VGPR_COUNT, + 15); + rocjitsu::write_kernel_descriptor_for_test(image.data() + rodata->sectionOffset(), source_kd); + + auto *words = + reinterpret_cast(image.data() + layout.text_sections()[0]->sectionOffset()); + words[0] = 0xBEFE01C1u; // s_mov_b64 exec, -1 (ordinary path establishes Full). + const auto cvt = make_cdna4_cvt_pk_f16_f32_words(); // Needs one scratch temp. + words[64] = cvt[0]; + words[65] = cvt[1]; + // Masked vector def of the floor VGPR, read afterwards. Under the firmware + // entry's pinned-Unknown EXEC this def is not a whole-register kill, so v120 is + // live across the cvt and find_free_run must not reuse it. + words[66] = cdna4::build_vop1(cdna4::kVMovB32Vop1, {.src0 = 0, .vdst = kScratchFloor})[0]; + words[67] = cdna4::build_vop1( + cdna4::kVMovB32Vop1, {.src0 = static_cast(256 + kScratchFloor), .vdst = 20})[0]; + words[68] = cdna4::build_sopp(cdna4::kSEndpgmSopp)[0]; + + rocjitsu::AmdGpuCodeObject source(image.data(), image.size()); + ASSERT_TRUE(source.is_valid()); + + rocjitsu::BinaryTranslatorOptions options; + options.debug_min_free_vgpr = kScratchFloor; + rocjitsu::BinaryTranslator translator(ROCJITSU_CODE_ARCH_CDNA4, ROCJITSU_CODE_ARCH_CDNA3, 0, + options); + auto result = translator.translate(source); + ASSERT_TRUE(result.ok()) << result.diagnostics.front().message; + + rocjitsu::AmdGpuCodeObject translated(result.elf_bytes.data(), result.elf_bytes.size()); + ASSERT_TRUE(translated.is_valid()); + ASSERT_FALSE(translated.text_sections().empty()); + const auto *target_words = + reinterpret_cast(translated.text_sections()[0]->data()); + const size_t target_word_count = translated.text_sections()[0]->size() / sizeof(uint32_t); + + // The packed-F16 lowering converts the high half into a scratch temp picked by + // find_free_run (globally-unused VGPRs are exhausted at the floor). With the + // firmware entry pinned Unknown, v120's masked def is not a kill, so v120 is + // live across the cvt and the temp must skip it (v121). If the firmware entry + // wrongly inherited Full, v120 would look dead and be reused as the temp (v120), + // clobbering the value the kernel reads after the preload window. + const auto writes_cvt_f16_to = [&](uint16_t vdst) { + for (size_t i = 0; i + 1 < target_word_count; ++i) { + rocjitsu::cdna3::Vop3MachineInst v{}; + std::memcpy(&v, target_words + i, sizeof(v)); + if (v.encoding == 0x34u && v.op == cdna3::kVCvtF16F32Vop3 && v.vdst == vdst) + return true; + } + return false; + }; + EXPECT_TRUE(writes_cvt_f16_to(kScratchFloor + 1)) + << "temp must skip the live firmware-entry def register v" << kScratchFloor; + EXPECT_FALSE(writes_cvt_f16_to(kScratchFloor)) + << "temp reused v" << kScratchFloor << ", clobbering the live firmware-entry def"; +} + TEST(BinaryTranslatorE2E, Cdna4ToCdna3Bitop3ScratchGrowsDescriptor) { constexpr uint16_t kScratchFloor = 120; const auto words = make_cdna4_bitop3_words(cdna4::kVBitop3B32Vop3, 16); diff --git a/emulation/rocjitsu/tests/patch/instrumentor_test.cpp b/emulation/rocjitsu/tests/patch/instrumentor_test.cpp index c224b7443561..a636fa83ca01 100644 --- a/emulation/rocjitsu/tests/patch/instrumentor_test.cpp +++ b/emulation/rocjitsu/tests/patch/instrumentor_test.cpp @@ -3,6 +3,8 @@ #include "rocjitsu/code/patch/instrumentor.h" +#include "rocjitsu/analysis/exec_state.h" +#include "rocjitsu/analysis/liveness.h" #include "rocjitsu/code/amdgpu_code_object.h" #include "rocjitsu/code/amdgpu_elf.h" #include "rocjitsu/code/basic_block.h" @@ -637,6 +639,125 @@ std::vector make_gfx950_elf_with_two_nops() { return image; } +// gfx950 ELF holding `text_words` in .text plus a kernel descriptor whose +// kernel_code_entry_byte_offset points @p entry_byte_offset bytes into that +// .text. The descriptor lives in an allocated .rodata named by a "kern.kd" +// symbol so AmdGpuCodeObject::kernel_entry_text_offsets() resolves the entry. +// .text and .rodata carry nonzero sh_addr because the descriptor lookup skips +// sections whose vaddr is zero. Sections: [1]=.text, [2]=.rodata, [3]=.strtab, +// [4]=.symtab, [5]=.shstrtab. +// TODO: this mirrors make_minimal_amdgpu_elf_with_descriptor_after_text in +// tests/dbt/translate_test.cpp; fold both into a shared test-fixture header (see +// the duplication note above) in a follow-up. +std::vector make_gfx950_elf_with_kd(const std::vector &text_words, + uint64_t entry_byte_offset, + uint16_t kernarg_preload = 0) { + constexpr uint64_t kTextVaddr = 0x1000; + constexpr uint64_t kKdVaddr = 0x2000; + constexpr uint64_t kKdSize = 64; // sizeof(rocr::llvm::amdhsa::kernel_descriptor_t) + const uint64_t text_offset = 0x100; + const uint64_t text_size = text_words.size() * sizeof(uint32_t); + + std::vector shstrtab{'\0'}; + const uint32_t text_name = add_elf_name(shstrtab, ".text"); + const uint32_t rodata_name = add_elf_name(shstrtab, ".rodata"); + const uint32_t strtab_name = add_elf_name(shstrtab, ".strtab"); + const uint32_t symtab_name = add_elf_name(shstrtab, ".symtab"); + const uint32_t shstrtab_name = add_elf_name(shstrtab, ".shstrtab"); + + std::vector strtab{'\0'}; + const uint32_t kd_sym_name = add_elf_name(strtab, "kern.kd"); + + // Only kernel_code_entry_byte_offset (int64 at offset 16) matters here. It is + // descriptor-relative, so bias it back to the .text entry virtual address. + std::array kd{}; + const int64_t entry_delta = + static_cast(kTextVaddr + entry_byte_offset) - static_cast(kKdVaddr); + std::memcpy(kd.data() + 16, &entry_delta, sizeof(entry_delta)); + // kernarg_preload (uint16 at offset 58): its low 7 bits are the preload spec + // length, whose nonzero value gives CDNA3/CDNA4 a firmware entry at entry+256. + std::memcpy(kd.data() + 58, &kernarg_preload, sizeof(kernarg_preload)); + + // Two symbols: the mandatory null entry plus the "kern.kd" descriptor. + std::array syms{}; + syms[1].st_name = kd_sym_name; + syms[1].st_info = static_cast((1u << 4) | kElfSymbolTypeObject); // global object + syms[1].st_shndx = 2; // .rodata + syms[1].st_value = kKdVaddr; + syms[1].st_size = kKdSize; + + const uint64_t rodata_offset = text_offset + text_size; + const uint64_t strtab_offset = rodata_offset + kKdSize; + const uint64_t symtab_offset = align_up_for_test(strtab_offset + strtab.size(), 8); + const uint64_t shstrtab_offset = symtab_offset + syms.size() * sizeof(Elf64_Sym); + const uint64_t shoff = align_up_for_test(shstrtab_offset + shstrtab.size(), 8); + constexpr uint16_t section_count = 6; + + std::vector image(shoff + section_count * sizeof(Elf64_Shdr), 0); + + Elf64_Ehdr ehdr{}; + std::memcpy(ehdr.e_ident, EI_MAGIC, EI_MAGIC_SIZE); + ehdr.e_ident[EI_CLASS] = ELFCLASS64; + ehdr.e_ident[EI_OSABI] = ELFOSABI_AMDGPU_HSA; + ehdr.e_type = ET_REL; + ehdr.e_machine = EM_AMDGPU; + ehdr.e_version = 1; + ehdr.e_shoff = shoff; + ehdr.e_flags = EF_AMDGPU_MACH_AMDGCN_GFX950; + ehdr.e_ehsize = sizeof(Elf64_Ehdr); + ehdr.e_shentsize = sizeof(Elf64_Shdr); + ehdr.e_shnum = section_count; + ehdr.e_shstrndx = 5; + std::memcpy(image.data(), &ehdr, sizeof(ehdr)); + + std::memcpy(image.data() + text_offset, text_words.data(), text_size); + std::memcpy(image.data() + rodata_offset, kd.data(), kd.size()); + std::memcpy(image.data() + strtab_offset, strtab.data(), strtab.size()); + std::memcpy(image.data() + symtab_offset, syms.data(), syms.size() * sizeof(Elf64_Sym)); + std::memcpy(image.data() + shstrtab_offset, shstrtab.data(), shstrtab.size()); + + std::array shdrs{}; + shdrs[1].sh_name = text_name; + shdrs[1].sh_type = SHT_PROGBITS; + shdrs[1].sh_flags = SHF_ALLOC | SHF_EXECINSTR; + shdrs[1].sh_addr = kTextVaddr; + shdrs[1].sh_offset = text_offset; + shdrs[1].sh_size = text_size; + shdrs[1].sh_addralign = sizeof(uint32_t); + + shdrs[2].sh_name = rodata_name; + shdrs[2].sh_type = SHT_PROGBITS; + shdrs[2].sh_flags = SHF_ALLOC; + shdrs[2].sh_addr = kKdVaddr; + shdrs[2].sh_offset = rodata_offset; + shdrs[2].sh_size = kKdSize; + shdrs[2].sh_addralign = sizeof(uint32_t); + + shdrs[3].sh_name = strtab_name; + shdrs[3].sh_type = SHT_STRTAB; + shdrs[3].sh_offset = strtab_offset; + shdrs[3].sh_size = strtab.size(); + shdrs[3].sh_addralign = 1; + + shdrs[4].sh_name = symtab_name; + shdrs[4].sh_type = SHT_SYMTAB; + shdrs[4].sh_offset = symtab_offset; + shdrs[4].sh_size = syms.size() * sizeof(Elf64_Sym); + shdrs[4].sh_link = 3; // .strtab + shdrs[4].sh_info = 1; // index of first global symbol + shdrs[4].sh_entsize = sizeof(Elf64_Sym); + shdrs[4].sh_addralign = 8; + + shdrs[5].sh_name = shstrtab_name; + shdrs[5].sh_type = SHT_STRTAB; + shdrs[5].sh_offset = shstrtab_offset; + shdrs[5].sh_size = shstrtab.size(); + shdrs[5].sh_addralign = 1; + + std::memcpy(image.data() + shoff, shdrs.data(), shdrs.size() * sizeof(Elf64_Shdr)); + return image; +} + TEST(Instrumentor, AddPointByOffsetResolvesValidatedSite) { auto image = make_gfx950_elf_with_two_nops(); AmdGpuCodeObject obj(image.data(), image.size()); @@ -837,6 +958,137 @@ TEST(Instrumentor, UnsupportedArchReportsErrorInsteadOfCrashing) { << "error was: " << patched.errors.front(); } +TEST(Instrumentor, KernelEntryInteriorToFallthroughBlockIsInstrumentable) { + // The kernel entry lands at .text offset 8, interior to a single straight-line + // block ending in s_endpgm. The leading ops stand in for a preceding EXEC + // write (e.g. s_mov exec, -1): unless the entry begins its own block and is + // seeded, EXEC would flow into it as Full even though hardware may enter with + // unknown EXEC. ensure_blocks_built passes the entry as an extra leader, so a + // block starts there and instrumentation succeeds rather than failing closed. + constexpr rj_code_arch_t kArch = ROCJITSU_CODE_ARCH_CDNA4; + const std::vector text = {build_s_nop(0, kArch), build_s_nop(0, kArch), + build_s_nop(0, kArch), build_s_endpgm(kArch)}; + auto image = make_gfx950_elf_with_kd(text, /*entry_byte_offset=*/8); + AmdGpuCodeObject obj(image.data(), image.size()); + ASSERT_TRUE(obj.is_valid()); + const auto entries = obj.kernel_entry_text_offsets(kArch); + ASSERT_EQ(entries.size(), 1u); + ASSERT_EQ(entries.front(), 8u); + + Instrumentor instr(obj, kArch); + instr.add_point_by_offset(/*anchor_offset=*/8); + auto result = instr.validate_points(); + EXPECT_TRUE(result.errors.empty()) + << (result.errors.empty() ? std::string{} : result.errors.front()); + EXPECT_EQ(result.sites.size(), 1u); +} + +TEST(Instrumentor, ReadableKernelEntryWithNoExactBlockFailsClosed) { + // The kernel entry points at .text offset 8, the second word of the 8-byte + // s_mov_b32 s0, at offset 4. No decoded instruction begins there, so + // even after the entry is added as an extra leader no block starts at the + // offset and block construction must fail closed rather than silently drop it. + constexpr rj_code_arch_t kArch = ROCJITSU_CODE_ARCH_CDNA4; + constexpr uint32_t kSMovLitWord0 = 0xBE8000FFu; // s_mov_b32 s0, + constexpr uint32_t kSMovLitWord1 = 0xDEADBEEFu; // the 32-bit literal + const std::vector text = {build_s_nop(0, kArch), kSMovLitWord0, kSMovLitWord1, + build_s_endpgm(kArch)}; + auto image = make_gfx950_elf_with_kd(text, /*entry_byte_offset=*/8); + AmdGpuCodeObject obj(image.data(), image.size()); + ASSERT_TRUE(obj.is_valid()); + const auto entries = obj.kernel_entry_text_offsets(kArch); + ASSERT_EQ(entries.size(), 1u); + ASSERT_EQ(entries.front(), 8u); + + Instrumentor instr(obj, kArch); + instr.add_point_by_offset(/*anchor_offset=*/0); + auto result = instr.validate_points(); + EXPECT_TRUE(result.sites.empty()); + ASSERT_FALSE(result.errors.empty()); + EXPECT_NE(result.errors.front().find("no basic block"), std::string::npos) + << "error was: " << result.errors.front(); +} + +TEST(Instrumentor, KernargPreloadFirmwareEntryEnumeratedAndPinnedUnknown) { + // A CDNA4 descriptor with a nonzero KERNARG_PRELOAD_SPEC_LENGTH has two hardware + // entries: the descriptor entry at .text[0] and the firmware kernarg-preload + // window at .text[256]. The descriptor entry writes EXEC all-ones and falls + // through to +256, so the ordinary path reaches the firmware entry with EXEC + // Full -- but firmware may jump straight to +256 with unknown EXEC, so once + // kernel_entry_text_offsets() enumerates it, that entry must stay Unknown. + constexpr rj_code_arch_t kArch = ROCJITSU_CODE_ARCH_CDNA4; + constexpr uint32_t kSMovExecAllOnes = 0xBEFE01C1u; // s_mov_b64 exec, -1 + constexpr uint32_t kVMovV0S0 = 0x7E000200u; // v_mov_b32 v0, s0 + std::vector text{kSMovExecAllOnes}; // .text[0]: descriptor entry + while (text.size() < 64) // pad the ordinary path to +256 + text.push_back(build_s_nop(0, kArch)); + text.push_back(kVMovV0S0); // .text[256]: firmware entry def + text.push_back(build_s_endpgm(kArch)); + + auto image = make_gfx950_elf_with_kd(text, /*entry_byte_offset=*/0, /*kernarg_preload=*/1); + AmdGpuCodeObject obj(image.data(), image.size()); + ASSERT_TRUE(obj.is_valid()); + + // Both hardware entries are enumerated: the descriptor entry plus +256. + const auto entries = obj.kernel_entry_text_offsets(kArch); + ASSERT_EQ(entries.size(), 2u); + EXPECT_NE(std::ranges::find(entries, 0u), entries.end()); + EXPECT_NE(std::ranges::find(entries, 256u), entries.end()); + + // Build blocks with the enumerated entries as leaders, as the instrumentor + // does, so a block starts at +256. + auto decoder = Decoder::create(kArch); + const auto blocks = BasicBlock::build(obj, *decoder, kArch, entries); + std::vector scope; + scope.reserve(blocks.size()); + for (const auto &block : blocks) + scope.push_back(block.get()); + + std::vector entry_blocks; + BasicBlock *entry_block = nullptr; + BasicBlock *firmware_block = nullptr; + for (BasicBlock *block : scope) { + if (block == nullptr) + continue; + if (std::ranges::find(entries, block->start_offset()) != entries.end()) + entry_blocks.push_back(block); + if (block->start_offset() == 0u) + entry_block = block; + if (block->start_offset() == 256u) + firmware_block = block; + } + ASSERT_NE(entry_block, nullptr); + ASSERT_NE(firmware_block, nullptr); + + const Instruction *s_mov = nullptr; + for (const Instruction &inst : entry_block->instructions()) { + s_mov = &inst; + break; + } + ASSERT_NE(s_mov, nullptr); + EXPECT_EQ(s_mov->mnemonic(), "s_mov_b64"); + const Instruction *firmware_entry = nullptr; + for (const Instruction &inst : firmware_block->instructions()) { + firmware_entry = &inst; + break; + } + ASSERT_NE(firmware_entry, nullptr); + EXPECT_TRUE(firmware_entry->mnemonic().starts_with("v_mov_b32")); + + // Establishing Full on the ordinary path needs the s_mov to carry RESULT_COPY. + ASSERT_TRUE(s_mov->flags() & RESULT_COPY) + << "s_mov lacks RESULT_COPY; regenerate ISA to enable EXEC-Full tracking"; + + const uint8_t wave_size = obj.kernel_wavefront_size(kArch); + // Without pinning, the ordinary fallthrough carries Full into +256; enumerating + // and pinning the firmware entry keeps it Unknown despite that Full predecessor. + const ExecMaskAnalysis unpinned{KernelBlockScope(scope), wave_size}; + EXPECT_EQ(unpinned.before(*firmware_entry), ExecState::Full); + const ExecMaskAnalysis pinned{KernelBlockScope(scope), wave_size, /*extra_edges=*/{}, + entry_blocks}; + EXPECT_EQ(pinned.before(*firmware_entry), ExecState::Unknown); +} + //============================================================================== // Section 4: Instrumentor::patch end-to-end // diff --git a/emulation/rocjitsu/tests/patch/spill_manager_test.cpp b/emulation/rocjitsu/tests/patch/spill_manager_test.cpp index 6005739c279c..f2b5492b5f5b 100644 --- a/emulation/rocjitsu/tests/patch/spill_manager_test.cpp +++ b/emulation/rocjitsu/tests/patch/spill_manager_test.cpp @@ -3,6 +3,7 @@ #include "rocjitsu/code/patch/spill_manager.h" +#include "rocjitsu/analysis/exec_state.h" #include "rocjitsu/analysis/liveness.h" #include "rocjitsu/code/basic_block.h" #include "rocjitsu/code/code_object.h" @@ -552,7 +553,8 @@ TEST(SpillManager, IntegrationFromLiveBefore) { std::vector scope; for (const auto &b : blocks) scope.push_back(b.get()); - LivenessAnalysis liveness{KernelBlockScope(scope)}; + const ExecMaskAnalysis exec{KernelBlockScope(scope), /*wave_size=*/64}; + LivenessAnalysis liveness{KernelBlockScope(scope), std::make_unique(exec)}; const RegisterSet &live = liveness.live_before(*probe); ASSERT_FALSE(live.none()) << "expected at least one live register at probe site";