Detailed Description

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
	Proxy of C++ bpt_location_t class. More...

class	bpt_t
	Proxy of C++ bpt_t class. More...

class	bpt_vec_t
	Proxy of C++ qvector< bpt_t > class. More...

class	bptaddrs_t
	Proxy of C++ bptaddrs_t class. More...

class	DBG_Hooks
	Proxy of C++ DBG_Hooks class. More...

class	eval_ctx_t
	Proxy of C++ eval_ctx_t class. More...

class	memreg_info_t
	Proxy of C++ memreg_info_t class. More...

class	memreg_infos_t
	Proxy of C++ qvector< memreg_info_t > class. More...

class	tev_info_reg_t
	Proxy of C++ tev_info_reg_t class. More...

class	tev_info_t
	Proxy of C++ tev_info_t class. More...

class	tev_reg_value_t
	Proxy of C++ tev_reg_value_t class. More...

class	tev_reg_values_t
	Proxy of C++ qvector< tev_reg_value_t > class. More...

class	tevinforeg_vec_t
	Proxy of C++ qvector< tev_info_reg_t > class. More...

Functions
"bool"	run_to (*args)
	run_to(ea, pid=pid_t(-1), tid=0) -> bool Execute the process until the given address is reached.

"bool"	request_run_to (*args)
	request_run_to(ea, pid=pid_t(-1), tid=0) -> bool Post a run_to() request.

"bool"	run_requests ()
	run_requests() -> bool Execute requests until all requests are processed or an asynchronous function is called.

"ui_notification_t"	get_running_request ()
	get_running_request() -> ui_notification_t Get the current running request.

"bool"	is_request_running ()
	is_request_running() -> bool Is a request currently running?

"dbg_notification_t"	get_running_notification ()
	get_running_notification() -> dbg_notification_t Get the notification associated (if any) with the current running request.

"void"	clear_requests_queue ()
	clear_requests_queue() Clear the queue of waiting requests.

"int"	get_process_state ()
	get_process_state() -> int Return the state of the currently debugged process.

"bool"	is_valid_dstate ("int" state)
	is_valid_dstate(state) -> bool

"int"	set_process_state ("int" newstate, "thid_t *" p_thid, "int" dbginv)
	set_process_state(newstate, p_thid, dbginv) -> int Set new state for the debugged process.

"int"	invalidate_dbg_state ("int" dbginv)
	invalidate_dbg_state(dbginv) -> int Invalidate cached debugger information.

"int"	start_process ("char const " path=None, "char const " args=None, "char const *" sdir=None)
	start_process(path=None, args=None, sdir=None) -> int Start a process in the debugger.

"int"	request_start_process ("char const " path=None, "char const " args=None, "char const *" sdir=None)
	request_start_process(path=None, args=None, sdir=None) -> int Post a start_process() request.

"bool"	suspend_process ()
	suspend_process() -> bool Suspend the process in the debugger.

"bool"	request_suspend_process ()
	request_suspend_process() -> bool Post a suspend_process() request.

"bool"	continue_process ()
	continue_process() -> bool Continue the execution of the process in the debugger.

"bool"	request_continue_process ()
	request_continue_process() -> bool Post a continue_process() request.

"bool"	exit_process ()
	exit_process() -> bool Terminate the debugging of the current process.

"bool"	request_exit_process ()
	request_exit_process() -> bool Post an exit_process() request.

"ssize_t"	get_processes ("procinfo_vec_t" proclist)
	get_processes(proclist) -> ssize_t Take a snapshot of running processes and return their description.

"int"	attach_process (*args)
	attach_process(pid=pid_t(-1), event_id=-1) -> int Attach the debugger to a running process.

"int"	request_attach_process ("pid_t" pid, "int" event_id)
	request_attach_process(pid, event_id) -> int Post an attach_process() request.

"bool"	detach_process ()
	detach_process() -> bool Detach the debugger from the debugged process.

"bool"	request_detach_process ()
	request_detach_process() -> bool Post a detach_process() request.

"bool"	is_debugger_busy ()
	is_debugger_busy() -> bool Is the debugger busy?.

"int"	get_thread_qty ()
	get_thread_qty() -> int Get number of threads.

"thid_t"	getn_thread ("int" n)
	getn_thread(n) -> thid_t Get the ID of a thread.

"thid_t"	get_current_thread ()
	get_current_thread() -> thid_t Get current thread ID.

"char const *"	getn_thread_name ("int" n)
	getn_thread_name(n) -> char const * Get the NAME of a thread \sq{Type, Synchronous function, Notification, none (synchronous function)}

"bool"	select_thread ("thid_t" tid)
	select_thread(tid) -> bool Select the given thread as the current debugged thread.

"bool"	request_select_thread ("thid_t" tid)
	request_select_thread(tid) -> bool Post a select_thread() request.

"int"	suspend_thread ("thid_t" tid)
	suspend_thread(tid) -> int Suspend thread.

"int"	request_suspend_thread ("thid_t" tid)
	request_suspend_thread(tid) -> int Post a suspend_thread() request.

"int"	resume_thread ("thid_t" tid)
	resume_thread(tid) -> int Resume thread.

"int"	request_resume_thread ("thid_t" tid)
	request_resume_thread(tid) -> int Post a resume_thread() request.

"bool"	get_first_module ("modinfo_t" modinfo)
	get_first_module(modinfo) -> bool

"bool"	get_next_module ("modinfo_t" modinfo)
	get_next_module(modinfo) -> bool

"bool"	step_into ()
	step_into() -> bool Execute one instruction in the current thread.

"bool"	request_step_into ()
	request_step_into() -> bool Post a step_into() request.

"bool"	step_over ()
	step_over() -> bool Execute one instruction in the current thread, but without entering into functions.

"bool"	request_step_over ()
	request_step_over() -> bool Post a step_over() request.

"bool"	step_until_ret ()
	step_until_ret() -> bool Execute instructions in the current thread until a function return instruction is executed (aka "step out").

"bool"	request_step_until_ret ()
	request_step_until_ret() -> bool Post a step_until_ret() request.

"bool"	set_resume_mode ("thid_t" tid, "resume_mode_t" mode)
	set_resume_mode(tid, mode) -> bool How to resume the application.

"bool"	request_set_resume_mode ("thid_t" tid, "resume_mode_t" mode)
	request_set_resume_mode(tid, mode) -> bool Post a set_resume_mode() request.

"bool"	get_dbg_reg_info ("char const *" regname, "register_info_t" ri)
	get_dbg_reg_info(regname, ri) -> bool Get register information \sq{Type, Synchronous function, Notification, none (synchronous function)}

"uint64 *"	get_sp_val ()
	get_sp_val() -> bool Get value of the SP register for the current thread.

"uint64 *"	get_ip_val ()
	get_ip_val() -> bool Get value of the IP (program counter) register for the current thread.

"bool"	is_reg_integer ("char const *" regname)
	is_reg_integer(regname) -> bool Does a register contain an integer value? \sq{Type, Synchronous function, Notification, none (synchronous function)}

"bool"	is_reg_float ("char const *" regname)
	is_reg_float(regname) -> bool Does a register contain a floating point value? \sq{Type, Synchronous function, Notification, none (synchronous function)}

"bool"	is_reg_custom ("char const *" regname)
	is_reg_custom(regname) -> bool Does a register contain a value of a custom data type? \sq{Type, Synchronous function, Notification, none (synchronous function)}

"int"	set_bptloc_string ("char const *" s)
	set_bptloc_string(s) -> int

"char const *"	get_bptloc_string ("int" i)
	get_bptloc_string(i) -> char const *

"int"	get_bpt_qty ()
	get_bpt_qty() -> int Get number of breakpoints.

"bool"	getn_bpt ("int" n, "bpt_t" bpt)
	getn_bpt(n, bpt) -> bool Get the characteristics of a breakpoint.

"bool"	get_bpt ("ea_t" ea, "bpt_t" bpt)
	get_bpt(ea, bpt) -> bool Get the characteristics of a breakpoint.

"bool"	exist_bpt ("ea_t" ea)
	exist_bpt(ea) -> bool Does a breakpoint exist at the given location?

"bool"	add_bpt (*args)
	add_bpt(ea, size=0, type=BPT_DEFAULT) -> bool Add a new breakpoint in the debugged process.

"bool"	request_add_bpt (*args)
	request_add_bpt(ea, size=0, type=BPT_DEFAULT) -> bool Post an add_bpt(const bpt_t &) request.

"bool"	del_bpt (*args)
	del_bpt(ea) -> bool Delete an existing breakpoint in the debugged process.

"bool"	request_del_bpt (*args)
	request_del_bpt(ea) -> bool Post a del_bpt(const bpt_location_t &) request.

"bool"	update_bpt ("bpt_t" bpt)
	update_bpt(bpt) -> bool Update modifiable characteristics of an existing breakpoint.

"bool"	find_bpt ("bpt_location_t" bptloc, "bpt_t" bpt)
	find_bpt(bptloc, bpt) -> bool Find a breakpoint by location.

"bool"	enable_bpt (*args)
	enable_bpt(ea, enable=True) -> bool

"bool"	disable_bpt (*args)
	disable_bpt(ea) -> bool

"bool"	request_enable_bpt (*args)
	request_enable_bpt(ea, enable=True) -> bool

"bool"	request_disable_bpt (*args)
	request_disable_bpt(ea) -> bool

"int"	check_bpt ("ea_t" ea)
	check_bpt(ea) -> int Check the breakpoint at the specified address.

"bool"	set_trace_size ("int" size)
	set_trace_size(size) -> bool Specify the new size of the circular buffer.

"void"	clear_trace ()
	clear_trace() Clear all events in the trace buffer.

"void"	request_clear_trace ()
	request_clear_trace() Post a clear_trace() request.

"bool"	is_step_trace_enabled ()
	is_step_trace_enabled() -> bool Get current state of step tracing.

"bool"	enable_step_trace ("int" enable=1)
	enable_step_trace(enable=1) -> bool

"bool"	disable_step_trace ()
	disable_step_trace() -> bool

"bool"	request_enable_step_trace ("int" enable=1)
	request_enable_step_trace(enable=1) -> bool

"bool"	request_disable_step_trace ()
	request_disable_step_trace() -> bool

"int"	get_step_trace_options ()
	get_step_trace_options() -> int Get current step tracing options.

"void"	set_step_trace_options ("int" options)
	set_step_trace_options(options) Modify step tracing options.

"void"	request_set_step_trace_options ("int" options)
	request_set_step_trace_options(options) Post a set_step_trace_options() request.

"bool"	is_insn_trace_enabled ()
	is_insn_trace_enabled() -> bool Get current state of instruction tracing.

"bool"	enable_insn_trace ("bool" enable=True)
	enable_insn_trace(enable=True) -> bool

"bool"	disable_insn_trace ()
	disable_insn_trace() -> bool

"bool"	request_enable_insn_trace ("bool" enable=True)
	request_enable_insn_trace(enable=True) -> bool

"bool"	request_disable_insn_trace ()
	request_disable_insn_trace() -> bool

"int"	get_insn_trace_options ()
	get_insn_trace_options() -> int Get current instruction tracing options.

"void"	set_insn_trace_options ("int" options)
	set_insn_trace_options(options) Modify instruction tracing options.

"void"	request_set_insn_trace_options ("int" options)
	request_set_insn_trace_options(options) Post a set_insn_trace_options() request.

"bool"	is_func_trace_enabled ()
	is_func_trace_enabled() -> bool Get current state of functions tracing.

"bool"	enable_func_trace ("bool" enable=True)
	enable_func_trace(enable=True) -> bool

"bool"	disable_func_trace ()
	disable_func_trace() -> bool

"bool"	request_enable_func_trace ("bool" enable=True)
	request_enable_func_trace(enable=True) -> bool

"bool"	request_disable_func_trace ()
	request_disable_func_trace() -> bool

"int"	get_func_trace_options ()
	get_func_trace_options() -> int Get current function tracing options.

"void"	set_func_trace_options ("int" options)
	set_func_trace_options(options) Modify function tracing options.

"void"	request_set_func_trace_options ("int" options)
	request_set_func_trace_options(options) Post a set_func_trace_options() request.

"bool"	enable_bblk_trace ("bool" enable=True)
	enable_bblk_trace(enable=True) -> bool

"bool"	disable_bblk_trace ()
	disable_bblk_trace() -> bool

"bool"	request_enable_bblk_trace ("bool" enable=True)
	request_enable_bblk_trace(enable=True) -> bool

"bool"	request_disable_bblk_trace ()
	request_disable_bblk_trace() -> bool

"bool"	is_bblk_trace_enabled ()
	is_bblk_trace_enabled() -> bool

"int"	get_bblk_trace_options ()
	get_bblk_trace_options() -> int Get current basic block tracing options.

"void"	set_bblk_trace_options ("int" options)
	set_bblk_trace_options(options) Modify basic block tracing options (see BT_LOG_INSTS)

"void"	request_set_bblk_trace_options ("int" options)
	request_set_bblk_trace_options(options) Post a set_bblk_trace_options() request.

"int"	get_tev_qty ()
	get_tev_qty() -> int Get number of trace events available in trace buffer.

"bool"	get_tev_info ("int" n, "tev_info_t" tev_info)
	get_tev_info(n, tev_info) -> bool Get main information about a trace event.

"bool"	get_insn_tev_reg_val ("int" n, "char const *" regname, "regval_t" regval)
	get_insn_tev_reg_val(n, regname, regval) -> bool

"bool"	get_insn_tev_reg_mem ("int" n, "memreg_infos_t" memmap)
	get_insn_tev_reg_mem(n, memmap) -> bool Read the memory pointed by register values from an instruction trace event.

"bool"	get_insn_tev_reg_result ("int" n, "char const *" regname, "regval_t" regval)
	get_insn_tev_reg_result(n, regname, regval) -> bool

"ea_t"	get_call_tev_callee ("int" n)
	get_call_tev_callee(n) -> ea_t Get the called function from a function call trace event.

"ea_t"	get_ret_tev_return ("int" n)
	get_ret_tev_return(n) -> ea_t Get the return address from a function return trace event.

"ea_t"	get_bpt_tev_ea ("int" n)
	get_bpt_tev_ea(n) -> ea_t Get the address associated to a read, read/write or execution trace event.

"bool"	get_tev_memory_info ("int" n, "meminfo_vec_t" mi)
	get_tev_memory_info(n, mi) -> bool Get the memory layout, if any, for the specified tev object.

"bool"	get_tev_event ("int" n, "debug_event_t" d)
	get_tev_event(n, d) -> bool Get the corresponding debug event, if any, for the specified tev object.

"ea_t"	get_trace_base_address ()
	get_trace_base_address() -> ea_t Get the base address of the current trace.

"void"	set_trace_base_address ("ea_t" ea)
	set_trace_base_address(ea) Set the base address of the current trace.

"void"	dbg_add_thread ("thid_t" tid)
	dbg_add_thread(tid) Add a thread to the current trace.

"void"	dbg_del_thread ("thid_t" tid)
	dbg_del_thread(tid) Delete a thread from the current trace.

"void"	dbg_add_tev ("tev_type_t" type, "thid_t" tid, "ea_t" address)
	dbg_add_tev(type, tid, address) Add a new trace element to the current trace.

"bool"	dbg_add_many_tevs ("tevinforeg_vec_t" new_tevs)
	dbg_add_many_tevs(new_tevs) -> bool Add many new trace elements to the current trace.

"bool"	dbg_add_insn_tev ("thid_t" tid, "ea_t" ea, "save_reg_values_t" save=SAVE_DIFF)
	dbg_add_insn_tev(tid, ea, save=SAVE_DIFF) -> bool Add a new instruction trace element to the current trace.

"bool"	dbg_add_bpt_tev ("thid_t" tid, "ea_t" ea, "ea_t" bp)
	dbg_add_bpt_tev(tid, ea, bp) -> bool Add a new breakpoint trace element to the current trace.

"void"	dbg_add_call_tev ("thid_t" tid, "ea_t" caller, "ea_t" callee)
	dbg_add_call_tev(tid, caller, callee) Add a new call trace element to the current trace.

"void"	dbg_add_ret_tev ("thid_t" tid, "ea_t" ret_insn, "ea_t" return_to)
	dbg_add_ret_tev(tid, ret_insn, return_to) Add a new return trace element to the current trace.

"void"	dbg_add_debug_event ("debug_event_t" event)
	dbg_add_debug_event(event) Add a new debug event to the current trace.

"qstring *"	load_trace_file ("char const *" filename)
	load_trace_file(filename) -> str Load a recorded trace file in the 'Tracing' window.

"bool"	save_trace_file ("char const " filename, "char const " description)
	save_trace_file(filename, description) -> bool Save the current trace in the specified file.

"bool"	is_valid_trace_file ("char const *" filename)
	is_valid_trace_file(filename) -> bool Is the specified file a valid trace file for the current database?

"bool"	set_trace_file_desc ("char const " filename, "char const " description)
	set_trace_file_desc(filename, description) -> bool Change the description of the specified trace file.

"qstring *"	get_trace_file_desc ("char const *" filename)
	get_trace_file_desc(filename) -> str Get the file header of the specified trace file.

"qstring *"	choose_trace_file ()
	choose_trace_file() -> str Show the choose trace dialog.

"bool"	diff_trace_file ("char const *" NONNULL_filename)
	diff_trace_file(NONNULL_filename) -> bool Show difference between the current trace and the one from 'filename'.

"bool"	graph_trace ()
	graph_trace() -> bool Show the trace callgraph.

"void"	set_highlight_trace_options ("bool" hilight, "bgcolor_t" color, "bgcolor_t" diff)
	set_highlight_trace_options(hilight, color, diff) Set highlight trace parameters.

"void"	set_trace_platform ("char const *" platform)
	set_trace_platform(platform) Set platform name of current trace.

"char const *"	get_trace_platform ()
	get_trace_platform() -> char const * Get platform name of current trace.

"void"	set_trace_dynamic_register_set ("dynamic_register_set_t &" idaregs)
	set_trace_dynamic_register_set(idaregs) Set dynamic register set of current trace.

"void"	get_trace_dynamic_register_set ("dynamic_register_set_t *" idaregs)
	get_trace_dynamic_register_set(idaregs) Get dynamic register set of current trace.

"dbg_event_code_t"	wait_for_next_event ("int" wfne, "int" timeout)
	wait_for_next_event(wfne, timeout) -> dbg_event_code_t Wait for the next event.

"debug_event_t const *"	get_debug_event ()
	get_debug_event() -> debug_event_t Get the current debugger event.

"uint"	set_debugger_options ("uint" options)
	set_debugger_options(options) -> uint Set debugger options.

"void"	set_remote_debugger ("char const " host, "char const " _pass, "int" port=-1)
	set_remote_debugger(host, _pass, port=-1) Set remote debugging options.

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

"excvec_t *"	retrieve_exceptions ()
	retrieve_exceptions() -> excvec_t Retrieve the exception information.

"bool"	store_exceptions ()
	store_exceptions() -> bool Update the exception information stored in the debugger module by invoking its dbg->set_exception_info callback

"char const *"	define_exception ("uint" code, "char const " name, "char const " desc, "int" flags)
	define_exception(code, name, desc, flags) -> char const * Convenience function: define new exception code.

"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_source_viewer(out_ccv, parent, custview, sf, lines, lnnum, colnum, flags) -> source_view_t * Create a source code view.

"uint32 *"	get_dbg_byte ("ea_t" ea)
	get_dbg_byte(ea) -> bool Get one byte of the debugged process memory.

"bool"	put_dbg_byte ("ea_t" ea, "uint32" x)
	put_dbg_byte(ea, x) -> bool Change one byte of the debugged process memory.

"void"	invalidate_dbgmem_config ()
	invalidate_dbgmem_config() Invalidate the debugged process memory configuration.

"void"	invalidate_dbgmem_contents ("ea_t" ea, "asize_t" size)
	invalidate_dbgmem_contents(ea, size) Invalidate the debugged process memory contents.

"bool"	is_debugger_on ()
	is_debugger_on() -> bool Is the debugger currently running?

"bool"	is_debugger_memory ("ea_t" ea)
	is_debugger_memory(ea) -> bool Is the address mapped to debugger memory?

"ea_t"	get_tev_ea ("int" n)
	get_tev_ea(n) -> ea_t

"int"	get_tev_type ("int" n)
	get_tev_type(n) -> int

"int"	get_tev_tid ("int" n)
	get_tev_tid(n) -> int

"void"	bring_debugger_to_front ()
	bring_debugger_to_front()

"void"	set_manual_regions ("meminfo_vec_t" ranges)
	set_manual_regions(ranges)

"void"	edit_manual_regions ()
	edit_manual_regions()

"void"	enable_manual_regions ("bool" enable)
	enable_manual_regions(enable)

"int"	handle_debug_event ("debug_event_t" ev, "int" rqflags)
	handle_debug_event(ev, rqflags) -> int

"bool"	add_virt_module ("modinfo_t" mod)
	add_virt_module(mod) -> bool

"bool"	del_virt_module ("ea_t const" base)
	del_virt_module(base) -> bool

"int"	internal_ioctl ("int" fn, "void const " buf, "void " poutbuf, "ssize_t " poutsize)
	internal_ioctl(fn, buf, poutbuf, poutsize) -> int

"int"	get_dbg_memory_info ("meminfo_vec_t" ranges)
	get_dbg_memory_info(ranges) -> int

"bool"	set_bpt_group ("bpt_t" bpt, "char const *" grp_name)
	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)}

"bool"	set_bptloc_group ("bpt_location_t" bptloc, "char const *" grp_name)
	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)}

"qstring *"	get_bpt_group ("bpt_location_t" bptloc)
	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)}

"bool"	rename_bptgrp ("char const " old_name, "char const " new_name)
	rename_bptgrp(old_name, new_name) -> bool Rename a folder of bpt dirtree \sq{Type, Synchronous function, Notification, none (synchronous function)}

"bool"	del_bptgrp ("char const *" name)
	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)}

"ssize_t"	get_grp_bpts ("bpt_vec_t" bpts, "char const *" grp_name)
	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)}

"int"	enable_bptgrp ("char const *" bptgrp_name, "bool" enable=True)
	enable_bptgrp(bptgrp_name, enable=True) -> int Enable (or disable) all bpts in a folder \sq{Type, Synchronous function, Notification, none (synchronous function)}

"bool"	get_local_vars ("srcinfo_provider_t " prov, "ea_t" ea, "source_items_t " out)
	get_local_vars(prov, ea, out) -> bool

"bool"	srcdbg_request_step_into ()
	srcdbg_request_step_into() -> bool

"bool"	srcdbg_request_step_over ()
	srcdbg_request_step_over() -> bool

"bool"	srcdbg_request_step_until_ret ()
	srcdbg_request_step_until_ret() -> bool

"int"	hide_all_bpts ()
	hide_all_bpts() -> int

"ssize_t"	read_dbg_memory ("ea_t" ea, "void *" buffer, "size_t" size)
	read_dbg_memory(ea, buffer, size) -> ssize_t

"bool"	get_module_info ("ea_t" ea, "modinfo_t" modinfo)
	get_module_info(ea, modinfo) -> bool

"uint64 , qstring "	dbg_bin_search ("ea_t" start_ea, "ea_t" end_ea, "compiled_binpat_vec_t const &" data, "int" srch_flags)
	dbg_bin_search(start_ea, end_ea, data, srch_flags) -> str

"bool"	load_debugger ("char const *" dbgname, "bool" use_remote)
	load_debugger(dbgname, use_remote) -> bool

"bool"	collect_stack_trace ("thid_t" tid, "call_stack_t" trace)
	collect_stack_trace(tid, trace) -> bool

"bool"	get_global_var ("srcinfo_provider_t " prov, "ea_t" ea, "char const " name, "source_item_ptr *" out)
	get_global_var(prov, ea, name, out) -> bool

"bool"	get_local_var ("srcinfo_provider_t " prov, "ea_t" ea, "char const " name, "source_item_ptr *" out)
	get_local_var(prov, ea, name, out) -> bool

"srcinfo_provider_t *"	get_srcinfo_provider ("char const *" name)
	get_srcinfo_provider(name) -> srcinfo_provider_t *

"qstring *"	get_current_source_file ()
	get_current_source_file() -> str

"int"	get_current_source_line ()
	get_current_source_line() -> int

"void"	add_path_mapping ("char const " src, "char const " dst)
	add_path_mapping(src, dst)

"bool"	srcdbg_step_into ()
	srcdbg_step_into() -> bool

"bool"	srcdbg_step_over ()
	srcdbg_step_over() -> bool

"bool"	srcdbg_step_until_ret ()
	srcdbg_step_until_ret() -> bool

"void"	set_debugger_event_cond ("char const *" NONNULL_evcond)
	set_debugger_event_cond(NONNULL_evcond)

"char const *"	get_debugger_event_cond ()
	get_debugger_event_cond() -> char const *

"void"	set_process_options (*args)
	set_process_options(path, args, envs, sdir, host, _pass, port) Set process options.

"qstring , qstring , qstring , qstring , qstring , int "	get_process_options ()
	get_process_options() Get process options.

"PyObject *"	get_manual_regions (*args)
	Returns the manual memory regions.

"bool"	dbg_is_loaded ()
	Checks if a debugger is loaded.

"PyObject *"	refresh_debugger_memory ()
	Refreshes the debugger memory.

"PyObject *"	list_bptgrps (*args)
	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)}

"ea_t"	internal_get_sreg_base ("thid_t" tid, "int" sreg_value)
	Get the sreg base, for the given thread.

"ssize_t"	write_dbg_memory (*args)
	write_dbg_memory(ea, py_buf, size=size_t(-1)) -> ssize_t

"bool"	dbg_can_query ()

"PyObject *"	set_reg_val (*args)
	set_reg_val(regname, o) -> PyObject

"PyObject *"	request_set_reg_val ("char const " regname, "PyObject " o)
	request_set_reg_val(regname, o) -> PyObject * Post a set_reg_val() request.

"PyObject *"	get_reg_val (*args)
	get_reg_val(regname, regval) -> bool Get register value as an unsigned 64-bit int.

"regvals_t *"	get_reg_vals ("thid_t" tid, "int" clsmask=-1)
	Fetch live registers values for the thread.

	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)
	Send a direct command to the debugger backend, and retrieve the result as a string.

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 )

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

Parameters

bpt	(C++: const bpt_t &) Breakpoint to add. It describes the break condition, type, flags, location (module relative, source breakpoint or absolute) and other attributes.
size	asize_t
type	bpttype_t

add_bpt(bpt) -> bool

Parameters

bpt	bpt_t const &

◆ add_path_mapping()

"void" add_path_mapping	(	"char const *"	src,
		"char const *"	dst )

Parameters

src	char const *
dst	char const *

◆ add_virt_module()

"bool" add_virt_module ( "modinfo_t" mod )

Parameters

mod	modinfo_t const *

◆ attach_process()

"int" attach_process ( * args )

\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.

Parameters

pid	(C++: pid_t) PID of the process to attach to. If NO_PROCESS, a dialog box will interactively ask the user for the process to attach to.

Return values

-4	debugger was not inited
-3	the attaching is not supported
-2	impossible to find a compatible process
-1	impossible to attach to the given process (process died, privilege needed, not supported by the debugger plugin, ...)
0	the user cancelled the attaching to the process
1	the debugger properly attached to the process

◆ bring_debugger_to_front()

"void" bring_debugger_to_front ( )

◆ check_bpt()

"int" check_bpt ( "ea_t" ea )

Parameters

ea	(C++: ea_t)

Returns: : one of Breakpoint status codes

◆ choose_trace_file()

"qstring *" choose_trace_file ( )

◆ clear_requests_queue()

"void" clear_requests_queue ( )

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

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

Parameters

tid	thid_t
trace	call_stack_t *

◆ continue_process()

"bool" continue_process ( )

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

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

Parameters

out_ccv	(C++: TWidget **)
parent	(C++: TWidget *)
custview	(C++: TWidget *)
sf	(C++: source_file_ptr)
lines	(C++: strvec_t *)
lnnum	(C++: int)
colnum	(C++: int)
flags	(C++: int)

◆ dbg_add_bpt_tev()

"bool" dbg_add_bpt_tev	(	"thid_t"	tid,
		"ea_t"	ea,
		"ea_t"	bp )

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

Parameters

tid	(C++: thid_t)
ea	(C++: ea_t)
bp	(C++: ea_t)

Returns: : false if the operation failed, true otherwise

◆ dbg_add_call_tev()

"void" dbg_add_call_tev	(	"thid_t"	tid,
		"ea_t"	caller,
		"ea_t"	callee )

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

Parameters

tid	(C++: thid_t)
caller	(C++: ea_t)
callee	(C++: ea_t)

◆ dbg_add_debug_event()

"void" dbg_add_debug_event ( "debug_event_t" event )

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

Parameters

event (C++: debug_event_t *)

◆ dbg_add_insn_tev()

"bool" dbg_add_insn_tev	(	"thid_t"	tid,
		"ea_t"	ea,
		"save_reg_values_t"	save = SAVE_DIFF )

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

Parameters

tid	(C++: thid_t)
ea	(C++: ea_t)
save	(C++: save_reg_values_t) enum save_reg_values_t

Returns: : false if the operation failed, true otherwise

◆ dbg_add_many_tevs()

"bool" dbg_add_many_tevs ( "tevinforeg_vec_t" new_tevs )

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

Parameters

new_tevs (C++: tevinforeg_vec_t *)

Returns: : false if the operation failed for any tev_info_t object

◆ dbg_add_ret_tev()

"void" dbg_add_ret_tev	(	"thid_t"	tid,
		"ea_t"	ret_insn,
		"ea_t"	return_to )

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

Parameters

tid	(C++: thid_t)
ret_insn	(C++: ea_t)
return_to	(C++: ea_t)

◆ dbg_add_tev()

"void" dbg_add_tev	(	"tev_type_t"	type,
		"thid_t"	tid,
		"ea_t"	address )

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

Parameters

type	(C++: tev_type_t) enum tev_type_t
tid	(C++: thid_t)
address	(C++: ea_t)

◆ dbg_add_thread()

"void" dbg_add_thread ( "thid_t" tid )

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

Parameters

tid	(C++: thid_t)

◆ dbg_bin_search()

"uint64 , qstring " dbg_bin_search	(	"ea_t"	start_ea,
		"ea_t"	end_ea,
		"compiled_binpat_vec_t const &"	data,
		"int"	srch_flags )

Parameters

start_ea	ea_t
end_ea	ea_t
data	compiled_binpat_vec_t const &
srch_flags	int

◆ dbg_can_query()

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

"void" dbg_del_thread ( "thid_t" tid )

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

Parameters

tid	(C++: thid_t)

◆ dbg_is_loaded()

"bool" dbg_is_loaded ( )

Returns: : Boolean

◆ define_exception()

"char const *" define_exception	(	"uint"	code,
		"char const *"	name,
		"char const *"	desc,
		"int"	flags )

Parameters

code	(C++: uint) exception code (cannot be 0)
name	(C++: const char *) exception name (cannot be empty or nullptr)
desc	(C++: const char *) exception description (maybe nullptr)
flags	(C++: int) 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 )

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

Parameters

bptloc	(C++: const bpt_location_t &) Breakpoint location del_bpt(bptloc) -> bool
bptloc	bpt_location_t const &

◆ del_bptgrp()

"bool" del_bptgrp ( "char const *" name )

Parameters

name	(C++: const char *) full path to the folder to be deleted

Returns: : success

◆ del_virt_module()

"bool" del_virt_module ( "ea_t const" base )

Parameters

base	ea_t const

◆ detach_process()

"bool" detach_process ( )

\sq{Type, Asynchronous function - available as Request, Notification, dbg_process_detach}

◆ diff_trace_file()

"bool" diff_trace_file ( "char const *" NONNULL_filename )

Parameters

NONNULL_filename (C++: const char *) char const *

◆ disable_bblk_trace()

"bool" disable_bblk_trace ( )

◆ disable_bpt()

"bool" disable_bpt ( * args )

Parameters

ea ea_t

disable_bpt(bptloc) -> bool

Parameters

bptloc bpt_location_t const &

◆ disable_func_trace()

"bool" disable_func_trace ( )

◆ disable_insn_trace()

"bool" disable_insn_trace ( )

◆ disable_step_trace()

"bool" disable_step_trace ( )

◆ edit_manual_regions()

"void" edit_manual_regions ( )

◆ enable_bblk_trace()

"bool" enable_bblk_trace ( "bool" enable = True )

Parameters

enable bool

◆ enable_bpt()

"bool" enable_bpt ( * args )

Parameters

ea	ea_t
enable	bool

enable_bpt(bptloc, enable=True) -> bool

Parameters

bptloc	bpt_location_t const &
enable	bool

◆ enable_bptgrp()

"int" enable_bptgrp	(	"char const *"	bptgrp_name,
		"bool"	enable = True )

Parameters

bptgrp_name	(C++: const char *) absolute path to the folder
enable	(C++: bool) by default true, enable bpts, false disable bpts

Returns: : -1 an error occured 0 no changes >0 nubmers of bpts udpated

◆ enable_func_trace()

"bool" enable_func_trace ( "bool" enable = True )

Parameters

enable bool

◆ enable_insn_trace()

"bool" enable_insn_trace ( "bool" enable = True )

Parameters

enable bool

◆ enable_manual_regions()

"void" enable_manual_regions ( "bool" enable )

Parameters

enable bool

◆ enable_step_trace()

"bool" enable_step_trace ( "int" enable = 1 )

Parameters

enable int

◆ exist_bpt()

"bool" exist_bpt ( "ea_t" ea )

Parameters

ea	(C++: ea_t)

◆ exit_process()

"bool" exit_process ( )

\sq{Type, Asynchronous function

available as Request, Notification, dbg_process_exit}

◆ find_bpt()

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

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

Parameters

bptloc	(C++: const bpt_location_t &) Breakpoint location
bpt	(C++: bpt_t *) bpt is filled if the breakpoint was found

◆ get_bblk_trace_options()

"int" get_bblk_trace_options ( )

Also see BT_LOG_INSTS \sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ get_bpt()

"bool" get_bpt	(	"ea_t"	ea,
		"bpt_t"	bpt )

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

Parameters

ea	(C++: ea_t) any address in the breakpoint range
bpt	(C++: bpt_t *) if not nullptr, is filled with the characteristics.

Returns: : false if no breakpoint exists

◆ get_bpt_group()

"qstring *" get_bpt_group ( "bpt_location_t" bptloc )

Parameters

bptloc (C++: const bpt_location_t &) bptlocation of the bpt

Returns: : breakpoint correclty moved to the directory success

◆ get_bpt_qty()

"int" get_bpt_qty ( )

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

◆ get_bpt_tev_ea()

"ea_t" get_bpt_tev_ea ( "int" n )

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

Parameters

n	(C++: int) 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.

Note: : Usually, a breakpoint is associated with a read, read/write or execution trace event. However, the returned address could be any address in the range of this breakpoint. If the breakpoint was deleted after the trace event, the address no longer corresponds to a valid breakpoint.

◆ get_bptloc_string()

"char const *" get_bptloc_string ( "int" i )

Parameters

i int

◆ get_call_tev_callee()

"ea_t" get_call_tev_callee ( "int" n )

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

Parameters

n	(C++: int) 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()

"qstring *" get_current_source_file ( )

◆ get_current_source_line()

"int" get_current_source_line ( )

◆ get_current_thread()

"thid_t" get_current_thread ( )

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

◆ get_dbg_byte()

"uint32 *" get_dbg_byte ( "ea_t" ea )

Parameters

ea	(C++: ea_t) linear address

Returns: : true success false address inaccessible or debugger not running

◆ get_dbg_memory_info()

"int" get_dbg_memory_info ( "meminfo_vec_t" ranges )

Parameters

ranges meminfo_vec_t *

◆ get_dbg_reg_info()

"bool" get_dbg_reg_info	(	"char const *"	regname,
		"register_info_t"	ri )

Parameters

regname	(C++: const char ) char const
ri	(C++: register_info_t *)

◆ get_debug_event()

"debug_event_t const *" get_debug_event ( )

◆ get_debugger_event_cond()

"char const *" get_debugger_event_cond ( )

◆ get_first_module()

"bool" get_first_module ( "modinfo_t" modinfo )

Parameters

modinfo modinfo_t *

◆ get_func_trace_options()

"int" get_func_trace_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,
		"ea_t"	ea,
		"char const *"	name,
		"source_item_ptr *"	out )

Parameters

prov	srcinfo_provider_t *
ea	ea_t
name	char const *
out	source_item_ptr *

◆ get_grp_bpts()

"ssize_t" get_grp_bpts	(	"bpt_vec_t"	bpts,
		"char const *"	grp_name )

Parameters

bpts	(C++: bpt_vec_t *) : pointer to a vector where the copy of bpts are stored
grp_name	(C++: const char *) 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 )

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

Parameters

n	(C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event.
memmap	(C++: memreg_infos_t *) 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,
		"char const *"	regname,
		"regval_t"	regval )

Parameters

n	int
regname	char const *
regval	regval_t *

◆ get_insn_tev_reg_val()

"bool" get_insn_tev_reg_val	(	"int"	n,
		"char const *"	regname,
		"regval_t"	regval )

Parameters

n	int
regname	char const *
regval	regval_t *

◆ get_insn_trace_options()

"int" get_insn_trace_options ( )

Also see IT_LOG_SAME_IP \sq{Type, Synchronous function, Notification, none (synchronous function)}

◆ get_ip_val()

"uint64 *" get_ip_val ( )

Requires a suspended debugger.

◆ get_local_var()

"bool" get_local_var	(	"srcinfo_provider_t *"	prov,
		"ea_t"	ea,
		"char const *"	name,
		"source_item_ptr *"	out )

Parameters

prov	srcinfo_provider_t *
ea	ea_t
name	char const *
out	source_item_ptr *

◆ get_local_vars()

"bool" get_local_vars	(	"srcinfo_provider_t *"	prov,
		"ea_t"	ea,
		"source_items_t *"	out )

Parameters

prov	srcinfo_provider_t *
ea	ea_t
out	source_items_t *

◆ get_manual_regions()

"PyObject *" get_manual_regions ( * args )

Returns: : list(start_ea, end_ea, name, sclass, sbase, bitness, perm)

◆ get_module_info()

"bool" get_module_info	(	"ea_t"	ea,
		"modinfo_t"	modinfo )

Parameters

ea	ea_t
modinfo	modinfo_t *

◆ get_next_module()

"bool" get_next_module ( "modinfo_t" modinfo )

Parameters

modinfo modinfo_t *

◆ get_process_options()

"qstring *, qstring *, qstring *, qstring *, qstring *, int *" 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 ( )

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

Returns: : one of Debugged process states

◆ get_processes()

"ssize_t" get_processes ( "procinfo_vec_t" proclist )

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

Parameters

proclist (C++: procinfo_vec_t *) array with information about each running process

Returns: : number of processes or -1 on error

◆ get_reg_val()

"PyObject *" get_reg_val ( * args )

Parameters

regname	(C++: const char ) char const
regval	regval_t *

get_reg_val(regname, ival) -> bool

Parameters

regname	char const *
ival	uint64 *

get_reg_val(regname) -> bool, float, int

Parameters

regname char const *

◆ get_reg_vals()

"regvals_t *" get_reg_vals	(	"thid_t"	tid,
		"int"	clsmask = -1 )

Parameters

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

Returns: : a regvals_t instance (empty if an error occurs)

◆ get_ret_tev_return()

"ea_t" get_ret_tev_return ( "int" n )

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

Parameters

n	(C++: int) 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 ( )

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

Returns: : dbg_null if no running request

◆ get_running_request()

"ui_notification_t" get_running_request ( )

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

Returns: : ui_null if no running request

◆ get_sp_val()

"uint64 *" get_sp_val ( )

Requires a suspended debugger.

◆ get_srcinfo_provider()

"srcinfo_provider_t *" get_srcinfo_provider ( "char const *" name )

Parameters

name	char const *

◆ get_step_trace_options()

"int" get_step_trace_options ( )

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

Returns: : Step trace options

◆ get_tev_ea()

"ea_t" get_tev_ea ( "int" n )

Parameters

n int

◆ get_tev_event()

"bool" get_tev_event	(	"int"	n,
		"debug_event_t"	d )

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

Parameters

n	(C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event.
d	(C++: debug_event_t *) 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 )

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

Parameters

n	(C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event.
tev_info	(C++: tev_info_t *) result

Returns: : success

◆ get_tev_memory_info()

"bool" get_tev_memory_info	(	"int"	n,
		"meminfo_vec_t"	mi )

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

Parameters

n	(C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event.
mi	(C++: meminfo_vec_t *) 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 ( )

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

Parameters

n int

◆ get_tev_type()

"int" get_tev_type ( "int" n )

Parameters

n int

◆ get_thread_qty()

"int" get_thread_qty ( )

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

◆ get_trace_base_address()

"ea_t" get_trace_base_address ( )

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

Returns: : the base address of the currently loaded trace

◆ get_trace_dynamic_register_set()

"void" get_trace_dynamic_register_set ( "dynamic_register_set_t *" idaregs )

Parameters

idaregs (C++: dynamic_register_set_t *)

◆ get_trace_file_desc()

"qstring *" get_trace_file_desc ( "char const *" filename )

Parameters

filename (C++: const char *) char const *

◆ get_trace_platform()

"char const *" get_trace_platform ( )

◆ getn_bpt()

"bool" getn_bpt	(	"int"	n,
		"bpt_t"	bpt )

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

Parameters

n	(C++: int) number of breakpoint, is in range 0..get_bpt_qty()-1
bpt	(C++: bpt_t *) filled with the characteristics.

Returns: : false if no breakpoint exists

◆ getn_thread()

"thid_t" getn_thread ( "int" n )

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

Parameters

n	(C++: int) number of thread, is in range 0..get_thread_qty()-1

Returns: : NO_THREAD if the thread doesn't exist.

◆ getn_thread_name()

"char const *" getn_thread_name ( "int" n )

Parameters

n	(C++: int) 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 ( )

◆ handle_debug_event()

"int" handle_debug_event	(	"debug_event_t"	ev,
		"int"	rqflags )

Parameters

ev	debug_event_t const *
rqflags	int

◆ hide_all_bpts()

"int" hide_all_bpts ( )

◆ internal_get_sreg_base()

"ea_t" internal_get_sreg_base	(	"thid_t"	tid,
		"int"	sreg_value )

Parameters

tid	the thread ID
sreg_value	the sreg value

Returns: : The sreg base, or BADADDR on failure.

◆ internal_ioctl()

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

Parameters

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

◆ invalidate_dbg_state()

"int" invalidate_dbg_state ( "int" dbginv )

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

Parameters

dbginv (C++: int) Debugged process invalidation options

Returns: : current debugger state (one of Debugged process states)

◆ invalidate_dbgmem_config()

"void" invalidate_dbgmem_config ( )

Call this function if the debugged process might have changed its memory layout (allocated more memory, for example)

◆ invalidate_dbgmem_contents()

"void" invalidate_dbgmem_contents	(	"ea_t"	ea,
		"asize_t"	size )

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

Parameters

ea	(C++: ea_t)
size	(C++: asize_t)

◆ is_bblk_trace_enabled()

"bool" is_bblk_trace_enabled ( )

◆ is_debugger_busy()

"bool" is_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 ( "ea_t" ea )

Parameters

ea	(C++: ea_t)

◆ is_debugger_on()

"bool" is_debugger_on ( )

◆ is_func_trace_enabled()

"bool" is_func_trace_enabled ( )

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

◆ is_insn_trace_enabled()

"bool" is_insn_trace_enabled ( )

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

◆ is_reg_custom()

"bool" is_reg_custom ( "char const *" regname )

Parameters

regname (C++: const char *) char const *

◆ is_reg_float()

"bool" is_reg_float ( "char const *" regname )

Parameters

regname (C++: const char *) char const *

◆ is_reg_integer()

"bool" is_reg_integer ( "char const *" regname )

Parameters

regname (C++: const char *) char const *

◆ is_request_running()

"bool" is_request_running ( )

◆ is_step_trace_enabled()

"bool" is_step_trace_enabled ( )

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

◆ is_valid_dstate()

"bool" is_valid_dstate ( "int" state )

Parameters

state int

◆ is_valid_trace_file()

"bool" is_valid_trace_file ( "char const *" filename )

Parameters

filename (C++: const char *) char const *

◆ list_bptgrps()

"PyObject *" list_bptgrps ( * args )

Parameters

bptgrps (C++: qstrvec_t *) list of absolute path in the bpt dirtree

Returns: : number of folders returned list_bptgrps() -> [str, ...]

◆ load_debugger()

"bool" load_debugger	(	"char const *"	dbgname,
		"bool"	use_remote )

Parameters

dbgname	char const *
use_remote	bool

◆ load_trace_file()

"qstring *" load_trace_file ( "char const *" filename )

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'

Parameters

filename (C++: const char *) char const *

◆ put_dbg_byte()

"bool" put_dbg_byte	(	"ea_t"	ea,
		"uint32"	x )

Parameters

ea	(C++: ea_t) linear address
x	(C++: uint32) byte value

Returns: : true if the process memory has been modified

◆ read_dbg_memory()

"ssize_t" read_dbg_memory	(	"ea_t"	ea,
		"void *"	buffer,
		"size_t"	size )

Parameters

ea	ea_t
buffer	void *
size	size_t

◆ refresh_debugger_memory()

"PyObject *" refresh_debugger_memory ( )

Returns: : Nothing

◆ rename_bptgrp()

"bool" rename_bptgrp	(	"char const *"	old_name,
		"char const *"	new_name )

Parameters

old_name	(C++: const char *) absolute path to the folder to be renamed
new_name	(C++: const char *) absolute path of the new folder name

Returns: : success

◆ request_add_bpt()

"bool" request_add_bpt ( * args )

Parameters

ea	ea_t
size	asize_t
type	bpttype_t

request_add_bpt(bpt) -> bool

Parameters

bpt	bpt_t const &

◆ request_attach_process()

"int" request_attach_process	(	"pid_t"	pid,
		"int"	event_id )

Parameters

pid	(C++: pid_t)
event_id	(C++: int)

◆ request_clear_trace()

"void" request_clear_trace ( )

◆ request_continue_process()

"bool" request_continue_process ( )

Note: : This requires an explicit call to run_requests()

◆ request_del_bpt()

"bool" request_del_bpt ( * args )

Parameters

ea ea_t

request_del_bpt(bptloc) -> bool

Parameters

bptloc bpt_location_t const &

◆ request_detach_process()

"bool" request_detach_process ( )

◆ request_disable_bblk_trace()

"bool" request_disable_bblk_trace ( )

◆ request_disable_bpt()

"bool" request_disable_bpt ( * args )

Parameters

ea ea_t

request_disable_bpt(bptloc) -> bool

Parameters

bptloc bpt_location_t const &

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

Parameters

enable bool

◆ request_enable_bpt()

"bool" request_enable_bpt ( * args )

Parameters

ea	ea_t
enable	bool

request_enable_bpt(bptloc, enable=True) -> bool

Parameters

bptloc	bpt_location_t const &
enable	bool

◆ request_enable_func_trace()

"bool" request_enable_func_trace ( "bool" enable = True )

Parameters

enable bool

◆ request_enable_insn_trace()

"bool" request_enable_insn_trace ( "bool" enable = True )

Parameters

enable bool

◆ request_enable_step_trace()

"bool" request_enable_step_trace ( "int" enable = 1 )

Parameters

enable int

◆ request_exit_process()

"bool" request_exit_process ( )

◆ request_resume_thread()

"int" request_resume_thread ( "thid_t" tid )

Parameters

tid	(C++: thid_t)

◆ request_run_to()

"bool" request_run_to ( * args )

Parameters

ea	(C++: ea_t)
pid	(C++: pid_t)

◆ request_select_thread()

"bool" request_select_thread ( "thid_t" tid )

Parameters

tid	(C++: thid_t)

◆ request_set_bblk_trace_options()

"void" request_set_bblk_trace_options ( "int" options )

Parameters

options (C++: int)

◆ request_set_func_trace_options()

"void" request_set_func_trace_options ( "int" options )

Parameters

options (C++: int)

◆ request_set_insn_trace_options()

"void" request_set_insn_trace_options ( "int" options )

Parameters

options (C++: int)

◆ request_set_reg_val()

"PyObject *" request_set_reg_val	(	"char const *"	regname,
		"PyObject *"	o )

Parameters

regname	(C++: const char ) char const
o	PyObject *

◆ request_set_resume_mode()

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

Parameters

tid	(C++: thid_t)
mode	(C++: resume_mode_t) enum resume_mode_t

◆ request_set_step_trace_options()

"void" request_set_step_trace_options ( "int" options )

Parameters

options (C++: int)

◆ request_start_process()

"int" request_start_process	(	"char const *"	path = None,
		"char const *"	args = None,
		"char const *"	sdir = None )

Parameters

path	(C++: const char ) char const
args	(C++: const char ) char const
sdir	(C++: const char ) char const

◆ request_step_into()

"bool" request_step_into ( )

◆ request_step_over()

"bool" request_step_over ( )

◆ request_step_until_ret()

"bool" request_step_until_ret ( )

◆ request_suspend_process()

"bool" request_suspend_process ( )

◆ request_suspend_thread()

"int" request_suspend_thread ( "thid_t" tid )

Parameters

tid	(C++: thid_t)

◆ resume_thread()

"int" resume_thread ( "thid_t" tid )

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

Parameters

tid	(C++: thid_t) thread id

Return values

-1	network error
0	failed
1	ok

◆ retrieve_exceptions()

"excvec_t *" retrieve_exceptions ( )

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

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

Returns: : false if not all requests could be processed (indicates an asynchronous function was started)

Note: : If called from a notification handler, the execution of requests will be postponed to the end of the execution of all notification handlers.

◆ run_to()

"bool" run_to ( * args )

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}

Parameters

ea	(C++: ea_t) target address
pid	(C++: pid_t) not used yet. please do not specify this parameter.

◆ save_trace_file()

"bool" save_trace_file	(	"char const *"	filename,
		"char const *"	description )

Parameters

filename	(C++: const char ) char const
description	(C++: const char ) char const

◆ select_thread()

"bool" select_thread ( "thid_t" tid )

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

Parameters

tid	(C++: thid_t) ID of the thread to select

Returns: : false if the thread doesn't exist.

◆ send_dbg_command()

send_dbg_command ( command )

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

"void" set_bblk_trace_options ( "int" options )

Parameters

options (C++: int)

◆ set_bpt_group()

"bool" set_bpt_group	(	"bpt_t"	bpt,
		"char const *"	grp_name )

Parameters

bpt	(C++: bpt_t &) bpt that will be moved
grp_name	(C++: const char *) absolute path to the breakpoint dirtree folder

Returns: : success

◆ set_bptloc_group()

"bool" set_bptloc_group	(	"bpt_location_t"	bptloc,
		"char const *"	grp_name )

Parameters

bptloc	(C++: const bpt_location_t &) bptlocation of the bpt that will be moved
grp_name	(C++: const char *) absolute path to the breakpoint dirtree folder

Returns: : success

◆ set_bptloc_string()

"int" set_bptloc_string ( "char const *" s )

Parameters

s	char const *

◆ set_debugger_event_cond()

"void" set_debugger_event_cond ( "char const *" NONNULL_evcond )

Parameters

NONNULL_evcond char const *

◆ set_debugger_options()

"uint" set_debugger_options ( "uint" options )

Replaces debugger options with the specification combination Debugger options

Parameters

options (C++: uint)

Returns: : the old debugger options

◆ set_func_trace_options()

"void" set_func_trace_options ( "int" options )

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

Parameters

options (C++: int)

◆ set_highlight_trace_options()

"void" set_highlight_trace_options	(	"bool"	hilight,
		"bgcolor_t"	color,
		"bgcolor_t"	diff )

Parameters

hilight	(C++: bool)
color	(C++: bgcolor_t)
diff	(C++: bgcolor_t)

◆ set_insn_trace_options()

"void" set_insn_trace_options ( "int" options )

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

Parameters

options (C++: int)

◆ set_manual_regions()

"void" set_manual_regions ( "meminfo_vec_t" ranges )

Parameters

ranges meminfo_vec_t const *

◆ set_process_options()

"void" set_process_options ( * args )

Any of the arguments may be nullptr, which means 'do not modify'

Parameters

path	(C++: const char ) char const
args	(C++: const char ) char const
envs	(C++: const launch_env_t ) launch_env_t const
sdir	(C++: const char ) char const
host	(C++: const char ) char const
pass	(C++: const char ) char const
port	(C++: int)

set_process_options(path, args, sdir, host, _pass, port)

Parameters

path	char const *
args	char const *
sdir	char const *
host	char const *
pass	char const *
port	int

◆ set_process_state()

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

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

Parameters

newstate	(C++: int) new process state (one of Debugged process states) if DSTATE_NOTASK is passed then the state is not changed
p_thid	(C++: thid_t *) ptr to new thread id. may be nullptr or pointer to NO_THREAD. the pointed variable will contain the old thread id upon return
dbginv	(C++: int) Debugged process invalidation options

Returns: : old debugger state (one of Debugged process states)

◆ set_reg_val()

"PyObject *" set_reg_val ( * args )

Parameters

regname	char const *
o	PyObject *

set_reg_val(tid, regidx, o) -> bool, int

Parameters

tid	thid_t
regidx	int
o	PyObject *

◆ set_remote_debugger()

"void" set_remote_debugger	(	"char const *"	host,
		"char const *"	_pass,
		"int"	port = -1 )

Should be used before starting the debugger.

Parameters

host	(C++: const char *) If empty, IDA will use local debugger. If nullptr, the host will not be set.
pass	(C++: const char *) If nullptr, the password will not be set
port	(C++: int) If -1, the default port number will be used

◆ set_resume_mode()

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

Set resume mode but do not resume process.

Parameters

tid	(C++: thid_t)
mode	(C++: resume_mode_t) enum resume_mode_t

◆ set_step_trace_options()

"void" set_step_trace_options ( "int" options )

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

Parameters

options (C++: int)

◆ set_trace_base_address()

"void" set_trace_base_address ( "ea_t" ea )

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

Parameters

ea	(C++: ea_t)

◆ set_trace_dynamic_register_set()

"void" set_trace_dynamic_register_set ( "dynamic_register_set_t &" idaregs )

Parameters

idaregs (C++: dynamic_register_set_t &)

◆ set_trace_file_desc()

"bool" set_trace_file_desc	(	"char const *"	filename,
		"char const *"	description )

Parameters

filename	(C++: const char ) char const
description	(C++: const char ) char const

◆ set_trace_platform()

"void" set_trace_platform ( "char const *" platform )

Parameters

platform (C++: const char *) char const *

◆ set_trace_size()

"bool" set_trace_size ( "int" size )

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

Parameters

size	(C++: int) 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.

Note: : If you specify 0, all available memory can be quickly used !!!

◆ 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	(	"char const *"	path = None,
		"char const *"	args = None,
		"char const *"	sdir = None )

\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.; : For all parameters, a nullptr value indicates the debugger will take the value from the defined Process Options.

Parameters

path	(C++: const char *) path to the executable to start
args	(C++: const char *) arguments to pass to process
sdir	(C++: const char *) starting directory for the process

Return values

-1	impossible to create the process
0	the starting of the process was cancelled by the user
1	the process was properly started

◆ step_into()

"bool" step_into ( )

Other threads are kept suspended. \sq{Type, Asynchronous function - available as Request, Notification, dbg_step_into}

◆ step_over()

"bool" step_over ( )

Others threads keep suspended. \sq{Type, Asynchronous function - available as Request, Notification, dbg_step_over}

◆ step_until_ret()

"bool" step_until_ret ( )

Other threads are kept suspended. \sq{Type, Asynchronous function - available as Request, Notification, dbg_step_until_ret}

◆ store_exceptions()

"bool" store_exceptions ( )

◆ suspend_process()

"bool" suspend_process ( )

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

"int" suspend_thread ( "thid_t" tid )

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

Parameters

tid	(C++: thid_t) thread id

Return values

-1	network error
0	failed
1	ok

◆ update_bpt()

"bool" update_bpt ( "bpt_t" bpt )

To update the breakpoint location, use change_bptlocs() \sq{Type, Synchronous function, Notification, none (synchronous function)}

Note

: Only the following fields can be modified:

: 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

Parameters

bpt	(C++: const bpt_t ) bpt_t const

◆ wait_for_next_event()

"dbg_event_code_t" wait_for_next_event	(	"int"	wfne,
		"int"	timeout )

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

Parameters

wfne	(C++: int) combination of Wait for debugger event flags constants
timeout	(C++: int) 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 )

Parameters

ea	ea_t
py_buf	PyObject *
size	size_t

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

Detailed Description

Classes

Functions

Variables

Function Documentation

◆ add_bpt()

◆ add_path_mapping()

◆ add_virt_module()

◆ attach_process()

◆ bring_debugger_to_front()

◆ check_bpt()

◆ choose_trace_file()

◆ clear_requests_queue()

◆ clear_trace()

◆ collect_stack_trace()

◆ continue_process()

◆ create_source_viewer()

◆ dbg_add_bpt_tev()

◆ dbg_add_call_tev()

◆ dbg_add_debug_event()

◆ dbg_add_insn_tev()

◆ dbg_add_many_tevs()

◆ dbg_add_ret_tev()

◆ dbg_add_tev()

◆ dbg_add_thread()

◆ dbg_bin_search()

◆ dbg_can_query()

◆ dbg_del_thread()

◆ dbg_is_loaded()

◆ define_exception()

◆ del_bpt()

◆ del_bptgrp()

◆ del_virt_module()

◆ detach_process()

◆ diff_trace_file()

◆ disable_bblk_trace()

◆ disable_bpt()

◆ disable_func_trace()

◆ disable_insn_trace()

◆ disable_step_trace()

◆ edit_manual_regions()

◆ enable_bblk_trace()

◆ enable_bpt()

◆ enable_bptgrp()

◆ enable_func_trace()

◆ enable_insn_trace()

◆ enable_manual_regions()

◆ enable_step_trace()

◆ exist_bpt()

◆ exit_process()

◆ find_bpt()

◆ get_bblk_trace_options()

◆ get_bpt()

◆ get_bpt_group()

◆ get_bpt_qty()

◆ get_bpt_tev_ea()

◆ get_bptloc_string()

◆ get_call_tev_callee()

◆ get_current_source_file()

◆ get_current_source_line()

◆ get_current_thread()

◆ get_dbg_byte()

◆ get_dbg_memory_info()

◆ get_dbg_reg_info()

◆ get_debug_event()

◆ get_debugger_event_cond()

◆ get_first_module()

◆ get_func_trace_options()

◆ get_global_var()

◆ get_grp_bpts()

◆ get_insn_tev_reg_mem()

◆ get_insn_tev_reg_result()

◆ get_insn_tev_reg_val()

◆ get_insn_trace_options()

◆ get_ip_val()

◆ get_local_var()

◆ get_local_vars()

◆ get_manual_regions()

◆ get_module_info()

◆ get_next_module()