Module ida_idd
The interface consists of structures describing the target debugged processor and a debugging API.
Global Variables
APPCALL_DEBEV
APPCALL_MANUAL
APPCALL_TIMEOUT
BBLK_TRACE
BPT_BAD_ADDR
BPT_BAD_ALIGN
BPT_BAD_LEN
BPT_BAD_TYPE
BPT_DEFAULT
BPT_EXEC
BPT_INTERNAL_ERR
BPT_OK
BPT_PAGE_OK
BPT_RDWR
BPT_READ
BPT_READ_ERROR
BPT_SKIP
BPT_SOFT
BPT_TOO_MANY
BPT_WRITE
BPT_WRITE_ERROR
BREAKPOINT
DBG_FLAG_ADD_ENVS
DBG_FLAG_ANYSIZE_HWBPT
DBG_FLAG_CAN_CONT_BPT
DBG_FLAG_CLEAN_EXIT
DBG_FLAG_CONNSTRING
DBG_FLAG_DEBTHREAD
DBG_FLAG_DEBUG_DLL
DBG_FLAG_DISABLE_ASLR
DBG_FLAG_DONT_DISTURB
DBG_FLAG_EXITSHOTOK
DBG_FLAG_FAKE_ATTACH
DBG_FLAG_FAKE_MEMORY
DBG_FLAG_FAST_STEP
DBG_FLAG_HWDATBPT_ONE
DBG_FLAG_LAZY_WATCHPTS
DBG_FLAG_LOWCNDS
DBG_FLAG_MANMEMINFO
DBG_FLAG_MERGE_ENVS
DBG_FLAG_NEEDPORT
DBG_FLAG_NOHOST
DBG_FLAG_NOPARAMETERS
DBG_FLAG_NOPASSWORD
DBG_FLAG_NOSTARTDIR
DBG_FLAG_PREFER_SWBPTS
DBG_FLAG_REMOTE
DBG_FLAG_SAFE
DBG_FLAG_SMALLBLKS
DBG_FLAG_TRACER_MODULE
DBG_FLAG_USE_SREGS
DBG_FLAG_VIRTHREADS
DBG_HAS_APPCALL
DBG_HAS_ATTACH_PROCESS
DBG_HAS_CHECK_BPT
DBG_HAS_DETACH_PROCESS
DBG_HAS_GET_PROCESSES
DBG_HAS_MAP_ADDRESS
DBG_HAS_OPEN_FILE
DBG_HAS_REQUEST_PAUSE
DBG_HAS_REXEC
DBG_HAS_SET_EXCEPTION_INFO
DBG_HAS_SET_RESUME_MODE
DBG_HAS_THREAD_CONTINUE
DBG_HAS_THREAD_GET_SREG_BASE
DBG_HAS_THREAD_SUSPEND
DBG_HAS_UPDATE_CALL_STACK
DBG_HIDE_WINDOW
DBG_NO_ASLR
DBG_NO_TRACE
DBG_PROC_32BIT
DBG_PROC_64BIT
DBG_PROC_IS_DLL
DBG_PROC_IS_GUI
DBG_RESMOD_STEP_HANDLE
DBG_RESMOD_STEP_INTO
DBG_RESMOD_STEP_OUT
DBG_RESMOD_STEP_OVER
DBG_RESMOD_STEP_SRCINTO
DBG_RESMOD_STEP_SRCOUT
DBG_RESMOD_STEP_SRCOVER
DBG_RESMOD_STEP_USER
DBG_SUSPENDED
DEBUGGER_ID_6811_EMULATOR
DEBUGGER_ID_ARM_IPHONE_USER
DEBUGGER_ID_ARM_LINUX_USER
DEBUGGER_ID_ARM_MACOS_USER
DEBUGGER_ID_DALVIK_USER
DEBUGGER_ID_GDB_USER
DEBUGGER_ID_TRACE_REPLAYER
DEBUGGER_ID_WINDBG
DEBUGGER_ID_X86_DOSBOX_EMULATOR
DEBUGGER_ID_X86_IA32_BOCHS
DEBUGGER_ID_X86_IA32_LINUX_USER
DEBUGGER_ID_X86_IA32_MACOSX_USER
DEBUGGER_ID_X86_IA32_WIN32_USER
DEBUGGER_ID_X86_PIN_TRACER
DEBUGGER_ID_XNU_USER
DEF_ADDRSIZE
DRC_CRC
DRC_ERROR
DRC_EVENTS
DRC_FAILED
DRC_IDBSEG
DRC_NETERR
DRC_NOCHG
DRC_NOFILE
DRC_NONE
DRC_NOPROC
DRC_OK
EXCEPTION
EXC_BREAK
EXC_HANDLE
EXC_MSG
EXC_SILENT
FUNC_TRACE
IDD_INTERFACE_VERSION
INFORMATION
INSN_TRACE
LIB_LOADED
LIB_UNLOADED
NO_EVENT
NO_PROCESS
NO_THREAD
PROCESS_ATTACHED
PROCESS_DETACHED
PROCESS_EXITED
PROCESS_STARTED
PROCESS_SUSPENDED
REGISTER_ADDRESS
REGISTER_CS
REGISTER_CUSTFMT
REGISTER_FP
REGISTER_IP
REGISTER_NOLF
REGISTER_READONLY
REGISTER_SP
REGISTER_SS
RESMOD_HANDLE
RESMOD_INTO
RESMOD_MAX
RESMOD_NONE
RESMOD_OUT
RESMOD_OVER
RESMOD_SRCINTO
RESMOD_SRCOUT
RESMOD_SRCOVER
RESMOD_USER
RQ_IDAIDLE
RQ_IGNWERR
RQ_MASKING
RQ_NOSUSP
RQ_PROCEXIT
RQ_RESMOD
RQ_RESMOD_SHIFT
RQ_RESUME
RQ_SILENT
RQ_SUSPEND
RQ_SUSPRUN
RQ_SWSCREEN
RQ_VERBOSE
RQ__NOTHRRF
RVT_FLOAT
RVT_INT
RVT_UNAVAILABLE
STEP
STEP_TRACE
THREAD_EXITED
THREAD_STARTED
TRACE_FULL
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 *
can_exc_continue(ev: debug_event_t) ‑> bool
can_exc_continue(ev) -> bool
cleanup_appcall(tid: thid_t) ‑> error_t
cleanup_appcall(tid) -> error_t Cleanup after manual appcall.
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.
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.
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.
dbg_get_name() ‑> PyObject *
dbg_get_name() -> PyObject * This function returns the current debugger's name.
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
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
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
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
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
get_event_exc_code(ev: debug_event_t) ‑> uint
get_event_exc_code(ev) -> uint
get_event_exc_ea(ev: debug_event_t) ‑> ea_t
get_event_exc_ea(ev) -> ea_t
get_event_exc_info(ev: debug_event_t) ‑> size_t
get_event_exc_info(ev) -> str
get_event_info(ev: debug_event_t) ‑> size_t
get_event_info(ev) -> str
get_event_module_base(ev: debug_event_t) ‑> ea_t
get_event_module_base(ev) -> ea_t
get_event_module_name(ev: debug_event_t) ‑> size_t
get_event_module_name(ev) -> str
get_event_module_size(ev: debug_event_t) ‑> asize_t
get_event_module_size(ev) -> asize_t
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.
set_debug_event_code(ev: debug_event_t, id: event_id_t) ‑> void
set_debug_event_code(ev, id)
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)
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.
Instance variables
hea: ea_t
hea
kea: ea_t
kea
call_stack_info_t()
: Proxy of C++ call_stack_info_t class.
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.
Descendants
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.
Ancestors (in MRO)
debapp_attrs_t()
: Proxy of C++ debapp_attrs_t class.
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.
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.
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.
Instance variables
count: size_t
count
data: register_info_t *
data
exception_info_t(*args)
: Proxy of C++ exception_info_t class.
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.
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.
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.
Instance variables
merge: bool
merge
meminfo_vec_t()
: Proxy of C++ meminfo_vec_t class.
Ancestors (in MRO)
meminfo_vec_template_t(*args)
: Proxy of C++ qvector< memory_info_t > class.
Descendants
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.