NationalSecurityAgency/ghidra · error · ValueError

Cannot convert {}'s value: '{}', type: '{}'

Error message

Cannot convert {}'s value: '{}', type: '{}'

What it means

Raised by DefaultRegisterMapper.map_value when value.to_bytes(8, 'big') raises an exception. The method attempts to serialize an integer register value into 8 bytes in big-endian order; if the value is not an int, is negative, or exceeds 2**64-1, to_bytes fails and the broad except re-raises as ValueError.

Source

Thrown at Ghidra/Debug/Debugger-agent-x64dbg/src/main/py/src/ghidraxdbg/arch.py:184

    return memory_mappers[lang]


class DefaultRegisterMapper(object):

    def __init__(self, byte_order: str) -> None:
        if not byte_order in ['big', 'little']:
            raise ValueError("Invalid byte_order: {}".format(byte_order))
        self.byte_order = byte_order

    def map_name(self, proc: int, name: str):
        return name

    def map_value(self, proc: int, name: str, value: int):
        try:
            # TODO: this seems half-baked
            av = value.to_bytes(8, "big")
        except Exception:
            raise ValueError("Cannot convert {}'s value: '{}', type: '{}'"
                             .format(name, value, type(value)))
        return RegVal(self.map_name(proc, name), av)

    def map_name_back(self, proc: int, name: str) -> str:
        return name

    def map_value_back(self, proc: int, name: str, value: bytes):
        return RegVal(self.map_name_back(proc, name), value)


class Intel_x86_64_RegisterMapper(DefaultRegisterMapper):

    def __init__(self):
        super().__init__('little')

    def map_name(self, proc, name):
        if name is None:
            return 'UNKNOWN'

View on GitHub (pinned to d5f144c24d)

Solutions

1. Ensure value is a non-negative int that fits in 8 bytes before calling map_value.
2. Handle None or unavailable register values upstream before they reach map_value.
3. Override map_value in the language-specific mapper to handle wider registers or type coercion.

Example fix

# before: passing a non-int or oversized value
rv = mapper.map_value(proc, 'rax', '0xDEADBEEF')  # string fails to_bytes

# after: coerce to int, clamp to 64-bit
val = int(value, 0) if isinstance(value, str) else value
if val < 0:
    val = val & 0xFFFFFFFFFFFFFFFF
rv = mapper.map_value(proc, 'rax', val)

if not isinstance(value, int) or value < 0 or value > 0xFFFFFFFFFFFFFFFF:
    raise ValueError(
        f"Register value must be a non-negative int <= 2**64-1, got {value!r} ({type(value)})")

def is_valid_reg_value(val) -> bool:
    return isinstance(val, int) and 0 <= val <= 0xFFFFFFFFFFFFFFFF

try:
    rv = mapper.map_value(proc, name, value)
except ValueError:
    # attempt coercion: parse hex strings, mask negatives
    val = int(value, 0) if isinstance(value, str) else int(value)
    val = val & 0xFFFFFFFFFFFFFFFF
    rv = mapper.map_value(proc, name, val)

When it happens

Trigger: map_value(proc, name, value) is called during register-read operations. value.to_bytes(8, 'big') fails because value is None, a string, a negative integer, or an integer larger than 2**64-1.

Common situations: The x64dbg plugin returned a non-integer register value (e.g. a hex string or None for an unavailable register). A register value overflow for wide registers (e.g. AVX-512) that exceeds 64 bits. A mismatch between the debugger-reported register type and the expected int.

Related errors

• Invalid byte_order: {}
• Address {address} is not in process {proc}
• No register mapper
• Cannot convert {}'s value: '{}', type: '{}'
• No register mapper

AI-assisted analysis of NationalSecurityAgency/ghidra@d5f144c24d (2026-08-14). Data as JSON: /api/errors/f5fb65ff589e4cd1. Report an issue: GitHub.