Module index

# Module `ida_dbg`

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.

## Global variables

`var BKPT_ACTIVE`

  active?

`var BKPT_BADBPT`

  failed to write the bpt to the process memory (at least one location)

`var BKPT_CNDREADY`

  condition has been compiled

`var BKPT_FAKEPEND`

  fake pending bpt: it is inactive but another bpt of the same type is active at the same address(es)

`var BKPT_LISTBPT`

  include in bpt list (user-defined bpt)

`var BKPT_PAGE`

  written to the process as a page bpt. Available only after writing the bpt to the process.

`var BKPT_PARTIAL`

  partially active? (some locations were not written yet)

`var BKPT_TRACE`

  trace bpt; should not be deleted when the process gets suspended

`var BPLT_ABS`

  absolute address: ea

`var BPLT_REL`

  relative address: module_path, offset

`var BPLT_SRC`

  source level: filename, lineno

`var BPLT_SYM`

  symbolic: symbol_name, offset

`var BPTCK_ACT`

  breakpoint is active (written to the process)

`var BPTCK_NO`

  breakpoint is disabled

`var BPTCK_NONE`

  breakpoint does not exist

`var BPTCK_YES`

  breakpoint is enabled

`var BPTEV_ADDED`

  Breakpoint has been added.

`var BPTEV_CHANGED`

  Breakpoint has been modified.

`var BPTEV_REMOVED`

  Breakpoint has been removed.

`var BPT_BRK`

  suspend execution upon hit

`var BPT_ELANG_SHIFT`

  index of the extlang (scripting language) of the condition

`var BPT_ENABLED`

  enabled?

`var BPT_LOWCND`

  condition is calculated at low level (on the server side)

`var BPT_TRACE`

  add trace information upon hit

`var BPT_TRACEON`

  enable tracing when the breakpoint is reached

`var BPT_TRACE_BBLK`

  basic block tracing

`var BPT_TRACE_FUNC`

  function tracing

`var BPT_TRACE_INSN`

  instruction tracing

`var BPT_TRACE_TYPES`

  trace insns, functions, and basic blocks. if any of BPT_TRACE_TYPES bits are set but BPT_TRACEON is clear, then turn off tracing for the specified trace types

`var BPT_UPDMEM`

  refresh the memory layout and contents before evaluating bpt condition

`var BT_LOG_INSTS`

  specific options for basic block tracing (see set_bblk_trace_options())

  log all instructions in the current basic block

`var DBGINV_ALL`

  invalidate everything

`var DBGINV_MEMCFG`

  invalidate cached process segmentation

`var DBGINV_MEMORY`

  invalidate cached memory contents

`var DBGINV_NONE`

  invalidate nothing

`var DBGINV_REDRAW`

  refresh the screen

`var DBGINV_REGS`

  invalidate cached register values

`var DEC_ERROR`

  error

`var DEC_NOTASK`

  process does not exist

`var DEC_TIMEOUT`

  timeout

`var DOPT_BPT_MSGS`

  log breakpoints

`var DOPT_DISABLE_ASLR`

  disable ASLR

`var DOPT_END_BPT`

  evaluate event condition on process end

`var DOPT_ENTRY_BPT`

  break on program entry point

`var DOPT_EXCDLG`

  exception dialogs:

`var DOPT_FAST_STEP`

  prevent debugger memory refreshes when single-stepping

`var DOPT_INFO_BPT`

  break on debugging information

`var DOPT_INFO_MSGS`

  log debugging info events

`var DOPT_LIB_BPT`

  break on library load/unload

`var DOPT_LIB_MSGS`

  log library loads/unloads

`var DOPT_LOAD_DINFO`

  automatically load debug files (pdb)

`var DOPT_REAL_MEMORY`

  do not hide breakpoint instructions

`var DOPT_REDO_STACK`

  reconstruct the stack

`var DOPT_SEGM_MSGS`

  log debugger segments modifications

`var DOPT_START_BPT`

  break on process start

`var DOPT_TEMP_HWBPT`

  when possible use hardware bpts for temp bpts

`var DOPT_THREAD_BPT`

  break on thread start/exit

`var DOPT_THREAD_MSGS`

  log thread starts/exits

`var DSTATE_NOTASK`

  no process is currently debugged

`var DSTATE_RUN`

  process is running

`var DSTATE_SUSP`

  process is suspended and will not continue

`var EXCDLG_ALWAYS`

  always display

`var EXCDLG_NEVER`

  never display exception dialogs

`var EXCDLG_UNKNOWN`

  display for unknown exceptions

`var FT_LOG_RET`

  specific options for function tracing (see set_func_trace_options())

  function tracing will log returning instructions

`var IT_LOG_SAME_IP`

  specific options for instruction tracing (see set_insn_trace_options())

  instruction tracing will log new instructions even when IP doesn't change

`var MOVBPT_BAD_TYPE`

  BPLT_ABS is not supported.

`var MOVBPT_DEST_BUSY`

  destination location is busy (we already have such a bpt)

`var MOVBPT_NOT_FOUND`

  source bpt not found

`var MOVBPT_OK`

  moved ok

`var SRCIT_EXPR`

  an expression (a+b*c)

`var SRCIT_FUNC`

  function

`var SRCIT_LOCVAR`

  a stack, register, or register-relative local variable or parameter

`var SRCIT_MODULE`

  module

`var SRCIT_NONE`

  unknown

`var SRCIT_STMT`

  a statement (if/while/for…)

`var SRCIT_STTVAR`

  static variable/code

`var ST_ALREADY_LOGGED`

  step tracing will be disabled when IP is already logged

`var ST_DIFFERENTIAL`

  tracing: log only new instructions (not previously logged)

`var ST_OPTIONS_MASK`

  mask of available options, to ensure compatibility with newer IDA versions

`var ST_OVER_DEBUG_SEG`

  step tracing will be disabled when IP is in a debugger segment

`var ST_OVER_LIB_FUNC`

  step tracing will be disabled when IP is in a library function

`var ST_SKIP_LOOPS`

  step tracing will try to skip loops already recorded

`var WFNE_ANY`

  return the first event (even if it doesn't suspend the process)

`var WFNE_CONT`

  continue from the suspended state

`var WFNE_NOWAIT`

  do not wait for any event, immediately return DEC_TIMEOUT (to be used with WFNE_CONT)

`var WFNE_SILENT`

  1: be silent, 0:display modal boxes if necessary

`var WFNE_SUSP`

  wait until the process gets suspended

`var WFNE_USEC`

  timeout is specified in microseconds (minimum non-zero timeout is 40000us)

`var dbg_bpt`

  A user defined breakpoint was reached. @param tid: (thid_t) @param bptea: (::ea_t) @param warn: (int *) filled with: * -1: display an exception warning dialog if the process is suspended. * 0: never display an exception warning dialog. * 1: always display an exception warning dialog.

`var dbg_bpt_changed`

  Breakpoint has been changed. @param bptev_code: (int) Breakpoint modification events @param bpt: (bpt_t *)

`var dbg_exception`

  @param event: (const debug_event_t ) @param warn: (int ) filled with: * -1: display an exception warning dialog if the process is suspended. * 0: never display an exception warning dialog. * 1: always display an exception warning dialog.

`var dbg_finished_loading_bpts`

  Finished loading breakpoint info from idb.

`var dbg_information`

  @param event: (const debug_event_t *)

`var dbg_last`

  The last debugger notification code.

`var dbg_library_load`

  @param event: (const debug_event_t *)

`var dbg_library_unload`

  @param event: (const debug_event_t *)

`var dbg_process_attach`

  @param event: (const debug_event_t *) @note: This event notification is also an asynchronous function result notification for start_process() !

`var dbg_process_detach`

  @param event: (const debug_event_t *) @note: This event notification is also an asynchronous function result notification for start_process() !

`var dbg_process_exit`

  @param event: (const debug_event_t *) @note: This event notification is also an asynchronous function result notification for start_process() !

`var dbg_process_start`

  @param event: (const debug_event_t *) @note: This event notification is also an asynchronous function result notification for start_process() !

`var dbg_request_error`

  An error occurred during the processing of a request. @param failed_command: (ui_notification_t) @param failed_dbg_notification: (dbg_notification_t)

`var dbg_run_to`

  @param event: (const debug_event_t *)

`var dbg_started_loading_bpts`

  Started loading breakpoint info from idb.

`var dbg_step_into`

  @param event: (const debug_event_t *)

`var dbg_step_over`

  @param event: (const debug_event_t *)

`var dbg_step_until_ret`

  @param event: (const debug_event_t *)

`var dbg_suspend_process`

  The process is now suspended. @param event: (const debug_event_t *) @note: This event notification is also an asynchronous function result notification for suspend_process() !

`var dbg_thread_exit`

  @param event: (const debug_event_t *)

`var dbg_thread_start`

  @param event: (const debug_event_t *)

`var dbg_trace`

  A step occurred (one instruction was executed). This event notification is only generated if step tracing is enabled. @param tid: (thid_t) thread ID @param ip: (::ea_t) current instruction pointer. usually points after the executed instruction @retval 1: do not log this trace event @retval 0: log it

`var tev_bpt`

  write, read/write, execution trace

`var tev_call`

  a function call trace

`var tev_event`

  debug event occurred

`var tev_insn`

  an instruction trace

`var tev_max`

  first unused event type

`var tev_mem`

  memory layout changed

`var tev_none`

  no event

`var tev_ret`

  a function return trace

## Functions

`def add_bpt(*args) ‑> bool`

  add_bpt(ea, size=0, type=BPT_DEFAULT) -> bool Add a new breakpoint in the debugged process. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}

  @param 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. @param size: asize_t @param type: bpttype_t

  add_bpt(bpt) -> bool

  @param bpt: bpt_t const &

`def add_path_mapping(src: char const *, dst: char const *)`

  add_path_mapping(src, dst)

  @param src: char const * @param dst: char const *

`def add_virt_module(mod: modinfo_t)`

  add_virt_module(mod) -> bool

  @param mod: modinfo_t const *

`def attach_process(*args) ‑> int`

  attach_process(pid=pid_t(-1), event_id=-1) -> int Attach the debugger to a running process. \sq{Type, Asynchronous function - available as Request, Notification, dbg_process_attach} @note: This function shouldn't be called as a request if NO_PROCESS is used.

  @param 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. @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

`def bring_debugger_to_front()`

  bring_debugger_to_front()

`def check_bpt(ea: ea_t)`

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

  @param ea: (C++: ea_t) @return: one of Breakpoint status codes

`def choose_trace_file()`

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

`def clear_requests_queue()`

  clear_requests_queue() Clear the queue of waiting requests. \sq{Type, Synchronous function, Notification, none (synchronous function)} @note: If a request is currently running, this one isn't stopped.

`def clear_trace()`

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

`def collect_stack_trace(tid: thid_t, trace: call_stack_t)`

  collect_stack_trace(tid, trace) -> bool

  @param tid: thid_t @param trace: call_stack_t *

`def continue_process() ‑> bool`

  continue_process() -> bool Continue the execution of the process in the debugger. \sq{Type, Synchronous function - available as Request, Notification, none (synchronous function)} @note: The continue_process() function can be called from a notification handler to force the continuation of the process. In this case the request queue will not be examined, IDA will simply resume execution. Usually it makes sense to call request_continue_process() followed by run_requests(), so that IDA will first start a queued request (if any) and then resume the application.

`def create_source_viewer(out_ccv: TWidget **, parent: TWidget *, custview: TWidget *, sf: source_file_ptr, lines: strvec_t *, lnnum: int, colnum: int, flags: int)`

  create_source_viewer(out_ccv, parent, custview, sf, lines, lnnum, colnum, flags) -> source_view_t * Create a source code view.

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

`def dbg_add_bpt_tev(tid: thid_t, ea: ea_t, bp: ea_t)`

  dbg_add_bpt_tev(tid, ea, bp) -> bool Add a new breakpoint trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @param tid: (C++: thid_t) @param ea: (C++: ea_t) @param bp: (C++: ea_t) @return: false if the operation failed, true otherwise

`def dbg_add_call_tev(tid: thid_t, caller: ea_t, callee: ea_t)`

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

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

`def dbg_add_debug_event(event: debug_event_t)`

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

  @param event: (C++: debug_event_t *)

`def dbg_add_insn_tev(tid: thid_t, ea: ea_t, save: save_reg_values_t = 1)`

  dbg_add_insn_tev(tid, ea, save=SAVE_DIFF) -> bool Add a new instruction trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @param tid: (C++: thid_t) @param ea: (C++: ea_t) @param save: (C++: save_reg_values_t) enum save_reg_values_t @return: false if the operation failed, true otherwise

`def dbg_add_many_tevs(new_tevs: tevinforeg_vec_t) ‑> bool`

  dbg_add_many_tevs(new_tevs) -> bool Add many new trace elements to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @param new_tevs: (C++: tevinforeg_vec_t *) @return: false if the operation failed for any tev_info_t object

`def dbg_add_ret_tev(tid: thid_t, ret_insn: ea_t, return_to: ea_t)`

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

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

`def dbg_add_tev(type: tev_type_t, tid: thid_t, address: ea_t)`

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

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

`def dbg_add_thread(tid: thid_t)`

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

  @param tid: (C++: thid_t)

`def dbg_bin_search(start_ea: ea_t, end_ea: ea_t, data: compiled_binpat_vec_t const &, srch_flags: int)`

  dbg_bin_search(start_ea, end_ea, data, srch_flags) -> str

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

`def dbg_can_query() ‑> bool`

  dbg_can_query() -> bool This function can be used to check if the debugger can be queried: - debugger is loaded - process is suspended - process is not suspended but can take requests. In this case some requests like memory read/write, bpt management succeed and register querying will fail. Check if idaapi.get_process_state() < 0 to tell if the process is suspended

  @return: Boolean

`def dbg_del_thread(tid: thid_t)`

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

  @param tid: (C++: thid_t)

`def dbg_is_loaded() ‑> bool`

  dbg_is_loaded() -> bool Checks if a debugger is loaded

  @return: Boolean

`def define_exception(code: uint, name: char const *, desc: char const *, flags: int)`

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

  @param code: (C++: uint) exception code (cannot be 0) @param name: (C++: const char ) exception name (cannot be empty or nullptr) @param desc: (C++: const char ) exception description (maybe nullptr) @param flags: (C++: int) combination of Exception info flags @return: failure message or nullptr. You must call store_exceptions() if this function succeeds

`def del_bpt(*args) ‑> bool`

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

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

  @param bptloc: bpt_location_t const &

`def del_bptgrp(name: char const *)`

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

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

`def del_virt_module(base: ea_t const)`

  del_virt_module(base) -> bool

  @param base: ea_t const

`def detach_process() ‑> bool`

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

`def diff_trace_file(NONNULL_filename: char const *)`

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

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

`def disable_bblk_trace() ‑> bool`

  disable_bblk_trace() -> bool

`def disable_bpt(*args) ‑> bool`

  disable_bpt(ea) -> bool

  @param ea: ea_t

  disable_bpt(bptloc) -> bool

  @param bptloc: bpt_location_t const &

`def disable_func_trace() ‑> bool`

  disable_func_trace() -> bool

`def disable_insn_trace() ‑> bool`

  disable_insn_trace() -> bool

`def disable_step_trace() ‑> bool`

  disable_step_trace() -> bool

`def edit_manual_regions()`

  edit_manual_regions()

`def enable_bblk_trace(enable: bool = True) ‑> bool`

  enable_bblk_trace(enable=True) -> bool

  @param enable: bool

`def enable_bpt(*args) ‑> bool`

  enable_bpt(ea, enable=True) -> bool

  @param ea: ea_t @param enable: bool

  enable_bpt(bptloc, enable=True) -> bool

  @param bptloc: bpt_location_t const & @param enable: bool

`def enable_bptgrp(bptgrp_name: char const *, enable: bool = True)`

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

  @param bptgrp_name: (C++: const char *) absolute path to the folder @param enable: (C++: bool) by default true, enable bpts, false disable bpts @return: -1 an error occured 0 no changes >0 nubmers of bpts udpated

`def enable_func_trace(enable: bool = True) ‑> bool`

  enable_func_trace(enable=True) -> bool

  @param enable: bool

`def enable_insn_trace(enable: bool = True) ‑> bool`

  enable_insn_trace(enable=True) -> bool

  @param enable: bool

`def enable_manual_regions(enable: bool)`

  enable_manual_regions(enable)

  @param enable: bool

`def enable_step_trace(enable: int = 1) ‑> bool`

  enable_step_trace(enable=1) -> bool

  @param enable: int

`def exist_bpt(ea: ea_t)`

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

  @param ea: (C++: ea_t)

`def exit_process() ‑> bool`

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

`def find_bpt(bptloc: bpt_location_t, bpt: bpt_t) ‑> bool`

  find_bpt(bptloc, bpt) -> bool Find a breakpoint by location. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}

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

`def get_bblk_trace_options() ‑> int`

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

`def get_bpt(ea: ea_t, bpt: bpt_t)`

  get_bpt(ea, bpt) -> bool Get the characteristics of a breakpoint. \sq{Type, Synchronous function, Notification, none (synchronous function)}

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

`def get_bpt_group(bptloc: bpt_location_t)`

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

  @param bptloc: (C++: const bpt_location_t &) bptlocation of the bpt @return: breakpoint correclty moved to the directory success

`def get_bpt_qty() ‑> int`

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

`def get_bpt_tev_ea(n: int)`

  get_bpt_tev_ea(n) -> ea_t Get the address associated to a read, read/write or execution trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)}

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

`def get_bptloc_string(i: int)`

  get_bptloc_string(i) -> char const *

  @param i: int

`def get_call_tev_callee(n: int)`

  get_call_tev_callee(n) -> ea_t Get the called function from a function call trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event. @return: BADADDR if not a function call event.

`def get_current_source_file()`

  get_current_source_file() -> str

`def get_current_source_line() ‑> int`

  get_current_source_line() -> int

`def get_current_thread()`

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

`def get_dbg_byte(ea: ea_t)`

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

  @param ea: (C++: ea_t) linear address @return: true success false address inaccessible or debugger not running

`def get_dbg_memory_info(ranges: meminfo_vec_t)`

  get_dbg_memory_info(ranges) -> int

  @param ranges: meminfo_vec_t *

`def get_dbg_reg_info(regname: char const *, ri: register_info_t)`

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

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

`def get_debug_event()`

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

`def get_debugger_event_cond()`

  get_debugger_event_cond() -> char const *

`def get_first_module(modinfo: modinfo_t)`

  get_first_module(modinfo) -> bool

  @param modinfo: modinfo_t *

`def get_func_trace_options() ‑> int`

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

`def get_global_var(prov: srcinfo_provider_t *, ea: ea_t, name: char const *, out: source_item_ptr *)`

  get_global_var(prov, ea, name, out) -> bool

  @param prov: srcinfo_provider_t * @param ea: ea_t @param name: char const * @param out: source_item_ptr *

`def get_grp_bpts(bpts: bpt_vec_t, grp_name: char const *)`

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

  @param bpts: (C++: bpt_vec_t ) : pointer to a vector where the copy of bpts are stored @param grp_name: (C++: const char ) absolute path to the folder @return: number of bpts present in the vector

`def get_insn_tev_reg_mem(n: int, memmap: memreg_infos_t) ‑> bool`

  get_insn_tev_reg_mem(n, memmap) -> bool Read the memory pointed by register values from an instruction trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event. @param memmap: (C++: memreg_infos_t *) result @return: false if not an instruction event or no memory is available

`def get_insn_tev_reg_result(n: int, regname: char const *, regval: regval_t)`

  get_insn_tev_reg_result(n, regname, regval) -> bool

  @param n: int @param regname: char const * @param regval: regval_t *

`def get_insn_tev_reg_val(n: int, regname: char const *, regval: regval_t)`

  get_insn_tev_reg_val(n, regname, regval) -> bool

  @param n: int @param regname: char const * @param regval: regval_t *

`def get_insn_trace_options() ‑> int`

  get_insn_trace_options() -> int Get current instruction tracing options. Also see IT_LOG_SAME_IP \sq{Type, Synchronous function, Notification, none (synchronous function)}

`def get_ip_val()`

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

`def get_local_var(prov: srcinfo_provider_t *, ea: ea_t, name: char const *, out: source_item_ptr *)`

  get_local_var(prov, ea, name, out) -> bool

  @param prov: srcinfo_provider_t * @param ea: ea_t @param name: char const * @param out: source_item_ptr *

`def get_local_vars(prov: srcinfo_provider_t *, ea: ea_t, out: source_items_t *)`

  get_local_vars(prov, ea, out) -> bool

  @param prov: srcinfo_provider_t * @param ea: ea_t @param out: source_items_t *

`def get_manual_regions(*args)`

  get_manual_regions(ranges) Returns the manual memory regions

  @param ranges: meminfo_vec_t *

  @return: list(start_ea, end_ea, name, sclass, sbase, bitness, perm) get_manual_regions() -> [(int, int, str, str, int, int, int), …] or None

`def get_module_info(ea: ea_t, modinfo: modinfo_t)`

  get_module_info(ea, modinfo) -> bool

  @param ea: ea_t @param modinfo: modinfo_t *

`def get_next_module(modinfo: modinfo_t)`

  get_next_module(modinfo) -> bool

  @param modinfo: modinfo_t *

`def get_process_options()`

  get_process_options() Get process options. Any of the arguments may be nullptr

`def get_process_state() ‑> int`

  get_process_state() -> int Return the state of the currently debugged process. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @return: one of Debugged process states

`def get_processes(proclist: procinfo_vec_t)`

  get_processes(proclist) -> ssize_t Take a snapshot of running processes and return their description. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @param proclist: (C++: procinfo_vec_t *) array with information about each running process @return: number of processes or -1 on error

`def get_reg_val(*args)`

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

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

  get_reg_val(regname, ival) -> bool

  @param regname: char const * @param ival: uint64 *

  get_reg_val(regname) -> bool, float, int

  @param regname: char const *

`def get_reg_vals(tid: thid_t, clsmask: int = -1)`

  get_reg_vals(tid, clsmask=-1) -> regvals_t 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 regvals_t instance (empty if an error occurs)

`def get_ret_tev_return(n: int)`

  get_ret_tev_return(n) -> ea_t Get the return address from a function return trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event. @return: BADADDR if not a function return event.

`def get_running_notification()`

  get_running_notification() -> dbg_notification_t Get the notification associated (if any) with the current running request. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @return: dbg_null if no running request

`def get_running_request()`

  get_running_request() -> ui_notification_t Get the current running request. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @return: ui_null if no running request

`def get_sp_val()`

  get_sp_val() -> bool Get value of the SP register for the current thread. Requires a suspended debugger.

`def get_srcinfo_provider(name: char const *)`

  get_srcinfo_provider(name) -> srcinfo_provider_t *

  @param name: char const *

`def get_step_trace_options() ‑> int`

  get_step_trace_options() -> int Get current step tracing options. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @return: Step trace options

`def get_tev_ea(n: int)`

  get_tev_ea(n) -> ea_t

  @param n: int

`def get_tev_event(n: int, d: debug_event_t)`

  get_tev_event(n, d) -> bool Get the corresponding debug event, if any, for the specified tev object. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event. @param d: (C++: debug_event_t *) result @return: false if the tev_t object doesn't have any associated debug event, true otherwise, with the debug event in "d".

`def get_tev_info(n: int, tev_info: tev_info_t) ‑> bool`

  get_tev_info(n, tev_info) -> bool Get main information about a trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)}

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

`def get_tev_memory_info(n: int, mi: meminfo_vec_t)`

  get_tev_memory_info(n, mi) -> bool Get the memory layout, if any, for the specified tev object. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @param n: (C++: int) number of trace event, is in range 0..get_tev_qty()-1. 0 represents the latest added trace event. @param mi: (C++: meminfo_vec_t *) result @return: false if the tev_t object is not of type tev_mem, true otherwise, with the new memory layout in "mi".

`def get_tev_qty() ‑> int`

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

`def get_tev_reg_mem(tev, idx)`
`def get_tev_reg_mem_ea(tev, idx)`
`def get_tev_reg_mem_qty(tev)`
`def get_tev_reg_val(tev, reg)`
`def get_tev_tid(n: int) ‑> int`

  get_tev_tid(n) -> int

  @param n: int

`def get_tev_type(n: int) ‑> int`

  get_tev_type(n) -> int

  @param n: int

`def get_thread_qty() ‑> int`

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

`def get_trace_base_address()`

  get_trace_base_address() -> ea_t Get the base address of the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @return: the base address of the currently loaded trace

`def get_trace_dynamic_register_set(idaregs: dynamic_register_set_t *)`

  get_trace_dynamic_register_set(idaregs) Get dynamic register set of current trace.

  @param idaregs: (C++: dynamic_register_set_t *)

`def get_trace_file_desc(filename: char const *)`

  get_trace_file_desc(filename) -> str Get the file header of the specified trace file.

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

`def get_trace_platform()`

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

`def getn_bpt(n: int, bpt: bpt_t) ‑> bool`

  getn_bpt(n, bpt) -> bool Get the characteristics of a breakpoint. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @param n: (C++: int) number of breakpoint, is in range 0..get_bpt_qty()-1 @param bpt: (C++: bpt_t *) filled with the characteristics. @return: false if no breakpoint exists

`def getn_thread(n: int)`

  getn_thread(n) -> thid_t Get the ID of a thread. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @param n: (C++: int) number of thread, is in range 0..get_thread_qty()-1 @return: NO_THREAD if the thread doesn't exist.

`def getn_thread_name(n: int)`

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

  @param n: (C++: int) number of thread, is in range 0..get_thread_qty()-1 or -1 for the current thread @return: thread name or nullptr if the thread doesn't exist.

`def graph_trace() ‑> bool`

  graph_trace() -> bool Show the trace callgraph.

`def handle_debug_event(ev: debug_event_t, rqflags: int)`

  handle_debug_event(ev, rqflags) -> int

  @param ev: debug_event_t const * @param rqflags: int

`def hide_all_bpts() ‑> int`

  hide_all_bpts() -> int

`def internal_get_sreg_base(tid: thid_t, sreg_value: int)`

  internal_get_sreg_base(tid, sreg_value) -> ea_t Get the sreg base, for the given thread.

  @param tid: thid_t @param sreg_value: int @return: The sreg base, or BADADDR on failure.

`def internal_ioctl(fn: int, buf: void const *, poutbuf: void **, poutsize: ssize_t *)`

  internal_ioctl(fn, buf, poutbuf, poutsize) -> int

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

`def invalidate_dbg_state(dbginv: int) ‑> int`

  invalidate_dbg_state(dbginv) -> int Invalidate cached debugger information. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @param dbginv: (C++: int) Debugged process invalidation options @return: current debugger state (one of Debugged process states)

`def invalidate_dbgmem_config()`

  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)

`def invalidate_dbgmem_contents(ea: ea_t, size: asize_t)`

  invalidate_dbgmem_contents(ea, size) Invalidate the debugged process memory contents. Call this function each time the process has been stopped or the process memory is modified. If ea == BADADDR, then the whole memory contents will be invalidated

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

`def is_bblk_trace_enabled() ‑> bool`

  is_bblk_trace_enabled() -> bool

`def is_debugger_busy() ‑> bool`

  is_debugger_busy() -> bool Is the debugger busy?. Some debuggers do not accept any commands while the debugged application is running. For such a debugger, it is unsafe to do anything with the database (even simple queries like get_byte may lead to undesired consequences). Returns: true if the debugged application is running under such a debugger

`def is_debugger_memory(ea: ea_t)`

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

  @param ea: (C++: ea_t)

`def is_debugger_on() ‑> bool`

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

`def is_func_trace_enabled() ‑> bool`

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

`def is_insn_trace_enabled() ‑> bool`

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

`def is_reg_custom(regname: char const *)`

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

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

`def is_reg_float(regname: char const *)`

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

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

`def is_reg_integer(regname: char const *)`

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

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

`def is_request_running() ‑> bool`

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

`def is_step_trace_enabled() ‑> bool`

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

`def is_valid_dstate(state: int) ‑> bool`

  is_valid_dstate(state) -> bool

  @param state: int

`def is_valid_trace_file(filename: char const *)`

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

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

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

  @param bptgrps: (C++: qstrvec_t *) list of absolute path in the bpt dirtree @return: number of folders returned list_bptgrps() -> [str, …]

`def load_debugger(dbgname: char const *, use_remote: bool)`

  load_debugger(dbgname, use_remote) -> bool

  @param dbgname: char const * @param use_remote: bool

`def load_trace_file(filename: char const *)`

  load_trace_file(filename) -> str Load a recorded trace file in the 'Tracing' window. If the call succeeds and 'buf' is not null, the description of the trace stored in the binary trace file will be returned in 'buf'

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

`def move_bpt_to_grp(bpt: bpt_t, grp_name: char const *)`

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

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

`def put_dbg_byte(ea: ea_t, x: uint32)`

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

  @param ea: (C++: ea_t) linear address @param x: (C++: uint32) byte value @return: true if the process memory has been modified

`def read_dbg_memory(ea: ea_t, buffer: void *, size: size_t)`

  read_dbg_memory(ea, buffer, size) -> ssize_t

  @param ea: ea_t @param buffer: void * @param size: size_t

`def refresh_debugger_memory()`

  refresh_debugger_memory() -> PyObject * Refreshes the debugger memory

  @return: Nothing

`def rename_bptgrp(old_name: char const *, new_name: char const *)`

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

  @param old_name: (C++: const char ) absolute path to the folder to be renamed @param new_name: (C++: const char ) absolute path of the new folder name @return: success

`def request_add_bpt(*args) ‑> bool`

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

  @param ea: ea_t @param size: asize_t @param type: bpttype_t

  request_add_bpt(bpt) -> bool

  @param bpt: bpt_t const &

`def request_attach_process(pid: pid_t, event_id: int)`

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

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

`def request_clear_trace()`

  request_clear_trace() Post a clear_trace() request.

`def request_continue_process() ‑> bool`

  request_continue_process() -> bool Post a continue_process() request. @note: This requires an explicit call to run_requests()

`def request_del_bpt(*args) ‑> bool`

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

  @param ea: ea_t

  request_del_bpt(bptloc) -> bool

  @param bptloc: bpt_location_t const &

`def request_detach_process() ‑> bool`

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

`def request_disable_bblk_trace() ‑> bool`

  request_disable_bblk_trace() -> bool

`def request_disable_bpt(*args) ‑> bool`

  request_disable_bpt(ea) -> bool

  @param ea: ea_t

  request_disable_bpt(bptloc) -> bool

  @param bptloc: bpt_location_t const &

`def request_disable_func_trace() ‑> bool`

  request_disable_func_trace() -> bool

`def request_disable_insn_trace() ‑> bool`

  request_disable_insn_trace() -> bool

`def request_disable_step_trace() ‑> bool`

  request_disable_step_trace() -> bool

`def request_enable_bblk_trace(enable: bool = True) ‑> bool`

  request_enable_bblk_trace(enable=True) -> bool

  @param enable: bool

`def request_enable_bpt(*args) ‑> bool`

  request_enable_bpt(ea, enable=True) -> bool

  @param ea: ea_t @param enable: bool

  request_enable_bpt(bptloc, enable=True) -> bool

  @param bptloc: bpt_location_t const & @param enable: bool

`def request_enable_func_trace(enable: bool = True) ‑> bool`

  request_enable_func_trace(enable=True) -> bool

  @param enable: bool

`def request_enable_insn_trace(enable: bool = True) ‑> bool`

  request_enable_insn_trace(enable=True) -> bool

  @param enable: bool

`def request_enable_step_trace(enable: int = 1) ‑> bool`

  request_enable_step_trace(enable=1) -> bool

  @param enable: int

`def request_exit_process() ‑> bool`

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

`def request_resume_thread(tid: thid_t)`

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

  @param tid: (C++: thid_t)

`def request_run_to(*args) ‑> bool`

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

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

`def request_select_thread(tid: thid_t)`

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

  @param tid: (C++: thid_t)

`def request_set_bblk_trace_options(options: int)`

  request_set_bblk_trace_options(options) Post a set_bblk_trace_options() request.

  @param options: (C++: int)

`def request_set_func_trace_options(options: int)`

  request_set_func_trace_options(options) Post a set_func_trace_options() request.

  @param options: (C++: int)

`def request_set_insn_trace_options(options: int)`

  request_set_insn_trace_options(options) Post a set_insn_trace_options() request.

  @param options: (C++: int)

`def request_set_reg_val(regname: char const *, o: PyObject *)`

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

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

`def request_set_resume_mode(tid: thid_t, mode: resume_mode_t)`

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

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

`def request_set_step_trace_options(options: int)`

  request_set_step_trace_options(options) Post a set_step_trace_options() request.

  @param options: (C++: int)

`def request_start_process(path: char const * = None, args: char const * = None, sdir: char const * = None)`

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

  @param path: (C++: const char ) char const * @param args: (C++: const char ) char const * @param sdir: (C++: const char *) char const *

`def request_step_into() ‑> bool`

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

`def request_step_over() ‑> bool`

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

`def request_step_until_ret() ‑> bool`

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

`def request_suspend_process() ‑> bool`

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

`def request_suspend_thread(tid: thid_t)`

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

  @param tid: (C++: thid_t)

`def resume_thread(tid: thid_t)`

  resume_thread(tid) -> int Resume thread. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}

  @param tid: (C++: thid_t) thread id @retval -1: network error @retval 0: failed @retval 1: ok

`def retrieve_exceptions()`

  retrieve_exceptions() -> excvec_t Retrieve the exception information. You may freely modify the returned vector and add/edit/delete exceptions You must call store_exceptions() after any modifications Note: exceptions with code zero, multiple exception codes or names are prohibited

`def run_requests() ‑> bool`

  run_requests() -> bool Execute requests until all requests are processed or an asynchronous function is called. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @return: 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.

`def run_to(*args) ‑> bool`

  run_to(ea, pid=pid_t(-1), tid=0) -> bool Execute the process until the given address is reached. If no process is active, a new process is started. Technically, the debugger sets up a temporary breakpoint at the given address, and continues (or starts) the execution of the whole process. So, all threads continue their execution! \sq{Type, Asynchronous function - available as Request, Notification, dbg_run_to}

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

`def save_trace_file(filename: char const *, description: char const *)`

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

  @param filename: (C++: const char ) char const * @param description: (C++: const char ) char const *

`def select_thread(tid: thid_t)`

  select_thread(tid) -> bool Select the given thread as the current debugged thread. All thread related execution functions will work on this thread. The process must be suspended to select a new thread. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}

  @param tid: (C++: thid_t) ID of the thread to select @return: false if the thread doesn't exist.

`def send_dbg_command(command)`

  Send a direct command to the debugger backend, and retrieve the result as a string.

  Note: any double-quotes in 'command' must be backslash-escaped. Note: this only works with some debugger backends: Bochs, WinDbg, GDB.

  Returns: (True, ) on success, or (False, ) on failure

`def set_bblk_trace_options(options: int)`

  set_bblk_trace_options(options) Modify basic block tracing options (see BT_LOG_INSTS)

  @param options: (C++: int)

`def set_bpt_group(bpt: bpt_t, grp_name: char const *)`

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

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

`def set_bptloc_group(bptloc: bpt_location_t, grp_name: char const *)`

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

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

`def set_bptloc_string(s: char const *)`

  set_bptloc_string(s) -> int

  @param s: char const *

`def set_debugger_event_cond(NONNULL_evcond: char const *)`

  set_debugger_event_cond(NONNULL_evcond)

  @param NONNULL_evcond: char const *

`def set_debugger_options(options: uint)`

  set_debugger_options(options) -> uint Set debugger options. Replaces debugger options with the specification combination Debugger options

  @param options: (C++: uint) @return: the old debugger options

`def set_func_trace_options(options: int)`

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

  @param options: (C++: int)

`def set_highlight_trace_options(hilight: bool, color: bgcolor_t, diff: bgcolor_t)`

  set_highlight_trace_options(hilight, color, diff) Set highlight trace parameters.

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

`def set_insn_trace_options(options: int)`

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

  @param options: (C++: int)

`def set_manual_regions(ranges: meminfo_vec_t)`

  set_manual_regions(ranges)

  @param ranges: meminfo_vec_t const *

`def set_process_options(path: char const *, args: char const *, sdir: char const *, host: char const *, _pass: char const *, port: int)`

  set_process_options(path, args, sdir, host, _pass, port) Set process options. Any of the arguments may be nullptr, which means 'do not modify'

  @param path: (C++: const char ) char const * @param args: (C++: const char ) char const * @param sdir: (C++: const char ) char const * @param host: (C++: const char ) char const * @param pass: (C++: const char *) char const * @param port: (C++: int)

`def set_process_state(newstate: int, p_thid: thid_t *, dbginv: int)`

  set_process_state(newstate, p_thid, dbginv) -> int Set new state for the debugged process. Notifies the IDA kernel about the change of the debugged process state. For example, a debugger module could call this function when it knows that the process is suspended for a short period of time. Some IDA API calls can be made only when the process is suspended. The process state is usually restored before returning control to the caller. You must know that it is ok to change the process state, doing it at arbitrary moments may crash the application or IDA. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @param newstate: (C++: int) new process state (one of Debugged process states) if DSTATE_NOTASK is passed then the state is not changed @param 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 @param dbginv: (C++: int) Debugged process invalidation options @return: old debugger state (one of Debugged process states)

`def set_reg_val(*args)`

  set_reg_val(regname, o) -> PyObject

  @param regname: char const * @param o: PyObject *

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

  @param tid: thid_t @param regidx: int @param o: PyObject *

`def set_remote_debugger(host: char const *, _pass: char const *, port: int = -1)`

  set_remote_debugger(host, _pass, port=-1) Set remote debugging options. Should be used before starting the debugger.

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

`def set_resume_mode(tid: thid_t, mode: resume_mode_t)`

  set_resume_mode(tid, mode) -> bool How to resume the application. Set resume mode but do not resume process.

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

`def set_step_trace_options(options: int)`

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

  @param options: (C++: int)

`def set_trace_base_address(ea: ea_t)`

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

  @param ea: (C++: ea_t)

`def set_trace_dynamic_register_set(idaregs: dynamic_register_set_t &)`

  set_trace_dynamic_register_set(idaregs) Set dynamic register set of current trace.

  @param idaregs: (C++: dynamic_register_set_t &)

`def set_trace_file_desc(filename: char const *, description: char const *)`

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

  @param filename: (C++: const char ) char const * @param description: (C++: const char ) char const *

`def set_trace_platform(platform: char const *)`

  set_trace_platform(platform) Set platform name of current trace.

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

`def set_trace_size(size: int) ‑> bool`

  set_trace_size(size) -> bool Specify the new size of the circular buffer. \sq{Type, Synchronous function, Notification, none (synchronous function)}

  @param 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 !!!

`def srcdbg_request_step_into() ‑> bool`

  srcdbg_request_step_into() -> bool

`def srcdbg_request_step_over() ‑> bool`

  srcdbg_request_step_over() -> bool

`def srcdbg_request_step_until_ret() ‑> bool`

  srcdbg_request_step_until_ret() -> bool

`def srcdbg_step_into() ‑> bool`

  srcdbg_step_into() -> bool

`def srcdbg_step_over() ‑> bool`

  srcdbg_step_over() -> bool

`def srcdbg_step_until_ret() ‑> bool`

  srcdbg_step_until_ret() -> bool

`def start_process(path: char const * = None, args: char const * = None, sdir: char const * = None)`

  start_process(path=None, args=None, sdir=None) -> int Start a process in the debugger. \sq{Type, Asynchronous function - available as Request, Notification, dbg_process_start} @note: You can also use the run_to() function to easily start the execution of a process until a given address is reached. @note: For all parameters, a nullptr value indicates the debugger will take the value from the defined Process Options.

  @param path: (C++: const char ) path to the executable to start @param args: (C++: const char ) arguments to pass to process @param sdir: (C++: const char *) 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

`def step_into() ‑> bool`

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

`def step_over() ‑> bool`

  step_over() -> bool Execute one instruction in the current thread, but without entering into functions. Others threads keep suspended. \sq{Type, Asynchronous function - available as Request, Notification, dbg_step_over}

`def step_until_ret() ‑> bool`

  step_until_ret() -> bool Execute instructions in the current thread until a function return instruction is executed (aka "step out"). Other threads are kept suspended. \sq{Type, Asynchronous function - available as Request, Notification, dbg_step_until_ret}

`def store_exceptions() ‑> bool`

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

`def suspend_process() ‑> bool`

  suspend_process() -> bool Suspend the process in the debugger. \sq{ Type, * Synchronous function (if in a notification handler) * Asynchronous function (everywhere else) * available as Request, Notification, * none (if in a notification handler) * dbg_suspend_process (everywhere else) } @note: The suspend_process() function can be called from a notification handler to force the stopping of the process. In this case, no notification will be generated. When you suspend a process, the running command is always aborted.

`def suspend_thread(tid: thid_t)`

  suspend_thread(tid) -> int Suspend thread. Suspending a thread may deadlock the whole application if the suspended was owning some synchronization objects. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}

  @param tid: (C++: thid_t) thread id @retval -1: network error @retval 0: failed @retval 1: ok

`def update_bpt(bpt: bpt_t) ‑> bool`

  update_bpt(bpt) -> bool Update modifiable characteristics of an existing breakpoint. To update the breakpoint location, use change_bptlocs() \sq{Type, Synchronous function, Notification, none (synchronous function)} @note: Only the following fields can be modified: * bpt_t::cndbody * bpt_t::pass_count * bpt_t::flags * bpt_t::size * bpt_t::type @note: Changing some properties will require removing and then re-adding the breakpoint to the process memory (or the debugger backend), which can lead to race conditions (i.e., breakpoint(s) can be missed) in case the process is not suspended. Here are a list of scenarios that will require the breakpoint to be removed & then re-added: * bpt_t::size is modified * bpt_t::type is modified * bpt_t::flags's BPT_ENABLED is modified * bpt_t::flags's BPT_LOWCND is changed * bpt_t::flags's BPT_LOWCND remains set, but cndbody changed

  @param bpt: (C++: const bpt_t *) bpt_t const *

`def wait_for_next_event(wfne: int, timeout: int)`

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

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

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

`def write_dbg_memory(*args)`

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

  @param ea: ea_t @param py_buf: PyObject * @param size: size_t

## Classes

`class DBG_Hooks`

  Proxy of C++ DBG_Hooks class.

  init(self, _flags=0, _hkcb_flags=0x0001) -> DBG_Hooks

  @param _flags: uint32 @param _hkcb_flags: uint32

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def dbg_bpt(self, tid: thid_t, bptea: ea_t)`

    dbg_bpt(self, tid, bptea) -> int A user defined breakpoint was reached.

    @param tid: (thid_t) @param bptea: (::ea_t)

  `def dbg_bpt_changed(self, bptev_code: int, bpt: bpt_t)`

    dbg_bpt_changed(self, bptev_code, bpt) Breakpoint has been changed.

    @param bptev_code: (int) Breakpoint modification events @param bpt: (bpt_t *)

  `def dbg_exception(self, pid: pid_t, tid: thid_t, ea: ea_t, exc_code: int, exc_can_cont: bool, exc_ea: ea_t, exc_info: char const *)`

    dbg_exception(self, pid, tid, ea, exc_code, exc_can_cont, exc_ea, exc_info) -> int

    @param event: (const debug_event_t ) @param warn: (int ) filled with: * -1: display an exception warning dialog if the process is suspended. * 0: never display an exception warning dialog. * 1: always display an exception warning dialog. @param ea: ea_t @param exc_code: int @param exc_can_cont: bool @param exc_ea: ea_t @param exc_info: char const *

  `def dbg_finished_loading_bpts(self)`

    dbg_finished_loading_bpts(self) Finished loading breakpoint info from idb.

  `def dbg_information(self, pid: pid_t, tid: thid_t, ea: ea_t, info: char const *)`

    dbg_information(self, pid, tid, ea, info)

    @param event: (const debug_event_t *) @param tid: thid_t @param ea: ea_t @param info: char const *

  `def dbg_library_load(self, pid: pid_t, tid: thid_t, ea: ea_t, modinfo_name: char const *, modinfo_base: ea_t, modinfo_size: asize_t)`

    dbg_library_load(self, pid, tid, ea, modinfo_name, modinfo_base, modinfo_size)

    @param event: (const debug_event_t *) @param tid: thid_t @param ea: ea_t @param modinfo_name: char const * @param modinfo_base: ea_t @param modinfo_size: asize_t

  `def dbg_library_unload(self, pid: pid_t, tid: thid_t, ea: ea_t, info: char const *)`

    dbg_library_unload(self, pid, tid, ea, info)

    @param event: (const debug_event_t *) @param tid: thid_t @param ea: ea_t @param info: char const *

  `def dbg_process_attach(self, pid: pid_t, tid: thid_t, ea: ea_t, modinfo_name: char const *, modinfo_base: ea_t, modinfo_size: asize_t)`

    dbg_process_attach(self, pid, tid, ea, modinfo_name, modinfo_base, modinfo_size)

    @param event: (const debug_event_t *) @note: This event notification is also an asynchronous function result notification for start_process() ! @param tid: thid_t @param ea: ea_t @param modinfo_name: char const * @param modinfo_base: ea_t @param modinfo_size: asize_t

  `def dbg_process_detach(self, pid: pid_t, tid: thid_t, ea: ea_t)`

    dbg_process_detach(self, pid, tid, ea)

    @param event: (const debug_event_t *) @note: This event notification is also an asynchronous function result notification for start_process() ! @param tid: thid_t @param ea: ea_t

  `def dbg_process_exit(self, pid: pid_t, tid: thid_t, ea: ea_t, exit_code: int)`

    dbg_process_exit(self, pid, tid, ea, exit_code)

    @param event: (const debug_event_t *) @note: This event notification is also an asynchronous function result notification for start_process() ! @param tid: thid_t @param ea: ea_t @param exit_code: int

  `def dbg_process_start(self, pid: pid_t, tid: thid_t, ea: ea_t, modinfo_name: char const *, modinfo_base: ea_t, modinfo_size: asize_t)`

    dbg_process_start(self, pid, tid, ea, modinfo_name, modinfo_base, modinfo_size)

    @param event: (const debug_event_t *) @note: This event notification is also an asynchronous function result notification for start_process() ! @param tid: thid_t @param ea: ea_t @param modinfo_name: char const * @param modinfo_base: ea_t @param modinfo_size: asize_t

  `def dbg_request_error(self, failed_command: int, failed_dbg_notification: int)`

    dbg_request_error(self, failed_command, failed_dbg_notification) An error occurred during the processing of a request.

    @param failed_command: (ui_notification_t) @param failed_dbg_notification: (dbg_notification_t)

  `def dbg_run_to(self, pid: pid_t, tid: thid_t, ea: ea_t)`

    dbg_run_to(self, pid, tid, ea)

    @param event: (const debug_event_t *) @param tid: thid_t @param ea: ea_t

  `def dbg_started_loading_bpts(self)`

    dbg_started_loading_bpts(self) Started loading breakpoint info from idb.

  `def dbg_step_into(self)`

    dbg_step_into(self)

  `def dbg_step_over(self)`

    dbg_step_over(self)

  `def dbg_step_until_ret(self)`

    dbg_step_until_ret(self)

  `def dbg_suspend_process(self)`

    dbg_suspend_process(self) The process is now suspended.

  `def dbg_thread_exit(self, pid: pid_t, tid: thid_t, ea: ea_t, exit_code: int)`

    dbg_thread_exit(self, pid, tid, ea, exit_code)

    @param event: (const debug_event_t *) @param tid: thid_t @param ea: ea_t @param exit_code: int

  `def dbg_thread_start(self, pid: pid_t, tid: thid_t, ea: ea_t)`

    dbg_thread_start(self, pid, tid, ea)

    @param event: (const debug_event_t *) @param tid: thid_t @param ea: ea_t

  `def dbg_trace(self, tid: thid_t, ip: ea_t)`

    dbg_trace(self, tid, ip) -> int A step occurred (one instruction was executed). This event notification is only generated if step tracing is enabled.

    @param tid: (thid_t) thread ID @param ip: (::ea_t) current instruction pointer. usually points after the executed instruction @retval 1: do not log this trace event @retval 0: log it

  `def hook(self) ‑> bool`

    hook(self) -> bool

  `def unhook(self) ‑> bool`

    unhook(self) -> bool

`class bpt_location_t`

  Proxy of C++ bpt_location_t class.

  init(self) -> bpt_location_t

  ### Instance variables

  `var index : int`

    index

  `var info : ea_t`

    info

  `var loctype : bpt_loctype_t`

    loctype

  `var thisown`

    The membership flag

  ### Methods

  `def compare(self, r: bpt_location_t) ‑> int`

    compare(self, r) -> int Lexically compare two breakpoint locations. Bpt locations are first compared based on type (i.e. BPLT_ABS < BPLT_REL). BPLT_ABS locations are compared based on their ea values. For all other location types, locations are first compared based on their string (path/filename/symbol), then their offset/lineno.

    @param r: (C++: const bpt_location_t &) bpt_location_t const &

  `def ea(self)`

    ea(self) -> ea_t Get address (BPLT_ABS)

  `def is_empty_path(self) ‑> bool`

    is_empty_path(self) -> bool No path/filename specified? (BPLT_REL, BPLT_SRC)

  `def lineno(self) ‑> int`

    lineno(self) -> int Get line number (BPLT_SRC)

  `def offset(self)`

    offset(self) -> uval_t Get offset (BPLT_REL, BPLT_SYM)

  `def path(self)`

    path(self) -> char const * Get path/filename (BPLT_REL, BPLT_SRC)

  `def set_abs_bpt(self, a: ea_t)`

    set_abs_bpt(self, a) Specify an absolute address location.

    @param a: (C++: ea_t)

  `def set_rel_bpt(self, mod: char const *, _offset: uval_t)`

    set_rel_bpt(self, mod, _offset) Specify a relative address location.

    @param mod: (C++: const char *) char const * @param _offset: (C++: uval_t)

  `def set_src_bpt(self, fn: char const *, _lineno: int)`

    set_src_bpt(self, fn, _lineno) Specify a source level location.

    @param fn: (C++: const char *) char const * @param _lineno: (C++: int)

  `def set_sym_bpt(self, _symbol: char const *)`

    set_sym_bpt(self, _symbol, _offset=0) Specify a symbolic location.

    @param _symbol: (C++: const char *) char const * @param _offset: (C++: uval_t)

  `def symbol(self)`

    symbol(self) -> char const * Get symbol name (BPLT_SYM)

  `def type(self)`

    type(self) -> bpt_loctype_t Get bpt type.

`class bpt_t`

  Proxy of C++ bpt_t class.

  init(self) -> bpt_t

  ### Instance variables

  `var bptid : inode_t`

    Internal breakpoint id.

  `var cb : size_t`

    size of this structure

  `var cndidx : int`

    Internal number of the condition (<0-none)

  `var condition : PyObject *`

    condition

  `var ea : ea_t`

    Address, if known. For BPLT_SRC, index into an internal data struct.

  `var elang : PyObject *`

    elang

  `var flags : uint32`

    Breakpoint property bits

  `var loc : bpt_location_t`

    Location.

  `var pass_count : int`

    Number of times the breakpoint is hit before stopping (default is 0: stop always)

  `var pid : pid_t`

    breakpoint process id

  `var props : uint32`

    Internal breakpoint properties

  `var size : int`

    Size of the breakpoint (0 for software breakpoints)

  `var thisown`

    The membership flag

  `var tid : thid_t`

    breakpoint thread id

  `var type : bpttype_t`

    Breakpoint type.

  ### Methods

  `def badbpt(self) ‑> bool`

    badbpt(self) -> bool Failed to write bpt to process memory?

  `def enabled(self) ‑> bool`

    enabled(self) -> bool Is breakpoint enabled?

  `def get_cnd_elang_idx(self)`

    get_cnd_elang_idx(self) -> size_t

  `def get_size(self) ‑> int`

    get_size(self) -> int Get bpt size.

  `def is_absbpt(self) ‑> bool`

    is_absbpt(self) -> bool Is absolute address breakpoint?

  `def is_active(self) ‑> bool`

    is_active(self) -> bool Written completely to process?

  `def is_compiled(self) ‑> bool`

    is_compiled(self) -> bool Condition has been compiled?

  `def is_hwbpt(self) ‑> bool`

    is_hwbpt(self) -> bool Is hardware breakpoint?

  `def is_inactive(self) ‑> bool`

    is_inactive(self) -> bool Not written to process at all?

  `def is_low_level(self) ‑> bool`

    is_low_level(self) -> bool Is bpt condition calculated at low level?

  `def is_page_bpt(self) ‑> bool`

    is_page_bpt(self) -> bool Page breakpoint?

  `def is_partially_active(self) ‑> bool`

    is_partially_active(self) -> bool Written partially to process?

  `def is_relbpt(self) ‑> bool`

    is_relbpt(self) -> bool Is relative address breakpoint?

  `def is_srcbpt(self) ‑> bool`

    is_srcbpt(self) -> bool Is source level breakpoint?

  `def is_symbpt(self) ‑> bool`

    is_symbpt(self) -> bool Is symbolic breakpoint?

  `def is_tracemodebpt(self) ‑> bool`

    is_tracemodebpt(self) -> bool Does breakpoint trace anything?

  `def is_traceoffbpt(self) ‑> bool`

    is_traceoffbpt(self) -> bool Is this a tracing breakpoint, and is tracing disabled?

  `def is_traceonbpt(self) ‑> bool`

    is_traceonbpt(self) -> bool Is this a tracing breakpoint, and is tracing enabled?

  `def listbpt(self) ‑> bool`

    listbpt(self) -> bool Include in the bpt list?

  `def set_abs_bpt(self, a: ea_t)`

    set_abs_bpt(self, a) Set bpt location to an absolute address.

    @param a: (C++: ea_t)

  `def set_rel_bpt(self, mod: char const *, o: uval_t)`

    set_rel_bpt(self, mod, o) Set bpt location to a relative address.

    @param mod: (C++: const char *) char const * @param o: (C++: uval_t)

  `def set_src_bpt(self, fn: char const *, lineno: int)`

    set_src_bpt(self, fn, lineno) Set bpt location to a source line.

    @param fn: (C++: const char *) char const * @param lineno: (C++: int)

  `def set_sym_bpt(self, sym: char const *, o: uval_t)`

    set_sym_bpt(self, sym, o) Set bpt location to a symbol.

    @param sym: (C++: const char *) char const * @param o: (C++: uval_t)

  `def set_trace_action(self, enable: bool, trace_types: int) ‑> bool`

    set_trace_action(self, enable, trace_types) -> bool Configure tracing options.

    @param enable: (C++: bool) @param trace_types: (C++: int)

`class bpt_vec_t (*args)`

  Proxy of C++ qvector< bpt_t > class.

  init(self) -> bpt_vec_t init(self, x) -> bpt_vec_t

  @param x: qvector< bpt_t > const &

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def at(self, _idx: size_t)`

    at(self, _idx) -> bpt_t

    @param _idx: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> bpt_t

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> bpt_t

  `def erase(self, *args)`

    erase(self, it) -> bpt_t

    @param it: qvector< bpt_t >::iterator

    erase(self, first, last) -> bpt_t

    @param first: qvector< bpt_t >::iterator @param last: qvector< bpt_t >::iterator

  `def extract(self)`

    extract(self) -> bpt_t

  `def front(self)`
  `def grow(self, *args)`

    grow(self, x=bpt_t())

    @param x: bpt_t const &

  `def inject(self, s: bpt_t, len: size_t)`

    inject(self, s, len)

    @param s: bpt_t * @param len: size_t

  `def insert(self, it: bpt_t, x: bpt_t)`

    insert(self, it, x) -> bpt_t

    @param it: qvector< bpt_t >::iterator @param x: bpt_t const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: bpt_t const &

    push_back(self) -> bpt_t

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: bpt_t const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: bpt_vec_t)`

    swap(self, r)

    @param r: qvector< bpt_t > &

  `def truncate(self)`

    truncate(self)

`class bptaddrs_t`

  Proxy of C++ bptaddrs_t class.

  init(self) -> bptaddrs_t

  ### Instance variables

  `var bpt : bpt_t *`

    bpt

  `var thisown`

    The membership flag

`class eval_ctx_t (_ea: ea_t)`

  Proxy of C++ eval_ctx_t class.

  init(self, _ea) -> eval_ctx_t

  @param _ea: ea_t

  ### Instance variables

  `var ea : ea_t`

    ea

  `var thisown`

    The membership flag

`class memreg_info_t`

  Proxy of C++ memreg_info_t class.

  init(self) -> memreg_info_t

  ### Instance variables

  `var bytes : PyObject *`

    get_bytes(self) -> PyObject *

  `var ea : ea_t`

    ea

  `var thisown`

    The membership flag

  ### Methods

  `def get_bytes(self)`

    get_bytes(self) -> PyObject *

`class memreg_infos_t (*args)`

  Proxy of C++ qvector< memreg_info_t > class.

  init(self) -> memreg_infos_t init(self, x) -> memreg_infos_t

  @param x: qvector< memreg_info_t > const &

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def at(self, _idx: size_t)`

    at(self, _idx) -> memreg_info_t

    @param _idx: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> memreg_info_t

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> memreg_info_t

  `def erase(self, *args)`

    erase(self, it) -> memreg_info_t

    @param it: qvector< memreg_info_t >::iterator

    erase(self, first, last) -> memreg_info_t

    @param first: qvector< memreg_info_t >::iterator @param last: qvector< memreg_info_t >::iterator

  `def extract(self)`

    extract(self) -> memreg_info_t

  `def front(self)`
  `def grow(self, *args)`

    grow(self, x=memreg_info_t())

    @param x: memreg_info_t const &

  `def inject(self, s: memreg_info_t, len: size_t)`

    inject(self, s, len)

    @param s: memreg_info_t * @param len: size_t

  `def insert(self, it: memreg_info_t, x: memreg_info_t)`

    insert(self, it, x) -> memreg_info_t

    @param it: qvector< memreg_info_t >::iterator @param x: memreg_info_t const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: memreg_info_t const &

    push_back(self) -> memreg_info_t

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: memreg_info_t const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: memreg_infos_t)`

    swap(self, r)

    @param r: qvector< memreg_info_t > &

  `def truncate(self)`

    truncate(self)

`class tev_info_reg_t`

  Proxy of C++ tev_info_reg_t class.

  init(self) -> tev_info_reg_t

  ### Instance variables

  `var info : tev_info_t`

    info

  `var registers : tev_reg_values_t`

    registers

  `var thisown`

    The membership flag

`class tev_info_t`

  Proxy of C++ tev_info_t class.

  init(self) -> tev_info_t

  ### Instance variables

  `var ea : ea_t`

    address where the event occurred

  `var thisown`

    The membership flag

  `var tid : thid_t`

    thread where the event was recorded

  `var type : tev_type_t`

    trace event type

`class tev_reg_value_t (*args)`

  Proxy of C++ tev_reg_value_t class.

  init(self, _reg_idx=-1, _value=uint64(-1)) -> tev_reg_value_t

  @param _reg_idx: int @param _value: uint64

  ### Instance variables

  `var reg_idx : int`

    reg_idx

  `var thisown`

    The membership flag

  `var value : regval_t`

    value

`class tev_reg_values_t (*args)`

  Proxy of C++ qvector< tev_reg_value_t > class.

  init(self) -> tev_reg_values_t init(self, x) -> tev_reg_values_t

  @param x: qvector< tev_reg_value_t > const &

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def at(self, _idx: size_t)`

    at(self, _idx) -> tev_reg_value_t

    @param _idx: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> tev_reg_value_t

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> tev_reg_value_t

  `def erase(self, *args)`

    erase(self, it) -> tev_reg_value_t

    @param it: qvector< tev_reg_value_t >::iterator

    erase(self, first, last) -> tev_reg_value_t

    @param first: qvector< tev_reg_value_t >::iterator @param last: qvector< tev_reg_value_t >::iterator

  `def extract(self)`

    extract(self) -> tev_reg_value_t

  `def front(self)`
  `def grow(self, *args)`

    grow(self, x=tev_reg_value_t())

    @param x: tev_reg_value_t const &

  `def inject(self, s: tev_reg_value_t, len: size_t)`

    inject(self, s, len)

    @param s: tev_reg_value_t * @param len: size_t

  `def insert(self, it: tev_reg_value_t, x: tev_reg_value_t)`

    insert(self, it, x) -> tev_reg_value_t

    @param it: qvector< tev_reg_value_t >::iterator @param x: tev_reg_value_t const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: tev_reg_value_t const &

    push_back(self) -> tev_reg_value_t

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: tev_reg_value_t const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: tev_reg_values_t)`

    swap(self, r)

    @param r: qvector< tev_reg_value_t > &

  `def truncate(self)`

    truncate(self)

`class tevinforeg_vec_t (*args)`

  Proxy of C++ qvector< tev_info_reg_t > class.

  init(self) -> tevinforeg_vec_t init(self, x) -> tevinforeg_vec_t

  @param x: qvector< tev_info_reg_t > const &

  ### Instance variables

  `var thisown`

    The membership flag

  ### Methods

  `def at(self, _idx: size_t)`

    at(self, _idx) -> tev_info_reg_t

    @param _idx: size_t

  `def back(self)`
  `def begin(self, *args)`

    begin(self) -> tev_info_reg_t

  `def capacity(self)`

    capacity(self) -> size_t

  `def clear(self)`

    clear(self)

  `def empty(self) ‑> bool`

    empty(self) -> bool

  `def end(self, *args)`

    end(self) -> tev_info_reg_t

  `def erase(self, *args)`

    erase(self, it) -> tev_info_reg_t

    @param it: qvector< tev_info_reg_t >::iterator

    erase(self, first, last) -> tev_info_reg_t

    @param first: qvector< tev_info_reg_t >::iterator @param last: qvector< tev_info_reg_t >::iterator

  `def extract(self)`

    extract(self) -> tev_info_reg_t

  `def front(self)`
  `def grow(self, *args)`

    grow(self, x=tev_info_reg_t())

    @param x: tev_info_reg_t const &

  `def inject(self, s: tev_info_reg_t, len: size_t)`

    inject(self, s, len)

    @param s: tev_info_reg_t * @param len: size_t

  `def insert(self, it: tev_info_reg_t, x: tev_info_reg_t)`

    insert(self, it, x) -> tev_info_reg_t

    @param it: qvector< tev_info_reg_t >::iterator @param x: tev_info_reg_t const &

  `def pop_back(self)`

    pop_back(self)

  `def push_back(self, *args)`

    push_back(self, x)

    @param x: tev_info_reg_t const &

    push_back(self) -> tev_info_reg_t

  `def qclear(self)`

    qclear(self)

  `def reserve(self, cnt: size_t)`

    reserve(self, cnt)

    @param cnt: size_t

  `def resize(self, *args)`

    resize(self, _newsize, x)

    @param _newsize: size_t @param x: tev_info_reg_t const &

    resize(self, _newsize)

    @param _newsize: size_t

  `def size(self)`

    size(self) -> size_t

  `def swap(self, r: tevinforeg_vec_t)`

    swap(self, r)

    @param r: qvector< tev_info_reg_t > &

  `def truncate(self)`

    truncate(self)