dbg.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2026 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef DBG_HPP
#define DBG_HPP
 
#include <idp.hpp>
#include <idd.hpp>
#include <kernwin.hpp>          // for callui() and ui_notification_t

 
//--------------------------------------------------------------------
//             D E B U G G E R   I N F O R M A T I O N
//--------------------------------------------------------------------

idaman debugger_t ida_export_data *dbg;
 
//--------------------------------------------------------------------
//               D E B U G G E R   C A L L B A C K S
//--------------------------------------------------------------------
enum dbg_notification_t
{
  dbg_null = 0,
 
  // debugger low-level event notifications (see IDD.HPP for details).
 
  dbg_process_start,   
 
  dbg_process_exit,    
 
  dbg_process_attach,  
 
  dbg_process_detach,  
 
  dbg_thread_start,    
 
  dbg_thread_exit,     
 
  dbg_library_load,    
 
  dbg_library_unload,  
 
  dbg_information,     
 
  dbg_exception,       
 
  // debugger high-level event notifications
 
  dbg_suspend_process, 
 
  dbg_bpt,             
 
  dbg_trace,           
 
  dbg_request_error,   
 
  // debugger asynchronous function result notifications
  //   Please note some low-level event notifications also act as asynchronous
  //   function result notifications.
 
  dbg_step_into,       
 
  dbg_step_over,       
 
  dbg_run_to,          
 
  dbg_step_until_ret,  
 
  dbg_bpt_changed,     
 
  dbg_started_loading_bpts,  
  dbg_finished_loading_bpts, 
 
  dbg_last,            
};

#define BPTEV_ADDED    0 
#define BPTEV_REMOVED  1 
#define BPTEV_CHANGED  2 
 
#ifndef __UI__
 
//--------------------------------------------------------------------
//               D E B U G G E R    F U N C T I O N S
//--------------------------------------------------------------------

 
inline bool idaapi run_requests(void) { return callui(ui_dbg_run_requests).cnd; }
 

 
inline ui_notification_t idaapi get_running_request(void) { return (ui_notification_t)callui(ui_dbg_get_running_request).i; }
 

 
inline bool is_request_running(void) { return get_running_request() != ui_null; }
 

 
inline dbg_notification_t idaapi get_running_notification(void) { return (dbg_notification_t)callui(ui_dbg_get_running_notification).i; }
 

 
inline void idaapi clear_requests_queue(void) { callui(ui_dbg_clear_requests_queue); }
 
//--------------------------------------------------------------------
//                P R O C E S S   C O M M A N D S
//--------------------------------------------------------------------

 
inline int idaapi get_process_state(void) { return callui(ui_dbg_get_process_state).i; }
 
#endif // __UI__

#define DSTATE_SUSP             -1 
#define DSTATE_NOTASK            0 
#define DSTATE_RUN               1 
inline bool idaapi is_valid_dstate(int state)
{
  return state == DSTATE_SUSP || state == DSTATE_NOTASK || state == DSTATE_RUN;
}

#define DBGINV_MEMORY   0x0001  
#define DBGINV_MEMCFG   0x0002  
#define DBGINV_REGS     0x0004  
#define DBGINV_ALL      0x7FFF  
#define DBGINV_REDRAW   0x8000  
#define DBGINV_NONE     0       
 
#ifndef __UI__

 
inline int idaapi set_process_state(int newstate, thid_t *p_thid, int dbginv) { return callui(ui_dbg_set_process_state, newstate, p_thid, dbginv).i; }
 

 
inline int idaapi invalidate_dbg_state(int dbginv)
{
  return set_process_state(DSTATE_NOTASK, nullptr, dbginv);
}
 

 
inline int idaapi start_process(
        const char *path = nullptr,
        const char *args = nullptr,
        const char *sdir = nullptr)
{
  return callui(ui_dbg_start_process, path, args, sdir).i;
}
 

 
inline int idaapi request_start_process(
        const char *path = nullptr,
        const char *args = nullptr,
        const char *sdir = nullptr)
{
  return callui(ui_dbg_request_start_process, path, args, sdir).i;
}
 

 
inline bool idaapi suspend_process(void) { return callui(ui_dbg_suspend_process).cnd; }

 
inline bool idaapi request_suspend_process(void) { return callui(ui_dbg_request_suspend_process).cnd; }
 

 
inline bool idaapi continue_process(void) { return callui(ui_dbg_continue_process).cnd; }

 
inline bool idaapi request_continue_process(void) { return callui(ui_dbg_request_continue_process).cnd; }

 
inline bool idaapi continue_backwards(void) { return callui(ui_dbg_continue_backwards).cnd; }

 
inline bool idaapi request_continue_backwards(void) { return callui(ui_dbg_request_continue_backwards).cnd; }

 
inline bool idaapi exit_process(void) { return callui(ui_dbg_exit_process).cnd; }

 
inline bool idaapi request_exit_process(void) { return callui(ui_dbg_request_exit_process).cnd; }
 

 
inline ssize_t idaapi get_processes(procinfo_vec_t *proclist) { return callui(ui_dbg_get_processes, proclist).ssize; }
 

 
inline int idaapi attach_process(pid_t pid=NO_PROCESS, int event_id=-1) { return callui(ui_dbg_attach_process, pid, event_id).i; }

 
inline int idaapi request_attach_process(pid_t pid, int event_id) { return callui(ui_dbg_request_attach_process, pid, event_id).i; }
 

 
inline bool idaapi detach_process(void) { return callui(ui_dbg_detach_process).cnd; }

 
inline bool idaapi request_detach_process(void) { return callui(ui_dbg_request_detach_process).cnd; }
 

 
inline bool idaapi is_debugger_busy(void) { return callui(ui_dbg_is_busy).cnd; }

 
 
//--------------------------------------------------------------------
//                         T H R E A D S
//--------------------------------------------------------------------

 
inline int idaapi get_thread_qty(void) { return callui(ui_dbg_get_thread_qty).i; }
 

 
inline thid_t idaapi getn_thread(int n) { return (thid_t)callui(ui_dbg_getn_thread, n).i; }
 

 
inline thid_t idaapi get_current_thread(void) { return callui(ui_dbg_get_current_thread).i; }
 

 
inline const char *idaapi getn_thread_name(int n) { return callui(ui_dbg_getn_thread_name, n).cptr; }
 

 
inline bool idaapi select_thread(thid_t tid) { return callui(ui_dbg_select_thread, tid).cnd; }

 
inline bool idaapi request_select_thread(thid_t tid) { return callui(ui_dbg_request_select_thread, tid).cnd; }
 

 
inline int idaapi suspend_thread(thid_t tid) { return callui(ui_dbg_suspend_thread, tid).i; }

 
inline int idaapi request_suspend_thread(thid_t tid) { return callui(ui_dbg_request_suspend_thread, tid).i; }
 

 
inline int idaapi resume_thread(thid_t tid) { return callui(ui_dbg_resume_thread, tid).i; }

 
inline int idaapi request_resume_thread(thid_t tid) { return callui(ui_dbg_request_resume_thread, tid).i; }

 
 
//--------------------------------------------------------------------
//                         M O D U L E S
//--------------------------------------------------------------------
inline bool idaapi get_first_module(modinfo_t *modinfo) 
{ return callui(ui_dbg_get_first_module, modinfo).cnd; }
 
inline bool idaapi get_next_module(modinfo_t *modinfo)  
{ return callui(ui_dbg_get_next_module, modinfo).cnd; }

 
 
//--------------------------------------------------------------------
//    E X E C U T I O N   F L O W   C O N T R O L   C O M M A N D S
//--------------------------------------------------------------------

 
inline bool idaapi step_into(void) { return callui(ui_dbg_step_into).cnd; }

 
inline bool idaapi request_step_into(void) { return callui(ui_dbg_request_step_into).cnd; }
 

 
inline bool idaapi step_over(void) { return callui(ui_dbg_step_over).cnd; }

 
inline bool idaapi request_step_over(void) { return callui(ui_dbg_request_step_over).cnd; }
 

 
inline bool idaapi step_into_backwards(void) { return callui(ui_dbg_step_into_backwards).cnd; }

 
inline bool idaapi request_step_into_backwards(void) { return callui(ui_dbg_request_step_into_backwards).cnd; }
 

 
inline bool idaapi step_over_backwards(void) { return callui(ui_dbg_step_over_backwards).cnd; }

 
inline bool idaapi request_step_over_backwards(void) { return callui(ui_dbg_request_step_over_backwards).cnd; }
 

 
inline bool idaapi run_to(ea_t ea, pid_t pid = NO_PROCESS, thid_t tid = NO_THREAD) { return callui(ui_dbg_run_to, ea, pid, tid).cnd; }

 
inline bool idaapi request_run_to(ea_t ea, pid_t pid = NO_PROCESS, thid_t tid = NO_THREAD) { return callui(ui_dbg_request_run_to, ea, pid, tid).cnd; }
 

 
inline bool idaapi run_to_backwards(ea_t ea, pid_t pid = NO_PROCESS, thid_t tid = NO_THREAD) { return callui(ui_dbg_run_to_backwards, ea, pid, tid).cnd; }

 
inline bool idaapi request_run_to_backwards(ea_t ea, pid_t pid = NO_PROCESS, thid_t tid = NO_THREAD) { return callui(ui_dbg_request_run_to_backwards, ea, pid, tid).cnd; }
 

 
inline bool idaapi step_until_ret(void) { return callui(ui_dbg_step_until_ret).cnd; }

 
inline bool idaapi request_step_until_ret(void) { return callui(ui_dbg_request_step_until_ret).cnd; }
 

 
inline bool idaapi set_resume_mode(thid_t tid, resume_mode_t mode) { return callui(ui_dbg_set_resume_mode, tid, mode).cnd; }

 
inline bool idaapi request_set_resume_mode(thid_t tid, resume_mode_t mode) { return callui(ui_dbg_request_set_resume_mode, tid, mode).cnd; }

 
 
//--------------------------------------------------------------------
//                       R E G I S T E R S
//--------------------------------------------------------------------

 
inline bool idaapi get_dbg_reg_info(const char *regname, register_info_t *ri) { return callui(ui_dbg_get_reg_info, regname, ri).cnd; }

 
inline bool idaapi get_reg_val(const char *regname, regval_t *regval) { return callui(ui_dbg_get_reg_val, regname, regval).cnd; }

 
inline bool idaapi get_reg_val(const char *regname, uint64 *ival) { return callui(ui_dbg_get_reg_val_i, regname, ival).cnd; }
 

inline bool idaapi get_sp_val(ea_t *out) { return callui(ui_dbg_get_sp_val, out).cnd; }

inline bool idaapi get_ip_val(ea_t *out) { return callui(ui_dbg_get_ip_val, out).cnd; }

 
inline bool idaapi set_reg_val(const char *regname, const regval_t *regval) { return callui(ui_dbg_set_reg_val, regname, regval).cnd; }

 
inline bool idaapi set_reg_val(const char *regname, uint64 ival) { return callui(ui_dbg_set_reg_val_i, regname, ival).cnd; }

 
inline bool idaapi request_set_reg_val(const char *regname, const regval_t *regval) { return callui(ui_dbg_request_set_reg_val, regname, regval).cnd; }
 

 
inline bool idaapi is_reg_integer(const char *regname) { return callui(ui_dbg_get_reg_value_type, regname).i-2 == RVT_INT; }
 

 
inline bool idaapi is_reg_float(const char *regname) { return callui(ui_dbg_get_reg_value_type, regname).i-2 == RVT_FLOAT; }
 

 
inline bool idaapi is_reg_custom(const char *regname) { return callui(ui_dbg_get_reg_value_type, regname).i >= 2; }

 
#endif // __UI__
 
//--------------------------------------------------------------------
//                     B R E A K P O I N T S
//--------------------------------------------------------------------
 
int idaapi set_bptloc_string(const char *s);
const char *idaapi get_bptloc_string(int i);
 
struct bpt_t;
struct bpt_location_t;
struct movbpt_info_t;
typedef qvector<movbpt_info_t> movbpt_infos_t;
typedef qvector<const bpt_t *> bpt_constptr_vec_t;
typedef qvector<bpt_t *> bptptr_vec_t;
typedef qvector<bpt_t> bpt_vec_t; 
 
enum movbpt_code_t
{
  MOVBPT_OK,            
  MOVBPT_NOT_FOUND,     
  MOVBPT_DEST_BUSY,     
  MOVBPT_BAD_TYPE,      
};
typedef qvector<movbpt_code_t> movbpt_codes_t;
 
struct bptaddrs_t : public eavec_t
{
  bpt_t *bpt;   // bpt described by this structure.
                // we need it to handle internal srcbpts
};
 
typedef qvector<bptaddrs_t> bpteas_t;
 
 
 
#ifdef __UI__
// use direct call to compare_bpt_locs() in case of UI (otherwise will have
// "Bad event detected during undo" for ui_dbg_compare_bpt_locs)
idaman int ida_export compare_bpt_locs(const bpt_location_t &a, const bpt_location_t &b);
#endif

enum bpt_loctype_t
{
  BPLT_ABS,           
  BPLT_REL,           
  BPLT_SYM,           
  BPLT_SRC,           
  BPLT_LAST,
};

struct bpt_location_t
{
// private:
  ea_t info;
  int index;
  bpt_loctype_t loctype;
// public:
  bpt_loctype_t type(void) const { return loctype; }                  
  bool is_empty_path(void) const { return index == 0; }               
  const char *path(void) const { return get_bptloc_string(index); }   
  const char *symbol(void) const { return get_bptloc_string(index); } 
  int lineno(void) const { return int(info); }                        
  uval_t offset(void) const { return (uval_t)info; }                  
  ea_t ea(void) const { return info; }                                
 
  bpt_location_t(void) : info(BADADDR), index(0), loctype(BPLT_ABS) {}  

  bool valid() const { return loctype != BPLT_ABS || info != BADADDR; }

  void set_abs_bpt(ea_t a)
  {
    info = a;
    loctype = BPLT_ABS;
  }

  void set_src_bpt(const char *fn, int _lineno)
  {
    index   = set_bptloc_string(fn);
    info    = _lineno;
    loctype = BPLT_SRC;
  }

  void set_sym_bpt(const char *_symbol, uval_t _offset=0)
  {
    index   = set_bptloc_string(_symbol);
    info    = _offset;
    loctype = BPLT_SYM;
  }

  void set_rel_bpt(const char *mod, uval_t _offset)
  {
    index   = set_bptloc_string(mod);
    info    = _offset;
    loctype = BPLT_REL;
  }

#ifdef __UI__
  int compare(const bpt_location_t &r) const { return compare_bpt_locs(*this, r); }
#else
  int compare(const bpt_location_t &r) const { return callui(ui_dbg_compare_bpt_locs, this, &r).i; }
#endif
  bool operator==(const bpt_location_t &r) const { return compare(r) == 0; }
  bool operator!=(const bpt_location_t &r) const { return compare(r) != 0; }
  bool operator< (const bpt_location_t &r) const { return compare(r) <  0; }
  bool operator> (const bpt_location_t &r) const { return compare(r) >  0; }
  bool operator<=(const bpt_location_t &r) const { return compare(r) <= 0; }
  bool operator>=(const bpt_location_t &r) const { return compare(r) >= 0; }

  size_t print(qstring *buf) const;
};
DECLARE_TYPE_AS_MOVABLE(bpt_location_t);

struct bpt_t
{
  size_t cb;                 
  qstring cndbody;           
  bpt_location_t loc;        
  pid_t pid;                 
  thid_t tid;                
  ea_t ea;                   
  bpttype_t type;            
  int pass_count;            
  uint32 flags;              
#define BPT_BRK        0x001 
#define BPT_TRACE      0x002 
#define BPT_UPDMEM     0x004 
#define BPT_ENABLED    0x008 
#define BPT_LOWCND     0x010 
#define BPT_TRACEON    0x020 
#define BPT_TRACE_INSN 0x040 
#define BPT_TRACE_FUNC 0x080 
#define BPT_TRACE_BBLK 0x100 
#define BPT_TRACE_TYPES (BPT_TRACE_INSN|BPT_TRACE_FUNC|BPT_TRACE_BBLK)
#define BPT_ELANG_MASK  0xF0000000u
#define BPT_ELANG_SHIFT 28 
 
  uint32 props;            
#define BKPT_BADBPT   0x01  
#define BKPT_LISTBPT  0x02  
#define BKPT_TRACE    0x04  
#define BKPT_ACTIVE   0x08  
#define BKPT_PARTIAL  0x10  
#define BKPT_CNDREADY 0x20  
#define BKPT_FAKEPEND 0x40  
#define BKPT_PAGE     0x80  
 
  int size;                 
  int cndidx;               
  inode_t bptid;            
 
  bpt_t(void) : cb(sizeof(*this)), pid(NO_PROCESS), tid(NO_THREAD), ea(BADADDR),
                type(BPT_SOFT), pass_count(0), flags(BPT_BRK|BPT_ENABLED),
                props(0), size(0), cndidx(-1), bptid(0) {}
 
  bool is_hwbpt(void) const { return type != BPT_SOFT; }                
  bool enabled(void) const { return (flags & BPT_ENABLED) != 0; }       
  bool is_low_level(void) const { return (flags & BPT_LOWCND) != 0; }   
  bool badbpt(void) const { return (props & BKPT_BADBPT) != 0; }        
  bool listbpt(void) const { return (props & BKPT_LISTBPT) != 0; }      
  bool is_compiled(void) const { return (props & BKPT_CNDREADY) != 0; } 
  /// Written completely to process?
  bool is_active(void) const { return (props & (BKPT_PARTIAL|BKPT_ACTIVE)) == BKPT_ACTIVE; }
  bool is_partially_active(void) const { return (props & BKPT_PARTIAL) != 0; }
  bool is_inactive(void) const { return (props & (BKPT_PARTIAL|BKPT_ACTIVE)) == 0; }
  bool is_page_bpt(void) const { return (props & BKPT_PAGE) != 0; }

  int get_size(void) const { return is_hwbpt() ? size : 1; }
  void set_abs_bpt(ea_t a) { loc.set_abs_bpt(a); ea = a; }
  void set_src_bpt(const char *fn, int lineno) { loc.set_src_bpt(fn, lineno); ea = BADADDR; }
  void set_sym_bpt(const char *sym, uval_t o) { loc.set_sym_bpt(sym, o); ea = BADADDR; }
  void set_rel_bpt(const char *mod, uval_t o) { loc.set_rel_bpt(mod, o); ea = BADADDR; }
 
  bool is_absbpt(void) const { return loc.type() == BPLT_ABS; } 
  bool is_relbpt(void) const { return loc.type() == BPLT_REL; } 
  bool is_symbpt(void) const { return loc.type() == BPLT_SYM; } 
  bool is_srcbpt(void) const { return loc.type() == BPLT_SRC; } 

  bool is_tracemodebpt(void) const { return (flags & BPT_TRACE_TYPES) != 0; }
  bool is_traceonbpt(void) const { return is_tracemodebpt() && (flags & BPT_TRACEON) != 0; }
  bool is_traceoffbpt(void) const { return is_tracemodebpt() && (flags & BPT_TRACEON) == 0; }
  bool set_trace_action(bool enable, int trace_types)
  {
    trace_types &= BPT_TRACE_TYPES;
    if ( trace_types == 0 )
      return false;
    flags |= trace_types;
    setflag(flags, BPT_TRACEON, enable);
    return true;
  }


  const char *get_cnd_elang() const;

  bool set_cnd_elang(const char *name);
 
  size_t get_cnd_elang_idx() const { return flags >> BPT_ELANG_SHIFT; }
 
  void set_cond(const char *cnd); 
  bool eval_cond(ea_t ea, bool *fire, const char *bpt_type); 
};
DECLARE_TYPE_AS_MOVABLE(bpt_t);
 
struct movbpt_info_t
{
  bpt_location_t from;
  bpt_location_t to;
};
DECLARE_TYPE_AS_MOVABLE(movbpt_info_t);
 
#ifndef __UI__
 

 
inline int idaapi get_bpt_qty(void) { return callui(ui_dbg_get_bpt_qty).i; }
 

 
inline bool idaapi getn_bpt(int n, bpt_t *bpt) { return callui(ui_dbg_getn_bpt, n, bpt).cnd; }
 

 
inline bool idaapi get_bpt(ea_t ea, bpt_t *bpt) { return callui(ui_dbg_get_bpt, ea, bpt).cnd; }
 

 
inline bool exist_bpt(ea_t ea) { return get_bpt(ea, nullptr); }
 

 
inline bool idaapi add_bpt(ea_t ea, asize_t size = 0, bpttype_t type = BPT_DEFAULT) { return callui(ui_dbg_add_oldbpt, ea, size, type).cnd; }

 
inline bool idaapi request_add_bpt(ea_t ea, asize_t size = 0, bpttype_t type = BPT_DEFAULT) { return callui(ui_dbg_request_add_oldbpt, ea, size, type).cnd; }
 

 
inline bool idaapi add_bpt(const bpt_t &bpt) { return callui(ui_dbg_add_bpt, &bpt).cnd; }

 
inline bool idaapi request_add_bpt(const bpt_t &bpt) { return callui(ui_dbg_request_add_bpt, &bpt).cnd; }
 

 
inline bool idaapi del_bpt(ea_t ea) { return callui(ui_dbg_del_oldbpt, ea).cnd; }

 
inline bool idaapi request_del_bpt(ea_t ea) { return callui(ui_dbg_request_del_oldbpt, ea).cnd; }
 

 
inline bool idaapi del_bpt(const bpt_location_t &bptloc) { return callui(ui_dbg_del_bpt, &bptloc).cnd; }

 
inline bool idaapi request_del_bpt(const bpt_location_t &bptloc) { return callui(ui_dbg_request_del_bpt, &bptloc).cnd; }
 

 
inline bool idaapi update_bpt(const bpt_t *bpt) { return callui(ui_dbg_update_bpt, bpt).cnd; }
 

 
inline bool idaapi find_bpt(const bpt_location_t &bptloc, bpt_t *bpt) { return callui(ui_dbg_find_bpt, &bptloc, bpt).cnd; }
 

 
inline int idaapi change_bptlocs(
        const movbpt_infos_t &movinfo,
        movbpt_codes_t *codes = nullptr,
        bool del_hindering_bpts = true)
{
  return callui(ui_dbg_change_bptlocs, &movinfo, codes, del_hindering_bpts).i;
}
 

inline bool idaapi enable_bpt(ea_t ea, bool enable = true) { return callui(ui_dbg_enable_oldbpt, ea, enable).cnd; }
inline bool idaapi enable_bpt(const bpt_location_t &bptloc, bool enable = true) { return callui(ui_dbg_enable_bpt, &bptloc, enable).cnd; }
inline bool disable_bpt(ea_t ea) { return enable_bpt(ea, false); }
inline bool disable_bpt(const bpt_location_t &bptloc) { return enable_bpt(bptloc, false); }
inline bool idaapi request_enable_bpt(ea_t ea, bool enable = true) { return callui(ui_dbg_request_enable_oldbpt, ea, enable).cnd; }
inline bool idaapi request_enable_bpt(const bpt_location_t &bptloc, bool enable = true) { return callui(ui_dbg_request_enable_bpt, &bptloc, enable).cnd; }
inline bool request_disable_bpt(ea_t ea) { return request_enable_bpt(ea, false); }
inline bool request_disable_bpt(const bpt_location_t &bptloc) { return request_enable_bpt(bptloc, false); }
 

 
inline int idaapi check_bpt(ea_t ea) { return callui(ui_dbg_check_bpt, ea).i; }
 
#endif // __UI__

#define BPTCK_NONE -1  
#define BPTCK_NO    0  
#define BPTCK_YES   1  
#define BPTCK_ACT   2  
 
#ifndef SWIG
struct bpt_visitor_t
{
  range_t range;                  
  const char *name;               
  bpt_visitor_t(void) : range(0, BADADDR), name(nullptr) {}
  virtual int idaapi visit_bpt(const bpt_t *bpt) = 0;
  int idaapi for_all_bpts(int bvflags)
  {
    return callui(ui_dbg_for_all_bpts, this, bvflags).i;
  }
};

#define BVF_ABS             0x0001  
#define BVF_REL             0x0002  
#define BVF_SYM             0x0004  
#define BVF_SRC             0x0008  
#define BVF_ALL             0x000F  
#define BVF_STATE           0x0030  
#define   BVFS_ANY          0x0000  
#define   BVFS_INPROC       0x0010  
#define   BVFS_PENDING      0x0020  
#define   BVFS_DISABLED     0x0030  
#endif // SWIG
 

 
 
#ifndef __UI__

 
//--------------------------------------------------------------------
//                    T R A C I N G   B U F F E R
//--------------------------------------------------------------------
 

 
inline bool idaapi set_trace_size(int size) { return callui(ui_dbg_set_trace_size, size).cnd; }
 

 
inline void idaapi clear_trace(void) { callui(ui_dbg_clear_trace); }

 
inline void idaapi request_clear_trace(void) { callui(ui_dbg_request_clear_trace); }

 
 
//--------------------------------------------------------------------
//                        S T E P    T R A C I N G
//--------------------------------------------------------------------

 
inline bool idaapi is_step_trace_enabled(void) { return callui(ui_dbg_is_step_trace_enabled).cnd; }
 

 
inline bool idaapi enable_step_trace(int enable = 1) { return callui(ui_dbg_enable_step_trace, enable).cnd; }
inline bool disable_step_trace(void) { return enable_step_trace(0); }
inline bool idaapi request_enable_step_trace(int enable = 1) { return callui(ui_dbg_request_enable_step_trace, enable).cnd; }
inline bool request_disable_step_trace(void) { return request_enable_step_trace(false); }
 
#endif // __UI__
 

#define ST_OVER_DEBUG_SEG 0x01 
#define ST_OVER_LIB_FUNC  0x02 
#define ST_ALREADY_LOGGED 0x04 
#define ST_SKIP_LOOPS     0x08 
#define ST_DIFFERENTIAL   0x10 
#define ST_OPTIONS_MASK    (ST_OVER_DEBUG_SEG|ST_OVER_LIB_FUNC|ST_ALREADY_LOGGED|ST_SKIP_LOOPS|ST_DIFFERENTIAL)
#define ST_OPTIONS_DEFAULT (ST_OVER_DEBUG_SEG|ST_OVER_LIB_FUNC)

#define IT_LOG_SAME_IP    0x01 
#define FT_LOG_RET        0x01 
#define BT_LOG_INSTS      0x01 
 
#ifndef __UI__

 
inline int idaapi get_step_trace_options(void) { return callui(ui_dbg_get_step_trace_options).i; }

 
inline void idaapi set_step_trace_options(int options) { callui(ui_dbg_set_step_trace_options, options); }

 
inline void idaapi request_set_step_trace_options(int options) { callui(ui_dbg_request_set_step_trace_options, options); }

 
 
//--------------------------------------------------------------------
//               I N S T R U C T I O N S   T R A C I N G
//--------------------------------------------------------------------

 
inline bool idaapi is_insn_trace_enabled(void) { return callui(ui_dbg_is_insn_trace_enabled).cnd; }

inline bool idaapi enable_insn_trace(bool enable = true) { return callui(ui_dbg_enable_insn_trace, enable).cnd; }
inline bool disable_insn_trace(void) { return enable_insn_trace(false); }
inline bool idaapi request_enable_insn_trace(bool enable = true) { return callui(ui_dbg_request_enable_insn_trace, enable).cnd; }
inline bool request_disable_insn_trace(void) { return request_enable_insn_trace(false); }
 

 
inline int idaapi get_insn_trace_options(void) { return callui(ui_dbg_get_insn_trace_options).i; }
 

 
inline void idaapi set_insn_trace_options(int options) { callui(ui_dbg_set_insn_trace_options, options); }

 
inline void idaapi request_set_insn_trace_options(int options) { callui(ui_dbg_request_set_insn_trace_options, options); }

 
 
//--------------------------------------------------------------------
//                 F U N C T I O N S   T R A C I N G
//--------------------------------------------------------------------

 
inline bool idaapi is_func_trace_enabled(void) { return callui(ui_dbg_is_func_trace_enabled).cnd; }
 

inline bool idaapi enable_func_trace(bool enable = true) { return callui(ui_dbg_enable_func_trace, enable).cnd; }
inline bool disable_func_trace(void) { return enable_func_trace(false); }
inline bool idaapi request_enable_func_trace(bool enable = true) { return callui(ui_dbg_request_enable_func_trace, enable).cnd; }
inline bool request_disable_func_trace(void) { return request_enable_func_trace(false); }
 

 
inline int idaapi get_func_trace_options(void) { return callui(ui_dbg_get_func_trace_options).i; }
 

 
inline void idaapi set_func_trace_options(int options) { callui(ui_dbg_set_func_trace_options, options); }

 
inline void idaapi request_set_func_trace_options(int options) { callui(ui_dbg_request_set_func_trace_options, options); }

 
 
//--------------------------------------------------------------------
//              B A S I C   B L O C K   T R A C I N G
//--------------------------------------------------------------------
 
// Modify basic block tracing options.
// Type:         Synchronous function - available as Request
// Notification: none (synchronous function)
 

inline bool idaapi enable_bblk_trace(bool enable = true) { return callui(ui_dbg_enable_bblk_trace, enable).cnd; }
inline bool disable_bblk_trace(void) { return enable_bblk_trace(false); }
inline bool idaapi request_enable_bblk_trace(bool enable = true) { return callui(ui_dbg_request_enable_bblk_trace, enable).cnd; }
inline bool request_disable_bblk_trace(void) { return request_enable_bblk_trace(false); }
inline bool idaapi is_bblk_trace_enabled(void) { return callui(ui_dbg_is_bblk_trace_enabled).cnd; }

 
inline int idaapi get_bblk_trace_options(void) { return callui(ui_dbg_get_bblk_trace_options).i; }
 

 
inline void idaapi set_bblk_trace_options(int options) { callui(ui_dbg_set_bblk_trace_options, options); }

 
inline void idaapi request_set_bblk_trace_options(int options) { callui(ui_dbg_request_set_bblk_trace_options, options); }

 
#endif // __UI__
 
//--------------------------------------------------------------------
//                   T R A C I N G   E V E N T S
//--------------------------------------------------------------------

enum tev_type_t
{
  tev_none = 0, 
  tev_insn,     
  tev_call,     
  tev_ret,      
  tev_bpt,      
  tev_mem,      
  tev_event,    
  tev_max,      
};
 
typedef qvector<debug_event_t> dbgevt_vec_t; 

struct tev_info_t
{
  tev_type_t   type;    
  thid_t       tid;     
  ea_t         ea;      
};
typedef qvector<tev_info_t> tevinfo_vec_t; 
 

struct memreg_info_t
{
  ea_t ea;
  bytevec_t bytes;
};
DECLARE_TYPE_AS_MOVABLE(memreg_info_t);
typedef qvector<memreg_info_t> memreg_infos_t;
 
 
#ifndef __UI__

 
inline int idaapi get_tev_qty(void) { return callui(ui_dbg_get_tev_qty).i; }
 

 
inline bool idaapi get_tev_info(int n, tev_info_t *tev_info) { return callui(ui_dbg_get_tev_info, n, tev_info).cnd; }
 

 
inline bool idaapi get_insn_tev_reg_val(int n, const char *regname, regval_t *regval) { return callui(ui_dbg_get_insn_tev_reg_val, n, regname, regval).cnd; }
 
inline bool idaapi get_insn_tev_reg_val(int n, const char *regname, uint64 *ival) { return callui(ui_dbg_get_insn_tev_reg_val_i, n, regname, ival).cnd; }
 

 
inline bool idaapi get_insn_tev_reg_mem(int n, memreg_infos_t *memmap) { return callui(ui_dbg_get_insn_tev_reg_mem, n, memmap).cnd; }
 

 
inline bool idaapi get_insn_tev_reg_result(int n, const char *regname, regval_t *regval) { return callui(ui_dbg_get_insn_tev_reg_result, n, regname, regval).cnd; }
 
inline bool idaapi get_insn_tev_reg_result(int n, const char *regname, uint64 *ival) { return callui(ui_dbg_get_insn_tev_reg_result_i, n, regname, ival).cnd; }
 

 
inline ea_t idaapi get_call_tev_callee(int n) { ea_t ea; callui(ui_dbg_get_call_tev_callee, n, &ea); return ea; }
 

 
inline ea_t idaapi get_ret_tev_return(int n) { ea_t ea; callui(ui_dbg_get_ret_tev_return, n, &ea); return ea; }
 

 
inline ea_t idaapi get_bpt_tev_ea(int n) { ea_t ea; callui(ui_dbg_get_bpt_tev_ea, n, &ea); return ea; }
 

 
inline bool idaapi get_tev_memory_info(int n, meminfo_vec_t *mi) { return callui(ui_dbg_get_tev_memory_info, n, mi).cnd; }
 

 
inline bool idaapi get_tev_event(int n, debug_event_t *d) { return callui(ui_dbg_get_tev_event, n, d).cnd; }
 

 
inline ea_t idaapi get_trace_base_address(void) { ea_t ea; callui(ui_dbg_get_trace_base_address, &ea); return ea; }
 

 
inline void idaapi set_trace_base_address(ea_t ea) { callui(ui_dbg_set_trace_base_address, ea); }
 

 
inline void idaapi dbg_add_thread(thid_t tid) { callui(ui_dbg_add_thread, tid); }
 

 
inline void idaapi dbg_del_thread(thid_t tid) { callui(ui_dbg_del_thread, tid); }
 

 
inline void idaapi dbg_add_tev(tev_type_t type, thid_t tid, ea_t address) { callui(ui_dbg_add_tev, type, tid, address); }
 
#endif // __UI__

struct tev_reg_value_t
{
  regval_t value;
  int reg_idx;
 
  tev_reg_value_t(int _reg_idx = -1, uint64 _value = uint64(-1)) : reg_idx(_reg_idx)
  {
    value._set_int(_value);
  }
};
DECLARE_TYPE_AS_MOVABLE(tev_reg_value_t);
typedef qvector<tev_reg_value_t> tev_reg_values_t; 

struct tev_info_reg_t
{
  tev_info_t info;
  tev_reg_values_t registers;
};
DECLARE_TYPE_AS_MOVABLE(tev_info_reg_t);
typedef qvector<tev_info_reg_t> tevinforeg_vec_t; 
 

enum save_reg_values_t
{
  SAVE_ALL_VALUES = 0,
  SAVE_DIFF,
  SAVE_NONE
};
 
#ifndef __UI__

 
inline bool idaapi dbg_add_many_tevs(tevinforeg_vec_t *new_tevs) { return callui(ui_dbg_add_many_tevs, new_tevs).cnd; }
 

 
inline bool idaapi dbg_add_insn_tev(thid_t tid, ea_t ea, save_reg_values_t save = SAVE_DIFF) { return callui(ui_dbg_add_insn_tev, tid, ea, save).cnd; }
 

 
inline bool idaapi dbg_add_bpt_tev(thid_t tid, ea_t ea, ea_t bp) { return callui(ui_dbg_add_bpt_tev, tid, ea, bp).cnd; }
 

 
inline void idaapi dbg_add_call_tev(thid_t tid, ea_t caller, ea_t callee) { callui(ui_dbg_add_call_tev, tid, caller, callee); }
 

 
inline void idaapi dbg_add_ret_tev(thid_t tid, ea_t ret_insn, ea_t return_to) { callui(ui_dbg_add_ret_tev, tid, ret_insn, return_to); }
 

 
inline void idaapi dbg_add_debug_event(debug_event_t *event) { callui(ui_dbg_add_debug_event, event); }

 
 
//---------------------------------------------------------------------------
//                    Trace management functions
//---------------------------------------------------------------------------

 
inline bool idaapi load_trace_file(qstring *buf, const char *filename) { return callui(ui_dbg_load_trace_file, buf, filename).cnd; }
 

 
inline bool idaapi save_trace_file(const char *filename, const char *description) { return callui(ui_dbg_save_trace_file, filename, description).cnd; }
 

 
inline bool idaapi is_valid_trace_file(const char *filename) { return callui(ui_dbg_is_valid_trace_file, filename).cnd; }
 

 
inline bool idaapi set_trace_file_desc(const char *filename, const char *description) { return callui(ui_dbg_set_trace_file_desc, filename, description).cnd; }
 

 
inline bool idaapi get_trace_file_desc(qstring *buf, const char *filename) { return callui(ui_dbg_get_trace_file_desc, buf, filename).cnd; }
 

 
inline bool idaapi choose_trace_file(qstring *buf) { return callui(ui_dbg_choose_trace_file, buf).cnd; }
 

 
inline bool idaapi diff_trace_file(const char *NONNULL filename) { return callui(ui_dbg_diff_trace_file, filename).cnd; }
 

 
inline bool idaapi graph_trace(void) { return callui(ui_dbg_graph_trace).cnd; }
 

 
inline void idaapi set_highlight_trace_options(
        bool hilight,
        bgcolor_t color,
        bgcolor_t diff)
{
  callui(ui_dbg_set_highlight_trace_options, hilight, color, diff);
}
 

 
inline void idaapi set_trace_platform(const char *platform) { callui(ui_dbg_set_trace_platform, platform); }
 

 
inline const char *idaapi get_trace_platform() { return callui(ui_dbg_get_trace_platform).cptr; }
 

 
inline void idaapi set_trace_dynamic_register_set(dynamic_register_set_t &idaregs) { callui(ui_dbg_set_trace_dynamic_register_set, &idaregs); }
 

 
inline void idaapi get_trace_dynamic_register_set(dynamic_register_set_t *idaregs) { callui(ui_dbg_get_trace_dynamic_register_set, idaregs); }

 
#endif // __UI__
 
//---------------------------------------------------------------------------
//      High level functions (usable from scripts)
//--------------------------------------------------------------------


enum dbg_event_code_t
{
  DEC_NOTASK  = -2,  
  DEC_ERROR   = -1,  
  DEC_TIMEOUT = 0,   
};

#define WFNE_ANY    0x0001 
#define WFNE_SUSP   0x0002 
#define WFNE_SILENT 0x0004 
#define WFNE_CONT   0x0008 
#define WFNE_NOWAIT 0x0010 
#define WFNE_USEC   0x0020 

#define DOPT_SEGM_MSGS    0x00000001 
#define DOPT_START_BPT    0x00000002 
#define DOPT_THREAD_MSGS  0x00000004 
#define DOPT_THREAD_BPT   0x00000008 
#define DOPT_BPT_MSGS     0x00000010 
//#define DOPT_BINS_BPT     0x00000020 // break on breakpoint instruction
#define DOPT_LIB_MSGS     0x00000040 
#define DOPT_LIB_BPT      0x00000080 
#define DOPT_INFO_MSGS    0x00000100 
#define DOPT_INFO_BPT     0x00000200 
#define DOPT_REAL_MEMORY  0x00000400 
#define DOPT_REDO_STACK   0x00000800 
#define DOPT_ENTRY_BPT    0x00001000 
#define DOPT_EXCDLG       0x00006000 
#  define EXCDLG_NEVER    0x00000000 
#  define EXCDLG_UNKNOWN  0x00002000 
#  define EXCDLG_ALWAYS   0x00006000 
#define DOPT_LOAD_DINFO   0x00008000 
#define DOPT_END_BPT      0x00010000 
#define DOPT_TEMP_HWBPT   0x00020000 
#define DOPT_FAST_STEP    0x00040000 
#define DOPT_DISABLE_ASLR 0x00080000 
#ifndef __UI__

 
inline dbg_event_code_t idaapi wait_for_next_event(int wfne, int timeout) { return dbg_event_code_t(callui(ui_dbg_wait_for_next_event, wfne, timeout).i); }
 

 
inline const debug_event_t *idaapi get_debug_event(void) { return (const debug_event_t *)callui(ui_dbg_get_debug_event).vptr; }
 

 
inline uint idaapi set_debugger_options(uint options) { return callui(ui_dbg_set_debugger_options, options).i; }
 

 
inline void idaapi set_remote_debugger(const char *host, const char *pass, int port=-1) { callui(ui_dbg_set_remote_debugger, host, pass, port); }
 

 
inline void idaapi get_process_options(
        qstring *path,
        qstring *args,
        launch_env_t *out_envs,
        qstring *sdir,
        qstring *host,
        qstring *pass,
        int *port)
{
  callui(ui_dbg_get_process_options, path, args, sdir, host, pass, port, out_envs);
}
 

 
inline void idaapi set_process_options(
        const char *path,
        const char *args,
        const launch_env_t *envs,
        const char *sdir,
        const char *host,
        const char *pass,
        int port)
{
  callui(ui_dbg_set_process_options, path, args, sdir, host, pass, port, envs);
}
 

 
inline excvec_t *idaapi retrieve_exceptions(void) { return (excvec_t *)callui(ui_dbg_retrieve_exceptions).vptr; }
 

 
inline bool idaapi store_exceptions(void) { return callui(ui_dbg_store_exceptions).cnd; }
 

 
inline const char *idaapi define_exception(uint code, const char *name, const char *desc, int flags) { return callui(ui_dbg_define_exception, code, name, desc, flags).cptr; }
 
#endif // __UI__
 
 
//--------------------------------------------------------------------

 
inline THREAD_SAFE bool have_set_options(const debugger_t *_dbg)
{
  return _dbg != nullptr && _dbg->have_set_options();
}

 
inline const char *idaapi set_dbg_options(
        debugger_t *_dbg,
        const char *keyword,
        int pri,
        int value_type,
        const void *value)
{
  const char *res = IDPOPT_BADKEY;
  if ( have_set_options(_dbg) )
    _dbg->set_dbg_options(&res, keyword, pri, value_type, value);
  return res;
}
 
 
inline const char *idaapi set_dbg_default_options(
        debugger_t *_dbg,
        const char *keyword,
        int value_type,
        const void *value)
{
  return set_dbg_options(_dbg, keyword, IDPOPT_PRI_DEFAULT, value_type, value);
}
 
inline const char *idaapi set_int_dbg_options(
        debugger_t *_dbg,
        const char *keyword,
        int32 value)
{
  sval_t sv = value;
  return set_dbg_default_options(_dbg, keyword, IDPOPT_NUM, &sv);
}
 
#ifndef __KERNEL__
 
inline const char *idaapi set_dbg_options(
        const char *keyword,
        int pri,
        int value_type,
        const void *value)
{
  return set_dbg_options(dbg, keyword, pri, value_type, value);
}

 
inline const char *idaapi set_dbg_default_options(
        const char *keyword,
        int value_type,
        const void *value)
{
  return set_dbg_options(keyword, IDPOPT_PRI_DEFAULT, value_type, value);
}

 
inline const char *idaapi set_int_dbg_options(
        const char *keyword,
        int32 value)
{
  sval_t sv = value;
  return set_dbg_default_options(keyword, IDPOPT_NUM, &sv);
}
#endif // __KERNEL__

 
//---------------------------------------------------------------------------
//      S O U R C E   I N F O R M A T I O N   P R O V I D E R S
//---------------------------------------------------------------------------
 
class srcinfo_provider_t;
 
class idc_value_t;
class rangeset_t;
class source_item_t;
class argloc_t;

typedef qrefcnt_t<source_item_t> source_item_ptr;
typedef qiterator<source_item_ptr> _source_item_iterator;
typedef qrefcnt_t<_source_item_iterator> source_item_iterator;
typedef qvector<source_item_ptr> source_items_t;
 
//--------------------------------------------------------------------------
 
class eval_ctx_t
{
  int size_cb;
public:
  eval_ctx_t(ea_t _ea) : size_cb(sizeof(*this)), ea(_ea) {}
  ea_t ea;
};
 
 
#ifndef __UI__
class TWidget;
#endif
 
//--------------------------------------------------------------------------
class source_file_t : public qrefcnt_obj_t
{
public:
  virtual void idaapi release() override = 0;

  virtual srcinfo_provider_t *idaapi get_provider(void) const = 0;

  virtual const char *idaapi get_path(qstring *errbuf) = 0;

  virtual TWidget *open_srcview(strvec_t **strvec, TWidget **pview, int lnnum, int colnum) = 0;

  virtual bool idaapi read_file(strvec_t *buf, qstring *errbuf) = 0;
};

typedef qrefcnt_t<source_file_t> source_file_ptr;
typedef qiterator<source_file_ptr> _source_file_iterator;
typedef qrefcnt_t<_source_file_iterator> source_file_iterator;
 
//--------------------------------------------------------------------------
enum src_item_kind_t
{
  SRCIT_NONE,       
  SRCIT_MODULE,     
  SRCIT_FUNC,       
  SRCIT_STMT,       
  SRCIT_EXPR,       
  SRCIT_STTVAR,     
  SRCIT_LOCVAR      
};
 
//--------------------------------------------------------------------------
class source_item_t : public qrefcnt_obj_t
{
public:
  virtual void idaapi release() override = 0;

  virtual source_file_iterator idaapi get_source_files() = 0;

  virtual bool idaapi get_name(qstring *buf) const = 0;

  virtual int idaapi get_lnnum() const = 0;

  virtual int idaapi get_end_lnnum() const = 0;

  virtual int idaapi get_colnum() const = 0;

  virtual int idaapi get_end_colnum() const = 0;

  virtual ea_t idaapi get_ea() const = 0;

  virtual asize_t idaapi get_size() const = 0;

  virtual bool idaapi get_item_bounds(rangeset_t *set) const = 0;

  virtual source_item_ptr idaapi get_parent(src_item_kind_t max_kind) const = 0;

  virtual source_item_iterator idaapi create_children_iterator() = 0;

  virtual bool idaapi get_hint(
        qstring *hint,
        const eval_ctx_t *ctx,
        int *nlines) const = 0;

  virtual bool idaapi evaluate(
        const eval_ctx_t *ctx,
        idc_value_t *res,
        qstring *errbuf) const = 0;

  virtual bool idaapi equals(const source_item_t *other) const = 0;


  virtual src_item_kind_t idaapi get_item_kind(const eval_ctx_t * /*ctx*/) const newapi { return SRCIT_NONE; }
  bool is_stmt(const eval_ctx_t *ctx)   const { return get_item_kind(ctx) == SRCIT_STMT; }
  bool is_module(const eval_ctx_t *ctx) const { return get_item_kind(ctx) == SRCIT_MODULE; }
  bool is_func(const eval_ctx_t *ctx)   const { return get_item_kind(ctx) == SRCIT_FUNC; }
  bool is_expr(const eval_ctx_t *ctx)   const { return get_item_kind(ctx) >= SRCIT_EXPR; }
  bool is_locvar(const eval_ctx_t *ctx) const { return get_item_kind(ctx) >= SRCIT_LOCVAR; }
  bool is_sttvar(const eval_ctx_t *ctx) const { return get_item_kind(ctx) == SRCIT_STTVAR; }

  virtual srcinfo_provider_t *idaapi get_provider(void) const = 0;

  virtual bool idaapi get_location(argloc_t * /*out*/, const eval_ctx_t * /*ctx*/) const newapi { return false; }

  virtual bool idaapi get_expr_tinfo(tinfo_t *tif) const = 0;
};
 
#define SRCDBG_PROV_VERSION 4
 
//--------------------------------------------------------------------------
class srcinfo_provider_t
{
public:
  size_t cb;

  int flags;
#define SPF_DECOMPILER    0x0001        
#define SPF_ENABLED       0x0002        
#define SPF_ACTIVE        0x0004        
#define SPF_VERSION_MASK  0xFF000000    

  const char *name;

  const char *display_name;
 
  srcinfo_provider_t(const char *_name, const char *_display_name, int _flags=0)
    : cb(sizeof(*this)), flags(_flags), name(_name), display_name(_display_name)
  {
    flags |= SRCDBG_PROV_VERSION << 24;
  }

  bool is_decompiler(void) const { return (flags & SPF_DECOMPILER) != 0; }
  bool is_enabled(void) const { return (flags & SPF_ENABLED) != 0; }
  bool is_active(void) const { return (flags & SPF_ACTIVE) != 0; }

  uint8 get_version() const { return (flags >> 24) & 0xFF; }

  virtual bool idaapi enable_provider(bool enable) = 0;

  virtual const char *idaapi set_options(
        const char *keyword,
        int value_type,
        const void *value) = 0;

  virtual void idaapi add_module(const char *path, ea_t base, asize_t size) = 0;

  virtual void idaapi del_module(ea_t base) = 0;

  virtual void idaapi get_ready(void) = 0;

  virtual int idaapi get_change_flags(void) = 0;
#define SPCH_NONE  0x0000       
#define SPCH_FILES 0x0001       
#define SPCH_ITEMS 0x0002       
#define SPCH_LINES 0x0004       

  virtual source_item_iterator idaapi find_source_items(
        ea_t ea,
        asize_t size,
        src_item_kind_t level,
        bool may_decompile) = 0;

  virtual source_item_iterator idaapi find_source_items(source_file_t *sf, int lnnum, int colnum=0) = 0;

  virtual source_file_iterator idaapi create_file_iterator(const char *filename=nullptr) = 0;

  virtual source_item_iterator idaapi create_item_iterator(const source_file_t *sf) = 0;

  virtual bool idaapi apply_module_info(const char * /*path*/) { return false; }

  virtual source_item_ptr idaapi find_static_item(const char *name, ea_t ea) = 0;
};
 
 
//--------------------------------------------------------------------------
 
inline bool idaapi register_srcinfo_provider(srcinfo_provider_t *sp) { return callui(ui_dbg_register_provider, sp).cnd; }
 

 
inline bool idaapi unregister_srcinfo_provider(srcinfo_provider_t *sp) { return callui(ui_dbg_unregister_provider, sp).cnd; }
 
 
#ifndef __UI__
class source_view_t;

 
inline 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)
{
  return (source_view_t *) callui(
          ui_create_source_viewer, out_ccv, parent, custview, &sf,
          lines, lnnum, colnum, flags).vptr;
}
 
#endif
 
//--------------------------------------------------------------------------
 
idaman bool ida_export get_dbg_byte(uint32 *out, ea_t ea);
 

 
idaman bool ida_export put_dbg_byte(ea_t ea, uint32 x);

 
//--------------------------------------------------------------------------
//      D E B U G G E R   M E M O R Y   F U N C T I O N S   F O R   U I
//--------------------------------------------------------------------------

 
idaman void ida_export set_dbgmem_source(
        range_t *(idaapi*dbg_get_memory_config)(int *n),
        int (idaapi*memory_read)(ea_t ea, void *buffer, int size),
        int (idaapi*memory_write)(ea_t ea, const void *buffer, int size));
 

 
idaman void ida_export invalidate_dbgmem_config(void);
 

 
idaman void ida_export invalidate_dbgmem_contents(ea_t ea, asize_t size);
 

 
idaman bool ida_export is_debugger_on(void);
 

 
idaman bool ida_export is_debugger_memory(ea_t ea);

 
//------------------------------------------------------------------------
#if !defined(__UI__) && !defined(__KERNEL__)         // Not for the UI nor the kernel
 

inline ea_t idaapi get_tev_ea(int n)                                                          { ea_t ea; callui(ui_dbg_get_tev_ea, n, &ea); return ea; }
inline int  idaapi get_tev_type(int n)                                                        { return callui(ui_dbg_get_tev_type, n).i; }
inline int  idaapi get_tev_tid(int n)                                                         { return callui(ui_dbg_get_tev_tid, n).i; }
inline void idaapi bring_debugger_to_front(void)                                              { callui(ui_dbg_bring_to_front); }
inline void idaapi get_manual_regions(meminfo_vec_t *ranges)                                  { callui(ui_dbg_get_manual_regions, ranges); }
inline void idaapi set_manual_regions(const meminfo_vec_t *ranges)                            { callui(ui_dbg_set_manual_regions, ranges); }
inline void idaapi edit_manual_regions()                                                      { callui(ui_dbg_edit_manual_regions); }
inline void idaapi enable_manual_regions(bool enable)                                         { callui(ui_dbg_enable_manual_regions, enable); }
inline int  idaapi handle_debug_event(const debug_event_t *ev, int rqflags)                   { return callui(ui_dbg_handle_debug_event, ev, rqflags).i; }
inline bool idaapi add_virt_module(const modinfo_t *mod)                                      { return callui(ui_dbg_add_vmod, mod).cnd; }
inline bool idaapi del_virt_module(const ea_t base)                                           { return callui(ui_dbg_del_vmod, base).cnd; }
inline int  idaapi set_bptloc_string(const char *s)                                           { return callui(ui_dbg_set_bptloc_string, s).i; }
inline const char *idaapi get_bptloc_string(int i)                                            { return callui(ui_dbg_get_bptloc_string, i).cptr; }
inline int  idaapi internal_get_sreg_base(ea_t *answer, thid_t tid, int sreg_value)           { return callui(ui_dbg_internal_get_sreg_base, answer, tid, sreg_value).i; }
inline int  idaapi internal_ioctl(int fn, const void *buf, size_t size, void **poutbuf, ssize_t *poutsize) { return callui(ui_dbg_internal_ioctl, fn, buf, size, poutbuf, poutsize).i; }
inline int idaapi get_reg_vals(thid_t tid, int clsmask, regval_t *values)                     { return callui(ui_dbg_read_registers, tid, clsmask, values).i; }
inline int idaapi set_reg_val(thid_t tid, int regidx, const regval_t *value)                  { return callui(ui_dbg_write_register, tid, regidx, value).i; }
inline int idaapi get_dbg_memory_info(meminfo_vec_t *ranges)                                  { return callui(ui_dbg_get_memory_info, ranges).i; }

inline bool idaapi set_bpt_group(bpt_t &bpt, const char *grp_name)                            { return callui(ui_dbg_set_bpt_group, &bpt, grp_name).cnd; }

inline bool idaapi set_bptloc_group(const bpt_location_t &bptloc, const char *grp_name)       { return callui(ui_dbg_set_bptloc_group, &bptloc, grp_name).cnd; }

inline bool idaapi get_bpt_group(qstring *grp_name, const bpt_location_t &bptloc)             { return callui(ui_dbg_get_bpt_group, grp_name, &bptloc).cnd; }

inline size_t idaapi list_bptgrps(qstrvec_t *bptgrps)                                         { return callui(ui_dbg_list_bptgrps, bptgrps).ssize; }

inline bool idaapi rename_bptgrp(const char *old_name, const char *new_name)                  { return callui(ui_dbg_rename_bptgrp, old_name, new_name).cnd; }

inline bool idaapi del_bptgrp(const char *name)                                               { return callui(ui_dbg_del_bptgrp, name).cnd; }

inline ssize_t idaapi get_grp_bpts(bpt_vec_t *bpts, const char *grp_name)                     { return callui(ui_dbg_get_grp_bpts, bpts, grp_name).ssize; }

inline int idaapi enable_bptgrp(const char *bptgrp_name, bool enable=true)                    { return callui(ui_dbg_enable_bptgrp, bptgrp_name, enable).i; }
inline bool idaapi get_local_vars(srcinfo_provider_t *prov, ea_t ea, source_items_t *out)     { return callui(ui_dbg_get_local_vars, prov, ea, out).cnd; }
inline bool idaapi srcdbg_request_step_into(void)                                             { return callui(ui_dbg_srcdbg_request_step_into).cnd; }
inline bool idaapi srcdbg_request_step_over(void)                                             { return callui(ui_dbg_srcdbg_request_step_over).cnd; }
inline bool idaapi srcdbg_request_step_until_ret(void)                                        { return callui(ui_dbg_srcdbg_request_step_until_ret).cnd; }
#endif // !__UI__ && !__KERNEL__
 
// These are needed by the kernel, and need to go through the UI
#ifndef __UI__
inline int  idaapi internal_cleanup_appcall(thid_t tid)                                       { return callui(ui_dbg_internal_cleanup_appcall, tid).i; }
inline int  idaapi hide_all_bpts(void)                                                        { return callui(ui_dbg_hide_all_bpts).i; }
inline ssize_t idaapi read_dbg_memory(ea_t ea, void *buffer, size_t size)                     { return callui(ui_dbg_read_memory, ea, buffer, size).ssize; }
inline bool idaapi get_module_info(ea_t ea, modinfo_t *modinfo)                               { return callui(ui_dbg_get_module_info, ea, modinfo).cnd; }
inline drc_t idaapi dbg_bin_search(ea_t *out, ea_t start_ea, ea_t end_ea, const compiled_binpat_vec_t &data, int srch_flags, qstring *errbuf)
                                                                                              { return drc_t(callui(ui_dbg_bin_search, out, start_ea, end_ea, &data, srch_flags, errbuf).i); }
inline bool idaapi dbg_can_query(debugger_t *_dbg)
{
  // Debugger can be queried iif it is set and either currently in
  // suspended state, or can be queried while not in suspended state
  return _dbg != nullptr && (_dbg->may_disturb() || get_process_state() < DSTATE_NOTASK);
}
inline bool idaapi dbg_can_query(void)
{
  return dbg_can_query(dbg);
}
inline bool idaapi load_debugger(const char *dbgname, bool use_remote)                        { return callui(ui_dbg_load_debugger, dbgname, use_remote).cnd; }
inline bool idaapi collect_stack_trace(thid_t tid, call_stack_t *trace)                       { return callui(ui_dbg_collect_stack_trace, tid, trace).cnd; }
inline bool idaapi get_global_var(srcinfo_provider_t *prov, ea_t ea, const char *name, source_item_ptr *out) { return callui(ui_dbg_get_global_var, prov, ea, name, out).cnd; }
inline bool idaapi get_local_var(srcinfo_provider_t *prov, ea_t ea, const char *name, source_item_ptr *out)  { return callui(ui_dbg_get_local_var, prov, ea, name, out).cnd; }
inline srcinfo_provider_t *idaapi get_srcinfo_provider(const char *name)                      { return (srcinfo_provider_t *)callui(ui_dbg_get_srcinfo_provider, name).vptr; }
inline bool idaapi get_current_source_file(qstring *out)                                      { return callui(ui_dbg_get_current_source_file, out).cnd; }
inline int idaapi get_current_source_line(void)                                               { return callui(ui_dbg_get_current_source_line).i; }
inline void idaapi add_path_mapping(const char *src, const char *dst)                         { callui(ui_dbg_add_path_mapping, src, dst); }
inline bool idaapi srcdbg_step_into(void)                                                     { return callui(ui_dbg_srcdbg_step_into).cnd; }
inline bool idaapi srcdbg_step_over(void)                                                     { return callui(ui_dbg_srcdbg_step_over).cnd; }
inline bool idaapi srcdbg_step_until_ret(void)                                                { return callui(ui_dbg_srcdbg_step_until_ret).cnd; }
inline ssize_t idaapi write_dbg_memory(ea_t ea, const void *buffer, size_t size)              { return callui(ui_dbg_write_memory, ea, buffer, size).ssize; }
inline void idaapi set_debugger_event_cond(const char *NONNULL evcond)                        { callui(ui_dbg_set_event_cond, evcond); }
inline const char *idaapi get_debugger_event_cond(void)                                       { return callui(ui_dbg_get_event_cond).cptr; }
inline const char *bpt_t::get_cnd_elang() const                                               { return (const char *)(callui(ui_dbg_internal_get_elang, this).cptr); }
inline bool bpt_t::set_cnd_elang(const char *name)                                            { return callui(ui_dbg_internal_set_elang, this, name).cnd; }
#endif // !__UI__
 
 
// internal kernel functions to lock the debugger memory configuration updates
// Do not use these functions! They will be removed!
idaman void ida_export lock_dbgmem_config(void);
idaman void ida_export unlock_dbgmem_config(void);
 
 
struct dbg_deref_options_t
{
private:
  size_t cb = sizeof(dbg_deref_options_t);
public:
  int deref_limit = 5;
  bool hide_default_segments = true;
};
 
 
#endif