Module ida_dbg
See Debugger functions for a complete explanation of these functions.
These functions are inlined for the kernel. They are not inlined for the user- interfaces.
Global Variables
BKPT_ACTIVE
BKPT_BADBPT
BKPT_CNDREADY
BKPT_FAKEPEND
BKPT_LISTBPT
BKPT_PAGE
BKPT_PARTIAL
BKPT_TRACE
BPLT_ABS
BPLT_REL
BPLT_SRC
BPLT_SYM
BPTCK_ACT
BPTCK_NO
BPTCK_NONE
BPTCK_YES
BPTEV_ADDED
BPTEV_CHANGED
BPTEV_REMOVED
BPT_BRK
BPT_ELANG_MASK
BPT_ELANG_SHIFT
BPT_ENABLED
BPT_LOWCND
BPT_TRACE
BPT_TRACEON
BPT_TRACE_BBLK
BPT_TRACE_FUNC
BPT_TRACE_INSN
BPT_TRACE_TYPES
BPT_UPDMEM
BT_LOG_INSTS
DBGINV_ALL
DBGINV_MEMCFG
DBGINV_MEMORY
DBGINV_NONE
DBGINV_REDRAW
DBGINV_REGS
DEC_ERROR
DEC_NOTASK
DEC_TIMEOUT
DOPT_BPT_MSGS
DOPT_DISABLE_ASLR
DOPT_END_BPT
DOPT_ENTRY_BPT
DOPT_EXCDLG
DOPT_FAST_STEP
DOPT_INFO_BPT
DOPT_INFO_MSGS
DOPT_LIB_BPT
DOPT_LIB_MSGS
DOPT_LOAD_DINFO
DOPT_REAL_MEMORY
DOPT_REDO_STACK
DOPT_SEGM_MSGS
DOPT_START_BPT
DOPT_TEMP_HWBPT
DOPT_THREAD_BPT
DOPT_THREAD_MSGS
DSTATE_NOTASK
DSTATE_RUN
DSTATE_SUSP
EXCDLG_ALWAYS
EXCDLG_NEVER
EXCDLG_UNKNOWN
FT_LOG_RET
IT_LOG_SAME_IP
MOVBPT_BAD_TYPE
MOVBPT_DEST_BUSY
MOVBPT_NOT_FOUND
MOVBPT_OK
SAVE_ALL_VALUES
SAVE_DIFF
SAVE_NONE
SRCDBG_PROV_VERSION
SRCIT_EXPR
SRCIT_FUNC
SRCIT_LOCVAR
SRCIT_MODULE
SRCIT_NONE
SRCIT_STMT
SRCIT_STTVAR
ST_ALREADY_LOGGED
ST_DIFFERENTIAL
ST_OPTIONS_DEFAULT
ST_OPTIONS_MASK
ST_OVER_DEBUG_SEG
ST_OVER_LIB_FUNC
ST_SKIP_LOOPS
WFNE_ANY
WFNE_CONT
WFNE_NOWAIT
WFNE_SILENT
WFNE_SUSP
WFNE_USEC
dbg_bpt
dbg_bpt_changed
dbg_exception
dbg_finished_loading_bpts
dbg_information
dbg_last
dbg_library_load
dbg_library_unload
dbg_null
dbg_process_attach
dbg_process_detach
dbg_process_exit
dbg_process_start
dbg_request_error
dbg_run_to
dbg_started_loading_bpts
dbg_step_into
dbg_step_over
dbg_step_until_ret
dbg_suspend_process
dbg_thread_exit
dbg_thread_start
dbg_trace
tev_bpt
tev_call
tev_event
tev_insn
tev_max
tev_mem
tev_none
tev_ret
Functions
add_bpt(*args) ‑> bool
add_bpt(ea, size=0, type=BPT_DEFAULT) -> bool Add a new breakpoint in the debugged process. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}
add_bpt(bpt) -> bool
add_path_mapping(src: char const *, dst: char const *) ‑> void
add_path_mapping(src, dst)
add_virt_module(mod: modinfo_t) ‑> bool
add_virt_module(mod) -> bool
attach_process(*args) ‑> int
attach_process(pid=pid_t(-1), event_id=-1) -> int Attach the debugger to a running process. \sq{Type, Asynchronous function - available as Request, Notification, dbg_process_attach} note: This function shouldn't be called as a request if NO_PROCESS is used.
bring_debugger_to_front() ‑> void
bring_debugger_to_front()
check_bpt(ea: ea_t) ‑> int
check_bpt(ea) -> int Check the breakpoint at the specified address.
choose_trace_file() ‑> qstring *
choose_trace_file() -> str Show the choose trace dialog.
clear_requests_queue() ‑> void
clear_requests_queue() Clear the queue of waiting requests. \sq{Type, Synchronous function, Notification, none (synchronous function)} note: If a request is currently running, this one isn't stopped.
clear_trace() ‑> void
clear_trace() Clear all events in the trace buffer. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}
collect_stack_trace(tid: thid_t, trace: call_stack_t) ‑> bool
collect_stack_trace(tid, trace) -> bool
continue_process() ‑> bool
continue_process() -> bool Continue the execution of the process in the debugger. \sq{Type, Synchronous function - available as Request, Notification, none (synchronous function)} note: The continue_process() function can be called from a notification handler to force the continuation of the process. In this case the request queue will not be examined, IDA will simply resume execution. Usually it makes sense to call request_continue_process() followed by run_requests(), so that IDA will first start a queued request (if any) and then resume the application.
create_source_viewer(out_ccv: TWidget **, parent: TWidget *, custview: TWidget *, sf: source_file_ptr, lines: strvec_t *, lnnum: int, colnum: int, flags: int) ‑> source_view_t *
create_source_viewer(out_ccv, parent, custview, sf, lines, lnnum, colnum, flags) -> source_view_t * Create a source code view.
dbg_add_bpt_tev(tid: thid_t, ea: ea_t, bp: ea_t) ‑> bool
dbg_add_bpt_tev(tid, ea, bp) -> bool Add a new breakpoint trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}
dbg_add_call_tev(tid: thid_t, caller: ea_t, callee: ea_t) ‑> void
dbg_add_call_tev(tid, caller, callee) Add a new call trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}
dbg_add_debug_event(event: debug_event_t) ‑> void
dbg_add_debug_event(event) Add a new debug event to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}
dbg_add_insn_tev(tid: thid_t, ea: ea_t, save: save_reg_values_t = 1) ‑> bool
dbg_add_insn_tev(tid, ea, save=SAVE_DIFF) -> bool Add a new instruction trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}
dbg_add_many_tevs(new_tevs: tevinforeg_vec_t) ‑> bool
dbg_add_many_tevs(new_tevs) -> bool Add many new trace elements to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}
dbg_add_ret_tev(tid: thid_t, ret_insn: ea_t, return_to: ea_t) ‑> void
dbg_add_ret_tev(tid, ret_insn, return_to) Add a new return trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}
dbg_add_tev(type: tev_type_t, tid: thid_t, address: ea_t) ‑> void
dbg_add_tev(type, tid, address) Add a new trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}
dbg_add_thread(tid: thid_t) ‑> void
dbg_add_thread(tid) Add a thread to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}
dbg_bin_search(start_ea: ea_t, end_ea: ea_t, data: compiled_binpat_vec_t const &, srch_flags: int) ‑> uint64 *, qstring *
dbg_bin_search(start_ea, end_ea, data, srch_flags) -> str
dbg_can_query() ‑> bool
dbg_can_query() -> bool This function can be used to check if the debugger can be queried: - debugger is loaded - process is suspended - process is not suspended but can take requests. In this case some requests like memory read/write, bpt management succeed and register querying will fail. Check if idaapi.get_process_state() < 0 to tell if the process is suspended
dbg_del_thread(tid: thid_t) ‑> void
dbg_del_thread(tid) Delete a thread from the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}
dbg_is_loaded() ‑> bool
dbg_is_loaded() -> bool Checks if a debugger is loaded
define_exception(code: uint, name: char const *, desc: char const *, flags: int) ‑> char const *
define_exception(code, name, desc, flags) -> char const * Convenience function: define new exception code.
del_bpt(*args) ‑> bool
del_bpt(ea) -> bool Delete an existing breakpoint in the debugged process. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}
del_bpt(bptloc) -> bool
del_bptgrp(name: char const *) ‑> bool
del_bptgrp(name) -> bool Delete a folder, bpt that were part of this folder are moved to the root folder \sq{Type, Synchronous function, Notification, none (synchronous function)}
del_virt_module(base: ea_t const) ‑> bool
del_virt_module(base) -> bool
detach_process() ‑> bool
detach_process() -> bool Detach the debugger from the debugged process. \sq{Type, Asynchronous function - available as Request, Notification, dbg_process_detach}
diff_trace_file(NONNULL_filename: char const *) ‑> bool
diff_trace_file(NONNULL_filename) -> bool Show difference between the current trace and the one from 'filename'.
disable_bblk_trace() ‑> bool
disable_bblk_trace() -> bool
disable_bpt(*args) ‑> bool
disable_bpt(ea) -> bool
disable_bpt(bptloc) -> bool
disable_func_trace() ‑> bool
disable_func_trace() -> bool
disable_insn_trace() ‑> bool
disable_insn_trace() -> bool
disable_step_trace() ‑> bool
disable_step_trace() -> bool
edit_manual_regions() ‑> void
edit_manual_regions()
enable_bblk_trace(enable: bool = True) ‑> bool
enable_bblk_trace(enable=True) -> bool
enable_bpt(*args) ‑> bool
enable_bpt(ea, enable=True) -> bool
enable_bpt(bptloc, enable=True) -> bool
enable_bptgrp(bptgrp_name: char const *, enable: bool = True) ‑> int
enable_bptgrp(bptgrp_name, enable=True) -> int Enable (or disable) all bpts in a folder \sq{Type, Synchronous function, Notification, none (synchronous function)}
enable_func_trace(enable: bool = True) ‑> bool
enable_func_trace(enable=True) -> bool
enable_insn_trace(enable: bool = True) ‑> bool
enable_insn_trace(enable=True) -> bool
enable_manual_regions(enable: bool) ‑> void
enable_manual_regions(enable)
enable_step_trace(enable: int = 1) ‑> bool
enable_step_trace(enable=1) -> bool
exist_bpt(ea: ea_t) ‑> bool
exist_bpt(ea) -> bool Does a breakpoint exist at the given location?
exit_process() ‑> bool
exit_process() -> bool Terminate the debugging of the current process. \sq{Type, Asynchronous function
available as Request, Notification, dbg_process_exit}
find_bpt(bptloc: bpt_location_t, bpt: bpt_t) ‑> bool
find_bpt(bptloc, bpt) -> bool Find a breakpoint by location. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}
get_bblk_trace_options() ‑> int
get_bblk_trace_options() -> int Get current basic block tracing options. Also see BT_LOG_INSTS \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_bpt(ea: ea_t, bpt: bpt_t) ‑> bool
get_bpt(ea, bpt) -> bool Get the characteristics of a breakpoint. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_bpt_group(bptloc: bpt_location_t) ‑> qstring *
get_bpt_group(bptloc) -> str Retrieve the absolute path to the folder of the bpt based on the bpt_location find_bpt is called to retrieve the bpt \sq{Type, Synchronous function, Notification, none (synchronous function)}
success
get_bpt_qty() ‑> int
get_bpt_qty() -> int Get number of breakpoints. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_bpt_tev_ea(n: int) ‑> ea_t
get_bpt_tev_ea(n) -> ea_t Get the address associated to a read, read/write or execution trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_bptloc_string(i: int) ‑> char const *
get_bptloc_string(i) -> char const *
get_call_tev_callee(n: int) ‑> ea_t
get_call_tev_callee(n) -> ea_t Get the called function from a function call trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_current_source_file() ‑> qstring *
get_current_source_file() -> str
get_current_source_line() ‑> int
get_current_source_line() -> int
get_current_thread() ‑> thid_t
get_current_thread() -> thid_t Get current thread ID. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_dbg_byte(ea: ea_t) ‑> uint32 *
get_dbg_byte(ea) -> bool Get one byte of the debugged process memory.
false address inaccessible or debugger not running
get_dbg_memory_info(ranges: meminfo_vec_t) ‑> int
get_dbg_memory_info(ranges) -> int
get_dbg_reg_info(regname: char const *, ri: register_info_t) ‑> bool
get_dbg_reg_info(regname, ri) -> bool Get register information \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_debug_event() ‑> debug_event_t const *
get_debug_event() -> debug_event_t Get the current debugger event.
get_debugger_event_cond() ‑> char const *
get_debugger_event_cond() -> char const *
get_first_module(modinfo: modinfo_t) ‑> bool
get_first_module(modinfo) -> bool
get_func_trace_options() ‑> int
get_func_trace_options() -> int Get current function tracing options. Also see FT_LOG_RET \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_global_var(prov: srcinfo_provider_t *, ea: ea_t, name: char const *, out: source_item_ptr *) ‑> bool
get_global_var(prov, ea, name, out) -> bool
get_grp_bpts(bpts: bpt_vec_t, grp_name: char const *) ‑> ssize_t
get_grp_bpts(bpts, grp_name) -> ssize_t Retrieve a copy the bpts stored in a folder \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_insn_tev_reg_mem(n: int, memmap: memreg_infos_t) ‑> bool
get_insn_tev_reg_mem(n, memmap) -> bool Read the memory pointed by register values from an instruction trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_insn_tev_reg_result(n: int, regname: char const *, regval: regval_t) ‑> bool
get_insn_tev_reg_result(n, regname, regval) -> bool
get_insn_tev_reg_val(n: int, regname: char const *, regval: regval_t) ‑> bool
get_insn_tev_reg_val(n, regname, regval) -> bool
get_insn_trace_options() ‑> int
get_insn_trace_options() -> int Get current instruction tracing options. Also see IT_LOG_SAME_IP \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_ip_val() ‑> uint64 *
get_ip_val() -> bool Get value of the IP (program counter) register for the current thread. Requires a suspended debugger.
get_local_var(prov: srcinfo_provider_t *, ea: ea_t, name: char const *, out: source_item_ptr *) ‑> bool
get_local_var(prov, ea, name, out) -> bool
get_local_vars(prov: srcinfo_provider_t *, ea: ea_t, out: source_items_t *) ‑> bool
get_local_vars(prov, ea, out) -> bool
get_manual_regions(*args) ‑> PyObject *
get_manual_regions(ranges) Returns the manual memory regions
get_manual_regions() -> [(int, int, str, str, int, int, int), ...] or None
get_module_info(ea: ea_t, modinfo: modinfo_t) ‑> bool
get_module_info(ea, modinfo) -> bool
get_next_module(modinfo: modinfo_t) ‑> bool
get_next_module(modinfo) -> bool
get_process_options() ‑> qstring *, qstring *, qstring *, qstring *, qstring *, int *
get_process_options() Get process options. Any of the arguments may be nullptr
get_process_state() ‑> int
get_process_state() -> int Return the state of the currently debugged process. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_processes(proclist: procinfo_vec_t) ‑> ssize_t
get_processes(proclist) -> ssize_t Take a snapshot of running processes and return their description. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_reg_val(*args) ‑> PyObject *
get_reg_val(regname, regval) -> bool Get register value as an unsigned 64-bit int.
get_reg_val(regname, ival) -> bool
get_reg_val(regname) -> bool, float, int
get_reg_vals(tid: thid_t, clsmask: int = -1) ‑> regvals_t *
get_reg_vals(tid, clsmask=-1) -> regvals_t Fetch live registers values for the thread
get_ret_tev_return(n: int) ‑> ea_t
get_ret_tev_return(n) -> ea_t Get the return address from a function return trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_running_notification() ‑> dbg_notification_t
get_running_notification() -> dbg_notification_t Get the notification associated (if any) with the current running request. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_running_request() ‑> ui_notification_t
get_running_request() -> ui_notification_t Get the current running request. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_sp_val() ‑> uint64 *
get_sp_val() -> bool Get value of the SP register for the current thread. Requires a suspended debugger.
get_srcinfo_provider(name: char const *) ‑> srcinfo_provider_t *
get_srcinfo_provider(name) -> srcinfo_provider_t *
get_step_trace_options() ‑> int
get_step_trace_options() -> int Get current step tracing options. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_tev_ea(n: int) ‑> ea_t
get_tev_ea(n) -> ea_t
get_tev_event(n: int, d: debug_event_t) ‑> bool
get_tev_event(n, d) -> bool Get the corresponding debug event, if any, for the specified tev object. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_tev_info(n: int, tev_info: tev_info_t) ‑> bool
get_tev_info(n, tev_info) -> bool Get main information about a trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_tev_memory_info(n: int, mi: meminfo_vec_t) ‑> bool
get_tev_memory_info(n, mi) -> bool Get the memory layout, if any, for the specified tev object. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_tev_qty() ‑> int
get_tev_qty() -> int Get number of trace events available in trace buffer. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_tev_reg_mem(tev, idx)
get_tev_reg_mem_ea(tev, idx)
get_tev_reg_mem_qty(tev)
get_tev_reg_val(tev, reg)
get_tev_tid(n: int) ‑> int
get_tev_tid(n) -> int
get_tev_type(n: int) ‑> int
get_tev_type(n) -> int
get_thread_qty() ‑> int
get_thread_qty() -> int Get number of threads. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_trace_base_address() ‑> ea_t
get_trace_base_address() -> ea_t Get the base address of the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}
get_trace_dynamic_register_set(idaregs: dynamic_register_set_t *) ‑> void
get_trace_dynamic_register_set(idaregs) Get dynamic register set of current trace.
get_trace_file_desc(filename: char const *) ‑> qstring *
get_trace_file_desc(filename) -> str Get the file header of the specified trace file.
get_trace_platform() ‑> char const *
get_trace_platform() -> char const * Get platform name of current trace.
getn_bpt(n: int, bpt: bpt_t) ‑> bool
getn_bpt(n, bpt) -> bool Get the characteristics of a breakpoint. \sq{Type, Synchronous function, Notification, none (synchronous function)}
getn_thread(n: int) ‑> thid_t
getn_thread(n) -> thid_t Get the ID of a thread. \sq{Type, Synchronous function, Notification, none (synchronous function)}
getn_thread_name(n: int) ‑> char const *
getn_thread_name(n) -> char const * Get the NAME of a thread \sq{Type, Synchronous function, Notification, none (synchronous function)}
graph_trace() ‑> bool
graph_trace() -> bool Show the trace callgraph.
handle_debug_event(ev: debug_event_t, rqflags: int) ‑> int
handle_debug_event(ev, rqflags) -> int
hide_all_bpts() ‑> int
hide_all_bpts() -> int
internal_get_sreg_base(tid: thid_t, sreg_value: int) ‑> ea_t
internal_get_sreg_base(tid, sreg_value) -> ea_t Get the sreg base, for the given thread.
internal_ioctl(fn: int, buf: void const *, poutbuf: void **, poutsize: ssize_t *) ‑> int
internal_ioctl(fn, buf, poutbuf, poutsize) -> int
invalidate_dbg_state(dbginv: int) ‑> int
invalidate_dbg_state(dbginv) -> int Invalidate cached debugger information. \sq{Type, Synchronous function, Notification, none (synchronous function)}
invalidate_dbgmem_config() ‑> void
invalidate_dbgmem_config() Invalidate the debugged process memory configuration. Call this function if the debugged process might have changed its memory layout (allocated more memory, for example)
invalidate_dbgmem_contents(ea: ea_t, size: asize_t) ‑> void
invalidate_dbgmem_contents(ea, size) Invalidate the debugged process memory contents. Call this function each time the process has been stopped or the process memory is modified. If ea == BADADDR, then the whole memory contents will be invalidated
is_bblk_trace_enabled() ‑> bool
is_bblk_trace_enabled() -> bool
is_debugger_busy() ‑> bool
is_debugger_busy() -> bool Is the debugger busy?. Some debuggers do not accept any commands while the debugged application is running. For such a debugger, it is unsafe to do anything with the database (even simple queries like get_byte may lead to undesired consequences). Returns: true if the debugged application is running under such a debugger
is_debugger_memory(ea: ea_t) ‑> bool
is_debugger_memory(ea) -> bool Is the address mapped to debugger memory?
is_debugger_on() ‑> bool
is_debugger_on() -> bool Is the debugger currently running?
is_func_trace_enabled() ‑> bool
is_func_trace_enabled() -> bool Get current state of functions tracing. \sq{Type, Synchronous function, Notification, none (synchronous function)}
is_insn_trace_enabled() ‑> bool
is_insn_trace_enabled() -> bool Get current state of instruction tracing. \sq{Type, Synchronous function, Notification, none (synchronous function)}
is_reg_custom(regname: char const *) ‑> bool
is_reg_custom(regname) -> bool Does a register contain a value of a custom data type? \sq{Type, Synchronous function, Notification, none (synchronous function)}
is_reg_float(regname: char const *) ‑> bool
is_reg_float(regname) -> bool Does a register contain a floating point value? \sq{Type, Synchronous function, Notification, none (synchronous function)}
is_reg_integer(regname: char const *) ‑> bool
is_reg_integer(regname) -> bool Does a register contain an integer value? \sq{Type, Synchronous function, Notification, none (synchronous function)}
is_request_running() ‑> bool
is_request_running() -> bool Is a request currently running?
is_step_trace_enabled() ‑> bool
is_step_trace_enabled() -> bool Get current state of step tracing. \sq{Type, Synchronous function, Notification, none (synchronous function)}
is_valid_dstate(state: int) ‑> bool
is_valid_dstate(state) -> bool
is_valid_trace_file(filename: char const *) ‑> bool
is_valid_trace_file(filename) -> bool Is the specified file a valid trace file for the current database?
list_bptgrps(*args) ‑> PyObject *
list_bptgrps(bptgrps) -> size_t Retrieve the list of absolute path of all folders of bpt dirtree \sq{Type, Synchronous function, Notification, none (synchronous function)}
list_bptgrps() -> [str, ...]
load_debugger(dbgname: char const *, use_remote: bool) ‑> bool
load_debugger(dbgname, use_remote) -> bool
load_trace_file(filename: char const *) ‑> qstring *
load_trace_file(filename) -> str Load a recorded trace file in the 'Tracing' window. If the call succeeds and 'buf' is not null, the description of the trace stored in the binary trace file will be returned in 'buf'
move_bpt_to_grp(bpt: bpt_t, grp_name: char const *) ‑> bool
set_bpt_group(bpt, grp_name) -> bool Move a bpt into a folder in the breakpoint dirtree if the folder didn't exists, it will be created \sq{Type, Synchronous function, Notification, none (synchronous function)}
put_dbg_byte(ea: ea_t, x: uint32) ‑> bool
put_dbg_byte(ea, x) -> bool Change one byte of the debugged process memory.
read_dbg_memory(ea: ea_t, buffer: void *, size: size_t) ‑> ssize_t
read_dbg_memory(ea, buffer, size) -> ssize_t
refresh_debugger_memory() ‑> PyObject *
refresh_debugger_memory() -> PyObject * Refreshes the debugger memory
rename_bptgrp(old_name: char const *, new_name: char const *) ‑> bool
rename_bptgrp(old_name, new_name) -> bool Rename a folder of bpt dirtree \sq{Type, Synchronous function, Notification, none (synchronous function)}
request_add_bpt(*args) ‑> bool
request_add_bpt(ea, size=0, type=BPT_DEFAULT) -> bool Post an add_bpt(const bpt_t &) request.
request_add_bpt(bpt) -> bool
request_attach_process(pid: pid_t, event_id: int) ‑> int
request_attach_process(pid, event_id) -> int Post an attach_process() request.
request_clear_trace() ‑> void
request_clear_trace() Post a clear_trace() request.
request_continue_process() ‑> bool
request_continue_process() -> bool Post a continue_process() request. note: This requires an explicit call to run_requests()
request_del_bpt(*args) ‑> bool
request_del_bpt(ea) -> bool Post a del_bpt(const bpt_location_t &) request.
request_del_bpt(bptloc) -> bool
request_detach_process() ‑> bool
request_detach_process() -> bool Post a detach_process() request.
request_disable_bblk_trace() ‑> bool
request_disable_bblk_trace() -> bool
request_disable_bpt(*args) ‑> bool
request_disable_bpt(ea) -> bool
request_disable_bpt(bptloc) -> bool
request_disable_func_trace() ‑> bool
request_disable_func_trace() -> bool
request_disable_insn_trace() ‑> bool
request_disable_insn_trace() -> bool
request_disable_step_trace() ‑> bool
request_disable_step_trace() -> bool
request_enable_bblk_trace(enable: bool = True) ‑> bool
request_enable_bblk_trace(enable=True) -> bool
request_enable_bpt(*args) ‑> bool
request_enable_bpt(ea, enable=True) -> bool
request_enable_bpt(bptloc, enable=True) -> bool
request_enable_func_trace(enable: bool = True) ‑> bool
request_enable_func_trace(enable=True) -> bool
request_enable_insn_trace(enable: bool = True) ‑> bool
request_enable_insn_trace(enable=True) -> bool
request_enable_step_trace(enable: int = 1) ‑> bool
request_enable_step_trace(enable=1) -> bool
request_exit_process() ‑> bool
request_exit_process() -> bool Post an exit_process() request.
request_resume_thread(tid: thid_t) ‑> int
request_resume_thread(tid) -> int Post a resume_thread() request.
request_run_to(*args) ‑> bool
request_run_to(ea, pid=pid_t(-1), tid=0) -> bool Post a run_to() request.
request_select_thread(tid: thid_t) ‑> bool
request_select_thread(tid) -> bool Post a select_thread() request.
request_set_bblk_trace_options(options: int) ‑> void
request_set_bblk_trace_options(options) Post a set_bblk_trace_options() request.
request_set_func_trace_options(options: int) ‑> void
request_set_func_trace_options(options) Post a set_func_trace_options() request.
request_set_insn_trace_options(options: int) ‑> void
request_set_insn_trace_options(options) Post a set_insn_trace_options() request.
request_set_reg_val(regname: char const *, o: PyObject *) ‑> PyObject *
request_set_reg_val(regname, o) -> PyObject * Post a set_reg_val() request.
request_set_resume_mode(tid: thid_t, mode: resume_mode_t) ‑> bool
request_set_resume_mode(tid, mode) -> bool Post a set_resume_mode() request.
request_set_step_trace_options(options: int) ‑> void
request_set_step_trace_options(options) Post a set_step_trace_options() request.
request_start_process(path: char const * = None, args: char const * = None, sdir: char const * = None) ‑> int
request_start_process(path=None, args=None, sdir=None) -> int Post a start_process() request.
request_step_into() ‑> bool
request_step_into() -> bool Post a step_into() request.
request_step_over() ‑> bool
request_step_over() -> bool Post a step_over() request.
request_step_until_ret() ‑> bool
request_step_until_ret() -> bool Post a step_until_ret() request.
request_suspend_process() ‑> bool
request_suspend_process() -> bool Post a suspend_process() request.
request_suspend_thread(tid: thid_t) ‑> int
request_suspend_thread(tid) -> int Post a suspend_thread() request.
resume_thread(tid: thid_t) ‑> int
resume_thread(tid) -> int Resume thread. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}
retrieve_exceptions() ‑> excvec_t *
retrieve_exceptions() -> excvec_t Retrieve the exception information. You may freely modify the returned vector and add/edit/delete exceptions You must call store_exceptions() after any modifications Note: exceptions with code zero, multiple exception codes or names are prohibited
run_requests() ‑> bool
run_requests() -> bool Execute requests until all requests are processed or an asynchronous function is called. \sq{Type, Synchronous function, Notification, none (synchronous function)}
run_to(*args) ‑> bool
run_to(ea, pid=pid_t(-1), tid=0) -> bool Execute the process until the given address is reached. If no process is active, a new process is started. Technically, the debugger sets up a temporary breakpoint at the given address, and continues (or starts) the execution of the whole process. So, all threads continue their execution! \sq{Type, Asynchronous function - available as Request, Notification, dbg_run_to}
save_trace_file(filename: char const *, description: char const *) ‑> bool
save_trace_file(filename, description) -> bool Save the current trace in the specified file.
select_thread(tid: thid_t) ‑> bool
select_thread(tid) -> bool Select the given thread as the current debugged thread. All thread related execution functions will work on this thread. The process must be suspended to select a new thread. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}
send_dbg_command(command)
Send a direct command to the debugger backend, and retrieve the result as a string.
Note: any double-quotes in 'command' must be backslash-escaped. Note: this only works with some debugger backends: Bochs, WinDbg, GDB.
Returns: (True, ) on success, or (False, ) on failure
set_bblk_trace_options(options: int) ‑> void
set_bblk_trace_options(options) Modify basic block tracing options (see BT_LOG_INSTS)
set_bpt_group(bpt: bpt_t, grp_name: char const *) ‑> bool
set_bpt_group(bpt, grp_name) -> bool Move a bpt into a folder in the breakpoint dirtree if the folder didn't exists, it will be created \sq{Type, Synchronous function, Notification, none (synchronous function)}
set_bptloc_group(bptloc: bpt_location_t, grp_name: char const *) ‑> bool
set_bptloc_group(bptloc, grp_name) -> bool Move a bpt into a folder in the breakpoint dirtree based on the bpt_location find_bpt is called to retrieve the bpt and then set_bpt_group if the folder didn't exists, it will be created \sq{Type, Synchronous function, Notification, none (synchronous function)}
set_bptloc_string(s: char const *) ‑> int
set_bptloc_string(s) -> int
set_debugger_event_cond(NONNULL_evcond: char const *) ‑> void
set_debugger_event_cond(NONNULL_evcond)
set_debugger_options(options: uint) ‑> uint
set_debugger_options(options) -> uint Set debugger options. Replaces debugger options with the specification combination Debugger options
set_func_trace_options(options: int) ‑> void
set_func_trace_options(options) Modify function tracing options. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}
set_highlight_trace_options(hilight: bool, color: bgcolor_t, diff: bgcolor_t) ‑> void
set_highlight_trace_options(hilight, color, diff) Set highlight trace parameters.
set_insn_trace_options(options: int) ‑> void
set_insn_trace_options(options) Modify instruction tracing options. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}
set_manual_regions(ranges: meminfo_vec_t) ‑> void
set_manual_regions(ranges)
set_process_options(path: char const *, args: char const *, sdir: char const *, host: char const *, _pass: char const *, port: int) ‑> void
set_process_options(path, args, sdir, host, _pass, port) Set process options. Any of the arguments may be nullptr, which means 'do not modify'
set_process_state(newstate: int, p_thid: thid_t *, dbginv: int) ‑> int
set_process_state(newstate, p_thid, dbginv) -> int Set new state for the debugged process. Notifies the IDA kernel about the change of the debugged process state. For example, a debugger module could call this function when it knows that the process is suspended for a short period of time. Some IDA API calls can be made only when the process is suspended. The process state is usually restored before returning control to the caller. You must know that it is ok to change the process state, doing it at arbitrary moments may crash the application or IDA. \sq{Type, Synchronous function, Notification, none (synchronous function)}
set_reg_val(*args) ‑> PyObject *
set_reg_val(regname, o) -> PyObject
set_reg_val(tid, regidx, o) -> bool, int
set_remote_debugger(host: char const *, _pass: char const *, port: int = -1) ‑> void
set_remote_debugger(host, _pass, port=-1) Set remote debugging options. Should be used before starting the debugger.
set_resume_mode(tid: thid_t, mode: resume_mode_t) ‑> bool
set_resume_mode(tid, mode) -> bool How to resume the application. Set resume mode but do not resume process.
set_step_trace_options(options: int) ‑> void
set_step_trace_options(options) Modify step tracing options. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}
set_trace_base_address(ea: ea_t) ‑> void
set_trace_base_address(ea) Set the base address of the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}
set_trace_dynamic_register_set(idaregs: dynamic_register_set_t &) ‑> void
set_trace_dynamic_register_set(idaregs) Set dynamic register set of current trace.
set_trace_file_desc(filename: char const *, description: char const *) ‑> bool
set_trace_file_desc(filename, description) -> bool Change the description of the specified trace file.
set_trace_platform(platform: char const *) ‑> void
set_trace_platform(platform) Set platform name of current trace.
set_trace_size(size: int) ‑> bool
set_trace_size(size) -> bool Specify the new size of the circular buffer. \sq{Type, Synchronous function, Notification, none (synchronous function)}
srcdbg_request_step_into() ‑> bool
srcdbg_request_step_into() -> bool
srcdbg_request_step_over() ‑> bool
srcdbg_request_step_over() -> bool
srcdbg_request_step_until_ret() ‑> bool
srcdbg_request_step_until_ret() -> bool
srcdbg_step_into() ‑> bool
srcdbg_step_into() -> bool
srcdbg_step_over() ‑> bool
srcdbg_step_over() -> bool
srcdbg_step_until_ret() ‑> bool
srcdbg_step_until_ret() -> bool
start_process(path: char const * = None, args: char const * = None, sdir: char const * = None) ‑> int
start_process(path=None, args=None, sdir=None) -> int Start a process in the debugger. \sq{Type, Asynchronous function - available as Request, Notification, dbg_process_start} note: You can also use the run_to() function to easily start the execution of a process until a given address is reached. note: For all parameters, a nullptr value indicates the debugger will take the value from the defined Process Options.
step_into() ‑> bool
step_into() -> bool Execute one instruction in the current thread. Other threads are kept suspended. \sq{Type, Asynchronous function - available as Request, Notification, dbg_step_into}
step_over() ‑> bool
step_over() -> bool Execute one instruction in the current thread, but without entering into functions. Others threads keep suspended. \sq{Type, Asynchronous function - available as Request, Notification, dbg_step_over}
step_until_ret() ‑> bool
step_until_ret() -> bool Execute instructions in the current thread until a function return instruction is executed (aka "step out"). Other threads are kept suspended. \sq{Type, Asynchronous function - available as Request, Notification, dbg_step_until_ret}
store_exceptions() ‑> bool
store_exceptions() -> bool Update the exception information stored in the debugger module by invoking its dbg->set_exception_info callback
suspend_process() ‑> bool
suspend_process() -> bool Suspend the process in the debugger. \sq{ Type,
Synchronous function (if in a notification handler)
Asynchronous function (everywhere else)
available as Request, Notification,
none (if in a notification handler)
dbg_suspend_process (everywhere else) } note: The suspend_process() function can be called from a notification handler to force the stopping of the process. In this case, no notification will be generated. When you suspend a process, the running command is always aborted.
suspend_thread(tid: thid_t) ‑> int
suspend_thread(tid) -> int Suspend thread. Suspending a thread may deadlock the whole application if the suspended was owning some synchronization objects. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}
update_bpt(bpt: bpt_t) ‑> bool
update_bpt(bpt) -> bool Update modifiable characteristics of an existing breakpoint. To update the breakpoint location, use change_bptlocs() \sq{Type, Synchronous function, Notification, none (synchronous function)} note: Only the following fields can be modified:
bpt_t::cndbody
bpt_t::pass_count
bpt_t::flags
bpt_t::size
bpt_t::type note: Changing some properties will require removing and then re-adding the breakpoint to the process memory (or the debugger backend), which can lead to race conditions (i.e., breakpoint(s) can be missed) in case the process is not suspended. Here are a list of scenarios that will require the breakpoint to be removed & then re-added:
bpt_t::size is modified
bpt_t::type is modified
bpt_t::flags's BPT_ENABLED is modified
bpt_t::flags's BPT_LOWCND is changed
bpt_t::flags's BPT_LOWCND remains set, but cndbody changed
wait_for_next_event(wfne: int, timeout: int) ‑> dbg_event_code_t
wait_for_next_event(wfne, timeout) -> dbg_event_code_t Wait for the next event.
This function (optionally) resumes the process execution, and waits for a debugger event until a possible timeout occurs.
write_dbg_memory(*args) ‑> ssize_t
write_dbg_memory(ea, py_buf, size=size_t(-1)) -> ssize_t
Classes
DBG_Hooks()
: Proxy of C++ DBG_Hooks class.
Methods
dbg_bpt(self, tid: thid_t, bptea: ea_t) ‑> int dbg_bpt(self, tid, bptea) -> int A user defined breakpoint was reached.
tid: (thid_t) bptea: (::ea_t)
dbg_bpt_changed(self, bptev_code: int, bpt: bpt_t) ‑> void dbg_bpt_changed(self, bptev_code, bpt) Breakpoint has been changed.
bptev_code: (int) Breakpoint modification events bpt: (bpt_t *)
dbg_exception(self, pid: pid_t, tid: thid_t, ea: ea_t, exc_code: int, exc_can_cont: bool, exc_ea: ea_t, exc_info: char const *) ‑> int dbg_exception(self, pid, tid, ea, exc_code, exc_can_cont, exc_ea, exc_info) -> int
event: (const debug_event_t *) warn: (int *) filled with:
-1: display an exception warning dialog if the process is suspended.
0: never display an exception warning dialog.
1: always display an exception warning dialog. ea: ea_t exc_code: int exc_can_cont: bool exc_ea: ea_t exc_info: char const *
dbg_finished_loading_bpts(self) ‑> void dbg_finished_loading_bpts(self) Finished loading breakpoint info from idb.
dbg_information(self, pid: pid_t, tid: thid_t, ea: ea_t, info: char const *) ‑> void dbg_information(self, pid, tid, ea, info)
event: (const debug_event_t *) tid: thid_t ea: ea_t info: char const *
dbg_library_load(self, pid: pid_t, tid: thid_t, ea: ea_t, modinfo_name: char const *, modinfo_base: ea_t, modinfo_size: asize_t) ‑> void dbg_library_load(self, pid, tid, ea, modinfo_name, modinfo_base, modinfo_size)
event: (const debug_event_t *) tid: thid_t ea: ea_t modinfo_name: char const * modinfo_base: ea_t modinfo_size: asize_t
dbg_library_unload(self, pid: pid_t, tid: thid_t, ea: ea_t, info: char const *) ‑> void dbg_library_unload(self, pid, tid, ea, info)
event: (const debug_event_t *) tid: thid_t ea: ea_t info: char const *
dbg_process_attach(self, pid: pid_t, tid: thid_t, ea: ea_t, modinfo_name: char const *, modinfo_base: ea_t, modinfo_size: asize_t) ‑> void dbg_process_attach(self, pid, tid, ea, modinfo_name, modinfo_base, modinfo_size)
event: (const debug_event_t *) note: This event notification is also an asynchronous function result notification for start_process() ! tid: thid_t ea: ea_t modinfo_name: char const * modinfo_base: ea_t modinfo_size: asize_t
dbg_process_detach(self, pid: pid_t, tid: thid_t, ea: ea_t) ‑> void dbg_process_detach(self, pid, tid, ea)
event: (const debug_event_t *) note: This event notification is also an asynchronous function result notification for start_process() ! tid: thid_t ea: ea_t
dbg_process_exit(self, pid: pid_t, tid: thid_t, ea: ea_t, exit_code: int) ‑> void dbg_process_exit(self, pid, tid, ea, exit_code)
event: (const debug_event_t *) note: This event notification is also an asynchronous function result notification for start_process() ! tid: thid_t ea: ea_t exit_code: int
dbg_process_start(self, pid: pid_t, tid: thid_t, ea: ea_t, modinfo_name: char const *, modinfo_base: ea_t, modinfo_size: asize_t) ‑> void dbg_process_start(self, pid, tid, ea, modinfo_name, modinfo_base, modinfo_size)
event: (const debug_event_t *) note: This event notification is also an asynchronous function result notification for start_process() ! tid: thid_t ea: ea_t modinfo_name: char const * modinfo_base: ea_t modinfo_size: asize_t
dbg_request_error(self, failed_command: int, failed_dbg_notification: int) ‑> void dbg_request_error(self, failed_command, failed_dbg_notification) An error occurred during the processing of a request.
failed_command: (ui_notification_t) failed_dbg_notification: (dbg_notification_t)
dbg_run_to(self, pid: pid_t, tid: thid_t, ea: ea_t) ‑> void dbg_run_to(self, pid, tid, ea)
event: (const debug_event_t *) tid: thid_t ea: ea_t
dbg_started_loading_bpts(self) ‑> void dbg_started_loading_bpts(self) Started loading breakpoint info from idb.
dbg_step_into(self) ‑> void dbg_step_into(self)
dbg_step_over(self) ‑> void dbg_step_over(self)
dbg_step_until_ret(self) ‑> void dbg_step_until_ret(self)
dbg_suspend_process(self) ‑> void dbg_suspend_process(self) The process is now suspended.
dbg_thread_exit(self, pid: pid_t, tid: thid_t, ea: ea_t, exit_code: int) ‑> void dbg_thread_exit(self, pid, tid, ea, exit_code)
event: (const debug_event_t *) tid: thid_t ea: ea_t exit_code: int
dbg_thread_start(self, pid: pid_t, tid: thid_t, ea: ea_t) ‑> void dbg_thread_start(self, pid, tid, ea)
event: (const debug_event_t *) tid: thid_t ea: ea_t
dbg_trace(self, tid: thid_t, ip: ea_t) ‑> int dbg_trace(self, tid, ip) -> int A step occurred (one instruction was executed). This event notification is only generated if step tracing is enabled.
tid: (thid_t) thread ID ip: (::ea_t) current instruction pointer. usually points after the executed instruction retval 1: do not log this trace event retval 0: log it
hook(self) ‑> bool hook(self) -> bool
unhook(self) ‑> bool unhook(self) -> bool
bpt_location_t()
: Proxy of C++ bpt_location_t class.
Instance variables
index: int
index
info: ea_t
info
loctype: bpt_loctype_t
loctype
Methods
compare(self, r: bpt_location_t) ‑> int compare(self, r) -> int Lexically compare two breakpoint locations. Bpt locations are first compared based on type (i.e. BPLT_ABS < BPLT_REL). BPLT_ABS locations are compared based on their ea values. For all other location types, locations are first compared based on their string (path/filename/symbol), then their offset/lineno.
r: (C++: const bpt_location_t &) bpt_location_t const &
ea(self) ‑> ea_t ea(self) -> ea_t Get address (BPLT_ABS)
is_empty_path(self) ‑> bool is_empty_path(self) -> bool No path/filename specified? (BPLT_REL, BPLT_SRC)
lineno(self) ‑> int lineno(self) -> int Get line number (BPLT_SRC)
offset(self) ‑> uval_t offset(self) -> uval_t Get offset (BPLT_REL, BPLT_SYM)
path(self) ‑> char const * path(self) -> char const * Get path/filename (BPLT_REL, BPLT_SRC)
set_abs_bpt(self, a: ea_t) ‑> void set_abs_bpt(self, a) Specify an absolute address location.
a: (C++: ea_t)
set_rel_bpt(self, mod: char const *, _offset: uval_t) ‑> void set_rel_bpt(self, mod, _offset) Specify a relative address location.
mod: (C++: const char *) char const * _offset: (C++: uval_t)
set_src_bpt(self, fn: char const *, _lineno: int) ‑> void set_src_bpt(self, fn, _lineno) Specify a source level location.
fn: (C++: const char *) char const * _lineno: (C++: int)
set_sym_bpt(self, _symbol: char const *) ‑> void set_sym_bpt(self, _symbol, _offset=0) Specify a symbolic location.
_symbol: (C++: const char *) char const * _offset: (C++: uval_t)
symbol(self) ‑> char const * symbol(self) -> char const * Get symbol name (BPLT_SYM)
type(self) ‑> bpt_loctype_t type(self) -> bpt_loctype_t Get bpt type.
bpt_t()
: Proxy of C++ bpt_t class.
Instance variables
bptid: inode_t
bptid
cb: size_t
cb
cndidx: int
cndidx
condition: PyObject *
condition
ea: ea_t
ea
elang: PyObject *
elang
flags: uint32
flags
loc: bpt_location_t
loc
pass_count: int
pass_count
pid: pid_t
pid
props: uint32
props
size: int
size
tid: thid_t
tid
type: bpttype_t
type
Methods
badbpt(self) ‑> bool badbpt(self) -> bool Failed to write bpt to process memory?
enabled(self) ‑> bool enabled(self) -> bool Is breakpoint enabled?
get_cnd_elang_idx(self) ‑> size_t get_cnd_elang_idx(self) -> size_t
get_size(self) ‑> int get_size(self) -> int Get bpt size.
is_absbpt(self) ‑> bool is_absbpt(self) -> bool Is absolute address breakpoint?
is_active(self) ‑> bool is_active(self) -> bool Written completely to process?
is_compiled(self) ‑> bool is_compiled(self) -> bool Condition has been compiled?
is_hwbpt(self) ‑> bool is_hwbpt(self) -> bool Is hardware breakpoint?
is_inactive(self) ‑> bool is_inactive(self) -> bool Not written to process at all?
is_low_level(self) ‑> bool is_low_level(self) -> bool Is bpt condition calculated at low level?
is_page_bpt(self) ‑> bool is_page_bpt(self) -> bool Page breakpoint?
is_partially_active(self) ‑> bool is_partially_active(self) -> bool Written partially to process?
is_relbpt(self) ‑> bool is_relbpt(self) -> bool Is relative address breakpoint?
is_srcbpt(self) ‑> bool is_srcbpt(self) -> bool Is source level breakpoint?
is_symbpt(self) ‑> bool is_symbpt(self) -> bool Is symbolic breakpoint?
is_tracemodebpt(self) ‑> bool is_tracemodebpt(self) -> bool Does breakpoint trace anything?
is_traceoffbpt(self) ‑> bool is_traceoffbpt(self) -> bool Is this a tracing breakpoint, and is tracing disabled?
is_traceonbpt(self) ‑> bool is_traceonbpt(self) -> bool Is this a tracing breakpoint, and is tracing enabled?
listbpt(self) ‑> bool listbpt(self) -> bool Include in the bpt list?
set_abs_bpt(self, a: ea_t) ‑> void set_abs_bpt(self, a) Set bpt location to an absolute address.
a: (C++: ea_t)
set_rel_bpt(self, mod: char const *, o: uval_t) ‑> void set_rel_bpt(self, mod, o) Set bpt location to a relative address.
mod: (C++: const char *) char const * o: (C++: uval_t)
set_src_bpt(self, fn: char const *, lineno: int) ‑> void set_src_bpt(self, fn, lineno) Set bpt location to a source line.
fn: (C++: const char *) char const * lineno: (C++: int)
set_sym_bpt(self, sym: char const *, o: uval_t) ‑> void set_sym_bpt(self, sym, o) Set bpt location to a symbol.
sym: (C++: const char *) char const * o: (C++: uval_t)
set_trace_action(self, enable: bool, trace_types: int) ‑> bool set_trace_action(self, enable, trace_types) -> bool Configure tracing options.
enable: (C++: bool) trace_types: (C++: int)
bpt_vec_t(*args)
: Proxy of C++ qvector< bpt_t > class.
Methods
at(self, _idx: size_t) ‑> bpt_t const & at(self, _idx) -> bpt_t
_idx: size_t
back(self)
begin(self, *args) ‑> qvector< bpt_t >::const_iterator begin(self) -> bpt_t
capacity(self) ‑> size_t capacity(self) -> size_t
clear(self) ‑> void clear(self)
empty(self) ‑> bool empty(self) -> bool
end(self, *args) ‑> qvector< bpt_t >::const_iterator end(self) -> bpt_t
erase(self, *args) ‑> qvector< bpt_t >::iterator erase(self, it) -> bpt_t
it: qvector< bpt_t >::iterator
erase(self, first, last) -> bpt_t
first: qvector< bpt_t >::iterator last: qvector< bpt_t >::iterator
extract(self) ‑> bpt_t * extract(self) -> bpt_t
front(self)
grow(self, *args) ‑> void grow(self, x=bpt_t())
x: bpt_t const &
inject(self, s: bpt_t, len: size_t) ‑> void inject(self, s, len)
s: bpt_t * len: size_t
insert(self, it: bpt_t, x: bpt_t) ‑> qvector< bpt_t >::iterator insert(self, it, x) -> bpt_t
it: qvector< bpt_t >::iterator x: bpt_t const &
pop_back(self) ‑> void pop_back(self)
push_back(self, *args) ‑> bpt_t & push_back(self, x)
x: bpt_t const &
push_back(self) -> bpt_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: bpt_t const &
resize(self, _newsize)
_newsize: size_t
size(self) ‑> size_t size(self) -> size_t
swap(self, r: bpt_vec_t) ‑> void swap(self, r)
r: qvector< bpt_t > &
truncate(self) ‑> void truncate(self)
bptaddrs_t()
: Proxy of C++ bptaddrs_t class.
Instance variables
bpt: bpt_t *
bpt
eval_ctx_t(_ea: ea_t)
: Proxy of C++ eval_ctx_t class.
Instance variables
ea: ea_t
ea
memreg_info_t()
: Proxy of C++ memreg_info_t class.
Instance variables
bytes: PyObject *
get_bytes(self) -> PyObject *
ea: ea_t
ea
Methods
get_bytes(self) ‑> PyObject * get_bytes(self) -> PyObject *
memreg_infos_t(*args)
: Proxy of C++ qvector< memreg_info_t > class.
Methods
at(self, _idx: size_t) ‑> memreg_info_t const & at(self, _idx) -> memreg_info_t
_idx: size_t
back(self)
begin(self, *args) ‑> qvector< memreg_info_t >::const_iterator begin(self) -> memreg_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< memreg_info_t >::const_iterator end(self) -> memreg_info_t
erase(self, *args) ‑> qvector< memreg_info_t >::iterator erase(self, it) -> memreg_info_t
it: qvector< memreg_info_t >::iterator
erase(self, first, last) -> memreg_info_t
first: qvector< memreg_info_t >::iterator last: qvector< memreg_info_t >::iterator
extract(self) ‑> memreg_info_t * extract(self) -> memreg_info_t
front(self)
grow(self, *args) ‑> void grow(self, x=memreg_info_t())
x: memreg_info_t const &
inject(self, s: memreg_info_t, len: size_t) ‑> void inject(self, s, len)
s: memreg_info_t * len: size_t
insert(self, it: memreg_info_t, x: memreg_info_t) ‑> qvector< memreg_info_t >::iterator insert(self, it, x) -> memreg_info_t
it: qvector< memreg_info_t >::iterator x: memreg_info_t const &
pop_back(self) ‑> void pop_back(self)
push_back(self, *args) ‑> memreg_info_t & push_back(self, x)
x: memreg_info_t const &
push_back(self) -> memreg_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: memreg_info_t const &
resize(self, _newsize)
_newsize: size_t
size(self) ‑> size_t size(self) -> size_t
swap(self, r: memreg_infos_t) ‑> void swap(self, r)
r: qvector< memreg_info_t > &
truncate(self) ‑> void truncate(self)
tev_info_reg_t()
: Proxy of C++ tev_info_reg_t class.
Instance variables
info: ida_dbg.tev_info_t
info
registers: ida_dbg.tev_reg_values_t
registers
tev_info_t()
: Proxy of C++ tev_info_t class.
Instance variables
ea: ea_t
ea
tid: thid_t
tid
type: tev_type_t
type
tev_reg_value_t(*args)
: Proxy of C++ tev_reg_value_t class.
Instance variables
reg_idx: int
reg_idx
value: regval_t
value
tev_reg_values_t(*args)
: Proxy of C++ qvector< tev_reg_value_t > class.
Methods
at(self, _idx: size_t) ‑> tev_reg_value_t const & at(self, _idx) -> tev_reg_value_t
_idx: size_t
back(self)
begin(self, *args) ‑> qvector< tev_reg_value_t >::const_iterator begin(self) -> tev_reg_value_t
capacity(self) ‑> size_t capacity(self) -> size_t
clear(self) ‑> void clear(self)
empty(self) ‑> bool empty(self) -> bool
end(self, *args) ‑> qvector< tev_reg_value_t >::const_iterator end(self) -> tev_reg_value_t
erase(self, *args) ‑> qvector< tev_reg_value_t >::iterator erase(self, it) -> tev_reg_value_t
it: qvector< tev_reg_value_t >::iterator
erase(self, first, last) -> tev_reg_value_t
first: qvector< tev_reg_value_t >::iterator last: qvector< tev_reg_value_t >::iterator
extract(self) ‑> tev_reg_value_t * extract(self) -> tev_reg_value_t
front(self)
grow(self, *args) ‑> void grow(self, x=tev_reg_value_t())
x: tev_reg_value_t const &
inject(self, s: tev_reg_value_t, len: size_t) ‑> void inject(self, s, len)
s: tev_reg_value_t * len: size_t
insert(self, it: tev_reg_value_t, x: tev_reg_value_t) ‑> qvector< tev_reg_value_t >::iterator insert(self, it, x) -> tev_reg_value_t
it: qvector< tev_reg_value_t >::iterator x: tev_reg_value_t const &
pop_back(self) ‑> void pop_back(self)
push_back(self, *args) ‑> tev_reg_value_t & push_back(self, x)
x: tev_reg_value_t const &
push_back(self) -> tev_reg_value_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: tev_reg_value_t const &
resize(self, _newsize)
_newsize: size_t
size(self) ‑> size_t size(self) -> size_t
swap(self, r: tev_reg_values_t) ‑> void swap(self, r)
r: qvector< tev_reg_value_t > &
truncate(self) ‑> void truncate(self)
tevinforeg_vec_t(*args)
: Proxy of C++ qvector< tev_info_reg_t > class.
Methods
at(self, _idx: size_t) ‑> tev_info_reg_t const & at(self, _idx) -> tev_info_reg_t
_idx: size_t
back(self)
begin(self, *args) ‑> qvector< tev_info_reg_t >::const_iterator begin(self) -> tev_info_reg_t
capacity(self) ‑> size_t capacity(self) -> size_t
clear(self) ‑> void clear(self)
empty(self) ‑> bool empty(self) -> bool
end(self, *args) ‑> qvector< tev_info_reg_t >::const_iterator end(self) -> tev_info_reg_t
erase(self, *args) ‑> qvector< tev_info_reg_t >::iterator erase(self, it) -> tev_info_reg_t
it: qvector< tev_info_reg_t >::iterator
erase(self, first, last) -> tev_info_reg_t
first: qvector< tev_info_reg_t >::iterator last: qvector< tev_info_reg_t >::iterator
extract(self) ‑> tev_info_reg_t * extract(self) -> tev_info_reg_t
front(self)
grow(self, *args) ‑> void grow(self, x=tev_info_reg_t())
x: tev_info_reg_t const &
inject(self, s: tev_info_reg_t, len: size_t) ‑> void inject(self, s, len)
s: tev_info_reg_t * len: size_t
insert(self, it: tev_info_reg_t, x: tev_info_reg_t) ‑> qvector< tev_info_reg_t >::iterator insert(self, it, x) -> tev_info_reg_t
it: qvector< tev_info_reg_t >::iterator x: tev_info_reg_t const &
pop_back(self) ‑> void pop_back(self)
push_back(self, *args) ‑> tev_info_reg_t & push_back(self, x)
x: tev_info_reg_t const &
push_back(self) -> tev_info_reg_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: tev_info_reg_t const &
resize(self, _newsize)
_newsize: size_t
size(self) ‑> size_t size(self) -> size_t
swap(self, r: tevinforeg_vec_t) ‑> void swap(self, r)
r: qvector< tev_info_reg_t > &
truncate(self) ‑> void truncate(self)
Last updated