Detailed Description

Contains functions to control the debugging of a process.

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.

Classes
class	bpt_location_t

class	bpt_t

class	bpt_vec_t

class	bptaddrs_t

class	DBG_Hooks

class	eval_ctx_t

class	memreg_info_t

class	memreg_infos_t

class	tev_info_reg_t

class	tev_info_t

class	tev_reg_value_t

class	tev_reg_values_t

class	tevinforeg_vec_t

Functions
bool	run_to (*args)

bool	request_run_to (*args)

bool	run_requests ()

'ui_notification_t'	get_running_request ()

bool	is_request_running ()

'dbg_notification_t'	get_running_notification ()

None	clear_requests_queue ()

int	get_process_state ()

bool	is_valid_dstate (int state)

int	set_process_state (int newstate, 'thid_t *' p_thid, int dbginv)

int	invalidate_dbg_state (int dbginv)

int	start_process (str path=None, str args=None, str sdir=None)

int	request_start_process (str path=None, str args=None, str sdir=None)

bool	suspend_process ()

bool	request_suspend_process ()

bool	continue_process ()

bool	request_continue_process ()

bool	continue_backwards ()

bool	request_continue_backwards ()

bool	exit_process ()

bool	request_exit_process ()

'ssize_t'	get_processes ('procinfo_vec_t' proclist)

int	attach_process (*args)

int	request_attach_process ('pid_t' pid, int event_id)

bool	detach_process ()

bool	request_detach_process ()

bool	is_debugger_busy ()

int	get_thread_qty ()

'thid_t'	getn_thread (int n)

'thid_t'	get_current_thread ()

str	getn_thread_name (int n)

bool	select_thread ('thid_t' tid)

bool	request_select_thread ('thid_t' tid)

int	suspend_thread ('thid_t' tid)

int	request_suspend_thread ('thid_t' tid)

int	resume_thread ('thid_t' tid)

int	request_resume_thread ('thid_t' tid)

bool	get_first_module ('modinfo_t' modinfo)

bool	get_next_module ('modinfo_t' modinfo)

bool	step_into ()

bool	request_step_into ()

bool	step_over ()

bool	request_step_over ()

bool	step_into_backwards ()

bool	request_step_into_backwards ()

bool	step_over_backwards ()

bool	request_step_over_backwards ()

bool	run_to_backwards (*args)

bool	request_run_to_backwards (*args)

bool	step_until_ret ()

bool	request_step_until_ret ()

bool	set_resume_mode ('thid_t' tid, 'resume_mode_t' mode)

bool	request_set_resume_mode ('thid_t' tid, 'resume_mode_t' mode)

bool	get_dbg_reg_info (str regname, 'register_info_t' ri)

'uint64 *'	get_sp_val ()

'uint64 *'	get_ip_val ()

bool	is_reg_integer (str regname)

bool	is_reg_float (str regname)

bool	is_reg_custom (str regname)

int	set_bptloc_string (str s)

str	get_bptloc_string (int i)

int	get_bpt_qty ()

bool	getn_bpt (int n, 'bpt_t' bpt)

bool	get_bpt (ida_idaapi.ea_t ea, 'bpt_t' bpt)

bool	exist_bpt (ida_idaapi.ea_t ea)

bool	add_bpt (*args)

bool	request_add_bpt (*args)

bool	del_bpt (*args)

bool	request_del_bpt (*args)

bool	update_bpt ('bpt_t' bpt)

bool	find_bpt ('bpt_location_t' bptloc, 'bpt_t' bpt)

bool	enable_bpt (*args)

bool	disable_bpt (*args)

bool	request_enable_bpt (*args)

bool	request_disable_bpt (*args)

int	check_bpt (ida_idaapi.ea_t ea)

bool	set_trace_size (int size)

None	clear_trace ()

None	request_clear_trace ()

bool	is_step_trace_enabled ()

bool	enable_step_trace (int enable=1)

bool	disable_step_trace ()

bool	request_enable_step_trace (int enable=1)

bool	request_disable_step_trace ()

int	get_step_trace_options ()

None	set_step_trace_options (int options)

None	request_set_step_trace_options (int options)

bool	is_insn_trace_enabled ()

bool	enable_insn_trace (bool enable=True)

bool	disable_insn_trace ()

bool	request_enable_insn_trace (bool enable=True)

bool	request_disable_insn_trace ()

int	get_insn_trace_options ()

None	set_insn_trace_options (int options)

None	request_set_insn_trace_options (int options)

bool	is_func_trace_enabled ()

bool	enable_func_trace (bool enable=True)

bool	disable_func_trace ()

bool	request_enable_func_trace (bool enable=True)

bool	request_disable_func_trace ()

int	get_func_trace_options ()

None	set_func_trace_options (int options)

None	request_set_func_trace_options (int options)

bool	enable_bblk_trace (bool enable=True)

bool	disable_bblk_trace ()

bool	request_enable_bblk_trace (bool enable=True)

bool	request_disable_bblk_trace ()

bool	is_bblk_trace_enabled ()

int	get_bblk_trace_options ()

None	set_bblk_trace_options (int options)

None	request_set_bblk_trace_options (int options)

int	get_tev_qty ()

bool	get_tev_info (int n, 'tev_info_t' tev_info)

bool	get_insn_tev_reg_val (int n, str regname, 'regval_t' regval)

bool	get_insn_tev_reg_mem (int n, 'memreg_infos_t' memmap)

bool	get_insn_tev_reg_result (int n, str regname, 'regval_t' regval)

ida_idaapi.ea_t	get_call_tev_callee (int n)

ida_idaapi.ea_t	get_ret_tev_return (int n)

ida_idaapi.ea_t	get_bpt_tev_ea (int n)

bool	get_tev_memory_info (int n, 'meminfo_vec_t' mi)

bool	get_tev_event (int n, 'debug_event_t' d)

ida_idaapi.ea_t	get_trace_base_address ()

None	set_trace_base_address (ida_idaapi.ea_t ea)

None	dbg_add_thread ('thid_t' tid)

None	dbg_del_thread ('thid_t' tid)

None	dbg_add_tev ('tev_type_t' type, 'thid_t' tid, ida_idaapi.ea_t address)

bool	dbg_add_many_tevs ('tevinforeg_vec_t' new_tevs)

bool	dbg_add_insn_tev ('thid_t' tid, ida_idaapi.ea_t ea, 'save_reg_values_t' save=SAVE_DIFF)

bool	dbg_add_bpt_tev ('thid_t' tid, ida_idaapi.ea_t ea, ida_idaapi.ea_t bp)

None	dbg_add_call_tev ('thid_t' tid, ida_idaapi.ea_t caller, ida_idaapi.ea_t callee)

None	dbg_add_ret_tev ('thid_t' tid, ida_idaapi.ea_t ret_insn, ida_idaapi.ea_t return_to)

None	dbg_add_debug_event ('debug_event_t' event)

str	load_trace_file (str filename)

bool	save_trace_file (str filename, str description)

bool	is_valid_trace_file (str filename)

bool	set_trace_file_desc (str filename, str description)

str	get_trace_file_desc (str filename)

str	choose_trace_file ()

bool	diff_trace_file (str NONNULL_filename)

bool	graph_trace ()

None	set_highlight_trace_options (bool hilight, 'bgcolor_t' color, 'bgcolor_t' diff)

None	set_trace_platform (str platform)

str	get_trace_platform ()

None	set_trace_dynamic_register_set ('dynamic_register_set_t &' idaregs)

None	get_trace_dynamic_register_set ('dynamic_register_set_t *' idaregs)

'dbg_event_code_t'	wait_for_next_event (int wfne, int timeout)

'debug_event_t const *'	get_debug_event ()

'uint'	set_debugger_options ('uint' options)

None	set_remote_debugger (str host, str _pass, int port=-1)

'qstring , qstring , launch_env_t , qstring , qstring , qstring , int *'	get_process_options2 ()

'excvec_t *'	retrieve_exceptions ()

bool	store_exceptions ()

str	define_exception ('uint' code, str name, str desc, int flags)

'source_view_t *'	create_source_viewer ('TWidget *' out_ccv, 'TWidget ' parent, 'TWidget ' custview, 'source_file_ptr' sf, 'strvec_t ' lines, int lnnum, int colnum, int flags)

'uint32 *'	get_dbg_byte (ida_idaapi.ea_t ea)

bool	put_dbg_byte (ida_idaapi.ea_t ea, int x)

None	invalidate_dbgmem_config ()

None	invalidate_dbgmem_contents (ida_idaapi.ea_t ea, 'asize_t' size)

bool	is_debugger_on ()

bool	is_debugger_memory (ida_idaapi.ea_t ea)

ida_idaapi.ea_t	get_tev_ea (int n)

int	get_tev_type (int n)

int	get_tev_tid (int n)

None	bring_debugger_to_front ()

None	set_manual_regions ('meminfo_vec_t' ranges)

None	edit_manual_regions ()

None	enable_manual_regions (bool enable)

int	handle_debug_event ('debug_event_t' ev, int rqflags)

bool	add_virt_module ('modinfo_t' mod)

bool	del_virt_module ('ea_t const ' base)

int	internal_ioctl (int fn, 'void const ' buf, 'void ' poutbuf, 'ssize_t ' poutsize)

int	get_dbg_memory_info ('meminfo_vec_t' ranges)

bool	set_bpt_group ('bpt_t' bpt, str grp_name)

bool	set_bptloc_group ('bpt_location_t' bptloc, str grp_name)

str	get_bpt_group ('bpt_location_t' bptloc)

bool	rename_bptgrp (str old_name, str new_name)

bool	del_bptgrp (str name)

'ssize_t'	get_grp_bpts ('bpt_vec_t' bpts, str grp_name)

int	enable_bptgrp (str bptgrp_name, bool enable=True)

bool	get_local_vars ('srcinfo_provider_t ' prov, ida_idaapi.ea_t ea, 'source_items_t ' out)

bool	srcdbg_request_step_into ()

bool	srcdbg_request_step_over ()

bool	srcdbg_request_step_until_ret ()

int	hide_all_bpts ()

'ssize_t'	read_dbg_memory (ida_idaapi.ea_t ea, 'void *' buffer, 'size_t' size)

bool	get_module_info (ida_idaapi.ea_t ea, 'modinfo_t' modinfo)

str	dbg_bin_search (ida_idaapi.ea_t start_ea, ida_idaapi.ea_t end_ea, 'compiled_binpat_vec_t const &' data, int srch_flags)

bool	load_debugger (str dbgname, bool use_remote)

bool	collect_stack_trace ('thid_t' tid, 'call_stack_t' trace)

bool	get_global_var ('srcinfo_provider_t ' prov, ida_idaapi.ea_t ea, str name, 'source_item_ptr ' out)

bool	get_local_var ('srcinfo_provider_t ' prov, ida_idaapi.ea_t ea, str name, 'source_item_ptr ' out)

'srcinfo_provider_t *'	get_srcinfo_provider (str name)

str	get_current_source_file ()

int	get_current_source_line ()

None	add_path_mapping (str src, str dst)

bool	srcdbg_step_into ()

bool	srcdbg_step_over ()

bool	srcdbg_step_until_ret ()

None	set_debugger_event_cond (str NONNULL_evcond)

str	get_debugger_event_cond ()

None	set_process_options (*args)

'qstring , qstring , qstring , qstring , qstring , int '	get_process_options ()

	get_manual_regions (*args)

	dbg_is_loaded ()

	refresh_debugger_memory ()

List[str]	list_bptgrps ()

	internal_get_sreg_base (int tid, int sreg_value)

'ssize_t'	write_dbg_memory (*args)

	dbg_can_query ()

bool	set_reg_val (*args)

'PyObject *'	request_set_reg_val (str regname, 'PyObject *' o)

	get_reg_val (*args)

'ida_idd.regvals_t'	get_reg_vals (int tid, int clsmask=-1)

	get_tev_reg_val (tev, reg)

	get_tev_reg_mem_qty (tev)

	get_tev_reg_mem (tev, idx)

	get_tev_reg_mem_ea (tev, idx)

	send_dbg_command (command)

Variables
	dbg_null = _ida_dbg.dbg_null

	dbg_process_start = _ida_dbg.dbg_process_start

	dbg_process_exit = _ida_dbg.dbg_process_exit

	dbg_process_attach = _ida_dbg.dbg_process_attach

	dbg_process_detach = _ida_dbg.dbg_process_detach

	dbg_thread_start = _ida_dbg.dbg_thread_start

	dbg_thread_exit = _ida_dbg.dbg_thread_exit

	dbg_library_load = _ida_dbg.dbg_library_load

	dbg_library_unload = _ida_dbg.dbg_library_unload

	dbg_information = _ida_dbg.dbg_information

	dbg_exception = _ida_dbg.dbg_exception

	dbg_suspend_process = _ida_dbg.dbg_suspend_process

	dbg_bpt = _ida_dbg.dbg_bpt

	dbg_trace = _ida_dbg.dbg_trace

	dbg_request_error = _ida_dbg.dbg_request_error

	dbg_step_into = _ida_dbg.dbg_step_into

	dbg_step_over = _ida_dbg.dbg_step_over

	dbg_run_to = _ida_dbg.dbg_run_to

	dbg_step_until_ret = _ida_dbg.dbg_step_until_ret

	dbg_bpt_changed = _ida_dbg.dbg_bpt_changed

	dbg_started_loading_bpts = _ida_dbg.dbg_started_loading_bpts

	dbg_finished_loading_bpts = _ida_dbg.dbg_finished_loading_bpts

	dbg_last = _ida_dbg.dbg_last

	BPTEV_ADDED = _ida_dbg.BPTEV_ADDED

	BPTEV_REMOVED = _ida_dbg.BPTEV_REMOVED

	BPTEV_CHANGED = _ida_dbg.BPTEV_CHANGED

	DSTATE_SUSP = _ida_dbg.DSTATE_SUSP

	DSTATE_NOTASK = _ida_dbg.DSTATE_NOTASK

	DSTATE_RUN = _ida_dbg.DSTATE_RUN

	DBGINV_MEMORY = _ida_dbg.DBGINV_MEMORY

	DBGINV_MEMCFG = _ida_dbg.DBGINV_MEMCFG

	DBGINV_REGS = _ida_dbg.DBGINV_REGS

	DBGINV_ALL = _ida_dbg.DBGINV_ALL

	DBGINV_REDRAW = _ida_dbg.DBGINV_REDRAW

	DBGINV_NONE = _ida_dbg.DBGINV_NONE

	MOVBPT_OK = _ida_dbg.MOVBPT_OK

	MOVBPT_NOT_FOUND = _ida_dbg.MOVBPT_NOT_FOUND

	MOVBPT_DEST_BUSY = _ida_dbg.MOVBPT_DEST_BUSY

	MOVBPT_BAD_TYPE = _ida_dbg.MOVBPT_BAD_TYPE

	BPLT_ABS = _ida_dbg.BPLT_ABS

	BPLT_REL = _ida_dbg.BPLT_REL

	BPLT_SYM = _ida_dbg.BPLT_SYM

	BPLT_SRC = _ida_dbg.BPLT_SRC

	BPT_BRK = _ida_dbg.BPT_BRK

	BPT_TRACE = _ida_dbg.BPT_TRACE

	BPT_UPDMEM = _ida_dbg.BPT_UPDMEM

	BPT_ENABLED = _ida_dbg.BPT_ENABLED

	BPT_LOWCND = _ida_dbg.BPT_LOWCND

	BPT_TRACEON = _ida_dbg.BPT_TRACEON

	BPT_TRACE_INSN = _ida_dbg.BPT_TRACE_INSN

	BPT_TRACE_FUNC = _ida_dbg.BPT_TRACE_FUNC

	BPT_TRACE_BBLK = _ida_dbg.BPT_TRACE_BBLK

	BPT_TRACE_TYPES = _ida_dbg.BPT_TRACE_TYPES

	BPT_ELANG_MASK = _ida_dbg.BPT_ELANG_MASK

	BPT_ELANG_SHIFT = _ida_dbg.BPT_ELANG_SHIFT

	BKPT_BADBPT = _ida_dbg.BKPT_BADBPT

	BKPT_LISTBPT = _ida_dbg.BKPT_LISTBPT

	BKPT_TRACE = _ida_dbg.BKPT_TRACE

	BKPT_ACTIVE = _ida_dbg.BKPT_ACTIVE

	BKPT_PARTIAL = _ida_dbg.BKPT_PARTIAL

	BKPT_CNDREADY = _ida_dbg.BKPT_CNDREADY

	BKPT_FAKEPEND = _ida_dbg.BKPT_FAKEPEND

	BKPT_PAGE = _ida_dbg.BKPT_PAGE

	BPTCK_NONE = _ida_dbg.BPTCK_NONE

	BPTCK_NO = _ida_dbg.BPTCK_NO

	BPTCK_YES = _ida_dbg.BPTCK_YES

	BPTCK_ACT = _ida_dbg.BPTCK_ACT

	ST_OVER_DEBUG_SEG = _ida_dbg.ST_OVER_DEBUG_SEG

	ST_OVER_LIB_FUNC = _ida_dbg.ST_OVER_LIB_FUNC

	ST_ALREADY_LOGGED = _ida_dbg.ST_ALREADY_LOGGED

	ST_SKIP_LOOPS = _ida_dbg.ST_SKIP_LOOPS

	ST_DIFFERENTIAL = _ida_dbg.ST_DIFFERENTIAL

	ST_OPTIONS_MASK = _ida_dbg.ST_OPTIONS_MASK

	ST_OPTIONS_DEFAULT = _ida_dbg.ST_OPTIONS_DEFAULT

	IT_LOG_SAME_IP = _ida_dbg.IT_LOG_SAME_IP

	FT_LOG_RET = _ida_dbg.FT_LOG_RET

	BT_LOG_INSTS = _ida_dbg.BT_LOG_INSTS

	tev_none = _ida_dbg.tev_none

	tev_insn = _ida_dbg.tev_insn

	tev_call = _ida_dbg.tev_call

	tev_ret = _ida_dbg.tev_ret

	tev_bpt = _ida_dbg.tev_bpt

	tev_mem = _ida_dbg.tev_mem

	tev_event = _ida_dbg.tev_event

	tev_max = _ida_dbg.tev_max

	SAVE_ALL_VALUES = _ida_dbg.SAVE_ALL_VALUES

	SAVE_DIFF = _ida_dbg.SAVE_DIFF

	SAVE_NONE = _ida_dbg.SAVE_NONE

	DEC_NOTASK = _ida_dbg.DEC_NOTASK

	DEC_ERROR = _ida_dbg.DEC_ERROR

	DEC_TIMEOUT = _ida_dbg.DEC_TIMEOUT

	WFNE_ANY = _ida_dbg.WFNE_ANY

	WFNE_SUSP = _ida_dbg.WFNE_SUSP

	WFNE_SILENT = _ida_dbg.WFNE_SILENT

	WFNE_CONT = _ida_dbg.WFNE_CONT

	WFNE_NOWAIT = _ida_dbg.WFNE_NOWAIT

	WFNE_USEC = _ida_dbg.WFNE_USEC

	DOPT_SEGM_MSGS = _ida_dbg.DOPT_SEGM_MSGS

	DOPT_START_BPT = _ida_dbg.DOPT_START_BPT

	DOPT_THREAD_MSGS = _ida_dbg.DOPT_THREAD_MSGS

	DOPT_THREAD_BPT = _ida_dbg.DOPT_THREAD_BPT

	DOPT_BPT_MSGS = _ida_dbg.DOPT_BPT_MSGS

	DOPT_LIB_MSGS = _ida_dbg.DOPT_LIB_MSGS

	DOPT_LIB_BPT = _ida_dbg.DOPT_LIB_BPT

	DOPT_INFO_MSGS = _ida_dbg.DOPT_INFO_MSGS

	DOPT_INFO_BPT = _ida_dbg.DOPT_INFO_BPT

	DOPT_REAL_MEMORY = _ida_dbg.DOPT_REAL_MEMORY

	DOPT_REDO_STACK = _ida_dbg.DOPT_REDO_STACK

	DOPT_ENTRY_BPT = _ida_dbg.DOPT_ENTRY_BPT

	DOPT_EXCDLG = _ida_dbg.DOPT_EXCDLG

	EXCDLG_NEVER = _ida_dbg.EXCDLG_NEVER

	EXCDLG_UNKNOWN = _ida_dbg.EXCDLG_UNKNOWN

	EXCDLG_ALWAYS = _ida_dbg.EXCDLG_ALWAYS

	DOPT_LOAD_DINFO = _ida_dbg.DOPT_LOAD_DINFO

	DOPT_END_BPT = _ida_dbg.DOPT_END_BPT

	DOPT_TEMP_HWBPT = _ida_dbg.DOPT_TEMP_HWBPT

	DOPT_FAST_STEP = _ida_dbg.DOPT_FAST_STEP

	DOPT_DISABLE_ASLR = _ida_dbg.DOPT_DISABLE_ASLR

	SRCIT_NONE = _ida_dbg.SRCIT_NONE

	SRCIT_MODULE = _ida_dbg.SRCIT_MODULE

	SRCIT_FUNC = _ida_dbg.SRCIT_FUNC

	SRCIT_STMT = _ida_dbg.SRCIT_STMT

	SRCIT_EXPR = _ida_dbg.SRCIT_EXPR

	SRCIT_STTVAR = _ida_dbg.SRCIT_STTVAR

	SRCIT_LOCVAR = _ida_dbg.SRCIT_LOCVAR

	SRCDBG_PROV_VERSION = _ida_dbg.SRCDBG_PROV_VERSION

bool	move_bpt_to_grp = set_bpt_group

Function Documentation

◆ add_bpt()

bool add_bpt ( * args )

This function has the following signatures:

0. add_bpt(ea: ida_idaapi.ea_t, size: asize_t=0, type: bpttype_t=BPT_DEFAULT) -> bool
1. add_bpt(bpt: const bpt_t &) -> bool

# 0: add_bpt(ea: ida_idaapi.ea_t, size: asize_t=0, type: bpttype_t=BPT_DEFAULT) -> bool

Add a new breakpoint in the debugged process. \\sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} 
    

# 1: add_bpt(bpt: const bpt_t &) -> bool

Add a new breakpoint in the debugged process. \\sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}

◆ add_path_mapping()

None add_path_mapping	(	str	src,
		str	dst )

◆ add_virt_module()

bool add_virt_module ( 'modinfo_t' mod )

◆ attach_process()

int attach_process ( * args )

Attach the debugger to a running process. \\sq{Type, Asynchronous function - available as Request, Notification, dbg_process_attach} 
    
@param pid: PID of the process to attach to. If NO_PROCESS, a dialog box will interactively ask the user for the process to attach to.
@param event_id: event to trigger upon attaching
@retval -4: debugger was not inited
@retval -3: the attaching is not supported
@retval -2: impossible to find a compatible process
@retval -1: impossible to attach to the given process (process died, privilege needed, not supported by the debugger plugin, ...)
@retval 0: the user cancelled the attaching to the process
@retval 1: the debugger properly attached to the process

◆ bring_debugger_to_front()

None bring_debugger_to_front ( )

◆ check_bpt()

int check_bpt ( ida_idaapi.ea_t ea )

Check the breakpoint at the specified address. 
    
@returns one of Breakpoint status codes

◆ choose_trace_file()

str choose_trace_file ( )

Show the choose trace dialog.

◆ clear_requests_queue()

None clear_requests_queue ( )

Clear the queue of waiting requests. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ clear_trace()

None clear_trace ( )

Clear all events in the trace buffer. \\sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}

◆ collect_stack_trace()

bool collect_stack_trace	(	'thid_t'	tid,
		'call_stack_t'	trace )

◆ continue_backwards()

bool continue_backwards ( )

Continue the execution of the process in the debugger backwards. Can only be used with debuggers that support time-travel debugging. \\sq{Type, Synchronous function - available as Request, Notification, none (synchronous function)}

◆ continue_process()

bool continue_process ( )

Continue the execution of the process in the debugger. \\sq{Type, Synchronous function - available as Request, Notification, none (synchronous function)}

◆ create_source_viewer()

'source_view_t *' create_source_viewer	(	'TWidget **'	out_ccv,
		'TWidget *'	parent,
		'TWidget *'	custview,
		'source_file_ptr'	sf,
		'strvec_t *'	lines,
		int	lnnum,
		int	colnum,
		int	flags )

Create a source code view.

◆ dbg_add_bpt_tev()

bool dbg_add_bpt_tev	(	'thid_t'	tid,
		ida_idaapi.ea_t	ea,
		ida_idaapi.ea_t	bp )

Add a new breakpoint trace element to the current trace. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@returns false if the operation failed, true otherwise

◆ dbg_add_call_tev()

None dbg_add_call_tev	(	'thid_t'	tid,
		ida_idaapi.ea_t	caller,
		ida_idaapi.ea_t	callee )

Add a new call trace element to the current trace. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ dbg_add_debug_event()

None dbg_add_debug_event ( 'debug_event_t' event )

Add a new debug event to the current trace. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ dbg_add_insn_tev()

bool dbg_add_insn_tev	(	'thid_t'	tid,
		ida_idaapi.ea_t	ea,
		'save_reg_values_t'	save = SAVE_DIFF )

Add a new instruction trace element to the current trace. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@returns false if the operation failed, true otherwise

◆ dbg_add_many_tevs()

bool dbg_add_many_tevs ( 'tevinforeg_vec_t' new_tevs )

Add many new trace elements to the current trace. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@returns false if the operation failed for any tev_info_t object

◆ dbg_add_ret_tev()

None dbg_add_ret_tev	(	'thid_t'	tid,
		ida_idaapi.ea_t	ret_insn,
		ida_idaapi.ea_t	return_to )

Add a new return trace element to the current trace. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ dbg_add_tev()

None dbg_add_tev	(	'tev_type_t'	type,
		'thid_t'	tid,
		ida_idaapi.ea_t	address )

Add a new trace element to the current trace. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ dbg_add_thread()

None dbg_add_thread ( 'thid_t' tid )

Add a thread to the current trace. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ dbg_bin_search()

str dbg_bin_search	(	ida_idaapi.ea_t	start_ea,
		ida_idaapi.ea_t	end_ea,
		'compiled_binpat_vec_t const &'	data,
		int	srch_flags )

◆ dbg_can_query()

dbg_can_query ( )

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

@return: Boolean

◆ dbg_del_thread()

None dbg_del_thread ( 'thid_t' tid )

Delete a thread from the current trace. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ dbg_is_loaded()

dbg_is_loaded ( )

Checks if a debugger is loaded

@return: Boolean

◆ define_exception()

str define_exception	(	'uint'	code,
		str	name,
		str	desc,
		int	flags )

Convenience function: define new exception code. 
    
@param code: exception code (cannot be 0)
@param name: exception name (cannot be empty or nullptr)
@param desc: exception description (maybe nullptr)
@param flags: combination of Exception info flags
@returns failure message or nullptr. You must call store_exceptions() if this function succeeds

◆ del_bpt()

bool del_bpt ( * args )

This function has the following signatures:

0. del_bpt(ea: ida_idaapi.ea_t) -> bool
1. del_bpt(bptloc: const bpt_location_t &) -> bool

# 0: del_bpt(ea: ida_idaapi.ea_t) -> bool

Delete an existing breakpoint in the debugged process. \\sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} 
    

# 1: del_bpt(bptloc: const bpt_location_t &) -> bool

Delete an existing breakpoint in the debugged process. \\sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}

◆ del_bptgrp()

bool del_bptgrp ( str name )

Delete a folder, bpt that were part of this folder are moved to the root folder \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param name: full path to the folder to be deleted
@returns success

◆ del_virt_module()

bool del_virt_module ( 'ea_t const' base )

◆ detach_process()

bool detach_process ( )

Detach the debugger from the debugged process. \\sq{Type, Asynchronous function - available as Request, Notification, dbg_process_detach}

◆ diff_trace_file()

bool diff_trace_file ( str NONNULL_filename )

Show difference between the current trace and the one from 'filename'.

◆ disable_bblk_trace()

bool disable_bblk_trace ( )

◆ disable_bpt()

bool disable_bpt ( * args )

◆ disable_func_trace()

bool disable_func_trace ( )

◆ disable_insn_trace()

bool disable_insn_trace ( )

◆ disable_step_trace()

bool disable_step_trace ( )

◆ edit_manual_regions()

None edit_manual_regions ( )

◆ enable_bblk_trace()

bool enable_bblk_trace ( bool enable = True )

◆ enable_bpt()

bool enable_bpt ( * args )

◆ enable_bptgrp()

int enable_bptgrp	(	str	bptgrp_name,
		bool	enable = True )

Enable (or disable) all bpts in a folder \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param bptgrp_name: absolute path to the folder
@param enable: by default true, enable bpts, false disable bpts
@retval -1: an error occured
@retval 0: no changes
@retval >0: nubmers of bpts udpated

◆ enable_func_trace()

bool enable_func_trace ( bool enable = True )

◆ enable_insn_trace()

bool enable_insn_trace ( bool enable = True )

◆ enable_manual_regions()

None enable_manual_regions ( bool enable )

◆ enable_step_trace()

bool enable_step_trace ( int enable = 1 )

◆ exist_bpt()

bool exist_bpt ( ida_idaapi.ea_t ea )

Does a breakpoint exist at the given location?

◆ exit_process()

bool exit_process ( )

Terminate the debugging of the current process. \\sq{Type, Asynchronous function - available as Request, Notification, dbg_process_exit}

◆ find_bpt()

bool find_bpt	(	'bpt_location_t'	bptloc,
		'bpt_t'	bpt )

Find a breakpoint by location. \\sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} 
    
@param bptloc: Breakpoint location
@param bpt: bpt is filled if the breakpoint was found

◆ get_bblk_trace_options()

int get_bblk_trace_options ( )

Get current basic block tracing options. Also see BT_LOG_INSTS \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ get_bpt()

bool get_bpt	(	ida_idaapi.ea_t	ea,
		'bpt_t'	bpt )

Get the characteristics of a breakpoint. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param ea: any address in the breakpoint range
@param bpt: if not nullptr, is filled with the characteristics.
@returns false if no breakpoint exists

◆ get_bpt_group()

str get_bpt_group ( 'bpt_location_t' bptloc )

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)} 
    
@param bptloc: bptlocation of the bpt
@returns success
@retval true: breakpoint correclty moved to the directory

◆ get_bpt_qty()

int get_bpt_qty ( )

Get number of breakpoints. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ get_bpt_tev_ea()

ida_idaapi.ea_t get_bpt_tev_ea ( int n )

Get the address associated to a read, read/write or execution trace event. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event.
@returns BADADDR if not a read, read/write or execution trace event.

◆ get_bptloc_string()

str get_bptloc_string ( int i )

◆ get_call_tev_callee()

ida_idaapi.ea_t get_call_tev_callee ( int n )

Get the called function from a function call trace event. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event.
@returns BADADDR if not a function call event.

◆ get_current_source_file()

str get_current_source_file ( )

◆ get_current_source_line()

int get_current_source_line ( )

◆ get_current_thread()

'thid_t' get_current_thread ( )

Get current thread ID. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ get_dbg_byte()

'uint32 *' get_dbg_byte ( ida_idaapi.ea_t ea )

Get one byte of the debugged process memory. 
    
@param ea: linear address
@returns success
@retval true: success
@retval false: address inaccessible or debugger not running

◆ get_dbg_memory_info()

int get_dbg_memory_info ( 'meminfo_vec_t' ranges )

◆ get_dbg_reg_info()

bool get_dbg_reg_info	(	str	regname,
		'register_info_t'	ri )

Get register information \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ get_debug_event()

'debug_event_t const *' get_debug_event ( )

Get the current debugger event.

◆ get_debugger_event_cond()

str get_debugger_event_cond ( )

◆ get_first_module()

bool get_first_module ( 'modinfo_t' modinfo )

◆ get_func_trace_options()

int get_func_trace_options ( )

Get current function tracing options. Also see FT_LOG_RET \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ get_global_var()

bool get_global_var	(	'srcinfo_provider_t *'	prov,
		ida_idaapi.ea_t	ea,
		str	name,
		'source_item_ptr *'	out )

◆ get_grp_bpts()

'ssize_t' get_grp_bpts	(	'bpt_vec_t'	bpts,
		str	grp_name )

Retrieve a copy the bpts stored in a folder \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param bpts: : pointer to a vector where the copy of bpts are stored
@param grp_name: absolute path to the folder
@returns number of bpts present in the vector

◆ get_insn_tev_reg_mem()

bool get_insn_tev_reg_mem	(	int	n,
		'memreg_infos_t'	memmap )

Read the memory pointed by register values from an instruction trace event. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event.
@param memmap: result
@returns false if not an instruction event or no memory is available

◆ get_insn_tev_reg_result()

bool get_insn_tev_reg_result	(	int	n,
		str	regname,
		'regval_t'	regval )

Read the resulting register value from an instruction trace event. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event.
@param regname: name of desired register
@param regval: result
@returns false if not an instruction trace event or register wasn't modified.

◆ get_insn_tev_reg_val()

bool get_insn_tev_reg_val	(	int	n,
		str	regname,
		'regval_t'	regval )

Read a register value from an instruction trace event. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event.
@param regname: name of desired register
@param regval: result
@returns false if not an instruction event.

◆ get_insn_trace_options()

int get_insn_trace_options ( )

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 ( )

Get value of the IP (program counter) register for the current thread. Requires a suspended debugger.

◆ get_local_var()

bool get_local_var	(	'srcinfo_provider_t *'	prov,
		ida_idaapi.ea_t	ea,
		str	name,
		'source_item_ptr *'	out )

◆ get_local_vars()

bool get_local_vars	(	'srcinfo_provider_t *'	prov,
		ida_idaapi.ea_t	ea,
		'source_items_t *'	out )

◆ get_manual_regions()

get_manual_regions ( * args )

Returns the manual memory regions

This function has the following signatures:

1. get_manual_regions() -> List[Tuple(ida_idaapi.ea_t, ida_idaapi.ea_t, str, str, ida_idaapi.ea_t, int, int)]
   Where each tuple holds (start_ea, end_ea, name, sclass, sbase, bitness, perm)
2. get_manual_regions(storage: meminfo_vec_t) -> None

◆ get_module_info()

bool get_module_info	(	ida_idaapi.ea_t	ea,
		'modinfo_t'	modinfo )

◆ get_next_module()

bool get_next_module ( 'modinfo_t' modinfo )

◆ get_process_options()

'qstring *, qstring *, qstring *, qstring *, qstring *, int *' get_process_options ( )

Get process options. Any of the arguments may be nullptr

◆ get_process_options2()

'qstring *, qstring *, launch_env_t *, qstring *, qstring *, qstring *, int *' get_process_options2 ( )

◆ get_process_state()

int get_process_state ( )

Return the state of the currently debugged process. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@returns one of Debugged process states

◆ get_processes()

'ssize_t' get_processes ( 'procinfo_vec_t' proclist )

Take a snapshot of running processes and return their description. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param proclist: array with information about each running process
@returns number of processes or -1 on error

◆ get_reg_val()

get_reg_val ( * args )

Get a register value.

This function has the following signatures:

1. get_reg_val(name: str) -> Union[int, float, bytes]
2. get_reg_val(name: str, regval: regval_t) -> bool

The first (and most user-friendly) form will return
a value whose type is related to the register type.
I.e., either an integer, a float or, in the case of large
vector registers, a bytes sequence.

@param name the register name
@return the register value (1st form)

◆ get_reg_vals()

'ida_idd.regvals_t' get_reg_vals	(	int	tid,
		int	clsmask = -1 )

Fetch live registers values for the thread

@param tid The ID of the thread to read registers for
@param clsmask An OR'ed mask of register classes to
   read values for (can be used to speed up the
   retrieval process)

@return: a list of register values (empty if an error occurs)

◆ get_ret_tev_return()

ida_idaapi.ea_t get_ret_tev_return ( int n )

Get the return address from a function return trace event. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event.
@returns BADADDR if not a function return event.

◆ get_running_notification()

'dbg_notification_t' get_running_notification ( )

Get the notification associated (if any) with the current running request. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@returns dbg_null if no running request

◆ get_running_request()

'ui_notification_t' get_running_request ( )

Get the current running request. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@returns ui_null if no running request

◆ get_sp_val()

'uint64 *' get_sp_val ( )

Get value of the SP register for the current thread. Requires a suspended debugger.

◆ get_srcinfo_provider()

'srcinfo_provider_t *' get_srcinfo_provider ( str name )

◆ get_step_trace_options()

int get_step_trace_options ( )

Get current step tracing options. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@returns Step trace options

◆ get_tev_ea()

ida_idaapi.ea_t get_tev_ea ( int n )

◆ get_tev_event()

bool get_tev_event	(	int	n,
		'debug_event_t'	d )

Get the corresponding debug event, if any, for the specified tev object. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event.
@param d: result
@returns false if the tev_t object doesn't have any associated debug event, true otherwise, with the debug event in "d".

◆ get_tev_info()

bool get_tev_info	(	int	n,
		'tev_info_t'	tev_info )

Get main information about a trace event. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event.
@param tev_info: result
@returns success

◆ get_tev_memory_info()

bool get_tev_memory_info	(	int	n,
		'meminfo_vec_t'	mi )

Get the memory layout, if any, for the specified tev object. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param n: number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event.
@param mi: result
@returns false if the tev_t object is not of type tev_mem, true otherwise, with the new memory layout in "mi".

◆ get_tev_qty()

int get_tev_qty ( )

Get number of trace events available in trace buffer. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ get_tev_reg_mem()

get_tev_reg_mem	(		tev,
			idx )

◆ get_tev_reg_mem_ea()

get_tev_reg_mem_ea	(		tev,
			idx )

◆ get_tev_reg_mem_qty()

get_tev_reg_mem_qty ( tev )

◆ get_tev_reg_val()

get_tev_reg_val	(		tev,
			reg )

◆ get_tev_tid()

int get_tev_tid ( int n )

◆ get_tev_type()

int get_tev_type ( int n )

◆ get_thread_qty()

int get_thread_qty ( )

Get number of threads. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ get_trace_base_address()

ida_idaapi.ea_t get_trace_base_address ( )

Get the base address of the current trace. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@returns the base address of the currently loaded trace

◆ get_trace_dynamic_register_set()

None get_trace_dynamic_register_set ( 'dynamic_register_set_t *' idaregs )

Get dynamic register set of current trace.

◆ get_trace_file_desc()

str get_trace_file_desc ( str filename )

Get the file header of the specified trace file.

◆ get_trace_platform()

str get_trace_platform ( )

Get platform name of current trace.

◆ getn_bpt()

bool getn_bpt	(	int	n,
		'bpt_t'	bpt )

Get the characteristics of a breakpoint. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param n: number of breakpoint, is in range 0..get_bpt_qty()-1
@param bpt: filled with the characteristics.
@returns false if no breakpoint exists

◆ getn_thread()

'thid_t' getn_thread ( int n )

Get the ID of a thread. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param n: number of thread, is in range 0..get_thread_qty()-1
@returns NO_THREAD if the thread doesn't exist.

◆ getn_thread_name()

str getn_thread_name ( int n )

Get the NAME of a thread \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param n: number of thread, is in range 0..get_thread_qty()-1 or -1 for the current thread
@returns thread name or nullptr if the thread doesn't exist.

◆ graph_trace()

bool graph_trace ( )

Show the trace callgraph.

◆ handle_debug_event()

int handle_debug_event	(	'debug_event_t'	ev,
		int	rqflags )

◆ hide_all_bpts()

int hide_all_bpts ( )

◆ internal_get_sreg_base()

internal_get_sreg_base	(	int	tid,
		int	sreg_value )

Get the sreg base, for the given thread.

@param tid: the thread ID
@param sreg_value: the sreg value
@return: The sreg base, or BADADDR on failure.

◆ internal_ioctl()

int internal_ioctl	(	int	fn,
		'void const *'	buf,
		'void **'	poutbuf,
		'ssize_t *'	poutsize )

◆ invalidate_dbg_state()

int invalidate_dbg_state ( int dbginv )

Invalidate cached debugger information. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param dbginv: Debugged process invalidation options
@returns current debugger state (one of Debugged process states)

◆ invalidate_dbgmem_config()

None 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()

None invalidate_dbgmem_contents	(	ida_idaapi.ea_t	ea,
		'asize_t'	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 ( )

◆ is_debugger_busy()

bool is_debugger_busy ( )

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()

bool is_debugger_memory ( ida_idaapi.ea_t ea )

Is the address mapped to debugger memory?

◆ is_debugger_on()

bool is_debugger_on ( )

Is the debugger currently running?

◆ is_func_trace_enabled()

bool is_func_trace_enabled ( )

Get current state of functions tracing. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ is_insn_trace_enabled()

bool is_insn_trace_enabled ( )

Get current state of instruction tracing. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ is_reg_custom()

bool is_reg_custom ( str regname )

Does a register contain a value of a custom data type? \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ is_reg_float()

bool is_reg_float ( str regname )

Does a register contain a floating point value? \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ is_reg_integer()

bool is_reg_integer ( str regname )

Does a register contain an integer value? \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ is_request_running()

bool is_request_running ( )

Is a request currently running?

◆ is_step_trace_enabled()

bool is_step_trace_enabled ( )

Get current state of step tracing. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ is_valid_dstate()

bool is_valid_dstate ( int state )

◆ is_valid_trace_file()

bool is_valid_trace_file ( str filename )

Is the specified file a valid trace file for the current database?

◆ list_bptgrps()

List[str] list_bptgrps ( )

Retrieve the list of absolute path of all folders of bpt dirtree.
Synchronous function, Notification, none (synchronous function)

◆ load_debugger()

bool load_debugger	(	str	dbgname,
		bool	use_remote )

◆ load_trace_file()

str load_trace_file ( str filename )

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'

◆ put_dbg_byte()

bool put_dbg_byte	(	ida_idaapi.ea_t	ea,
		int	x )

Change one byte of the debugged process memory. 
    
@param ea: linear address
@param x: byte value
@returns true if the process memory has been modified

◆ read_dbg_memory()

'ssize_t' read_dbg_memory	(	ida_idaapi.ea_t	ea,
		'void *'	buffer,
		'size_t'	size )

◆ refresh_debugger_memory()

refresh_debugger_memory ( )

Refreshes the debugger memory

@return: Nothing

◆ rename_bptgrp()

bool rename_bptgrp	(	str	old_name,
		str	new_name )

Rename a folder of bpt dirtree \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param old_name: absolute path to the folder to be renamed
@param new_name: absolute path of the new folder name
@returns success

◆ request_add_bpt()

bool request_add_bpt ( * args )

This function has the following signatures:

0. request_add_bpt(ea: ida_idaapi.ea_t, size: asize_t=0, type: bpttype_t=BPT_DEFAULT) -> bool
1. request_add_bpt(bpt: const bpt_t &) -> bool

# 0: request_add_bpt(ea: ida_idaapi.ea_t, size: asize_t=0, type: bpttype_t=BPT_DEFAULT) -> bool

Post an add_bpt(ea_t, asize_t, bpttype_t) request.


# 1: request_add_bpt(bpt: const bpt_t &) -> bool

Post an add_bpt(const bpt_t &) request.

◆ request_attach_process()

int request_attach_process	(	'pid_t'	pid,
		int	event_id )

Post an attach_process() request.

◆ request_clear_trace()

None request_clear_trace ( )

Post a clear_trace() request.

◆ request_continue_backwards()

bool request_continue_backwards ( )

Post a continue_backwards() request.

◆ request_continue_process()

bool request_continue_process ( )

Post a continue_process() request.

◆ request_del_bpt()

bool request_del_bpt ( * args )

This function has the following signatures:

0. request_del_bpt(ea: ida_idaapi.ea_t) -> bool
1. request_del_bpt(bptloc: const bpt_location_t &) -> bool

# 0: request_del_bpt(ea: ida_idaapi.ea_t) -> bool

Post a del_bpt(ea_t) request.


# 1: request_del_bpt(bptloc: const bpt_location_t &) -> bool

Post a del_bpt(const bpt_location_t &) request.

◆ request_detach_process()

bool request_detach_process ( )

Post a detach_process() request.

◆ request_disable_bblk_trace()

bool request_disable_bblk_trace ( )

◆ request_disable_bpt()

bool request_disable_bpt ( * args )

◆ request_disable_func_trace()

bool request_disable_func_trace ( )

◆ request_disable_insn_trace()

bool request_disable_insn_trace ( )

◆ request_disable_step_trace()

bool request_disable_step_trace ( )

◆ request_enable_bblk_trace()

bool request_enable_bblk_trace ( bool enable = True )

◆ request_enable_bpt()

bool request_enable_bpt ( * args )

◆ request_enable_func_trace()

bool request_enable_func_trace ( bool enable = True )

◆ request_enable_insn_trace()

bool request_enable_insn_trace ( bool enable = True )

◆ request_enable_step_trace()

bool request_enable_step_trace ( int enable = 1 )

◆ request_exit_process()

bool request_exit_process ( )

Post an exit_process() request.

◆ request_resume_thread()

int request_resume_thread ( 'thid_t' tid )

Post a resume_thread() request.

◆ request_run_to()

bool request_run_to ( * args )

Post a run_to() request.

◆ request_run_to_backwards()

bool request_run_to_backwards ( * args )

Post a run_to_backwards() request.

◆ request_select_thread()

bool request_select_thread ( 'thid_t' tid )

Post a select_thread() request.

◆ request_set_bblk_trace_options()

None request_set_bblk_trace_options ( int options )

Post a set_bblk_trace_options() request.

◆ request_set_func_trace_options()

None request_set_func_trace_options ( int options )

Post a set_func_trace_options() request.

◆ request_set_insn_trace_options()

None request_set_insn_trace_options ( int options )

Post a set_insn_trace_options() request.

◆ request_set_reg_val()

'PyObject *' request_set_reg_val	(	str	regname,
		'PyObject *'	o )

Post a set_reg_val() request.

◆ request_set_resume_mode()

bool request_set_resume_mode	(	'thid_t'	tid,
		'resume_mode_t'	mode )

Post a set_resume_mode() request.

◆ request_set_step_trace_options()

None request_set_step_trace_options ( int options )

Post a set_step_trace_options() request.

◆ request_start_process()

int request_start_process	(	str	path = None,
		str	args = None,
		str	sdir = None )

Post a start_process() request.

◆ request_step_into()

bool request_step_into ( )

Post a step_into() request.

◆ request_step_into_backwards()

bool request_step_into_backwards ( )

Post a step_into_backwards() request.

◆ request_step_over()

bool request_step_over ( )

Post a step_over() request.

◆ request_step_over_backwards()

bool request_step_over_backwards ( )

Post a step_over_backwards() request.

◆ request_step_until_ret()

bool request_step_until_ret ( )

Post a step_until_ret() request.

◆ request_suspend_process()

bool request_suspend_process ( )

Post a suspend_process() request.

◆ request_suspend_thread()

int request_suspend_thread ( 'thid_t' tid )

Post a suspend_thread() request.

◆ resume_thread()

int resume_thread ( 'thid_t' tid )

Resume thread. \\sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} 
    
@param tid: thread id
@retval -1: network error
@retval 0: failed
@retval 1: ok

◆ retrieve_exceptions()

'excvec_t *' retrieve_exceptions ( )

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 ( )

Execute requests until all requests are processed or an asynchronous function is called. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@returns false if not all requests could be processed (indicates an asynchronous function was started)

◆ run_to()

bool run_to ( * args )

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} 
    
@param ea: target address
@param pid: not used yet. please do not specify this parameter.
@param tid: not used yet. please do not specify this parameter.

◆ run_to_backwards()

bool run_to_backwards ( * args )

Execute the process backwards until the given address is reached. Technically, the debugger sets up a temporary breakpoint at the given address, and continues (or starts) the execution of the whole process. \\sq{Type, Asynchronous function - available as Request, Notification, dbg_run_to} 
    
@param ea: target address
@param pid: not used yet. please do not specify this parameter.
@param tid: not used yet. please do not specify this parameter.

◆ save_trace_file()

bool save_trace_file	(	str	filename,
		str	description )

Save the current trace in the specified file.

◆ select_thread()

bool select_thread ( 'thid_t' tid )

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)} 
    
@param tid: ID of the thread to select
@returns false if the thread doesn't exist.

◆ send_dbg_command()

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, <result string>) on success, or (False, <Error message string>) on failure

◆ set_bblk_trace_options()

None set_bblk_trace_options ( int options )

Modify basic block tracing options (see BT_LOG_INSTS)

◆ set_bpt_group()

bool set_bpt_group	(	'bpt_t'	bpt,
		str	grp_name )

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)} 
    
@param bpt: bpt that will be moved
@param grp_name: absolute path to the breakpoint dirtree folder
@returns success

◆ set_bptloc_group()

bool set_bptloc_group	(	'bpt_location_t'	bptloc,
		str	grp_name )

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)} 
    
@param bptloc: bptlocation of the bpt that will be moved
@param grp_name: absolute path to the breakpoint dirtree folder
@returns success

◆ set_bptloc_string()

int set_bptloc_string ( str s )

◆ set_debugger_event_cond()

None set_debugger_event_cond ( str NONNULL_evcond )

◆ set_debugger_options()

'uint' set_debugger_options ( 'uint' options )

Set debugger options. Replaces debugger options with the specification combination Debugger options 
    
@returns the old debugger options

◆ set_func_trace_options()

None set_func_trace_options ( int options )

Modify function tracing options. \\sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}

◆ set_highlight_trace_options()

None set_highlight_trace_options	(	bool	hilight,
		'bgcolor_t'	color,
		'bgcolor_t'	diff )

Set highlight trace parameters.

◆ set_insn_trace_options()

None set_insn_trace_options ( int options )

Modify instruction tracing options. \\sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}

◆ set_manual_regions()

None set_manual_regions ( 'meminfo_vec_t' ranges )

◆ set_process_options()

None set_process_options ( * args )

Set process options. Any of the arguments may be nullptr, which means 'do not modify'

◆ set_process_state()

int set_process_state	(	int	newstate,
		'thid_t *'	p_thid,
		int	dbginv )

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)} 
    
@param newstate: new process state (one of Debugged process states) if DSTATE_NOTASK is passed then the state is not changed
@param p_thid: ptr to new thread id. may be nullptr or pointer to NO_THREAD. the pointed variable will contain the old thread id upon return
@param dbginv: Debugged process invalidation options
@returns old debugger state (one of Debugged process states)

◆ set_reg_val()

bool set_reg_val ( * args )

Set a register value by name

This function has the following signatures:
1. set_reg_val(name: str, value: Union[int, float, bytes]) -> bool
1. set_reg_val(tid: int, regidx: int, value: Union[int, float, bytes]) -> bool

Depending on the register type, this will expect
either an integer, a float or, in the case of large
vector registers, a bytes sequence.

@param name (1st form) the register name
@param tid (2nd form) the thread ID
@param regidx (2nd form) the register index
@param value the register value
@return success

◆ set_remote_debugger()

None set_remote_debugger	(	str	host,
		str	_pass,
		int	port = -1 )

Set remote debugging options. Should be used before starting the debugger. 
    
@param host: If empty, IDA will use local debugger. If nullptr, the host will not be set.
@param port: If -1, the default port number will be used

◆ set_resume_mode()

bool set_resume_mode	(	'thid_t'	tid,
		'resume_mode_t'	mode )

How to resume the application. Set resume mode but do not resume process.

◆ set_step_trace_options()

None set_step_trace_options ( int options )

Modify step tracing options. \\sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}

◆ set_trace_base_address()

None set_trace_base_address ( ida_idaapi.ea_t ea )

Set the base address of the current trace. \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ set_trace_dynamic_register_set()

None set_trace_dynamic_register_set ( 'dynamic_register_set_t &' idaregs )

Set dynamic register set of current trace.

◆ set_trace_file_desc()

bool set_trace_file_desc	(	str	filename,
		str	description )

Change the description of the specified trace file.

◆ set_trace_platform()

None set_trace_platform ( str platform )

Set platform name of current trace.

◆ set_trace_size()

bool set_trace_size ( int size )

Specify the new size of the circular buffer. \\sq{Type, Synchronous function, Notification, none (synchronous function)} 
    
@param size: if 0, buffer isn't circular and events are never removed. If the new size is smaller than the existing number of trace events, a corresponding number of trace events are removed.

◆ srcdbg_request_step_into()

bool srcdbg_request_step_into ( )

◆ srcdbg_request_step_over()

bool srcdbg_request_step_over ( )

◆ srcdbg_request_step_until_ret()

bool srcdbg_request_step_until_ret ( )

◆ srcdbg_step_into()

bool srcdbg_step_into ( )

◆ srcdbg_step_over()

bool srcdbg_step_over ( )

◆ srcdbg_step_until_ret()

bool srcdbg_step_until_ret ( )

◆ start_process()

int start_process	(	str	path = None,
		str	args = None,
		str	sdir = None )

Start a process in the debugger. \\sq{Type, Asynchronous function - available as Request, Notification, dbg_process_start} 
    
@param path: path to the executable to start
@param args: arguments to pass to process
@param sdir: starting directory for the process
@retval -1: impossible to create the process
@retval 0: the starting of the process was cancelled by the user
@retval 1: the process was properly started

◆ step_into()

bool step_into ( )

Execute one instruction in the current thread. Other threads are kept suspended. \\sq{Type, Asynchronous function - available as Request, Notification, dbg_step_into}

◆ step_into_backwards()

bool step_into_backwards ( )

Execute one instruction backwards 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 ( )

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_over_backwards()

bool step_over_backwards ( )

Execute one instruction backwards in the current thread, but without entering into functions. Other threads are kept suspended. \\sq{Type, Asynchronous function - available as Request, Notification, dbg_step_over}

◆ step_until_ret()

bool step_until_ret ( )

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 ( )

Update the exception information stored in the debugger module by invoking its dbg->set_exception_info callback

◆ suspend_process()

bool suspend_process ( )

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) }

◆ suspend_thread()

int suspend_thread ( 'thid_t' tid )

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)} 
    
@param tid: thread id
@retval -1: network error
@retval 0: failed
@retval 1: ok

◆ update_bpt()

bool update_bpt ( 'bpt_t' bpt )

Update modifiable characteristics of an existing breakpoint. To update the breakpoint location, use change_bptlocs() \\sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ wait_for_next_event()

'dbg_event_code_t' wait_for_next_event	(	int	wfne,
		int	timeout )

Wait for the next event.
This function (optionally) resumes the process execution, and waits for a debugger event until a possible timeout occurs.

@param wfne: combination of Wait for debugger event flags constants
@param timeout: number of seconds to wait, -1-infinity
@returns either an event_id_t (if > 0), or a dbg_event_code_t (if <= 0)

◆ write_dbg_memory()

'ssize_t' write_dbg_memory ( * args )

Variable Documentation

◆ BKPT_ACTIVE

BKPT_ACTIVE = _ida_dbg.BKPT_ACTIVE

◆ BKPT_BADBPT

BKPT_BADBPT = _ida_dbg.BKPT_BADBPT

◆ BKPT_CNDREADY

BKPT_CNDREADY = _ida_dbg.BKPT_CNDREADY

◆ BKPT_FAKEPEND

BKPT_FAKEPEND = _ida_dbg.BKPT_FAKEPEND

◆ BKPT_LISTBPT

BKPT_LISTBPT = _ida_dbg.BKPT_LISTBPT

◆ BKPT_PAGE

BKPT_PAGE = _ida_dbg.BKPT_PAGE

◆ BKPT_PARTIAL

BKPT_PARTIAL = _ida_dbg.BKPT_PARTIAL

◆ BKPT_TRACE

BKPT_TRACE = _ida_dbg.BKPT_TRACE

◆ BPLT_ABS

BPLT_ABS = _ida_dbg.BPLT_ABS

◆ BPLT_REL

BPLT_REL = _ida_dbg.BPLT_REL

◆ BPLT_SRC

BPLT_SRC = _ida_dbg.BPLT_SRC

◆ BPLT_SYM

BPLT_SYM = _ida_dbg.BPLT_SYM

◆ BPT_BRK

BPT_BRK = _ida_dbg.BPT_BRK

◆ BPT_ELANG_MASK

BPT_ELANG_MASK = _ida_dbg.BPT_ELANG_MASK

◆ BPT_ELANG_SHIFT

BPT_ELANG_SHIFT = _ida_dbg.BPT_ELANG_SHIFT

◆ BPT_ENABLED

BPT_ENABLED = _ida_dbg.BPT_ENABLED

◆ BPT_LOWCND

BPT_LOWCND = _ida_dbg.BPT_LOWCND

◆ BPT_TRACE

BPT_TRACE = _ida_dbg.BPT_TRACE

◆ BPT_TRACE_BBLK

BPT_TRACE_BBLK = _ida_dbg.BPT_TRACE_BBLK

◆ BPT_TRACE_FUNC

BPT_TRACE_FUNC = _ida_dbg.BPT_TRACE_FUNC

◆ BPT_TRACE_INSN

BPT_TRACE_INSN = _ida_dbg.BPT_TRACE_INSN

◆ BPT_TRACE_TYPES

BPT_TRACE_TYPES = _ida_dbg.BPT_TRACE_TYPES

◆ BPT_TRACEON

BPT_TRACEON = _ida_dbg.BPT_TRACEON

◆ BPT_UPDMEM

BPT_UPDMEM = _ida_dbg.BPT_UPDMEM

◆ BPTCK_ACT

BPTCK_ACT = _ida_dbg.BPTCK_ACT

◆ BPTCK_NO

BPTCK_NO = _ida_dbg.BPTCK_NO

◆ BPTCK_NONE

BPTCK_NONE = _ida_dbg.BPTCK_NONE

◆ BPTCK_YES

BPTCK_YES = _ida_dbg.BPTCK_YES

◆ BPTEV_ADDED

BPTEV_ADDED = _ida_dbg.BPTEV_ADDED

◆ BPTEV_CHANGED

BPTEV_CHANGED = _ida_dbg.BPTEV_CHANGED

◆ BPTEV_REMOVED

BPTEV_REMOVED = _ida_dbg.BPTEV_REMOVED

◆ BT_LOG_INSTS

BT_LOG_INSTS = _ida_dbg.BT_LOG_INSTS

◆ dbg_bpt

dbg_bpt = _ida_dbg.dbg_bpt

◆ dbg_bpt_changed

dbg_bpt_changed = _ida_dbg.dbg_bpt_changed

◆ dbg_exception

dbg_exception = _ida_dbg.dbg_exception

◆ dbg_finished_loading_bpts

dbg_finished_loading_bpts = _ida_dbg.dbg_finished_loading_bpts

◆ dbg_information

dbg_information = _ida_dbg.dbg_information

◆ dbg_last

dbg_last = _ida_dbg.dbg_last

◆ dbg_library_load

dbg_library_load = _ida_dbg.dbg_library_load

◆ dbg_library_unload

dbg_library_unload = _ida_dbg.dbg_library_unload

◆ dbg_null

dbg_null = _ida_dbg.dbg_null

◆ dbg_process_attach

dbg_process_attach = _ida_dbg.dbg_process_attach

◆ dbg_process_detach

dbg_process_detach = _ida_dbg.dbg_process_detach

◆ dbg_process_exit

dbg_process_exit = _ida_dbg.dbg_process_exit

◆ dbg_process_start

dbg_process_start = _ida_dbg.dbg_process_start

◆ dbg_request_error

dbg_request_error = _ida_dbg.dbg_request_error

◆ dbg_run_to

dbg_run_to = _ida_dbg.dbg_run_to

◆ dbg_started_loading_bpts

dbg_started_loading_bpts = _ida_dbg.dbg_started_loading_bpts

◆ dbg_step_into

dbg_step_into = _ida_dbg.dbg_step_into

◆ dbg_step_over

dbg_step_over = _ida_dbg.dbg_step_over

◆ dbg_step_until_ret

dbg_step_until_ret = _ida_dbg.dbg_step_until_ret

◆ dbg_suspend_process

dbg_suspend_process = _ida_dbg.dbg_suspend_process

◆ dbg_thread_exit

dbg_thread_exit = _ida_dbg.dbg_thread_exit

◆ dbg_thread_start

dbg_thread_start = _ida_dbg.dbg_thread_start

◆ dbg_trace

dbg_trace = _ida_dbg.dbg_trace

◆ DBGINV_ALL

DBGINV_ALL = _ida_dbg.DBGINV_ALL

◆ DBGINV_MEMCFG

DBGINV_MEMCFG = _ida_dbg.DBGINV_MEMCFG

◆ DBGINV_MEMORY

DBGINV_MEMORY = _ida_dbg.DBGINV_MEMORY

◆ DBGINV_NONE

DBGINV_NONE = _ida_dbg.DBGINV_NONE

◆ DBGINV_REDRAW

DBGINV_REDRAW = _ida_dbg.DBGINV_REDRAW

◆ DBGINV_REGS

DBGINV_REGS = _ida_dbg.DBGINV_REGS

◆ DEC_ERROR

DEC_ERROR = _ida_dbg.DEC_ERROR

◆ DEC_NOTASK

DEC_NOTASK = _ida_dbg.DEC_NOTASK

◆ DEC_TIMEOUT

DEC_TIMEOUT = _ida_dbg.DEC_TIMEOUT

◆ DOPT_BPT_MSGS

DOPT_BPT_MSGS = _ida_dbg.DOPT_BPT_MSGS

◆ DOPT_DISABLE_ASLR

DOPT_DISABLE_ASLR = _ida_dbg.DOPT_DISABLE_ASLR

◆ DOPT_END_BPT

DOPT_END_BPT = _ida_dbg.DOPT_END_BPT

◆ DOPT_ENTRY_BPT

DOPT_ENTRY_BPT = _ida_dbg.DOPT_ENTRY_BPT

◆ DOPT_EXCDLG

DOPT_EXCDLG = _ida_dbg.DOPT_EXCDLG

◆ DOPT_FAST_STEP

DOPT_FAST_STEP = _ida_dbg.DOPT_FAST_STEP

◆ DOPT_INFO_BPT

DOPT_INFO_BPT = _ida_dbg.DOPT_INFO_BPT

◆ DOPT_INFO_MSGS

DOPT_INFO_MSGS = _ida_dbg.DOPT_INFO_MSGS

◆ DOPT_LIB_BPT

DOPT_LIB_BPT = _ida_dbg.DOPT_LIB_BPT

◆ DOPT_LIB_MSGS

DOPT_LIB_MSGS = _ida_dbg.DOPT_LIB_MSGS

◆ DOPT_LOAD_DINFO

DOPT_LOAD_DINFO = _ida_dbg.DOPT_LOAD_DINFO

◆ DOPT_REAL_MEMORY

DOPT_REAL_MEMORY = _ida_dbg.DOPT_REAL_MEMORY

◆ DOPT_REDO_STACK

DOPT_REDO_STACK = _ida_dbg.DOPT_REDO_STACK

◆ DOPT_SEGM_MSGS

DOPT_SEGM_MSGS = _ida_dbg.DOPT_SEGM_MSGS

◆ DOPT_START_BPT

DOPT_START_BPT = _ida_dbg.DOPT_START_BPT

◆ DOPT_TEMP_HWBPT

DOPT_TEMP_HWBPT = _ida_dbg.DOPT_TEMP_HWBPT

◆ DOPT_THREAD_BPT

DOPT_THREAD_BPT = _ida_dbg.DOPT_THREAD_BPT

◆ DOPT_THREAD_MSGS

DOPT_THREAD_MSGS = _ida_dbg.DOPT_THREAD_MSGS

◆ DSTATE_NOTASK

DSTATE_NOTASK = _ida_dbg.DSTATE_NOTASK

◆ DSTATE_RUN

DSTATE_RUN = _ida_dbg.DSTATE_RUN

◆ DSTATE_SUSP

DSTATE_SUSP = _ida_dbg.DSTATE_SUSP

◆ EXCDLG_ALWAYS

EXCDLG_ALWAYS = _ida_dbg.EXCDLG_ALWAYS

◆ EXCDLG_NEVER

EXCDLG_NEVER = _ida_dbg.EXCDLG_NEVER

◆ EXCDLG_UNKNOWN

EXCDLG_UNKNOWN = _ida_dbg.EXCDLG_UNKNOWN

◆ FT_LOG_RET

FT_LOG_RET = _ida_dbg.FT_LOG_RET

◆ IT_LOG_SAME_IP

IT_LOG_SAME_IP = _ida_dbg.IT_LOG_SAME_IP

◆ MOVBPT_BAD_TYPE

MOVBPT_BAD_TYPE = _ida_dbg.MOVBPT_BAD_TYPE

◆ MOVBPT_DEST_BUSY

MOVBPT_DEST_BUSY = _ida_dbg.MOVBPT_DEST_BUSY

◆ MOVBPT_NOT_FOUND

MOVBPT_NOT_FOUND = _ida_dbg.MOVBPT_NOT_FOUND

◆ MOVBPT_OK

MOVBPT_OK = _ida_dbg.MOVBPT_OK

◆ move_bpt_to_grp

bool move_bpt_to_grp = set_bpt_group

◆ SAVE_ALL_VALUES

SAVE_ALL_VALUES = _ida_dbg.SAVE_ALL_VALUES

◆ SAVE_DIFF

SAVE_DIFF = _ida_dbg.SAVE_DIFF

◆ SAVE_NONE

SAVE_NONE = _ida_dbg.SAVE_NONE

◆ SRCDBG_PROV_VERSION

SRCDBG_PROV_VERSION = _ida_dbg.SRCDBG_PROV_VERSION

◆ SRCIT_EXPR

SRCIT_EXPR = _ida_dbg.SRCIT_EXPR

◆ SRCIT_FUNC

SRCIT_FUNC = _ida_dbg.SRCIT_FUNC

◆ SRCIT_LOCVAR

SRCIT_LOCVAR = _ida_dbg.SRCIT_LOCVAR

◆ SRCIT_MODULE

SRCIT_MODULE = _ida_dbg.SRCIT_MODULE

◆ SRCIT_NONE

SRCIT_NONE = _ida_dbg.SRCIT_NONE

◆ SRCIT_STMT

SRCIT_STMT = _ida_dbg.SRCIT_STMT

◆ SRCIT_STTVAR

SRCIT_STTVAR = _ida_dbg.SRCIT_STTVAR

◆ ST_ALREADY_LOGGED

ST_ALREADY_LOGGED = _ida_dbg.ST_ALREADY_LOGGED

◆ ST_DIFFERENTIAL

ST_DIFFERENTIAL = _ida_dbg.ST_DIFFERENTIAL

◆ ST_OPTIONS_DEFAULT

ST_OPTIONS_DEFAULT = _ida_dbg.ST_OPTIONS_DEFAULT

◆ ST_OPTIONS_MASK

ST_OPTIONS_MASK = _ida_dbg.ST_OPTIONS_MASK

◆ ST_OVER_DEBUG_SEG

ST_OVER_DEBUG_SEG = _ida_dbg.ST_OVER_DEBUG_SEG

◆ ST_OVER_LIB_FUNC

ST_OVER_LIB_FUNC = _ida_dbg.ST_OVER_LIB_FUNC

◆ ST_SKIP_LOOPS

ST_SKIP_LOOPS = _ida_dbg.ST_SKIP_LOOPS

◆ tev_bpt

tev_bpt = _ida_dbg.tev_bpt

◆ tev_call

tev_call = _ida_dbg.tev_call

◆ tev_event

tev_event = _ida_dbg.tev_event

◆ tev_insn

tev_insn = _ida_dbg.tev_insn

◆ tev_max

tev_max = _ida_dbg.tev_max

◆ tev_mem

tev_mem = _ida_dbg.tev_mem

◆ tev_none

tev_none = _ida_dbg.tev_none

◆ tev_ret

tev_ret = _ida_dbg.tev_ret

◆ WFNE_ANY

WFNE_ANY = _ida_dbg.WFNE_ANY

◆ WFNE_CONT

WFNE_CONT = _ida_dbg.WFNE_CONT

◆ WFNE_NOWAIT

WFNE_NOWAIT = _ida_dbg.WFNE_NOWAIT

◆ WFNE_SILENT

WFNE_SILENT = _ida_dbg.WFNE_SILENT

◆ WFNE_SUSP

WFNE_SUSP = _ida_dbg.WFNE_SUSP

◆ WFNE_USEC

WFNE_USEC = _ida_dbg.WFNE_USEC