Module ida_idd

The interface consists of structures describing the target debugged processor and a debugging API.

Global Variables

APPCALL_DEBEV

APPCALL_DEBEV = 2

APPCALL_MANUAL

APPCALL_MANUAL = 1

APPCALL_TIMEOUT

APPCALL_TIMEOUT = 4

BBLK_TRACE

BBLK_TRACE = 8

BPT_BAD_ADDR

BPT_BAD_ADDR = 4

BPT_BAD_ALIGN

BPT_BAD_ALIGN = 3

BPT_BAD_LEN

BPT_BAD_LEN = 5

BPT_BAD_TYPE

BPT_BAD_TYPE = 2

BPT_DEFAULT

BPT_DEFAULT = 12

BPT_EXEC

BPT_EXEC = 8

BPT_INTERNAL_ERR

BPT_INTERNAL_ERR = 1

BPT_OK

BPT_OK = 0

BPT_PAGE_OK

BPT_PAGE_OK = 10

BPT_RDWR

BPT_RDWR = 3

BPT_READ

BPT_READ = 2

BPT_READ_ERROR

BPT_READ_ERROR = 7

BPT_SKIP

BPT_SKIP = 9

BPT_SOFT

BPT_SOFT = 4

BPT_TOO_MANY

BPT_TOO_MANY = 6

BPT_WRITE

BPT_WRITE = 1

BPT_WRITE_ERROR

BPT_WRITE_ERROR = 8

BREAKPOINT

BREAKPOINT = 16

DBG_FLAG_ADD_ENVS

DBG_FLAG_ADD_ENVS = 134217728

DBG_FLAG_ANYSIZE_HWBPT

DBG_FLAG_ANYSIZE_HWBPT = 4194304

DBG_FLAG_CAN_CONT_BPT

DBG_FLAG_CAN_CONT_BPT = 16

DBG_FLAG_CLEAN_EXIT

DBG_FLAG_CLEAN_EXIT = 256

DBG_FLAG_CONNSTRING

DBG_FLAG_CONNSTRING = 8192

DBG_FLAG_DEBTHREAD

DBG_FLAG_DEBTHREAD = 524288

DBG_FLAG_DEBUG_DLL

DBG_FLAG_DEBUG_DLL = 1048576

DBG_FLAG_DISABLE_ASLR

DBG_FLAG_DISABLE_ASLR = 536870912

DBG_FLAG_DONT_DISTURB

DBG_FLAG_DONT_DISTURB = 64

DBG_FLAG_EXITSHOTOK

DBG_FLAG_EXITSHOTOK = 65536

DBG_FLAG_FAKE_ATTACH

DBG_FLAG_FAKE_ATTACH = 4

DBG_FLAG_FAKE_MEMORY

DBG_FLAG_FAKE_MEMORY = 2097152

DBG_FLAG_FAST_STEP

DBG_FLAG_FAST_STEP = 67108864

DBG_FLAG_HWDATBPT_ONE

DBG_FLAG_HWDATBPT_ONE = 8

DBG_FLAG_LAZY_WATCHPTS

DBG_FLAG_LAZY_WATCHPTS = 33554432

DBG_FLAG_LOWCNDS

DBG_FLAG_LOWCNDS = 262144

DBG_FLAG_MANMEMINFO

DBG_FLAG_MANMEMINFO = 32768

DBG_FLAG_MERGE_ENVS

DBG_FLAG_MERGE_ENVS = 268435456

DBG_FLAG_NEEDPORT

DBG_FLAG_NEEDPORT = 32

DBG_FLAG_NOHOST

DBG_FLAG_NOHOST = 2

DBG_FLAG_NOPARAMETERS

DBG_FLAG_NOPARAMETERS = 2048

DBG_FLAG_NOPASSWORD

DBG_FLAG_NOPASSWORD = 4096

DBG_FLAG_NOSTARTDIR

DBG_FLAG_NOSTARTDIR = 1024

DBG_FLAG_PREFER_SWBPTS

DBG_FLAG_PREFER_SWBPTS = 16777216

DBG_FLAG_REMOTE

DBG_FLAG_REMOTE = 1

DBG_FLAG_SAFE

DBG_FLAG_SAFE = 128

DBG_FLAG_SMALLBLKS

DBG_FLAG_SMALLBLKS = 16384

DBG_FLAG_TRACER_MODULE

DBG_FLAG_TRACER_MODULE = 8388608

DBG_FLAG_USE_SREGS

DBG_FLAG_USE_SREGS = 512

DBG_FLAG_VIRTHREADS

DBG_FLAG_VIRTHREADS = 131072

DBG_HAS_APPCALL

DBG_HAS_APPCALL = 4096

DBG_HAS_ATTACH_PROCESS

DBG_HAS_ATTACH_PROCESS = 2

DBG_HAS_CHECK_BPT

DBG_HAS_CHECK_BPT = 512

DBG_HAS_DETACH_PROCESS

DBG_HAS_DETACH_PROCESS = 4

DBG_HAS_GET_PROCESSES

DBG_HAS_GET_PROCESSES = 1

DBG_HAS_MAP_ADDRESS

DBG_HAS_MAP_ADDRESS = 16384

DBG_HAS_OPEN_FILE

DBG_HAS_OPEN_FILE = 1024

DBG_HAS_REQUEST_PAUSE

DBG_HAS_REQUEST_PAUSE = 8

DBG_HAS_REXEC

DBG_HAS_REXEC = 8192

DBG_HAS_SET_EXCEPTION_INFO

DBG_HAS_SET_EXCEPTION_INFO = 16

DBG_HAS_SET_RESUME_MODE

DBG_HAS_SET_RESUME_MODE = 128

DBG_HAS_THREAD_CONTINUE

DBG_HAS_THREAD_CONTINUE = 64

DBG_HAS_THREAD_GET_SREG_BASE

DBG_HAS_THREAD_GET_SREG_BASE = 256

DBG_HAS_THREAD_SUSPEND

DBG_HAS_THREAD_SUSPEND = 32

DBG_HAS_UPDATE_CALL_STACK

DBG_HAS_UPDATE_CALL_STACK = 2048

DBG_HIDE_WINDOW

DBG_HIDE_WINDOW = 32

DBG_NO_ASLR

DBG_NO_ASLR = 128

DBG_NO_TRACE

DBG_NO_TRACE = 16

DBG_PROC_32BIT

DBG_PROC_32BIT = 4

DBG_PROC_64BIT

DBG_PROC_64BIT = 8

DBG_PROC_IS_DLL

DBG_PROC_IS_DLL = 1

DBG_PROC_IS_GUI

DBG_PROC_IS_GUI = 2

DBG_RESMOD_STEP_HANDLE

DBG_RESMOD_STEP_HANDLE = 128

DBG_RESMOD_STEP_INTO

DBG_RESMOD_STEP_INTO = 1

DBG_RESMOD_STEP_OUT

DBG_RESMOD_STEP_OUT = 4

DBG_RESMOD_STEP_OVER

DBG_RESMOD_STEP_OVER = 2

DBG_RESMOD_STEP_SRCINTO

DBG_RESMOD_STEP_SRCINTO = 8

DBG_RESMOD_STEP_SRCOUT

DBG_RESMOD_STEP_SRCOUT = 32

DBG_RESMOD_STEP_SRCOVER

DBG_RESMOD_STEP_SRCOVER = 16

DBG_RESMOD_STEP_USER

DBG_RESMOD_STEP_USER = 64

DBG_SUSPENDED

DBG_SUSPENDED = 64

DEBUGGER_ID_6811_EMULATOR

DEBUGGER_ID_6811_EMULATOR = 7

DEBUGGER_ID_ARM_IPHONE_USER

DEBUGGER_ID_ARM_IPHONE_USER = 5

DEBUGGER_ID_ARM_LINUX_USER

DEBUGGER_ID_ARM_LINUX_USER = 11

DEBUGGER_ID_ARM_MACOS_USER

DEBUGGER_ID_ARM_MACOS_USER = 17

DEBUGGER_ID_DALVIK_USER

DEBUGGER_ID_DALVIK_USER = 15

DEBUGGER_ID_GDB_USER

DEBUGGER_ID_GDB_USER = 8

DEBUGGER_ID_TRACE_REPLAYER

DEBUGGER_ID_TRACE_REPLAYER = 12

DEBUGGER_ID_WINDBG

DEBUGGER_ID_WINDBG = 9

DEBUGGER_ID_X86_DOSBOX_EMULATOR

DEBUGGER_ID_X86_DOSBOX_EMULATOR = 10

DEBUGGER_ID_X86_IA32_BOCHS

DEBUGGER_ID_X86_IA32_BOCHS = 6

DEBUGGER_ID_X86_IA32_LINUX_USER

DEBUGGER_ID_X86_IA32_LINUX_USER = 1

DEBUGGER_ID_X86_IA32_MACOSX_USER

DEBUGGER_ID_X86_IA32_MACOSX_USER = 3

DEBUGGER_ID_X86_IA32_WIN32_USER

DEBUGGER_ID_X86_IA32_WIN32_USER = 0

DEBUGGER_ID_X86_PIN_TRACER

DEBUGGER_ID_X86_PIN_TRACER = 14

DEBUGGER_ID_XNU_USER

DEBUGGER_ID_XNU_USER = 16

DEF_ADDRSIZE

DEF_ADDRSIZE = 8

DRC_CRC

DRC_CRC = 2

DRC_ERROR

DRC_ERROR = -7

DRC_EVENTS

DRC_EVENTS = 3

DRC_FAILED

DRC_FAILED = -1

DRC_IDBSEG

DRC_IDBSEG = -4

DRC_NETERR

DRC_NETERR = -2

DRC_NOCHG

DRC_NOCHG = -6

DRC_NOFILE

DRC_NOFILE = -3

DRC_NONE

DRC_NONE = 0

DRC_NOPROC

DRC_NOPROC = -5

DRC_OK

DRC_OK = 1

EXCEPTION

EXCEPTION = 64

EXC_BREAK

EXC_BREAK = 1

EXC_HANDLE

EXC_HANDLE = 2

EXC_MSG

EXC_MSG = 4

EXC_SILENT

EXC_SILENT = 8

FUNC_TRACE

FUNC_TRACE = 4

IDD_INTERFACE_VERSION

IDD_INTERFACE_VERSION = 30

INFORMATION

INFORMATION = 512

INSN_TRACE

INSN_TRACE = 2

LIB_LOADED

LIB_LOADED = 128

LIB_UNLOADED

LIB_UNLOADED = 256

NO_EVENT

NO_EVENT = 0

NO_PROCESS

NO_PROCESS = 4294967295

NO_THREAD

NO_THREAD = 0

PROCESS_ATTACHED

PROCESS_ATTACHED = 1024

PROCESS_DETACHED

PROCESS_DETACHED = 2048

PROCESS_EXITED

PROCESS_EXITED = 2

PROCESS_STARTED

PROCESS_STARTED = 1

PROCESS_SUSPENDED

PROCESS_SUSPENDED = 4096

REGISTER_ADDRESS

REGISTER_ADDRESS = 16

REGISTER_CS

REGISTER_CS = 32

REGISTER_CUSTFMT

REGISTER_CUSTFMT = 256

REGISTER_FP

REGISTER_FP = 8

REGISTER_IP

REGISTER_IP = 2

REGISTER_NOLF

REGISTER_NOLF = 128

REGISTER_READONLY

REGISTER_READONLY = 1

REGISTER_SP

REGISTER_SP = 4

REGISTER_SS

REGISTER_SS = 64

RESMOD_HANDLE

RESMOD_HANDLE = 8

RESMOD_INTO

RESMOD_INTO = 1

RESMOD_MAX

RESMOD_MAX = 9

RESMOD_NONE

RESMOD_NONE = 0

RESMOD_OUT

RESMOD_OUT = 3

RESMOD_OVER

RESMOD_OVER = 2

RESMOD_SRCINTO

RESMOD_SRCINTO = 4

RESMOD_SRCOUT

RESMOD_SRCOUT = 6

RESMOD_SRCOVER

RESMOD_SRCOVER = 5

RESMOD_USER

RESMOD_USER = 7

RQ_IDAIDLE

RQ_IDAIDLE = 128

RQ_IGNWERR

RQ_IGNWERR = 4

RQ_MASKING

RQ_MASKING = 1

RQ_NOSUSP

RQ_NOSUSP = 0

RQ_PROCEXIT

RQ_PROCEXIT = 64

RQ_RESMOD

RQ_RESMOD = 61440

RQ_RESMOD_SHIFT

RQ_RESMOD_SHIFT = 12

RQ_RESUME

RQ_RESUME = 512

RQ_SILENT

RQ_SILENT = 8

RQ_SUSPEND

RQ_SUSPEND = 2

RQ_SUSPRUN

RQ_SUSPRUN = 256

RQ_SWSCREEN

RQ_SWSCREEN = 16

RQ_VERBOSE

RQ_VERBOSE = 0

RQ__NOTHRRF

RQ__NOTHRRF = 32

RVT_FLOAT

RVT_FLOAT = -1

RVT_INT

RVT_INT = -2

RVT_UNAVAILABLE

RVT_UNAVAILABLE = -3

STEP

STEP = 32

STEP_TRACE

STEP_TRACE = 1

THREAD_EXITED

THREAD_EXITED = 8

THREAD_STARTED

THREAD_STARTED = 4

TRACE_FULL

TRACE_FULL = 8192

Functions

appcall(func_ea: ea_t, tid: thid_t, _type_or_none: bytevec_t const &, _fields: bytevec_t const &, arg_list: PyObject *) ‑> PyObject *

appcall(func_ea, tid, _type_or_none, _fields, arg_list) -> PyObject *

func_ea: ea_t
tid: thid_t
_type_or_none: bytevec_t const &
_fields: bytevec_t const &
arg_list: PyObject *

can_exc_continue(ev: debug_event_t) ‑> bool

can_exc_continue(ev) -> bool

ev: debug_event_t const *

cleanup_appcall(tid: thid_t) ‑> error_t

cleanup_appcall(tid) -> error_t Cleanup after manual appcall.

tid: (C++: thid_t) thread to use. NO_THREAD means to use the current thread The
           application state is restored as it was before calling the last
           appcall(). Nested appcalls are supported.
return: eOk if successful, otherwise an error code

cpu2ieee(ieee_out: fpvalue_t *, cpu_fpval: void const *, size: int) ‑> int

cpu2ieee(ieee_out, cpu_fpval, size) -> int Convert a floating point number in CPU native format to IDA's internal format.

ieee_out: (C++: fpvalue_t *) output buffer
cpu_fpval: (C++: const void *) floating point number in CPU native format
size: (C++: int) size of cpu_fpval in bytes (size of the input buffer)
return: Floating point/IEEE Conversion codes

dbg_appcall(retval: idc_value_t *, func_ea: ea_t, tid: thid_t, ptif: tinfo_t, argv: idc_value_t *, argnum: size_t) ‑> error_t

dbg_appcall(retval, func_ea, tid, ptif, argv, argnum) -> error_t Call a function from the debugged application.

retval: (C++: idc_value_t *) function return value
  • for APPCALL_MANUAL, r will hold the new stack point value

  • for APPCALL_DEBEV, r will hold the exception information upon failure and the return code will be eExecThrow func_ea: (C++: ea_t) address to call tid: (C++: thid_t) thread to use. NO_THREAD means to use the current thread ptif: (C++: const tinfo_t *) pointer to type of the function to call argv: (C++: idc_value_t *) array of arguments argnum: (C++: size_t) number of actual arguments return: eOk if successful, otherwise an error code

dbg_get_memory_info() ‑> PyObject *

dbg_get_memory_info() -> PyObject * This function returns the memory configuration of a debugged process.

return:     None if no debugger is active
   tuple(start_ea, end_ea, name, sclass, sbase, bitness, perm)

dbg_get_name() ‑> PyObject *

dbg_get_name() -> PyObject * This function returns the current debugger's name.

return: Debugger name or None if no debugger is active

dbg_get_registers() ‑> PyObject *

dbg_get_registers() -> PyObject * This function returns the register definition from the currently loaded debugger. Basically, it returns an array of structure similar to to idd.hpp / register_info_t

return:     None if no debugger is loaded
   tuple(name, flags, class, dtype, bit_strings, default_bit_strings_mask)
   The bit_strings can be a tuple of strings or None (if the register does not have bit_strings)

dbg_get_thread_sreg_base(tid: thid_t, sreg_value: int) ‑> PyObject *

dbg_get_thread_sreg_base(tid, sreg_value) -> PyObject * Returns the segment register base value

tid: thread id
sreg_value: segment register (selector) value
return:     - The base as an 'ea'
   - Or None on failure

dbg_read_memory(ea: ea_t, sz: size_t) ‑> PyObject *

dbg_read_memory(ea, sz) -> PyObject * Reads from the debugee's memory at the specified ea

ea: ea_t
sz: size_t
return:     - The read buffer (as bytes)
   - Or None on failure

dbg_write_memory(ea: ea_t, buf: bytevec_t const &) ‑> PyObject *

dbg_write_memory(ea, buf) -> bool Writes a buffer to the debugee's memory

ea: ea_t
buf: bytevec_t const &
return: Boolean

get_dbg() ‑> debugger_t *

get_dbg() -> debugger_t

get_event_bpt_hea(ev: debug_event_t) ‑> ea_t

get_event_bpt_hea(ev) -> ea_t

ev: debug_event_t const *

get_event_exc_code(ev: debug_event_t) ‑> uint

get_event_exc_code(ev) -> uint

ev: debug_event_t const *

get_event_exc_ea(ev: debug_event_t) ‑> ea_t

get_event_exc_ea(ev) -> ea_t

ev: debug_event_t const *

get_event_exc_info(ev: debug_event_t) ‑> size_t

get_event_exc_info(ev) -> str

ev: debug_event_t const *

get_event_info(ev: debug_event_t) ‑> size_t

get_event_info(ev) -> str

ev: debug_event_t const *

get_event_module_base(ev: debug_event_t) ‑> ea_t

get_event_module_base(ev) -> ea_t

ev: debug_event_t const *

get_event_module_name(ev: debug_event_t) ‑> size_t

get_event_module_name(ev) -> str

ev: debug_event_t const *

get_event_module_size(ev: debug_event_t) ‑> asize_t

get_event_module_size(ev) -> asize_t

ev: debug_event_t const *

ieee2cpu(cpu_fpval_out: void *, ieee: fpvalue_t const &, size: int) ‑> int

ieee2cpu(cpu_fpval_out, ieee, size) -> int Convert a floating point number in IDA's internal format to CPU native format.

cpu_fpval_out: (C++: void *) output buffer
ieee: (C++: const fpvalue_t &) floating point number of IDA's internal format
size: (C++: int) size of cpu_fpval in bytes (size of the output buffer)
return: Floating point/IEEE Conversion codes

set_debug_event_code(ev: debug_event_t, id: event_id_t) ‑> void

set_debug_event_code(ev, id)

ev: debug_event_t *
id: enum event_id_t

Classes

Appcall__()

:

Class variables

  • APPCALL_DEBEV


  • APPCALL_MANUAL


  • APPCALL_TIMEOUT


Static methods

  • UTF16(s)


  • array(type_name) Defines an array type. Later you need to pack() / unpack()


  • buffer(str=None, size=0, fill='\x00') Creates a string buffer. The returned value (r) will be a byref object. Use r.value to get the contents and r.size to get the buffer's size


  • byref(val) Method to create references to immutable objects Currently we support references to int/strings Objects need not be passed by reference (this will be done automatically)


  • cleanup_appcall(tid=0) Equivalent to IDC's CleanupAppcall()


  • cstr(val)


  • get_appcall_options() Return the global Appcall options


  • int64(v) Whenever a 64bit number is needed use this method to construct an object


  • obj(**kwds) Returns an empty object or objects with attributes as passed via its keywords arguments


  • proto(name_or_ea, proto_or_tinfo, flags=None) Allows you to instantiate an appcall (callable object) with the desired prototype name_or_ea: The name of the function (will be resolved with LocByName()) proto_or_tinfo: function prototype as a string or type of the function as tinfo_t object return: - On failure it raises an exception if the prototype could not be parsed or the address is not resolvable - Returns a callbable Appcall instance with the given prototypes and flags


  • set_appcall_options(opt) Method to change the Appcall options globally (not per Appcall)


  • typedobj(typedecl_or_tinfo, ea=None) Returns an appcall object for a type (can be given as tinfo_t object or as a string declaration) One can then use retrieve() member method ea: Optional parameter that later can be used to retrieve the type return: Appcall object or raises ValueError exception


  • unicode(s)


  • valueof(name, default=0) Returns the numeric value of a given name string. If the name could not be resolved then the default value will be returned


Instance variables

  • Consts


Appcall_array__(tp)

: This class is used with Appcall.array() method

Methods

  • pack(self, L) Packs a list or tuple into a byref buffer


  • try_to_convert_to_list(self, obj) Is this object a list? We check for the existance of attribute zero and attribute self.size-1


  • unpack(self, buf, as_list=True) Unpacks an array back into a list or an object


Appcall_callable__(ea, tinfo_or_typestr=None, fields=None)

: Helper class to issue appcalls using a natural syntax: appcall.FunctionNameInTheDatabase(arguments, ....) or appcall["Function@8"](arguments, ...) or f8 = appcall["Function@8"] f8(arg1, arg2, ...) or o = appcall.obj() i = byref(5) appcall.funcname(arg1, i, "hello", o)

Initializes an appcall with a given function ea

Instance variables

  • ea


  • fields


  • options


  • size


  • tif


  • timeout


  • type


Methods

  • retrieve(self, src=None, flags=0) Unpacks a typed object from the database if an ea is given or from a string if a string was passed src: the address of the object or a string return: Returns a tuple of boolean and object or error number (Bool, Error | Object).


  • store(self, obj, dest_ea=None, base_ea=0, flags=0) Packs an object into a given ea if provided or into a string if no address was passed. obj: The object to pack dest_ea: If packing to idb this will be the store location base_ea: If packing to a buffer, this will be the base that will be used to relocate the pointers

    return: - If packing to a string then a Tuple(Boolean, packed_string or error code) - If packing to the database then a return code is returned (0 is success)


Appcall_consts__(default=None)

: Helper class used by Appcall.Consts attribute It is used to retrieve constants via attribute access

bptaddr_t()

: Proxy of C++ bptaddr_t class.

__init__(self) -> bptaddr_t

Instance variables

  • hea: ea_t hea


  • kea: ea_t kea


call_stack_info_t()

: Proxy of C++ call_stack_info_t class.

__init__(self) -> call_stack_info_t

Instance variables

  • callea: ea_t callea


  • fp: ea_t fp


  • funcea: ea_t funcea


  • funcok: bool funcok


call_stack_info_vec_t(*args)

: Proxy of C++ qvector< call_stack_info_t > class.

__init__(self) -> call_stack_info_vec_t
__init__(self, x) -> call_stack_info_vec_t

 x: qvector< call_stack_info_t > const &

Descendants

* ida_idd.call_stack_t

Methods

  • add_unique(self, x: call_stack_info_t) ‑> bool add_unique(self, x) -> bool

    x: call_stack_info_t const &


  • at(self, _idx: size_t) ‑> call_stack_info_t const & at(self, _idx) -> call_stack_info_t

    _idx: size_t


  • back(self)


  • begin(self, *args) ‑> qvector< call_stack_info_t >::const_iterator begin(self) -> call_stack_info_t


  • capacity(self) ‑> size_t capacity(self) -> size_t


  • clear(self) ‑> void clear(self)


  • empty(self) ‑> bool empty(self) -> bool


  • end(self, *args) ‑> qvector< call_stack_info_t >::const_iterator end(self) -> call_stack_info_t


  • erase(self, *args) ‑> qvector< call_stack_info_t >::iterator erase(self, it) -> call_stack_info_t

    it: qvector< call_stack_info_t >::iterator

    erase(self, first, last) -> call_stack_info_t

    first: qvector< call_stack_info_t >::iterator last: qvector< call_stack_info_t >::iterator


  • extract(self) ‑> call_stack_info_t * extract(self) -> call_stack_info_t


  • find(self, *args) ‑> qvector< call_stack_info_t >::const_iterator find(self, x) -> call_stack_info_t

    x: call_stack_info_t const &


  • front(self)


  • grow(self, *args) ‑> void grow(self, x=call_stack_info_t())

    x: call_stack_info_t const &


  • has(self, x: call_stack_info_t) ‑> bool has(self, x) -> bool

    x: call_stack_info_t const &


  • inject(self, s: call_stack_info_t, len: size_t) ‑> void inject(self, s, len)

    s: call_stack_info_t * len: size_t


  • insert(self, it: call_stack_info_t, x: call_stack_info_t) ‑> qvector< call_stack_info_t >::iterator insert(self, it, x) -> call_stack_info_t

    it: qvector< call_stack_info_t >::iterator x: call_stack_info_t const &


  • pop_back(self) ‑> void pop_back(self)


  • push_back(self, *args) ‑> call_stack_info_t & push_back(self, x)

    x: call_stack_info_t const &

    push_back(self) -> call_stack_info_t


  • qclear(self) ‑> void qclear(self)


  • reserve(self, cnt: size_t) ‑> void reserve(self, cnt)

    cnt: size_t


  • resize(self, *args) ‑> void resize(self, _newsize, x)

    _newsize: size_t x: call_stack_info_t const &

    resize(self, _newsize)

    _newsize: size_t


  • size(self) ‑> size_t size(self) -> size_t


  • swap(self, r: call_stack_info_vec_t) ‑> void swap(self, r)

    r: qvector< call_stack_info_t > &


  • truncate(self) ‑> void truncate(self)


call_stack_t()

: Proxy of C++ call_stack_t class.

__init__(self) -> call_stack_t

Ancestors (in MRO)

* ida_idd.call_stack_info_vec_t

debapp_attrs_t()

: Proxy of C++ debapp_attrs_t class.

__init__(self) -> debapp_attrs_t

Instance variables

  • addrsize: int addrsize


  • cbsize: int32 cbsize


  • is_be: int is_be


  • platform: qstring platform


debug_event_t(*args)

: Proxy of C++ debug_event_t class.

__init__(self) -> debug_event_t
__init__(self, r) -> debug_event_t

 r: debug_event_t const &

Instance variables

  • ea: ea_t ea


  • handled: bool handled


  • pid: pid_t pid


  • tid: thid_t tid


Methods

  • bpt(self, *args) ‑> bptaddr_t const & bpt(self) -> bptaddr_t


  • bpt_ea(self) ‑> ea_t bpt_ea(self) -> ea_t On some systems with special memory mappings the triggered ea might be different from the actual ea. Calculate the address to use.


  • clear(self) ‑> void clear(self) clear the dependent information (see below), set event code to NO_EVENT


  • clear_all(self) ‑> void clear_all(self)


  • copy(self, r: debug_event_t) ‑> debug_event_t & copy(self, r) -> debug_event_t

    r: debug_event_t const &


  • eid(self) ‑> event_id_t eid(self) -> event_id_t Event code.


  • exc(self, *args) ‑> excinfo_t const & exc(self) -> excinfo_t


  • exit_code(self) ‑> int const & exit_code(self) -> int const &


  • info(self, *args) ‑> qstring const & info(self) -> qstring info(self) -> qstring const &


  • modinfo(self, *args) ‑> modinfo_t const & modinfo(self) -> modinfo_t


  • set_bpt(self) ‑> bptaddr_t & set_bpt(self) -> bptaddr_t


  • set_eid(self, id: event_id_t) ‑> void set_eid(self, id) Set event code. If the new event code is compatible with the old one then the dependent information (see below) will be preserved. Otherwise the event will be cleared and the new event code will be set.

    id: (C++: event_id_t) enum event_id_t


  • set_exception(self) ‑> excinfo_t & set_exception(self) -> excinfo_t


  • set_exit_code(self, id: event_id_t, code: int) ‑> void set_exit_code(self, id, code)

    id: enum event_id_t code: int


  • set_info(self, id: event_id_t) ‑> qstring & set_info(self, id) -> qstring &

    id: enum event_id_t


  • set_modinfo(self, id: event_id_t) ‑> modinfo_t & set_modinfo(self, id) -> modinfo_t

    id: enum event_id_t


debugger_t()

: Proxy of C++ debugger_t class.

__init__(self) -> debugger_t

Class variables

  • ev_appcall


  • ev_attach_process


  • ev_bin_search


  • ev_check_bpt


  • ev_cleanup_appcall


  • ev_close_file


  • ev_dbg_enable_trace


  • ev_detach_process


  • ev_eval_lowcnd


  • ev_exit_process


  • ev_get_debapp_attrs


  • ev_get_debmod_extensions


  • ev_get_debug_event


  • ev_get_memory_info


  • ev_get_processes


  • ev_get_srcinfo_path


  • ev_init_debugger


  • ev_is_tracing_enabled


  • ev_map_address


  • ev_open_file


  • ev_read_file


  • ev_read_memory


  • ev_read_registers


  • ev_rebase_if_required_to


  • ev_request_pause


  • ev_resume


  • ev_rexec


  • ev_send_ioctl


  • ev_set_exception_info


  • ev_set_resume_mode


  • ev_start_process


  • ev_suspended


  • ev_term_debugger


  • ev_thread_continue


  • ev_thread_get_sreg_base


  • ev_thread_suspend


  • ev_update_bpts


  • ev_update_call_stack


  • ev_update_lowcnds


  • ev_write_file


  • ev_write_memory


  • ev_write_register


Instance variables

  • bpt_bytes: bytevec_t __get_bpt_bytes(self) -> bytevec_t


  • bpt_size: uchar bpt_size


  • default_regclasses: int default_regclasses


  • filetype: uchar filetype


  • flags: uint32 flags


  • flags2: uint32 flags2


  • id: int id


  • memory_page_size: int memory_page_size


  • name: char const * name


  • nregisters: int __get_nregisters(self) -> int


  • processor: char const * processor


  • regclasses: PyObject * __get_regclasses(self) -> PyObject *


  • registers: dynamic_wrapped_array_t< register_info_t > __get_registers(self) -> dyn_register_info_array


  • resume_modes: ushort resume_modes


  • version: int version


Methods

  • attach_process(self, pid: pid_t, event_id: int, dbg_proc_flags: uint32) ‑> drc_t attach_process(self, pid, event_id, dbg_proc_flags) -> drc_t

    pid: pid_t event_id: int dbg_proc_flags: uint32


  • bin_search(self, start_ea: ea_t, end_ea: ea_t, data: compiled_binpat_vec_t const &, srch_flags: int) ‑> drc_t bin_search(self, start_ea, end_ea, data, srch_flags) -> drc_t

    start_ea: ea_t end_ea: ea_t data: compiled_binpat_vec_t const & srch_flags: int


  • cache_block_size(self) ‑> size_t cache_block_size(self) -> size_t


  • can_continue_from_bpt(self) ‑> bool can_continue_from_bpt(self) -> bool


  • can_debug_standalone_dlls(self) ‑> bool can_debug_standalone_dlls(self) -> bool


  • check_bpt(self, bptvc: int *, type: bpttype_t, ea: ea_t, len: int) ‑> drc_t check_bpt(self, bptvc, type, ea, len) -> drc_t

    bptvc: int * type: bpttype_t ea: ea_t len: int


  • cleanup_appcall(self, tid: thid_t) ‑> drc_t cleanup_appcall(self, tid) -> drc_t

    tid: thid_t


  • close_file(self, fn: int) ‑> void close_file(self, fn)

    fn: int


  • dbg_enable_trace(self, tid: thid_t, enable: bool, trace_flags: int) ‑> bool dbg_enable_trace(self, tid, enable, trace_flags) -> bool

    tid: thid_t enable: bool trace_flags: int


  • detach_process(self) ‑> drc_t detach_process(self) -> drc_t


  • eval_lowcnd(self, tid: thid_t, ea: ea_t) ‑> drc_t eval_lowcnd(self, tid, ea) -> drc_t

    tid: thid_t ea: ea_t


  • exit_process(self) ‑> drc_t exit_process(self) -> drc_t


  • fake_memory(self) ‑> bool fake_memory(self) -> bool


  • get_debapp_attrs(self, out_pattrs: debapp_attrs_t) ‑> bool get_debapp_attrs(self, out_pattrs) -> bool

    out_pattrs: debapp_attrs_t *


  • get_debmod_extensions(self) ‑> void const * get_debmod_extensions(self) -> void const *


  • get_debug_event(self, event: debug_event_t, timeout_ms: int) ‑> gdecode_t get_debug_event(self, event, timeout_ms) -> gdecode_t

    event: debug_event_t * timeout_ms: int


  • get_memory_info(self, ranges: meminfo_vec_t) ‑> drc_t get_memory_info(self, ranges) -> drc_t

    ranges: meminfo_vec_t &


  • get_processes(self, procs: procinfo_vec_t) ‑> drc_t get_processes(self, procs) -> drc_t

    procs: procinfo_vec_t *


  • get_srcinfo_path(self, path: qstring *, base: ea_t) ‑> bool get_srcinfo_path(self, path, base) -> bool

    path: qstring * base: ea_t


  • has_appcall(self) ‑> bool has_appcall(self) -> bool


  • has_attach_process(self) ‑> bool has_attach_process(self) -> bool


  • has_check_bpt(self) ‑> bool has_check_bpt(self) -> bool


  • has_detach_process(self) ‑> bool has_detach_process(self) -> bool


  • has_get_processes(self) ‑> bool has_get_processes(self) -> bool


  • has_map_address(self) ‑> bool has_map_address(self) -> bool


  • has_open_file(self) ‑> bool has_open_file(self) -> bool


  • has_request_pause(self) ‑> bool has_request_pause(self) -> bool


  • has_rexec(self) ‑> bool has_rexec(self) -> bool


  • has_set_exception_info(self) ‑> bool has_set_exception_info(self) -> bool


  • has_set_resume_mode(self) ‑> bool has_set_resume_mode(self) -> bool


  • has_soft_bpt(self) ‑> bool has_soft_bpt(self) -> bool


  • has_thread_continue(self) ‑> bool has_thread_continue(self) -> bool


  • has_thread_get_sreg_base(self) ‑> bool has_thread_get_sreg_base(self) -> bool


  • has_thread_suspend(self) ‑> bool has_thread_suspend(self) -> bool


  • has_update_call_stack(self) ‑> bool has_update_call_stack(self) -> bool


  • init_debugger(self, hostname: char const *, portnum: int, password: char const *) ‑> bool init_debugger(self, hostname, portnum, password) -> bool

    hostname: char const * portnum: int password: char const *


  • is_remote(self) ‑> bool is_remote(self) -> bool


  • is_resmod_avail(self, resmod: int) ‑> bool is_resmod_avail(self, resmod) -> bool

    resmod: int


  • is_safe(self) ‑> bool is_safe(self) -> bool


  • is_tracing_enabled(self, tid: thid_t, tracebit: int) ‑> bool is_tracing_enabled(self, tid, tracebit) -> bool

    tid: thid_t tracebit: int


  • map_address(self, off: ea_t, regs: regval_t, regnum: int) ‑> ea_t map_address(self, off, regs, regnum) -> ea_t

    off: ea_t regs: regval_t const * regnum: int


  • may_disturb(self) ‑> bool may_disturb(self) -> bool


  • may_take_exit_snapshot(self) ‑> bool may_take_exit_snapshot(self) -> bool


  • must_have_hostname(self) ‑> bool must_have_hostname(self) -> bool


  • open_file(self, file: char const *, fsize: uint64 *, readonly: bool) ‑> int open_file(self, file, fsize, readonly) -> int

    file: char const * fsize: uint64 * readonly: bool


  • read_file(self, fn: int, off: qoff64_t, buf: void *, size: size_t) ‑> ssize_t read_file(self, fn, off, buf, size) -> ssize_t

    fn: int off: qoff64_t buf: void * size: size_t


  • read_memory(self, nbytes: size_t *, ea: ea_t, buffer: void *, size: size_t) ‑> drc_t read_memory(self, nbytes, ea, buffer, size) -> drc_t

    nbytes: size_t * ea: ea_t buffer: void * size: size_t


  • read_registers(self, tid: thid_t, clsmask: int, values: regval_t) ‑> drc_t read_registers(self, tid, clsmask, values) -> drc_t

    tid: thid_t clsmask: int values: regval_t *


  • rebase_if_required_to(self, new_base: ea_t) ‑> void rebase_if_required_to(self, new_base)

    new_base: ea_t


  • regs(self, idx: int) ‑> register_info_t & regs(self, idx) -> register_info_t

    idx: int


  • request_pause(self) ‑> drc_t request_pause(self) -> drc_t


  • resume(self, event: debug_event_t) ‑> drc_t resume(self, event) -> drc_t

    event: debug_event_t const *


  • rexec(self, cmdline: char const *) ‑> int rexec(self, cmdline) -> int

    cmdline: char const *


  • send_ioctl(self, fn: int, buf: void const *, poutbuf: void **, poutsize: ssize_t *) ‑> drc_t send_ioctl(self, fn, buf, poutbuf, poutsize) -> drc_t

    fn: int buf: void const * poutbuf: void ** poutsize: ssize_t *


  • set_exception_info(self, info: exception_info_t, qty: int) ‑> void set_exception_info(self, info, qty)

    info: exception_info_t const * qty: int


  • set_resume_mode(self, tid: thid_t, resmod: resume_mode_t) ‑> drc_t set_resume_mode(self, tid, resmod) -> drc_t

    tid: thid_t resmod: enum resume_mode_t


  • start_process(self, path: char const *, args: char const *, envs: launch_env_t, startdir: char const *, dbg_proc_flags: uint32, input_path: char const *, input_file_crc32: uint32) ‑> drc_t start_process(self, path, args, envs, startdir, dbg_proc_flags, input_path, input_file_crc32) -> drc_t

    path: char const * args: char const * envs: launch_env_t * startdir: char const * dbg_proc_flags: uint32 input_path: char const * input_file_crc32: uint32


  • supports_debthread(self) ‑> bool supports_debthread(self) -> bool


  • supports_lowcnds(self) ‑> bool supports_lowcnds(self) -> bool


  • suspended(self, dlls_added: bool, thr_names: thread_name_vec_t * = None) ‑> void suspended(self, dlls_added, thr_names=None)

    dlls_added: bool thr_names: thread_name_vec_t *


  • term_debugger(self) ‑> bool term_debugger(self) -> bool


  • thread_continue(self, tid: thid_t) ‑> drc_t thread_continue(self, tid) -> drc_t

    tid: thid_t


  • thread_get_sreg_base(self, answer: ea_t *, tid: thid_t, sreg_value: int) ‑> drc_t thread_get_sreg_base(self, answer, tid, sreg_value) -> drc_t

    answer: ea_t * tid: thid_t sreg_value: int


  • thread_suspend(self, tid: thid_t) ‑> drc_t thread_suspend(self, tid) -> drc_t

    tid: thid_t


  • update_bpts(self, nbpts: int *, bpts: update_bpt_info_t *, nadd: int, ndel: int) ‑> drc_t update_bpts(self, nbpts, bpts, nadd, ndel) -> drc_t

    nbpts: int * bpts: update_bpt_info_t * nadd: int ndel: int


  • update_call_stack(self, tid: thid_t, trace: call_stack_t) ‑> drc_t update_call_stack(self, tid, trace) -> drc_t

    tid: thid_t trace: call_stack_t *


  • update_lowcnds(self, nupdated: int *, lowcnds: lowcnd_t const *, nlowcnds: int) ‑> drc_t update_lowcnds(self, nupdated, lowcnds, nlowcnds) -> drc_t

    nupdated: int * lowcnds: lowcnd_t const * nlowcnds: int


  • use_memregs(self) ‑> bool use_memregs(self) -> bool


  • use_sregs(self) ‑> bool use_sregs(self) -> bool


  • virtual_threads(self) ‑> bool virtual_threads(self) -> bool


  • write_file(self, fn: int, off: qoff64_t, buf: void const *) ‑> ssize_t write_file(self, fn, off, buf) -> ssize_t

    fn: int off: qoff64_t buf: void const *


  • write_memory(self, nbytes: size_t *, ea: ea_t, buffer: void const *, size: size_t) ‑> drc_t write_memory(self, nbytes, ea, buffer, size) -> drc_t

    nbytes: size_t * ea: ea_t buffer: void const * size: size_t


  • write_register(self, tid: thid_t, regidx: int, value: regval_t) ‑> drc_t write_register(self, tid, regidx, value) -> drc_t

    tid: thid_t regidx: int value: regval_t const *


dyn_register_info_array(_data: register_info_t, _count: size_t)

: Proxy of C++ dynamic_wrapped_array_t< register_info_t > class.

__init__(self, _data, _count) -> dyn_register_info_array

 _data: register_info_t *
 _count: size_t

Instance variables

  • count: size_t count


  • data: register_info_t * data


exception_info_t(*args)

: Proxy of C++ exception_info_t class.

__init__(self) -> exception_info_t
__init__(self, _code, _flags, _name, _desc) -> exception_info_t

 _code: uint
 _flags: uint32
 _name: char const *
 _desc: char const *

Instance variables

  • code: uint code


  • desc: qstring desc


  • flags: uint32 flags


  • name: qstring name


Methods

  • break_on(self) ‑> bool break_on(self) -> bool Should we break on the exception?


  • handle(self) ‑> bool handle(self) -> bool Should we handle the exception?


excinfo_t()

: Proxy of C++ excinfo_t class.

__init__(self) -> excinfo_t

Instance variables

  • can_cont: bool can_cont


  • code: uint32 code


  • ea: ea_t ea


  • info: qstring info


excvec_t(*args)

: Proxy of C++ qvector< exception_info_t > class.

__init__(self) -> excvec_t
__init__(self, x) -> excvec_t

 x: qvector< exception_info_t > const &

Methods

  • at(self, _idx: size_t) ‑> exception_info_t const & at(self, _idx) -> exception_info_t

    _idx: size_t


  • back(self)


  • begin(self, *args) ‑> qvector< exception_info_t >::const_iterator begin(self) -> exception_info_t


  • capacity(self) ‑> size_t capacity(self) -> size_t


  • clear(self) ‑> void clear(self)


  • empty(self) ‑> bool empty(self) -> bool


  • end(self, *args) ‑> qvector< exception_info_t >::const_iterator end(self) -> exception_info_t


  • erase(self, *args) ‑> qvector< exception_info_t >::iterator erase(self, it) -> exception_info_t

    it: qvector< exception_info_t >::iterator

    erase(self, first, last) -> exception_info_t

    first: qvector< exception_info_t >::iterator last: qvector< exception_info_t >::iterator


  • extract(self) ‑> exception_info_t * extract(self) -> exception_info_t


  • front(self)


  • grow(self, *args) ‑> void grow(self, x=exception_info_t())

    x: exception_info_t const &


  • inject(self, s: exception_info_t, len: size_t) ‑> void inject(self, s, len)

    s: exception_info_t * len: size_t


  • insert(self, it: exception_info_t, x: exception_info_t) ‑> qvector< exception_info_t >::iterator insert(self, it, x) -> exception_info_t

    it: qvector< exception_info_t >::iterator x: exception_info_t const &


  • pop_back(self) ‑> void pop_back(self)


  • push_back(self, *args) ‑> exception_info_t & push_back(self, x)

    x: exception_info_t const &

    push_back(self) -> exception_info_t


  • qclear(self) ‑> void qclear(self)


  • reserve(self, cnt: size_t) ‑> void reserve(self, cnt)

    cnt: size_t


  • resize(self, *args) ‑> void resize(self, _newsize, x)

    _newsize: size_t x: exception_info_t const &

    resize(self, _newsize)

    _newsize: size_t


  • size(self) ‑> size_t size(self) -> size_t


  • swap(self, r: excvec_t) ‑> void swap(self, r)

    r: qvector< exception_info_t > &


  • truncate(self) ‑> void truncate(self)


launch_env_t()

: Proxy of C++ launch_env_t class.

__init__(self) -> launch_env_t

Instance variables

  • merge: bool merge


meminfo_vec_t()

: Proxy of C++ meminfo_vec_t class.

__init__(self) -> meminfo_vec_t

Ancestors (in MRO)

* ida_idd.meminfo_vec_template_t

meminfo_vec_template_t(*args)

: Proxy of C++ qvector< memory_info_t > class.

__init__(self) -> meminfo_vec_template_t
__init__(self, x) -> meminfo_vec_template_t

 x: qvector< memory_info_t > const &

Descendants

* ida_idd.meminfo_vec_t

Methods

  • add_unique(self, x: memory_info_t) ‑> bool add_unique(self, x) -> bool

    x: memory_info_t const &


  • at(self, _idx: size_t) ‑> memory_info_t const & at(self, _idx) -> memory_info_t

    _idx: size_t


  • back(self)


  • begin(self, *args) ‑> qvector< memory_info_t >::const_iterator begin(self) -> memory_info_t


  • capacity(self) ‑> size_t capacity(self) -> size_t


  • clear(self) ‑> void clear(self)


  • empty(self) ‑> bool empty(self) -> bool


  • end(self, *args) ‑> qvector< memory_info_t >::const_iterator end(self) -> memory_info_t


  • erase(self, *args) ‑> qvector< memory_info_t >::iterator erase(self, it) -> memory_info_t

    it: qvector< memory_info_t >::iterator

    erase(self, first, last) -> memory_info_t

    first: qvector< memory_info_t >::iterator last: qvector< memory_info_t >::iterator


  • extract(self) ‑> memory_info_t * extract(self) -> memory_info_t


  • find(self, *args) ‑> qvector< memory_info_t >::const_iterator find(self, x) -> memory_info_t

    x: memory_info_t const &


  • front(self)


  • grow(self, *args) ‑> void grow(self, x=memory_info_t())

    x: memory_info_t const &


  • has(self, x: memory_info_t) ‑> bool has(self, x) -> bool

    x: memory_info_t const &


  • inject(self, s: memory_info_t, len: size_t) ‑> void inject(self, s, len)

    s: memory_info_t * len: size_t


  • insert(self, it: memory_info_t, x: memory_info_t) ‑> qvector< memory_info_t >::iterator insert(self, it, x) -> memory_info_t

    it: qvector< memory_info_t >::iterator x: memory_info_t const &


  • pop_back(self) ‑> void pop_back(self)


  • push_back(self, *args) ‑> memory_info_t & push_back(self, x)

    x: memory_info_t const &

    push_back(self) -> memory_info_t


  • qclear(self) ‑> void qclear(self)


  • reserve(self, cnt: size_t) ‑> void reserve(self, cnt)

    cnt: size_t


  • resize(self, *args) ‑> void resize(self, _newsize, x)

    _newsize: size_t x: memory_info_t const &

    resize(self, _newsize)

    _newsize: size_t


  • size(self) ‑> size_t size(self) -> size_t


  • swap(self, r: meminfo_vec_template_t) ‑> void swap(self, r)

    r: qvector< memory_info_t > &


  • truncate(self) ‑> void truncate(self)


memory_info_t()

: Proxy of C++ memory_info_t class.

__init__(self) -> memory_info_t

Ancestors (in