from abc import ABCMeta, abstractmethod
from typing import Any, Optional, Union

import lldb
import json, struct, signal


class ScriptedProcess(metaclass=ABCMeta):
    """
    The base class for a scripted process.

    Most of the base class methods are `@abstractmethod` that need to be
    overwritten by the inheriting class.
    """

    capabilities: Optional[dict[str, bool]] = None
    memory_regions: Optional[list[lldb.SBMemoryRegionInfo]] = None
    loaded_images: Optional[list[dict]] = None
    threads: Optional[dict[int, "lldb.plugins.scripted_process.ScriptedThread"]] = None
    metadata: Optional[dict[str, Any]] = None
    addressable_bits: Optional[dict[str, int]] = None

    target: lldb.SBTarget
    args: lldb.SBStructuredData
    arch: str
    dbg: lldb.SBDebugger
    pid: int

    @abstractmethod
    def __init__(self, exe_ctx: lldb.SBExecutionContext, args: lldb.SBStructuredData):
        """Construct a scripted process.

        Args:
            exe_ctx (lldb.SBExecutionContext): The execution context for the scripted process.
            args (lldb.SBStructuredData): A Dictionary holding arbitrary
                key/value pairs used by the scripted process.
        """
        target = None
        self.target = None
        self.args = None
        self.arch = None
        if isinstance(exe_ctx, lldb.SBExecutionContext):
            target = exe_ctx.target
        if isinstance(target, lldb.SBTarget) and target.IsValid():
            self.target = target
            self.arch = target.arch_name
            self.dbg = target.GetDebugger()
        if isinstance(args, lldb.SBStructuredData) and args.IsValid():
            self.args = args
        self.threads = {}
        self.loaded_images = []
        self.metadata = {}
        self.capabilities = {}
        self.addressable_bits = {}
        self.pid = 42

    def get_capabilities(self) -> dict[str, bool]:
        """Get a dictionary containing the process capabilities.

        Returns:
            Dict[str:bool]: The dictionary of capability, with the capability
            name as the key and a boolean flag as the value.
            The dictionary can be empty.
        """
        return self.capabilities

    def get_addressable_bits(self) -> dict[str, int]:
        """Get the number of bits this process uses for addressing.

        LLDB strips the remaining bits off every code and data address, the
        way the `LC_NOTE "addrable bits"` corefile note and the `qHostInfo`
        `addressing_bits` key do for corefiles and live processes.

        This is queried before the first stop is reported, so the threads and
        backtraces built from that stop already have the mask applied.

        Returns:
            Dict[str:int]: A dictionary with optional "lowmem" and "highmem"
            keys, holding the number of bits used for addressing in low and
            high memory. "highmem" defaults to "lowmem" when it is missing.
            The dictionary can be empty, in which case no bits are stripped.
        """
        return self.addressable_bits

    def get_memory_region_containing_address(
        self, addr: int
    ) -> Optional[lldb.SBMemoryRegionInfo]:
        """Get the memory region for the scripted process, containing a
            specific address.

        Args:
            addr (int): Address to look for in the scripted process memory
                regions.

        Returns:
            lldb.SBMemoryRegionInfo: The memory region containing the address.
                None if out of bounds.
        """
        return None

    def get_threads_info(self) -> dict[int, "lldb.plugins.scripted_process.ScriptedThread"]:
        """Get the dictionary describing the process' Scripted Threads.

        Returns:
            Dict: The dictionary of threads, with the thread ID as the key and
            a Scripted Thread instance as the value.
            The dictionary can be empty.
        """
        return self.threads

    @abstractmethod
    def read_memory_at_address(
        self, addr: int, size: int, error: lldb.SBError
    ) -> lldb.SBData:
        """Get a memory buffer from the scripted process at a certain address,
            of a certain size.

        Args:
            addr (int): Address from which we should start reading.
            size (int): Size of the memory to read.
            error (lldb.SBError): Error object.

        Returns:
            lldb.SBData: An `lldb.SBData` buffer with the target byte size and
                byte order storing the memory read.
        """
        pass

    def write_memory_at_address(
        self, addr: int, data: lldb.SBData, error: lldb.SBError
    ) -> int:
        """Write a buffer to the scripted process memory.

        Args:
            addr (int): Address from which we should start reading.
            data (lldb.SBData): An `lldb.SBData` buffer to write to the process
            memory.
            error (lldb.SBError): Error object.

        Returns:
            size (int): Size of the memory to read.
        """
        error.SetErrorString(
            "%s doesn't support memory writes." % self.__class__.__name__
        )
        return 0

    def get_loaded_images(self) -> Optional[list[dict]]:
        """Get the list of loaded images for the scripted process.

        .. code-block:: python

            scripted_image = {
                uuid = "c6ea2b64-f77c-3d27-9528-74f507b9078b",
                path = "/usr/lib/dyld"
                load_addr = 0xbadc0ffee
            }

        Returns:
            List[scripted_image]: A list of `scripted_image` dictionaries
                containing for each entry the library UUID or its file path
                and its load address.
                None if the list is empty.
        """
        return self.loaded_images

    def get_process_id(self) -> int:
        """Get the scripted process identifier.

        Returns:
            int: The scripted process identifier.
        """
        return self.pid

    def launch(self) -> lldb.SBError:
        """Simulate the scripted process launch.

        Returns:
            lldb.SBError: An `lldb.SBError` with error code 0.
        """
        return lldb.SBError()

    def attach(self, attach_info: lldb.SBAttachInfo) -> lldb.SBError:
        """Simulate the scripted process attach.

        Args:
            attach_info (lldb.SBAttachInfo): The information related to the
            process we're attaching to.

        Returns:
            lldb.SBError: An `lldb.SBError` with error code 0.
        """
        return lldb.SBError()

    def resume(self, should_stop: bool = True) -> lldb.SBError:
        """Simulate the scripted process resume.

        Args:
            should_stop (bool): If True, resume will also force the process
            state to stopped after running it.

        Returns:
            lldb.SBError: An `lldb.SBError` with error code 0.
        """
        process = self.target.GetProcess()
        if not process:
            error = lldb.SBError()
            error.SetErrorString("Invalid process.")
            return error

        process.ForceScriptedState(lldb.eStateRunning)
        if should_stop:
            process.ForceScriptedState(lldb.eStateStopped)
        return lldb.SBError()

    @abstractmethod
    def is_alive(self) -> bool:
        """Check if the scripted process is alive.

        Returns:
            bool: True if scripted process is alive. False otherwise.
        """
        pass

    @abstractmethod
    def get_scripted_thread_plugin(self) -> str:
        """Get scripted thread plugin name.

        Returns:
            str: Name of the scripted thread plugin.
        """
        return None

    def get_process_metadata(self) -> Optional[dict[str, Any]]:
        """Get some metadata for the scripted process.

        Returns:
            Dict: A dictionary containing metadata for the scripted process.
                  None if the process as no metadata.
        """
        return self.metadata

    def create_breakpoint(
        self, addr: int, error: lldb.SBError
    ) -> Union[lldb.SBBreakpoint, bool]:
        """Create a breakpoint in the scripted process from an address.
            This is mainly used with interactive scripted process debugging.

        Args:
            addr (int): Address at which the breakpoint should be set.
            error (lldb.SBError): Error object.

        Returns:
            SBBreakpoint: A valid breakpoint object that was created a the specified
                          address. None if the breakpoint creation failed.
        """
        error.SetErrorString(
            "%s doesn't support creating breakpoints." % self.__class__.__name__
        )
        return False


class ScriptedThread(metaclass=ABCMeta):
    """
    The base class for a scripted thread.

    Most of the base class methods are `@abstractmethod` that need to be
    overwritten by the inheriting class.
    """

    target: lldb.SBTarget
    arch: str
    originating_process: Union["lldb.plugins.scripted_process.ScriptedProcess", lldb.SBProcess]
    process: lldb.SBProcess
    args: lldb.SBStructuredData
    idx: int
    tid: int
    name: str
    queue: str
    state: int
    stop_reason: dict[str, Any]
    register_info: dict[str, Any]
    register_ctx: dict[str, int]
    frames: list[dict]
    extended_info: list[dict]

    @abstractmethod
    def __init__(
        self,
        process: Union["lldb.plugins.scripted_process.ScriptedProcess", lldb.SBProcess],
        args: Optional[lldb.SBStructuredData],
    ):
        """Construct a scripted thread.

        Args:
            process (ScriptedProcess/lldb.SBProcess): The process owning this thread.
            args (lldb.SBStructuredData): A Dictionary holding arbitrary
                key/value pairs used by the scripted thread.
        """
        self.target = None
        self.arch = None
        self.originating_process = None
        self.process = None
        self.args = None
        self.idx = 0
        self.tid = 0
        self.idx = None
        self.name = None
        self.queue = None
        self.state = None
        self.stop_reason = None
        self.register_info = None
        self.register_ctx = {}
        self.frames = []
        self.extended_info = []

        if (
            isinstance(process, ScriptedProcess)
            or isinstance(process, lldb.SBProcess)
            and process.IsValid()
        ):
            self.target = process.target
            triple = self.target.triple
            if triple:
                self.arch = triple.split("-")[0]
            self.originating_process = process
            self.process = self.target.GetProcess()
            self.get_register_info()

    def get_thread_idx(self) -> int:
        """Get the scripted thread index.

        Returns:
            int: The index of the scripted thread in the scripted process.
        """
        return self.idx

    def get_thread_id(self) -> int:
        """Get the scripted thread identifier.

        Returns:
            int: The identifier of the scripted thread.
        """
        return self.tid

    def get_name(self) -> str:
        """Get the scripted thread name.

        Returns:
            str: The name of the scripted thread.
        """
        return self.name

    def get_state(self) -> int:
        """Get the scripted thread state type.

        .. code-block:: python

            eStateStopped,   ///< Process or thread is stopped and can be examined.
            eStateRunning,   ///< Process or thread is running and can't be examined.
            eStateStepping,  ///< Process or thread is in the process of stepping and
                             /// can not be examined.
            eStateCrashed,   ///< Process or thread has crashed and can be examined.

        Returns:
            int: The state type of the scripted thread.
                 Returns lldb.eStateStopped by default.
        """
        return lldb.eStateStopped

    def get_queue(self) -> str:
        """Get the scripted thread associated queue name.
            This method is optional.

        Returns:
            str: The queue name associated with the scripted thread.
        """
        return self.queue

    @abstractmethod
    def get_stop_reason(self) -> dict[str, Any]:
        """Get the dictionary describing the stop reason type with some data.
            This method is optional.

        Returns:
            Dict: The dictionary holding the stop reason type and the possibly
            the stop reason data.
        """
        pass

    def get_stackframes(self) -> list[dict]:
        """Get the list of stack frames for the scripted thread.

        .. code-block:: python

            scripted_frame = {
                idx = 0,
                pc = 0xbadc0ffee
            }

        Returns:
            List[scripted_frame]: A list of `scripted_frame` dictionaries
                containing at least for each entry, the frame index and
                the program counter value for that frame.
                The list can be empty.
        """
        return self.frames

    def get_register_info(self) -> dict[str, Any]:
        """Get the register info dictionary describing the scripted thread's
        registers. Lazily populated on first call from a per-architecture
        general-purpose register layout keyed off `self.arch`.

        Returns:
            Dict: The register info dictionary with `sets` and `registers`
            keys. `sets` is a list of register set names and `registers`
            is a list of register descriptions.

        Raises:
            ValueError: If `self.arch` is not one of the architectures
                the base class ships a register layout for.
        """
        if self.register_info is None:
            self.register_info = dict()
            if "x86_64" in self.arch:
                self.register_info["sets"] = ["General Purpose Registers"]
                self.register_info["registers"] = INTEL64_GPR
            elif "arm64" in self.arch or self.arch == "aarch64":
                self.register_info["sets"] = ["General Purpose Registers"]
                self.register_info["registers"] = ARM64_GPR
            elif "arm" in self.arch or "thumb" in self.arch:
                self.register_info["sets"] = ["General Purpose Registers"]
                self.register_info["registers"] = ARM32_GPR
            elif "hexagon" in self.arch:
                self.register_info["sets"] = ["General Purpose Registers"]
                self.register_info["registers"] = HEXAGON_GPR
            else:
                raise ValueError("Unknown architecture", self.arch)
        return self.register_info

    @abstractmethod
    def get_register_context(self) -> str:
        """Get the scripted thread register context

        Returns:
            str: A byte representing all register's value.
        """
        pass

    def get_extended_info(self) -> list[dict]:
        """Get scripted thread extended information.

        Returns:
            List: A list containing the extended information for the scripted process.
                  None if the thread as no extended information.
        """
        return self.extended_info

    def get_scripted_frame_plugin(self) -> Optional[str]:
        """Get scripted frame plugin name.

        Returns:
            str: Name of the scripted frame plugin.
        """
        return None


class ScriptedFrame(metaclass=ABCMeta):
    """
    The base class for a scripted frame.

    Most of the base class methods are `@abstractmethod` that need to be
    overwritten by the inheriting class.
    """

    target: lldb.SBTarget
    arch: str
    originating_thread: Union["lldb.plugins.scripted_process.ScriptedThread", lldb.SBThread]
    thread: lldb.SBThread
    process: lldb.SBProcess
    args: lldb.SBStructuredData
    id: int
    name: str
    register_info: dict[str, Any]
    register_ctx: dict[str, int]
    variables: list[lldb.SBValue]

    @abstractmethod
    def __init__(
        self, thread: Union["lldb.plugins.scripted_process.ScriptedThread", lldb.SBThread], args: lldb.SBStructuredData
    ):
        """Construct a scripted frame.

        Args:
            thread (ScriptedThread/lldb.SBThread): The thread owning this frame.
            args (lldb.SBStructuredData): A Dictionary holding arbitrary
                key/value pairs used by the scripted frame.
        """
        self.target = None
        self.arch = None
        self.originating_thread = None
        self.thread = None
        self.args = None
        self.id = None
        self.name = None
        self.register_info = None
        self.register_ctx = {}
        self.variables = []

        if isinstance(thread, ScriptedThread) or (
            isinstance(thread, lldb.SBThread) and thread.IsValid()
        ):
            self.process = thread.process
            self.target = self.process.target
            triple = self.target.triple
            if triple:
                self.arch = triple.split("-")[0]
            tid = thread.tid if isinstance(thread, ScriptedThread) else thread.id
            self.originating_thread = thread
            self.thread = self.process.GetThreadByID(tid)
            self.get_register_info()

    @abstractmethod
    def get_id(self) -> int:
        """Get the scripted frame identifier.

        Returns:
            int: The identifier of the scripted frame in the scripted thread.
        """
        pass

    def get_pc(self) -> Optional[int]:
        """Get the scripted frame address.

        Returns:
            int: The optional address of the scripted frame in the scripted thread.
        """
        return None

    def get_cfa(self) -> int:
        """Get the Call Frame Address for this frame.
        By default pass the ID of this frame so the CFA's and the
        ID's order the same way on this stop.  This won't support
        step-in and step-out, for those the frames have to have a
        stable CFA.
        """
        return self.get_id()

    def get_symbol_context(self) -> Optional[lldb.SBSymbolContext]:
        """Get the scripted frame symbol context.

        Returns:
            lldb.SBSymbolContext: The symbol context of the scripted frame in the scripted thread.
        """
        return None

    def is_inlined(self) -> bool:
        """Check if the scripted frame is inlined.

        Returns:
            bool: True if scripted frame is inlined. False otherwise.
        """
        return False

    def is_artificial(self) -> bool:
        """Check if the scripted frame is artificial.

        Returns:
            bool: True if scripted frame is artificial. False otherwise.
        """
        return True

    def is_hidden(self) -> bool:
        """Check if the scripted frame is hidden.

        Returns:
            bool: True if scripted frame is hidden. False otherwise.
        """
        return False

    def get_function_name(self) -> Optional[str]:
        """Get the scripted frame function name.

        Returns:
            str: The function name of the scripted frame.
        """
        return self.name

    def get_display_function_name(self) -> Optional[str]:
        """Get the scripted frame display function name.

        Returns:
            str: The display function name of the scripted frame.
        """
        return self.get_function_name()

    def get_variables(
        self, filters: lldb.SBVariablesOptions
    ) -> Optional[lldb.SBValueList]:
        """Get the scripted thread state type.

        Args:
            filter (lldb.SBVariablesOptions): The filter used to resolve the variables
        Returns:
            lldb.SBValueList: The SBValueList containing the SBValue for each resolved variable.
                              Returns None by default.
        """
        return None

    def get_register_info(self) -> dict[str, Any]:
        """Get the register info dictionary describing the scripted frame's
        registers. Delegates to the originating scripted thread when there
        is one; otherwise lazily populates a per-architecture
        general-purpose register layout keyed off `self.arch`.

        Returns:
            Dict: The register info dictionary with `sets` and `registers`
            keys. `sets` is a list of register set names and `registers`
            is a list of register descriptions.

        Raises:
            ValueError: If `self.arch` is not one of the architectures
                the base class ships a register layout for.
        """
        if self.register_info is None:
            if isinstance(self.originating_thread, ScriptedThread):
                self.register_info = self.originating_thread.get_register_info()
            elif isinstance(self.originating_thread, lldb.SBThread):
                self.register_info = dict()
                if "x86_64" in self.arch:
                    self.register_info["sets"] = ["General Purpose Registers"]
                    self.register_info["registers"] = INTEL64_GPR
                elif "arm64" in self.arch or self.arch == "aarch64":
                    self.register_info["sets"] = ["General Purpose Registers"]
                    self.register_info["registers"] = ARM64_GPR
                elif "arm" in self.arch or "thumb" in self.arch:
                    self.register_info["sets"] = ["General Purpose Registers"]
                    self.register_info["registers"] = ARM32_GPR
                elif "hexagon" in self.arch:
                    self.register_info["sets"] = ["General Purpose Registers"]
                    self.register_info["registers"] = HEXAGON_GPR
                elif "wasm" in self.arch:
                    # WebAssembly is a stack machine with no general-purpose
                    # register file, so there is no GPR layout to expose. Leave
                    # the register info empty rather than raising, which would
                    # otherwise prevent the scripted frame from constructing.
                    self.register_info["sets"] = []
                    self.register_info["registers"] = []
                else:
                    raise ValueError("Unknown architecture", self.arch)
        return self.register_info

    @abstractmethod
    def get_register_context(self) -> str:
        """Get the scripted thread register context

        Returns:
            str: A byte representing all register's value.
        """
        pass

    # def get_plan_spec_for_step_type(self, step_type : lldb.StepType):
    #    """Optional method.  If this ScriptedFrame can produce a ThreadPlan
    #    that implements the given step_type, then it should return a Python
    #    dictionary with the `class_name` key giving the name of a class that
    #    implements the step plan, and an optional extra_args dictionary that
    #    will be passed to the constructor of your step-plan class.  If the
    #    class name is an empty string, that means use the standard stepping
    #    algorithms for this step.
    #    The body below tells lldb to fall back to the standard stepping
    #    algorithm.  However, the method is commented out in the base class,
    #    since if you really don't intend to provide stepping support,
    #    it's simpler to just not implement this API."""
    #
    # dict = {"class_name" : "", extra_args : {"step_type" : str(step_type)}
    #    return dict

class PassthroughScriptedProcess(ScriptedProcess):
    """A reference `ScriptedProcess` subclass that forwards every request to
    a "driving" process running in another target of the same debugger.
    Useful as a starting point when the extension only needs to reshape or
    filter data from a real underlying process."""

    driving_target = None
    driving_process = None

    def __init__(
        self,
        exe_ctx: lldb.SBExecutionContext,
        args: lldb.SBStructuredData,
        launched_driving_process: bool = True,
    ):
        """Construct a passthrough scripted process by looking up the driving
        target's index in `args["driving_target_idx"]` and (unless
        `launched_driving_process` is `False`) mirroring its threads and
        loaded images into `self`.
        """
        super().__init__(exe_ctx, args)

        self.driving_target = None
        self.driving_process = None

        self.driving_target_idx = args.GetValueForKey("driving_target_idx")
        if self.driving_target_idx and self.driving_target_idx.IsValid():
            idx = self.driving_target_idx.GetUnsignedIntegerValue(42)
            self.driving_target = self.target.GetDebugger().GetTargetAtIndex(idx)

            if launched_driving_process:
                self.driving_process = self.driving_target.GetProcess()
                for driving_thread in self.driving_process:
                    structured_data = lldb.SBStructuredData()
                    structured_data.SetFromJSON(
                        json.dumps(
                            {
                                "driving_target_idx": idx,
                                "thread_idx": driving_thread.GetIndexID(),
                            }
                        )
                    )

                    self.threads[driving_thread.GetThreadID()] = (
                        PassthroughScriptedThread(self, structured_data)
                    )

                for module in self.driving_target.modules:
                    path = module.file.fullpath
                    load_addr = module.GetObjectFileHeaderAddress().GetLoadAddress(
                        self.driving_target
                    )
                    self.loaded_images.append({"path": path, "load_addr": load_addr})

    def get_memory_region_containing_address(
        self, addr: int
    ) -> Optional[lldb.SBMemoryRegionInfo]:
        mem_region = lldb.SBMemoryRegionInfo()
        error = self.driving_process.GetMemoryRegionInfo(addr, mem_region)
        if error.Fail():
            return None
        return mem_region

    def read_memory_at_address(
        self, addr: int, size: int, error: lldb.SBError
    ) -> lldb.SBData:
        data = lldb.SBData()
        bytes_read = self.driving_process.ReadMemory(addr, size, error)

        if error.Fail():
            return data

        data.SetDataWithOwnership(
            error,
            bytes_read,
            self.driving_target.GetByteOrder(),
            self.driving_target.GetAddressByteSize(),
        )

        return data

    def write_memory_at_address(
        self, addr: int, data: lldb.SBData, error: lldb.SBError
    ) -> int:
        return self.driving_process.WriteMemory(
            addr, bytearray(data.uint8.all()), error
        )

    def get_process_id(self) -> int:
        return self.driving_process.GetProcessID()

    def is_alive(self) -> bool:
        return True

    def get_scripted_thread_plugin(self) -> str:
        return f"{PassthroughScriptedThread.__module__}.{PassthroughScriptedThread.__name__}"


class PassthroughScriptedThread(ScriptedThread):
    """A reference `ScriptedThread` subclass that forwards every request to
    a specific thread of a driving process. See `PassthroughScriptedProcess`
    for the process-side counterpart."""

    def __init__(
        self,
        process: Union["lldb.plugins.scripted_process.ScriptedProcess", lldb.SBProcess],
        args: lldb.SBStructuredData,
    ):
        super().__init__(process, args)
        driving_target_idx = args.GetValueForKey("driving_target_idx")
        thread_idx = args.GetValueForKey("thread_idx")

        # TODO: Change to Walrus operator (:=) with oneline if assignment
        # Requires python 3.8
        val = thread_idx.GetUnsignedIntegerValue()
        if val is not None:
            self.idx = val

        self.driving_target = None
        self.driving_process = None
        self.driving_thread = None

        # TODO: Change to Walrus operator (:=) with oneline if assignment
        # Requires python 3.8
        val = driving_target_idx.GetUnsignedIntegerValue()
        if val is not None:
            self.driving_target = self.target.GetDebugger().GetTargetAtIndex(val)
            self.driving_process = self.driving_target.GetProcess()
            self.driving_thread = self.driving_process.GetThreadByIndexID(self.idx)

        if self.driving_thread:
            self.id = self.driving_thread.GetThreadID()

    def get_thread_id(self) -> int:
        return self.id

    def get_name(self) -> str:
        return f"{PassthroughScriptedThread.__name__}.thread-{self.idx}"

    def get_stop_reason(self) -> dict:
        stop_reason = {"type": lldb.eStopReasonInvalid, "data": {}}

        if (
            self.driving_thread
            and self.driving_thread.IsValid()
            and self.get_thread_id() == self.driving_thread.GetThreadID()
        ):
            stop_reason["type"] = lldb.eStopReasonNone

            # TODO: Passthrough stop reason from driving process
            if self.driving_thread.GetStopReason() != lldb.eStopReasonNone:
                if "arm64" in self.arch:
                    stop_reason["type"] = lldb.eStopReasonException
                    stop_reason["data"]["desc"] = (
                        self.driving_thread.GetStopDescription(100)
                    )
                elif self.arch == "x86_64":
                    stop_reason["type"] = lldb.eStopReasonSignal
                    stop_reason["data"]["signal"] = signal.SIGTRAP
                else:
                    stop_reason["type"] = self.driving_thread.GetStopReason()

        return stop_reason

    def get_register_context(self) -> Optional[str]:
        if not self.driving_thread or self.driving_thread.GetNumFrames() == 0:
            return None
        frame = self.driving_thread.GetFrameAtIndex(0)

        GPRs = None
        registerSet = frame.registers  # Returns an SBValueList.
        for regs in registerSet:
            if "general purpose" in regs.name.lower():
                GPRs = regs
                break

        if not GPRs:
            return None

        for reg in GPRs:
            self.register_ctx[reg.name] = int(reg.value, base=16)

        return struct.pack(f"{len(self.register_ctx)}Q", *self.register_ctx.values())

ARM32_GPR = [
    {
        "name": "r0",
        "bitsize": 32,
        "offset": 0,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
        "generic": "arg0",
        "alt-name": "arg0",
    },
    {
        "name": "r1",
        "bitsize": 32,
        "offset": 4,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 1,
        "dwarf": 1,
        "generic": "arg1",
        "alt-name": "arg1",
    },
    {
        "name": "r2",
        "bitsize": 32,
        "offset": 8,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 2,
        "dwarf": 2,
        "generic": "arg2",
        "alt-name": "arg2",
    },
    {
        "name": "r3",
        "bitsize": 32,
        "offset": 12,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 3,
        "dwarf": 3,
        "generic": "arg3",
        "alt-name": "arg3",
    },
    {
        "name": "r4",
        "bitsize": 32,
        "offset": 16,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 4,
        "dwarf": 4,
    },
    {
        "name": "r5",
        "bitsize": 32,
        "offset": 20,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 5,
        "dwarf": 5,
    },
    {
        "name": "r6",
        "bitsize": 32,
        "offset": 24,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 6,
        "dwarf": 6,
    },
    {
        "name": "r7",
        "bitsize": 32,
        "offset": 28,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 7,
        "dwarf": 7,
    },
    {
        "name": "r8",
        "bitsize": 32,
        "offset": 32,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 8,
        "dwarf": 8,
    },
    {
        "name": "r9",
        "bitsize": 32,
        "offset": 36,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 9,
        "dwarf": 9,
    },
    {
        "name": "r10",
        "bitsize": 32,
        "offset": 40,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 10,
        "dwarf": 10,
    },
    {
        "name": "r11",
        "bitsize": 32,
        "offset": 44,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 11,
        "dwarf": 11,
        "generic": "fp",
        "alt-name": "fp",
    },
    {
        "name": "r12",
        "bitsize": 32,
        "offset": 48,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 12,
        "dwarf": 12,
    },
    {
        "name": "sp",
        "bitsize": 32,
        "offset": 52,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 13,
        "dwarf": 13,
        "generic": "sp",
        "alt-name": "r13",
    },
    {
        "name": "lr",
        "bitsize": 32,
        "offset": 56,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 14,
        "dwarf": 14,
        "generic": "lr",
        "alt-name": "r14",
    },
    {
        "name": "pc",
        "bitsize": 32,
        "offset": 60,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 15,
        "dwarf": 15,
        "generic": "pc",
        "alt-name": "r15",
    },
    {
        "name": "cpsr",
        "bitsize": 32,
        "offset": 64,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "dwarf": 128,
    },
]

ARM64_GPR = [
    {
        "name": "x0",
        "bitsize": 64,
        "offset": 0,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
        "generic": "arg0",
        "alt-name": "arg0",
    },
    {
        "name": "x1",
        "bitsize": 64,
        "offset": 8,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 1,
        "dwarf": 1,
        "generic": "arg1",
        "alt-name": "arg1",
    },
    {
        "name": "x2",
        "bitsize": 64,
        "offset": 16,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 2,
        "dwarf": 2,
        "generic": "arg2",
        "alt-name": "arg2",
    },
    {
        "name": "x3",
        "bitsize": 64,
        "offset": 24,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 3,
        "dwarf": 3,
        "generic": "arg3",
        "alt-name": "arg3",
    },
    {
        "name": "x4",
        "bitsize": 64,
        "offset": 32,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 4,
        "dwarf": 4,
        "generic": "arg4",
        "alt-name": "arg4",
    },
    {
        "name": "x5",
        "bitsize": 64,
        "offset": 40,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 5,
        "dwarf": 5,
        "generic": "arg5",
        "alt-name": "arg5",
    },
    {
        "name": "x6",
        "bitsize": 64,
        "offset": 48,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 6,
        "dwarf": 6,
        "generic": "arg6",
        "alt-name": "arg6",
    },
    {
        "name": "x7",
        "bitsize": 64,
        "offset": 56,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 7,
        "dwarf": 7,
        "generic": "arg7",
        "alt-name": "arg7",
    },
    {
        "name": "x8",
        "bitsize": 64,
        "offset": 64,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 8,
        "dwarf": 8,
    },
    {
        "name": "x9",
        "bitsize": 64,
        "offset": 72,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 9,
        "dwarf": 9,
    },
    {
        "name": "x10",
        "bitsize": 64,
        "offset": 80,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 10,
        "dwarf": 10,
    },
    {
        "name": "x11",
        "bitsize": 64,
        "offset": 88,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 11,
        "dwarf": 11,
    },
    {
        "name": "x12",
        "bitsize": 64,
        "offset": 96,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 12,
        "dwarf": 12,
    },
    {
        "name": "x13",
        "bitsize": 64,
        "offset": 104,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 13,
        "dwarf": 13,
    },
    {
        "name": "x14",
        "bitsize": 64,
        "offset": 112,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 14,
        "dwarf": 14,
    },
    {
        "name": "x15",
        "bitsize": 64,
        "offset": 120,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 15,
        "dwarf": 15,
    },
    {
        "name": "x16",
        "bitsize": 64,
        "offset": 128,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 16,
        "dwarf": 16,
    },
    {
        "name": "x17",
        "bitsize": 64,
        "offset": 136,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 17,
        "dwarf": 17,
    },
    {
        "name": "x18",
        "bitsize": 64,
        "offset": 144,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 18,
        "dwarf": 18,
    },
    {
        "name": "x19",
        "bitsize": 64,
        "offset": 152,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 19,
        "dwarf": 19,
    },
    {
        "name": "x20",
        "bitsize": 64,
        "offset": 160,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 20,
        "dwarf": 20,
    },
    {
        "name": "x21",
        "bitsize": 64,
        "offset": 168,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 21,
        "dwarf": 21,
    },
    {
        "name": "x22",
        "bitsize": 64,
        "offset": 176,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 22,
        "dwarf": 22,
    },
    {
        "name": "x23",
        "bitsize": 64,
        "offset": 184,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 23,
        "dwarf": 23,
    },
    {
        "name": "x24",
        "bitsize": 64,
        "offset": 192,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 24,
        "dwarf": 24,
    },
    {
        "name": "x25",
        "bitsize": 64,
        "offset": 200,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 25,
        "dwarf": 25,
    },
    {
        "name": "x26",
        "bitsize": 64,
        "offset": 208,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 26,
        "dwarf": 26,
    },
    {
        "name": "x27",
        "bitsize": 64,
        "offset": 216,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 27,
        "dwarf": 27,
    },
    {
        "name": "x28",
        "bitsize": 64,
        "offset": 224,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 28,
        "dwarf": 28,
    },
    {
        "name": "x29",
        "bitsize": 64,
        "offset": 232,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 29,
        "dwarf": 29,
        "generic": "fp",
        "alt-name": "fp",
    },
    {
        "name": "x30",
        "bitsize": 64,
        "offset": 240,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 30,
        "dwarf": 30,
        "generic": "lr",
        "alt-name": "lr",
    },
    {
        "name": "sp",
        "bitsize": 64,
        "offset": 248,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 31,
        "dwarf": 31,
        "generic": "sp",
        "alt-name": "sp",
    },
    {
        "name": "pc",
        "bitsize": 64,
        "offset": 256,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 32,
        "dwarf": 32,
        "generic": "pc",
        "alt-name": "pc",
    },
    {
        "name": "cpsr",
        "bitsize": 32,
        "offset": 264,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 33,
        "dwarf": 33,
    },
]

HEXAGON_GPR = [
    {
        "name": "r0",
        "bitsize": 32,
        "offset": 0,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r1",
        "bitsize": 32,
        "offset": 4,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r2",
        "bitsize": 32,
        "offset": 8,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r3",
        "bitsize": 32,
        "offset": 12,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r4",
        "bitsize": 32,
        "offset": 16,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r5",
        "bitsize": 32,
        "offset": 20,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r6",
        "bitsize": 32,
        "offset": 24,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r7",
        "bitsize": 32,
        "offset": 28,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r8",
        "bitsize": 32,
        "offset": 32,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r9",
        "bitsize": 32,
        "offset": 36,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r10",
        "bitsize": 32,
        "offset": 40,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r11",
        "bitsize": 32,
        "offset": 44,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r12",
        "bitsize": 32,
        "offset": 48,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r13",
        "bitsize": 32,
        "offset": 52,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r14",
        "bitsize": 32,
        "offset": 56,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r15",
        "bitsize": 32,
        "offset": 60,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r16",
        "bitsize": 32,
        "offset": 64,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r17",
        "bitsize": 32,
        "offset": 68,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r18",
        "bitsize": 32,
        "offset": 72,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r19",
        "bitsize": 32,
        "offset": 76,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r20",
        "bitsize": 32,
        "offset": 80,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r21",
        "bitsize": 32,
        "offset": 84,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r22",
        "bitsize": 32,
        "offset": 88,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r23",
        "bitsize": 32,
        "offset": 92,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r24",
        "bitsize": 32,
        "offset": 96,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r25",
        "bitsize": 32,
        "offset": 100,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r26",
        "bitsize": 32,
        "offset": 104,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r27",
        "bitsize": 32,
        "offset": 108,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r28",
        "bitsize": 32,
        "offset": 112,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "r29",
        "bitsize": 32,
        "offset": 116,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
        "alt-name": "sp",
    },
    {
        "name": "r30",
        "bitsize": 32,
        "offset": 120,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
        "alt-name": "fp",
    },
    {
        "name": "r31",
        "bitsize": 32,
        "offset": 124,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
        "alt-name": "lr",
    },
    {
        "name": "sa0",
        "bitsize": 32,
        "offset": 128,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "lc0",
        "bitsize": 32,
        "offset": 132,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "sa1",
        "bitsize": 32,
        "offset": 136,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "lc1",
        "bitsize": 32,
        "offset": 140,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "p3_0",
        "bitsize": 32,
        "offset": 144,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "m0",
        "bitsize": 32,
        "offset": 148,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "m1",
        "bitsize": 32,
        "offset": 152,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "usr",
        "bitsize": 32,
        "offset": 156,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "pc",
        "bitsize": 32,
        "offset": 160,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
        "generic": "pc",
        "alt-name": "pc",
    },
    {
        "name": "ugp",
        "bitsize": 32,
        "offset": 164,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "gp",
        "bitsize": 32,
        "offset": 168,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "cs0",
        "bitsize": 32,
        "offset": 172,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "cs1",
        "bitsize": 32,
        "offset": 176,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "framelimit",
        "bitsize": 32,
        "offset": 180,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "framekey",
        "bitsize": 32,
        "offset": 184,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
]

INTEL64_GPR = [
    {
        "name": "rax",
        "bitsize": 64,
        "offset": 0,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 0,
        "dwarf": 0,
    },
    {
        "name": "rbx",
        "bitsize": 64,
        "offset": 8,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 3,
        "dwarf": 3,
    },
    {
        "name": "rcx",
        "bitsize": 64,
        "offset": 16,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 2,
        "dwarf": 2,
        "generic": "arg4",
        "alt-name": "arg4",
    },
    {
        "name": "rdx",
        "bitsize": 64,
        "offset": 24,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 1,
        "dwarf": 1,
        "generic": "arg3",
        "alt-name": "arg3",
    },
    {
        "name": "rdi",
        "bitsize": 64,
        "offset": 32,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 5,
        "dwarf": 5,
        "generic": "arg1",
        "alt-name": "arg1",
    },
    {
        "name": "rsi",
        "bitsize": 64,
        "offset": 40,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 4,
        "dwarf": 4,
        "generic": "arg2",
        "alt-name": "arg2",
    },
    {
        "name": "rbp",
        "bitsize": 64,
        "offset": 48,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 6,
        "dwarf": 6,
        "generic": "fp",
        "alt-name": "fp",
    },
    {
        "name": "rsp",
        "bitsize": 64,
        "offset": 56,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 7,
        "dwarf": 7,
        "generic": "sp",
        "alt-name": "sp",
    },
    {
        "name": "r8",
        "bitsize": 64,
        "offset": 64,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 8,
        "dwarf": 8,
        "generic": "arg5",
        "alt-name": "arg5",
    },
    {
        "name": "r9",
        "bitsize": 64,
        "offset": 72,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 9,
        "dwarf": 9,
        "generic": "arg6",
        "alt-name": "arg6",
    },
    {
        "name": "r10",
        "bitsize": 64,
        "offset": 80,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 10,
        "dwarf": 10,
    },
    {
        "name": "r11",
        "bitsize": 64,
        "offset": 88,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 11,
        "dwarf": 11,
    },
    {
        "name": "r12",
        "bitsize": 64,
        "offset": 96,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 12,
        "dwarf": 12,
    },
    {
        "name": "r13",
        "bitsize": 64,
        "offset": 104,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 13,
        "dwarf": 13,
    },
    {
        "name": "r14",
        "bitsize": 64,
        "offset": 112,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 14,
        "dwarf": 14,
    },
    {
        "name": "r15",
        "bitsize": 64,
        "offset": 120,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 15,
        "dwarf": 15,
    },
    {
        "name": "rip",
        "bitsize": 64,
        "offset": 128,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "gcc": 16,
        "dwarf": 16,
        "generic": "pc",
        "alt-name": "pc",
    },
    {
        "name": "rflags",
        "bitsize": 64,
        "offset": 136,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
        "generic": "flags",
        "alt-name": "flags",
    },
    {
        "name": "cs",
        "bitsize": 64,
        "offset": 144,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
    },
    {
        "name": "fs",
        "bitsize": 64,
        "offset": 152,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
    },
    {
        "name": "gs",
        "bitsize": 64,
        "offset": 160,
        "encoding": "uint",
        "format": "hex",
        "set": 0,
    },
]