Class DebuggerController

api/python/debuggercontroller.py:492–1410

The ``DebuggerController`` object is the core of the debugger. Most debugger operations can be performed on it. It takes in a ``BinaryView`` and creates a debugger for it. If a debugger is already existing for the very same BinaryView object, the debugger is returned. Most operatio

class DebuggerController:
    """
    The ``DebuggerController`` object is the core of the debugger. Most debugger operations can be performed on it.
    It takes in a ``BinaryView`` and creates a debugger for it. If a debugger is already existing for the very same
    BinaryView object, the debugger is returned.

    Most operations of the debugger are performed on this class. For example, we can launch the debugger as follows::

        >>> bv = load("test/binaries/helloworld")
        >>> dbg = DebuggerController(bv)
        >>> dbg.launch()
        True

    When the ``launch()`` returns True, it means the debugger has launched the target successfully. The target breaks at
    the entry point of the binary. Now we can perform other control operations on it, e.g., resume the target by calling
    ``go()``.

        >>> dbg.go()
        <DebugStopReason.ProcessExited: 2>

    Since there are no other breakpoints in the target, the process executes and then exits.

    All target control funciotns, e.g., ``go()``, ``step_into()``, etc, are blocking. They will not return until the
    target breaks. In the future, we will switch to an asyunchrounous communication model where these functions return
    before the operation is performed.

    For each insteance of DebuggerController, there are two BinaryViews associated with it. The first one is the
    original BinaryView that gets rebased to the proper offset according to the target&#x27;s actual base. The second is a
    "live" BinaryView that represents the entire memory space of the target process. They can be accessed by ``data``
    and ``live_view``, respectively.

    """
    def __init__(self, bv: binaryninja.BinaryView):
        # bv.handle has type binaryninja.core.BNBinaryView, which is different from dbgcore.BNBinaryView,
        # so the casting here is necessary
        # A different way to deal with is that instead of defining a BNBinaryView struct in the _debuggercore.py,
        # do from binaryninja._binaryninjacore import BNBinaryView
        bv_obj = ctypes.cast(bv.handle, ctypes.POINTER(dbgcore.BNBinaryView))
        self.handle = dbgcore.BNGetDebuggerController(bv_obj)

    def destroy(self):
        """
        Delete the DebuggerController object. Intended for internal use. Ordinary users do not need to call it.
        """
        dbgcore.BNDebuggerDestroyController(self.handle)

    @property
    def data(self) -> binaryninja.BinaryView:
        """Get the (rebased) BinaryView of the debugger"""
        result = dbgcore.BNDebuggerGetData(self.handle)
        if result is None:
            return None
        result = ctypes.cast(result, ctypes.POINTER(binaryninja.core.BNBinaryView))
        if result is None:
            return None
        return binaryninja.BinaryView(handle=result)

    @property