idd.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2026 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef _IDD_HPP
#define _IDD_HPP
 
#include <range.hpp>
#include <ua.hpp>


#define         IDD_INTERFACE_VERSION   31
 
class idc_value_t;
struct fpvalue_t;
class tinfo_t;
 
//====================================================================
//
//                       Process and Threads
//
 
typedef int pid_t;                   
typedef int thid_t;                  
 
#define NO_PROCESS pid_t(-1)         
#define NO_THREAD  0                 

struct process_info_t
{
  pid_t pid;    
  qstring name; 
};
DECLARE_TYPE_AS_MOVABLE(process_info_t);
typedef qvector<process_info_t> procinfo_vec_t;
 
//--------------------------------------------------------------------
struct debapp_attrs_t
{
  int32 cbsize = sizeof(*this); 

  int addrsize;
 
  qstring platform;     

#ifdef __EA64__
#define DEF_ADDRSIZE  8
#else
#define DEF_ADDRSIZE  4
#endif
  int is_be = -1;
 
  debapp_attrs_t() : addrsize(DEF_ADDRSIZE) {}
};
 
//====================================================================
//
//                          Registers
//
 
typedef unsigned char register_class_t; 

struct register_info_t
{
  const char *name;                   
  uint32 flags;                       
#define REGISTER_READONLY 0x0001      
#define REGISTER_IP       0x0002      
#define REGISTER_SP       0x0004      
#define REGISTER_FP       0x0008      
#define REGISTER_ADDRESS  0x0010      
#define REGISTER_CS       0x0020      
#define REGISTER_SS       0x0040      
#define REGISTER_NOLF     0x0080      
#define REGISTER_CUSTFMT  0x0100      
  uchar register_class_mask;          
  op_dtype_t dtype;                   
  const char *const *bit_strings;     
  uval_t default_bit_strings_mask;    
};
DECLARE_TYPE_AS_MOVABLE(register_info_t);
typedef qvector<register_info_t> register_info_vec_t;
 
//--------------------------------------------------------------------------
struct dynamic_register_set_t
{
  typedef qvector<const char *> const_char_vec_t;
 
  register_info_vec_t       ri_vec;
  qstrvec_t                 strvec;
  const_char_vec_t          classname_ptrs;
  qvector<const_char_vec_t> bit_strings_ptrs_vec;
  int default_regclasses = 1; 
 
  void clear()
  {
    ri_vec.clear();
    strvec.clear();
    classname_ptrs.clear();
    bit_strings_ptrs_vec.clear();
  }
 
  void add_register(const register_info_t &ri)
  {
    add_register(ri.name,
                 ri.flags,
                 ri.dtype,
                 ri.register_class_mask,
                 ri.bit_strings,
                 ri.default_bit_strings_mask);
  }
 
  void add_register(
        const char *name,
        int flags,
        op_dtype_t dtype,
        register_class_t register_class,
        const char *const *bit_strings,
        uval_t bits_mask)
  {
    // Allocate bit_strings.
    if ( bit_strings != nullptr )
    {
      size_t num_bits = (flags & REGISTER_CUSTFMT) != 0 ? 1
                      : dtype == dt_word                ? 16
                      : dtype == dt_dword               ? 32
                      : dtype == dt_qword               ? 64
                      :                                 0;
      QASSERT(1795, num_bits != 0);
      const_char_vec_t &ptrvec = bit_strings_ptrs_vec.push_back();
      ptrvec.resize(num_bits, nullptr);
      for ( size_t i = 0; i < num_bits; i++ )
      {
        if ( bit_strings[i] != nullptr )
        {
          qstring &field_name = strvec.push_back();
          field_name = bit_strings[i];
          ptrvec[i] = field_name.c_str();
        }
      }
      bit_strings = ptrvec.begin();
    }
 
    // Allocate name.
    qstring &regname = strvec.push_back();
    regname = name;
 
    // Add entry for register.
    register_info_t &ri = ri_vec.push_back();
    ri.name                     = regname.c_str();
    ri.flags                    = flags;
    ri.dtype                    = dtype;
    ri.register_class_mask      = register_class;
    ri.bit_strings              = bit_strings;
    ri.default_bit_strings_mask = bits_mask;
  }
 
  void set_regclasses(const char **register_classes, int default_regcls)
  {
    while ( *register_classes != nullptr )
    {
      qstring &register_class = strvec.push_back();
      register_class = *register_classes++;
      classname_ptrs.push_back(register_class.begin());
    }
    classname_ptrs.push_back(nullptr);
    default_regclasses = default_regcls;
  }
 
  // Values for debugger_t.
  bool empty() const           { return ri_vec.empty(); }
  size_t nregs() const         { return ri_vec.size(); }
  register_info_t *registers() { return ri_vec.begin(); }
  const char **regclasses()    { return classname_ptrs.begin(); }
};
 
// helper functions:
idaman THREAD_SAFE void ida_export serialize_dynamic_register_set(
        bytevec_t *buf,
        dynamic_register_set_t &idaregs);
idaman THREAD_SAFE void ida_export deserialize_dynamic_register_set(
        dynamic_register_set_t *idaregs,
        memory_deserializer_t &mmdsr);
idaman THREAD_SAFE void ida_export serialize_insn(
        bytevec_t *s,
        const insn_t &insn);
idaman THREAD_SAFE void ida_export deserialize_insn(
        insn_t *insn,
        memory_deserializer_t &mmdsr);
 
//====================================================================
//
//                           Memory
//

struct memory_info_t : public range_t
{
  qstring name;                
  qstring sclass;              
  ea_t sbase = 0;              
  uchar bitness = 0;           
  uchar perm = 0;              
 
  bool operator ==(const memory_info_t &r) const
  {
    return start_ea == r.start_ea
        && end_ea   == r.end_ea
        && name    == r.name
        && sclass  == r.sclass
        && sbase   == r.sbase
        && bitness == r.bitness
        && perm    == r.perm;
  }
  bool operator !=(const memory_info_t &r) const { return !(*this == r); }
};
DECLARE_TYPE_AS_MOVABLE(memory_info_t);
struct meminfo_vec_t : public qvector<memory_info_t> {}; 

struct scattered_segm_t : public range_t
{
  qstring name; 
};
DECLARE_TYPE_AS_MOVABLE(scattered_segm_t);
typedef qvector<scattered_segm_t> scattered_image_t; 
 
//====================================================================
//
//                         Debug events
//

struct launch_env_t : public qstrvec_t
{
  bool merge = true;  // merge environment variables with system ones
                      // or replace it completely
};

enum event_id_t
{
  NO_EVENT         =  0, 
  PROCESS_STARTED  =  1, 
  PROCESS_EXITED   =  2, 
  THREAD_STARTED   =  3, 
  THREAD_EXITED    =  4, 
  BREAKPOINT       =  5, 
  STEP             =  6, 
  EXCEPTION        =  7, 
  LIB_LOADED       =  8, 
  LIB_UNLOADED     =  9, 
  INFORMATION      = 10, 
  PROCESS_ATTACHED = 11, 
  PROCESS_DETACHED = 12, 
  PROCESS_SUSPENDED= 13, 
  TRACE_FULL       = 14, 
 
  STATUS_MASK      = 0xF0000000, 
  BITNESS_CHANGED  = 0x80000000, 
};
 
// helper functions:
struct debug_event_t;
idaman THREAD_SAFE void ida_export free_debug_event(debug_event_t *ev);
idaman THREAD_SAFE void ida_export copy_debug_event(debug_event_t *ev, const debug_event_t &r);
idaman THREAD_SAFE void ida_export set_debug_event_code(debug_event_t *ev, event_id_t id);

struct modinfo_t
{
  qstring name;         
  ea_t base;            
  asize_t size;         
  ea_t rebase_to;       
};
DECLARE_TYPE_AS_MOVABLE(modinfo_t);
typedef qvector<modinfo_t> modinfovec_t;

struct bptaddr_t
{
  ea_t hea = BADADDR;   
  ea_t kea = BADADDR;   
};

struct excinfo_t
{
  uint32 code;          
  bool can_cont;        
  ea_t ea;              
  qstring info;         
};

struct debug_event_t
{
  pid_t pid = NO_PROCESS;  
  thid_t tid = NO_THREAD;  
  ea_t ea = BADADDR;       
  bool handled = false;    
private:
  event_id_t _eid = NO_EVENT;
#ifndef SWIG
  char bytes[qmax(sizeof(modinfo_t), sizeof(excinfo_t))];
#endif
 
public:
  debug_event_t() { memset(bytes, 0, sizeof(bytes)); }
  debug_event_t(const debug_event_t &r) { copy(r); }
  ~debug_event_t() { clear(); }
  debug_event_t &operator =(const debug_event_t &r) { return copy(r); }
  debug_event_t &copy(const debug_event_t &r) { copy_debug_event(this, r); return *this; }

  void clear() { free_debug_event(this); }
 
  void clear_all()
  {
    clear();
    pid = NO_PROCESS;
    tid = NO_THREAD;
    ea = BADADDR;
    handled = false;
  }

  event_id_t eid() const { return event_id_t(_eid & ~STATUS_MASK); }

  void set_eid(event_id_t id) { set_debug_event_code(this, id); }

  bool is_bitness_changed() const { return (_eid & BITNESS_CHANGED) != 0; }
  void set_bitness_changed(bool on=true) { setflag(_eid, BITNESS_CHANGED, on); }


  modinfo_t &modinfo()
  {
    QASSERT(3295, eid() == PROCESS_STARTED || eid() == PROCESS_ATTACHED || eid() == LIB_LOADED);
    return *(modinfo_t *)bytes;
  }
  int &exit_code()
  {
    QASSERT(3296, eid() == PROCESS_EXITED || eid() == THREAD_EXITED);
    return *(int *)bytes;
  }
  qstring &info()
  {
    QASSERT(3297, eid() == THREAD_STARTED || eid() == LIB_UNLOADED || eid() == INFORMATION);
    return *(qstring *)bytes;
  }
  bptaddr_t &bpt()
  {
    QASSERT(3298, eid() == BREAKPOINT);
    return *(bptaddr_t *)bytes;
  }
  excinfo_t &exc()
  {
    QASSERT(3299, eid() == EXCEPTION);
    return *(excinfo_t *)bytes;
  }
 
  const modinfo_t &modinfo() const { return CONST_CAST(debug_event_t*)(this)->modinfo(); }
  const int &exit_code() const     { return CONST_CAST(debug_event_t*)(this)->exit_code(); }
  const qstring &info() const      { return CONST_CAST(debug_event_t*)(this)->info(); }
  const bptaddr_t &bpt() const     { return CONST_CAST(debug_event_t*)(this)->bpt(); }
  const excinfo_t &exc() const     { return CONST_CAST(debug_event_t*)(this)->exc(); }
 
  modinfo_t &set_modinfo(event_id_t id)
  {
    set_eid(id);
    return modinfo();
  }
 
  void set_exit_code(event_id_t id, int code)
  {
    set_eid(id);
    exit_code() = code;
  }
 
  qstring &set_info(event_id_t id)
  {
    set_eid(id);
    return info();
  }
 
  bptaddr_t &set_bpt()
  {
    set_eid(BREAKPOINT);
    return bpt();
  }
 
  excinfo_t &set_exception()
  {
    set_eid(EXCEPTION);
    return exc();
  }

  ea_t bpt_ea() const
  {
    return _eid == BREAKPOINT && bpt().kea != BADADDR ? bpt().kea : ea;
  }
 
  friend THREAD_SAFE void ida_export free_debug_event(debug_event_t *ev);
  friend THREAD_SAFE void ida_export copy_debug_event(debug_event_t *ev, const debug_event_t &r);
  friend THREAD_SAFE void ida_export set_debug_event_code(debug_event_t *ev, event_id_t id);
};
DECLARE_TYPE_AS_MOVABLE(debug_event_t);

inline const char *get_debug_event_name(const debug_event_t &dev)
{
  switch ( dev.eid() )
  {
    case NO_EVENT:          return "NO_EVENT";
    case THREAD_STARTED:    return "THREAD_STARTED";
    case STEP:              return "STEP";
    case PROCESS_DETACHED:  return "PROCESS_DETACHED";
    case PROCESS_STARTED:   return "PROCESS_STARTED";
    case PROCESS_ATTACHED:  return "PROCESS_ATTACHED";
    case PROCESS_SUSPENDED: return "PROCESS_SUSPENDED";
    case LIB_LOADED:        return "LIB_LOADED";
    case PROCESS_EXITED:    return "PROCESS_EXITED";
    case THREAD_EXITED:     return "THREAD_EXITED";
    case BREAKPOINT:        return "BREAKPOINT";
    case EXCEPTION:         return "EXCEPTION";
    case LIB_UNLOADED:      return "LIB_UNLOADED";
    case INFORMATION:       return "INFORMATION";
    case TRACE_FULL:        return "TRACE_FULL";
    default: return "???";
  }
}
 
typedef int bpttype_t; 

const bpttype_t
  BPT_WRITE    = 1,                   
  BPT_READ     = 2,                   
  BPT_RDWR     = 3,                   
  BPT_SOFT     = 4,                   
  BPT_EXEC     = 8,                   
  BPT_DEFAULT  = (BPT_SOFT|BPT_EXEC); 

struct exception_info_t
{
  uint code = 0;          
  uint32 flags = 0;       
#define EXC_BREAK  0x0001 
#define EXC_HANDLE 0x0002 
#define EXC_MSG    0x0004 
#define EXC_SILENT 0x0008 

  bool break_on() const { return (flags & EXC_BREAK) != 0; }

  bool handle() const { return (flags & EXC_HANDLE) != 0; }
 
  qstring name;           
  qstring desc;           
 
  exception_info_t() {}
  exception_info_t(uint _code, uint32 _flags, const char *_name, const char *_desc)
    : code(_code), flags(_flags), name(_name), desc(_desc) {}
};
DECLARE_TYPE_AS_MOVABLE(exception_info_t);
typedef qvector<exception_info_t> excvec_t; 

struct regval_t
{
#define RVT_FLOAT       (-1)          
#define RVT_INT         (-2)          
#define RVT_UNAVAILABLE (-3)          
  int32 rvtype = RVT_INT;             
#ifndef SWIG
  // this union must be the last member (see memset below)
  union
  {
#endif
    uint64 ival;                      
#ifndef SWIG
    uchar reserve[sizeof(bytevec_t)]; 
  };
#endif
  bool use_bytevec() const { return rvtype >= RVT_FLOAT; } // floating and custom types
  regval_t()
  {
    memset(reserve, 0, sizeof(regval_t) - qoffsetof(regval_t, reserve));
    ival = ~uint64(0);
  }
  regval_t(const regval_t &r)
  {
    memset(reserve, 0, sizeof(regval_t) - qoffsetof(regval_t, reserve));
    *this = r;
  }
  ~regval_t() { clear(); }

  regval_t &operator = (const regval_t &r)
  {
    if ( this == &r )
      return *this;
    if ( r.use_bytevec() )
    {
      if ( use_bytevec() )
        bytes() = r.bytes();
      else
        new (&bytes()) bytevec_t(r.bytes());
    }
    else
    {
      if ( use_bytevec() )
        bytes().~bytevec_t();
      ival = r.ival;
    }
    rvtype = r.rvtype;
    return *this;
  }

  void clear()
  {
    if ( use_bytevec() )
    {
      bytes().~bytevec_t();
      rvtype = RVT_INT;
    }
  }

  bool operator == (const regval_t &r) const
  {
    if ( rvtype == r.rvtype )
    {
      if ( rvtype == RVT_UNAVAILABLE )
        return true;
      if ( rvtype == RVT_INT )
        return ival == r.ival;
      return bytes() == r.bytes();
    }
    return false;
  }

  bool operator != (const regval_t &r) const { return !(*this == r); }

  void swap(regval_t &r) { qswap(*this, r); }

  void _set_int(uint64 x) { ival = x; }
  void _set_float(const bytevec_t &v) { new (&bytes()) bytevec_t(v); rvtype = RVT_FLOAT; }
  void _set_bytes(const uchar *data, size_t size, int _rvtype=0)
  {
    new (&bytes()) bytevec_t(data, size);
    rvtype = _rvtype;
    QASSERT(3214, use_bytevec());
  }

  void _set_bytes(const bytevec_t &v, int _rvtype=0)
  {
    new (&bytes()) bytevec_t(v);
    rvtype = _rvtype;
    QASSERT(3215, use_bytevec());
  }

  bytevec_t &_set_bytes(int _rvtype)
  {
    new (&bytes()) bytevec_t;
    rvtype = _rvtype;
    QASSERT(3216, use_bytevec());
    return bytes();
  }

  void _set_unavailable() { ival = 0; rvtype = RVT_UNAVAILABLE; }

  void set_int(uint64 x) { clear(); _set_int(x); }
  void set_float(const bytevec_t &v) { set_bytes(v, RVT_FLOAT); }
  void set_bytes(const uchar *data, size_t size, int _rvtype=0) { clear(); _set_bytes(data, size, _rvtype); }
  void set_bytes(const bytevec_t &v, int _rvtype=0) { clear(); _set_bytes(v, _rvtype); }
  bytevec_t &set_bytes(int _rvtype) { clear(); _set_bytes(_rvtype); return bytes(); }
  void set_unavailable() { clear(); _set_unavailable(); }


        bytevec_t &bytes()       { return *(bytevec_t *)reserve; }
  const bytevec_t &bytes() const { return *(bytevec_t *)reserve; }
        void *get_data()       { return use_bytevec() ? (void *)bytes().begin() : (void *)&ival; }
  const void *get_data() const { return use_bytevec() ? (void *)bytes().begin() : (void *)&ival; }
  size_t get_data_size() const
  {
    if ( use_bytevec() )
      return bytes().size();
    if ( rvtype == RVT_INT )
      return sizeof(ival);
    return 0;
  }

};
DECLARE_TYPE_AS_MOVABLE(regval_t);
typedef qvector<regval_t> regvals_t; 

struct idd_opinfo_t
{
  bool modified = false; 
  ea_t ea = BADADDR;     
  regval_t value;        
  int debregidx = -1;    
  int value_size = 0;    
};

struct call_stack_info_t
{
  ea_t callea;          
  ea_t funcea;          
  ea_t fp;              
  bool funcok;          
  bool operator==(const call_stack_info_t &r) const
  {
    return callea == r.callea
        && funcea == r.funcea
        && funcok == r.funcok
        && fp     == r.fp;
  }
  bool operator!=(const call_stack_info_t &r) const { return !(*this == r); }
};
DECLARE_TYPE_AS_MOVABLE(call_stack_info_t);
struct call_stack_t : public qvector<call_stack_info_t> {}; 
 
//-------------------------------------------------------------------------
THREAD_SAFE inline void append_regval(bytevec_t &s, const regval_t &value)
{
  s.pack_dd(value.rvtype+3);
  if ( value.rvtype == RVT_INT )
  {
    s.pack_dq(value.ival+1); // +1 to efficiently serialize 0xffffffff
  }
  else if ( value.rvtype != RVT_UNAVAILABLE )
  {
    const bytevec_t &b = value.bytes();
    s.pack_dd(uint32(b.size()));
    s.append(b.begin(), b.size());
  }
}
 
//-------------------------------------------------------------------------
template <class T>
THREAD_SAFE inline void extract_regval(regval_t *out, T &v)
{
  out->clear();
  out->rvtype = extract_dd(v) - 3;
  if ( out->rvtype == RVT_INT )
  {
    out->ival = extract_dq(v) - 1;
  }
  else if ( out->rvtype != RVT_UNAVAILABLE )
  {
    bytevec_t &b = out->_set_bytes(out->rvtype);
    int size = extract_dd(v);
    b.resize(size);
    extract_obj(v, b.begin(), size);
  }
}
 
//-------------------------------------------------------------------------
template <class T>
THREAD_SAFE inline void extract_regvals(
        regval_t *values,
        int n,
        T &v,
        const uchar *regmap)
{
  for ( int i=0; i < n && !v.eof(); i++ )
    if ( regmap == nullptr || test_bit(regmap, i) )
      extract_regval(&values[i], v);
}
 
//--------------------------------------------------------------------------
THREAD_SAFE inline void unpack_regvals(
        regval_t *values,
        int n,
        const uchar *regmap,
        memory_deserializer_t &mmdsr)
{
  extract_regvals(values, n, mmdsr, regmap);
}
 

 
idaman error_t ida_export dbg_appcall(
        idc_value_t *retval,
        ea_t func_ea,
        thid_t tid,
        const tinfo_t *ptif,
        idc_value_t *argv,
        size_t argnum);
 

 
idaman error_t ida_export cleanup_appcall(thid_t tid);
 

enum gdecode_t
{
  GDE_ERROR = -1,       
  GDE_NO_EVENT,         
  GDE_ONE_EVENT,        
  GDE_MANY_EVENTS,      
};

struct update_bpt_info_t
{
  ea_t ea = BADADDR;      
  bytevec_t orgbytes;     
  bpttype_t type = BPT_SOFT; 
  int size = 0;           
  uchar code = 0;         
  pid_t pid = NO_PROCESS; 
  thid_t tid = NO_THREAD; 

  bool operator==(const update_bpt_info_t &b) const
  {
    return ea == b.ea && type == b.type;
  }
};
DECLARE_TYPE_AS_MOVABLE(update_bpt_info_t);
typedef qvector<update_bpt_info_t> update_bpt_vec_t; 

struct lowcnd_t
{
  ea_t ea;              
  qstring cndbody;      
  bpttype_t type;       
  bytevec_t orgbytes;   
  insn_t cmd;           
  bool compiled;        
  int size;             
};
typedef qvector<lowcnd_t> lowcnd_vec_t; 

struct thread_name_t
{
  thid_t tid;           
  qstring name;         
};
typedef qvector<thread_name_t> thread_name_vec_t; 
 
//====================================================================
enum resume_mode_t
{
  RESMOD_NONE,     
  RESMOD_INTO,     
  RESMOD_OVER,     
  RESMOD_OUT,      
  RESMOD_SRCINTO,  
  RESMOD_SRCOVER,  
  RESMOD_SRCOUT,   
  RESMOD_USER,     
  RESMOD_HANDLE,   
  RESMOD_BACKINTO, 
  RESMOD_MAX,
};
 
//====================================================================
// Tracing bits
#define STEP_TRACE 0x01 
#define INSN_TRACE 0x02 
#define FUNC_TRACE 0x04 
#define BBLK_TRACE 0x08 
 
//====================================================================
enum drc_t
{
  DRC_EVENTS = 3,   
  DRC_CRC    = 2,   
  DRC_OK     = 1,   
  DRC_NONE   = 0,   
  DRC_FAILED = -1,  
  DRC_NETERR = -2,  
  DRC_NOFILE = -3,  
  DRC_IDBSEG = -4,  
  DRC_NOPROC = -5,  
  DRC_NOCHG  = -6,  
  DRC_ERROR  = -7,  
};
 
#ifndef IDA_DBG_VALIDATE_REG_IDX
#define IDA_DBG_VALIDATE_REG_IDX(idx, n) ((void)0)
#endif
 
//====================================================================
struct debugger_t
{
  int version;            
  const char *name;       
  int id;                 

  #define DEBUGGER_ID_X86_IA32_WIN32_USER              0 
  #define DEBUGGER_ID_X86_IA32_LINUX_USER              1 
  #define DEBUGGER_ID_X86_IA32_MACOSX_USER             3 
  #define DEBUGGER_ID_ARM_IPHONE_USER                  5 
  #define DEBUGGER_ID_X86_IA32_BOCHS                   6 
  #define DEBUGGER_ID_6811_EMULATOR                    7 
  #define DEBUGGER_ID_GDB_USER                         8 
  #define DEBUGGER_ID_WINDBG                           9 
  #define DEBUGGER_ID_X86_DOSBOX_EMULATOR             10 
  #define DEBUGGER_ID_ARM_LINUX_USER                  11 
  #define DEBUGGER_ID_TRACE_REPLAYER                  12 
  #define DEBUGGER_ID_X86_PIN_TRACER                  14 
  #define DEBUGGER_ID_DALVIK_USER                     15 
  #define DEBUGGER_ID_XNU_USER                        16 
  #define DEBUGGER_ID_ARM_MACOS_USER                  17 
 
  const char *processor;  
 
  uint64 flags;           

  #define DBG_FLAG_REMOTE         0x0000000000000001ULL  
  #define DBG_FLAG_NOHOST         0x0000000000000002ULL  
  #define DBG_FLAG_FAKE_ATTACH    0x0000000000000004ULL  
  #define DBG_FLAG_HWDATBPT_ONE   0x0000000000000008ULL  
  #define DBG_FLAG_CAN_CONT_BPT   0x0000000000000010ULL  
  #define DBG_FLAG_NEEDPORT       0x0000000000000020ULL  
  #define DBG_FLAG_DONT_DISTURB   0x0000000000000040ULL  
  #define DBG_FLAG_SAFE           0x0000000000000080ULL  
  #define DBG_FLAG_CLEAN_EXIT     0x0000000000000100ULL  
  #define DBG_FLAG_USE_SREGS      0x0000000000000200ULL  
  #define DBG_FLAG_NOSTARTDIR     0x0000000000000400ULL  
  #define DBG_FLAG_NOPARAMETERS   0x0000000000000800ULL  
  #define DBG_FLAG_NOPASSWORD     0x0000000000001000ULL  
  #define DBG_FLAG_CONNSTRING     0x0000000000002000ULL  
  #define DBG_FLAG_SMALLBLKS      0x0000000000004000ULL  
  #define DBG_FLAG_MANMEMINFO     0x0000000000008000ULL  
  #define DBG_FLAG_EXITSHOTOK     0x0000000000010000ULL  
  #define DBG_FLAG_VIRTHREADS     0x0000000000020000ULL  
  #define DBG_FLAG_LOWCNDS        0x0000000000040000ULL  
  #define DBG_FLAG_DEBTHREAD      0x0000000000080000ULL  
  #define DBG_FLAG_DEBUG_DLL      0x0000000000100000ULL  
  #define DBG_FLAG_FAKE_MEMORY    0x0000000000200000ULL  
  #define DBG_FLAG_ANYSIZE_HWBPT  0x0000000000400000ULL  
  #define DBG_FLAG_TRACER_MODULE  0x0000000000800000ULL  
  #define DBG_FLAG_PREFER_SWBPTS  0x0000000001000000ULL  
  #define DBG_FLAG_LAZY_WATCHPTS  0x0000000002000000ULL  
  #define DBG_FLAG_FAST_STEP      0x0000000004000000ULL  
  #define DBG_FLAG_ADD_ENVS       0x0000000008000000ULL  
  #define DBG_FLAG_MERGE_ENVS     0x0000000010000000ULL  
  #define DBG_FLAG_DISABLE_ASLR   0x0000000020000000ULL  
  #define DBG_FLAG_TTD            0x0000000040000000ULL  
  #define DBG_FLAG_FULL_INSTR_BPT 0x0000000080000000ULL  
  #define DBG_HAS_GET_PROCESSES   0x0000000100000000ULL  
  #define DBG_HAS_ATTACH_PROCESS  0x0000000200000000ULL  
  #define DBG_HAS_DETACH_PROCESS  0x0000000400000000ULL  
  #define DBG_HAS_REQUEST_PAUSE   0x0000000800000000ULL  
  #define DBG_HAS_SET_EXCEPTION_INFO \
                                  0x0000001000000000ULL  
  #define DBG_HAS_THREAD_SUSPEND  0x0000002000000000ULL  
  #define DBG_HAS_THREAD_CONTINUE 0x0000004000000000ULL  
  #define DBG_HAS_SET_RESUME_MODE 0x0000008000000000ULL  
  #define DBG_HAS_THREAD_GET_SREG_BASE \
                                  0x0000010000000000ULL  
  #define DBG_HAS_CHECK_BPT       0x0000020000000000ULL  
  #define DBG_HAS_OPEN_FILE       0x0000040000000000ULL  
  #define DBG_HAS_UPDATE_CALL_STACK \
                                  0x0000080000000000ULL  
  #define DBG_HAS_APPCALL         0x0000100000000000ULL  
  #define DBG_HAS_REXEC           0x0000200000000000ULL  
  #define DBG_HAS_MAP_ADDRESS     0x0000400000000000ULL  
 
  bool is_remote() const { return (flags & DBG_FLAG_REMOTE) != 0; }
  bool must_have_hostname() const
    { return (flags & (DBG_FLAG_REMOTE|DBG_FLAG_NOHOST)) == DBG_FLAG_REMOTE; }
  bool can_continue_from_bpt() const
    { return (flags & DBG_FLAG_CAN_CONT_BPT) != 0; }
  bool may_disturb() const
    { return (flags & DBG_FLAG_DONT_DISTURB) == 0; }
  bool is_safe() const
    { return (flags & DBG_FLAG_SAFE) != 0; }
  bool use_sregs() const
    { return (flags & DBG_FLAG_USE_SREGS) != 0; }
  size_t cache_block_size() const
    { return (flags & DBG_FLAG_SMALLBLKS) != 0 ? 256 : 1024; }
  bool use_memregs() const
    { return (flags & DBG_FLAG_MANMEMINFO) != 0; }
  bool may_take_exit_snapshot() const
    { return (flags & DBG_FLAG_EXITSHOTOK) != 0; }
  bool virtual_threads() const
    { return (flags & DBG_FLAG_VIRTHREADS) != 0; }
  bool supports_lowcnds() const
    { return (flags & DBG_FLAG_LOWCNDS) != 0; }
  bool supports_debthread() const
    { return (flags & DBG_FLAG_DEBTHREAD) != 0; }
  bool can_debug_standalone_dlls() const
    { return (flags & DBG_FLAG_DEBUG_DLL) != 0; }
  bool fake_memory() const
    { return (flags & DBG_FLAG_FAKE_MEMORY) != 0; }
  bool is_ttd() const
    { return (flags & DBG_FLAG_TTD) != 0; }
 
  bool has_get_processes() const
    { return (flags & DBG_HAS_GET_PROCESSES) != 0; }
  bool has_attach_process() const
    { return (flags & DBG_HAS_ATTACH_PROCESS) != 0; }
  bool has_detach_process() const
    { return (flags & DBG_HAS_DETACH_PROCESS) != 0; }
  bool has_request_pause() const
    { return (flags & DBG_HAS_REQUEST_PAUSE) != 0; }
  bool has_set_exception_info() const
    { return (flags & DBG_HAS_SET_EXCEPTION_INFO) != 0; }
  bool has_thread_suspend() const
    { return (flags & DBG_HAS_THREAD_SUSPEND) != 0; }
  bool has_thread_continue() const
    { return (flags & DBG_HAS_THREAD_CONTINUE) != 0; }
  bool has_set_resume_mode() const
    { return (flags & DBG_HAS_SET_RESUME_MODE) != 0; }
  bool has_thread_get_sreg_base() const
    { return (flags & DBG_HAS_THREAD_GET_SREG_BASE) != 0; }
  bool has_check_bpt() const
    { return (flags & DBG_HAS_CHECK_BPT) != 0; }
  bool has_open_file() const
    { return (flags & DBG_HAS_OPEN_FILE) != 0; }
  bool has_update_call_stack() const
    { return (flags & DBG_HAS_UPDATE_CALL_STACK) != 0; }
  bool has_appcall() const
    { return (flags & DBG_HAS_APPCALL) != 0; }
  bool has_rexec() const
    { return (flags & DBG_HAS_REXEC) != 0; }
  bool has_map_address() const
    { return (flags & DBG_HAS_MAP_ADDRESS) != 0; }
  bool has_soft_bpt() const
    { return bpt_bytes != nullptr && bpt_size > 0; }
 
  const char **regclasses;                   
  int default_regclasses;                    
  register_info_t *registers;                
  int nregisters;                            
 
  // A function for accessing the 'registers' array
  inline register_info_t &regs(int idx)
  {
    IDA_DBG_VALIDATE_REG_IDX(idx, nregisters);
    return registers[idx];
  }
 
  int memory_page_size;                      
 
  const uchar *bpt_bytes;                    
  uchar bpt_size;                            
  uchar filetype;                            
  ushort resume_modes;                       
  #define DBG_RESMOD_STEP_INTO      0x0001   
  #define DBG_RESMOD_STEP_OVER      0x0002   
  #define DBG_RESMOD_STEP_OUT       0x0004   
  #define DBG_RESMOD_STEP_SRCINTO   0x0008   
  #define DBG_RESMOD_STEP_SRCOVER   0x0010   
  #define DBG_RESMOD_STEP_SRCOUT    0x0020   
  #define DBG_RESMOD_STEP_USER      0x0040   
  #define DBG_RESMOD_STEP_HANDLE    0x0080   
  #define DBG_RESMOD_STEP_BACKINTO  0x0100   
  bool is_resmod_avail(int resmod) const
    { return (resume_modes & (1 << (resmod - 1))) != 0; }
 
#if !defined(_MSC_VER)  // this compiler complains :(
  static const int default_port_number = 23946;
#define DEBUGGER_PORT_NUMBER debugger_t::default_port_number
#else
#define DEBUGGER_PORT_NUMBER 23946
#endif

  enum event_t
  {
    ev_init_debugger,

    ev_term_debugger,

    ev_get_processes,

    ev_start_process,

    ev_attach_process,

    ev_detach_process,

    ev_get_debapp_attrs,

    ev_rebase_if_required_to,

    ev_request_pause,

    ev_exit_process,

    ev_get_debug_event,

    ev_resume,

    ev_set_backwards,

    ev_set_exception_info,

    ev_suspended,


    ev_thread_suspend,

    ev_thread_continue,

    ev_set_resume_mode,


    ev_read_registers,

    ev_write_register,

    ev_thread_get_sreg_base,


    ev_get_memory_info,

    ev_read_memory,

    ev_write_memory,


    ev_check_bpt,

    ev_update_bpts,

    ev_update_lowcnds,


    ev_open_file,

    ev_close_file,

    ev_read_file,

    ev_write_file,


    ev_map_address,

    ev_get_debmod_extensions,

    ev_update_call_stack,

    ev_appcall,

    ev_cleanup_appcall,

    ev_eval_lowcnd,

    ev_send_ioctl,

    ev_dbg_enable_trace,

    ev_is_tracing_enabled,

    ev_rexec,

    ev_get_srcinfo_path,

    ev_bin_search,

    ev_get_dynamic_register_set,

    ev_set_dbg_options,
  };

  ssize_t notify(event_t event_code, ...)
  {
    va_list va;
    va_start(va, event_code);
    ssize_t code = invoke_callbacks(HT_IDD, event_code, va);
    va_end(va);
    return code;
  }
  drc_t notify_drc(event_t event_code, ...)
  {
    va_list va;
    va_start(va, event_code);
    drc_t code = drc_t(invoke_callbacks(HT_IDD, event_code, va));
    va_end(va);
    return code;
  }

  #define DBG_PROC_IS_DLL 0x01            
  #define DBG_PROC_IS_GUI 0x02            
  #define DBG_PROC_32BIT  0x04            
  #define DBG_PROC_64BIT  0x08            
  #define DBG_NO_TRACE    0x10            
  #define DBG_HIDE_WINDOW 0x20            
  #define DBG_SUSPENDED   0x40            
  #define DBG_NO_ASLR     0x80            

  #define BPT_OK           0      
  #define BPT_INTERNAL_ERR 1      
  #define BPT_BAD_TYPE     2      
  #define BPT_BAD_ALIGN    3      
  #define BPT_BAD_ADDR     4      
  #define BPT_BAD_LEN      5      
  #define BPT_TOO_MANY     6      
  #define BPT_READ_ERROR   7      
  #define BPT_WRITE_ERROR  8      
  #define BPT_SKIP         9      
  #define BPT_PAGE_OK     10      

  #define APPCALL_MANUAL  0x0001  
  #define APPCALL_DEBEV   0x0002  
  #define APPCALL_TIMEOUT 0x0004  
  #define SET_APPCALL_TIMEOUT(msecs)   ((uint(msecs) << 16)|APPCALL_TIMEOUT)
  #define GET_APPCALL_TIMEOUT(options) (uint(options) >> 16)
 
  // Notification helpers, should be used instead of direct dbg->notify(...) calls
  inline bool init_debugger(const char *hostname, int portnum, const char *password, qstring *errbuf=nullptr);
  inline bool term_debugger();
  inline drc_t get_processes(procinfo_vec_t *procs, qstring *errbuf=nullptr);
  inline drc_t start_process(const char *path,
                             const char *args,
                             launch_env_t *envs,
                             const char *startdir,
                             uint32 dbg_proc_flags,
                             const char *input_path,
                             uint32 input_file_crc32,
                             qstring *errbuf=nullptr);
  inline drc_t attach_process(pid_t pid, int event_id, uint32 dbg_proc_flags, qstring *errbuf=nullptr);
  inline drc_t detach_process(qstring *errbuf=nullptr);
  inline bool get_debapp_attrs(debapp_attrs_t *out_pattrs);
  inline void rebase_if_required_to(ea_t new_base);
  inline drc_t request_pause(qstring *errbuf=nullptr);
  inline drc_t exit_process(qstring *errbuf=nullptr);
  inline gdecode_t get_debug_event(debug_event_t *event, int timeout_ms);
  inline drc_t resume(const debug_event_t *event, qstring *errbuf=nullptr);
  inline drc_t set_backwards(bool backwards);
  inline void set_exception_info(const exception_info_t *info, int qty);
  inline void suspended(bool dlls_added, thread_name_vec_t *thr_names=nullptr);
  inline drc_t thread_suspend(thid_t tid, qstring *errbuf=nullptr);
  inline drc_t thread_continue(thid_t tid, qstring *errbuf=nullptr);
  inline drc_t set_resume_mode(thid_t tid, resume_mode_t resmod, qstring *errbuf=nullptr);
  inline drc_t read_registers(thid_t tid, int clsmask, regval_t *values, qstring *errbuf=nullptr);
  inline drc_t write_register(thid_t tid, int regidx, const regval_t *value, qstring *errbuf=nullptr);
  inline drc_t thread_get_sreg_base(ea_t *answer, thid_t tid, int sreg_value, qstring *errbuf=nullptr);
  inline drc_t get_memory_info(meminfo_vec_t &ranges, qstring *errbuf=nullptr);
  inline drc_t read_memory(size_t *nbytes, ea_t ea, void *buffer, size_t size, qstring *errbuf=nullptr);
  inline drc_t write_memory(size_t *nbytes, ea_t ea, const void *buffer, size_t size, qstring *errbuf=nullptr);
  inline drc_t check_bpt(int *bptvc, bpttype_t type, ea_t ea, int len);
  inline drc_t update_bpts(int *nbpts, update_bpt_info_t *bpts, int nadd, int ndel, qstring *errbuf=nullptr);
  inline drc_t update_lowcnds(int *nupdated, const lowcnd_t *lowcnds, int nlowcnds, qstring *errbuf=nullptr);
  inline int open_file(const char *file, uint64 *fsize, bool readonly, qstring *errbuf=nullptr);
  inline void close_file(int fn);
  inline ssize_t read_file(int fn, qoff64_t off, void *buf, size_t size, qstring *errbuf=nullptr);
  inline ssize_t write_file(int fn, qoff64_t off, const void *buf, size_t size, qstring *errbuf=nullptr);
  inline ea_t map_address(ea_t off, const regval_t *regs, int regnum);
  inline const void *get_debmod_extensions();
  inline drc_t update_call_stack(thid_t tid, call_stack_t *trace);
  inline ea_t appcall(
          ea_t func_ea,
          thid_t tid,
          const struct func_type_data_t *fti,
          int nargs,
          const struct regobjs_t *regargs,
          struct relobj_t *stkargs,
          struct regobjs_t *retregs,
          qstring *errbuf,
          debug_event_t *event,
          int options);
  inline drc_t cleanup_appcall(thid_t tid);
  inline drc_t eval_lowcnd(thid_t tid, ea_t ea, qstring *errbuf=nullptr);
  inline drc_t send_ioctl(int fn, const void *buf, size_t size, void **poutbuf, ssize_t *poutsize, qstring *errbuf=nullptr);
  inline bool dbg_enable_trace(thid_t tid, bool enable, int trace_flags);
  inline bool is_tracing_enabled(thid_t tid, int tracebit);
  inline int rexec(const char *cmdline);
  inline bool get_srcinfo_path(qstring *path, ea_t base);
  inline drc_t bin_search(
          ea_t *out,
          ea_t start_ea,
          ea_t end_ea,
          const compiled_binpat_vec_t &data,
          int srch_flags,
          qstring *errbuf=nullptr);
  inline bool get_dynamic_register_set(dynamic_register_set_t *regset);
  inline drc_t set_dbg_options(const char **res, const char *keyword, int pri, int value_type, const void *value);
  inline bool have_set_options() const;
};
 
 
#define RQ_MASKING  0x0001  
#define RQ_SUSPEND  0x0002  
#define RQ_NOSUSP   0x0000  
#define RQ_IGNWERR  0x0004  
#define RQ_SILENT   0x0008  
#define RQ_VERBOSE  0x0000  
#define RQ_SWSCREEN 0x0010  
#define RQ__NOTHRRF 0x0020  
#define RQ_PROCEXIT 0x0040  
#define RQ_IDAIDLE  0x0080  
#define RQ_SUSPRUN  0x0100  
#define RQ_RESUME   0x0200  
#define RQ_RESMOD   0xF000  
#define RQ_RESMOD_SHIFT 12
#define RQ_INTO (RESMOD_INTO << RQ_RESMOD_SHIFT)
#define RQ_BACKINTO (RESMOD_BACKINTO << RQ_RESMOD_SHIFT)
 
inline bool debugger_t::init_debugger(const char *hostname, int portnum, const char *password, qstring *errbuf)
{
  return notify_drc(ev_init_debugger, hostname, portnum, password, errbuf) == DRC_OK;
}
inline bool debugger_t::term_debugger()
{
  return notify_drc(ev_term_debugger) == DRC_OK;
}
inline drc_t debugger_t::get_processes(procinfo_vec_t *procs, qstring *errbuf)
{
  return notify_drc(ev_get_processes, procs, errbuf);
}
inline drc_t debugger_t::start_process(
        const char *path,
        const char *args,
        launch_env_t *envs,
        const char *startdir,
        uint32 dbg_proc_flags,
        const char *input_path,
        uint32 input_file_crc32,
        qstring *errbuf)
{
  return notify_drc(ev_start_process, path, args, startdir, dbg_proc_flags, input_path, input_file_crc32, errbuf, envs);
}
inline drc_t debugger_t::attach_process(pid_t pid, int event_id, uint32 dbg_proc_flags, qstring *errbuf)
{
  return notify_drc(ev_attach_process, pid, event_id, dbg_proc_flags, errbuf);
}
inline drc_t debugger_t::detach_process(qstring *errbuf)
{
  return notify_drc(ev_detach_process, errbuf);
}
inline bool debugger_t::get_debapp_attrs(debapp_attrs_t *out_pattrs)
{
  return notify_drc(ev_get_debapp_attrs, out_pattrs) != DRC_NONE;
}
inline void debugger_t::rebase_if_required_to(ea_t new_base)
{
  notify_drc(ev_rebase_if_required_to, new_base);
}
inline drc_t debugger_t::request_pause(qstring *errbuf)
{
  return notify_drc(ev_request_pause, errbuf);
}
inline drc_t debugger_t::exit_process(qstring *errbuf)
{
  return notify_drc(ev_exit_process, errbuf);
}
inline gdecode_t debugger_t::get_debug_event(debug_event_t *event, int timeout_ms)
{
  gdecode_t code = GDE_ERROR;
  notify_drc(ev_get_debug_event, &code, event, timeout_ms);
  return code;
}
inline drc_t debugger_t::resume(const debug_event_t *event, qstring *errbuf)
{
  return notify_drc(ev_resume, event, errbuf);
}
inline drc_t debugger_t::set_backwards(bool backwards)
{
  return notify_drc(ev_set_backwards, backwards);
}
inline void debugger_t::set_exception_info(const exception_info_t *info, int qty)
{
  notify_drc(ev_set_exception_info, info, qty);
}
inline void debugger_t::suspended(bool dlls_added, thread_name_vec_t *thr_names)
{
  notify_drc(ev_suspended, dlls_added, thr_names);
}
inline drc_t debugger_t::thread_suspend(thid_t tid, qstring *errbuf)
{
  return notify_drc(ev_thread_suspend, tid, errbuf);
}
inline drc_t debugger_t::thread_continue(thid_t tid, qstring *errbuf)
{
  return notify_drc(ev_thread_continue, tid, errbuf);
}
inline drc_t debugger_t::set_resume_mode(thid_t tid, resume_mode_t resmod, qstring *errbuf)
{
  return notify_drc(ev_set_resume_mode, tid, resmod, errbuf);
}
inline drc_t debugger_t::read_registers(thid_t tid, int clsmask, regval_t *values, qstring *errbuf)
{
  return notify_drc(ev_read_registers, tid, clsmask, values, errbuf);
}
inline drc_t debugger_t::write_register(thid_t tid, int regidx, const regval_t *value, qstring *errbuf)
{
  return notify_drc(ev_write_register, tid, regidx, value, errbuf);
}
inline drc_t debugger_t::thread_get_sreg_base(ea_t *answer, thid_t tid, int sreg_value, qstring *errbuf)
{
  return notify_drc(ev_thread_get_sreg_base, answer, tid, sreg_value, errbuf);
}
inline drc_t debugger_t::get_memory_info(meminfo_vec_t &ranges, qstring *errbuf)
{
  return notify_drc(ev_get_memory_info, &ranges, errbuf);
}
inline drc_t debugger_t::read_memory(size_t *nbytes, ea_t ea, void *buffer, size_t size, qstring *errbuf)
{
  return notify_drc(ev_read_memory, nbytes, ea, buffer, size, errbuf);
}
inline drc_t debugger_t::write_memory(size_t *nbytes, ea_t ea, const void *buffer, size_t size, qstring *errbuf)
{
  return notify_drc(ev_write_memory, nbytes, ea, buffer, size, errbuf);
}
inline drc_t debugger_t::check_bpt(int *bptvc, bpttype_t type, ea_t ea, int len)
{
  return notify_drc(ev_check_bpt, bptvc, type, ea, len);
}
inline drc_t debugger_t::update_bpts(int *nbpts, update_bpt_info_t *bpts, int nadd, int ndel, qstring *errbuf)
{
  return notify_drc(ev_update_bpts, nbpts, bpts, nadd, ndel, errbuf);
}
inline drc_t debugger_t::update_lowcnds(int *nupdated, const lowcnd_t *lowcnds, int nlowcnds, qstring *errbuf)
{
  return notify_drc(ev_update_lowcnds, nupdated, lowcnds, nlowcnds, errbuf);
}
inline int debugger_t::open_file(const char *file, uint64 *fsize, bool readonly, qstring *errbuf)
{
  return int(notify(ev_open_file, file, fsize, readonly, errbuf));
}
inline void debugger_t::close_file(int fn)
{
  notify(ev_close_file, fn);
}
inline ssize_t debugger_t::read_file(int fn, qoff64_t off, void *buf, size_t size, qstring *errbuf)
{
  return notify(ev_read_file, fn, off, buf, size, errbuf);
}
inline ssize_t debugger_t::write_file(int fn, qoff64_t off, const void *buf, size_t size, qstring *errbuf)
{
  return notify(ev_write_file, fn, off, buf, size, errbuf);
}
inline ea_t debugger_t::map_address(ea_t off, const regval_t *rvs, int regnum)
{
  ea_t mapped;
  return notify_drc(ev_map_address, &mapped, off, rvs, regnum) == DRC_OK
       ? mapped
       : off;
}
inline const void *debugger_t::get_debmod_extensions()
{
  void *ext;
  if ( notify_drc(ev_get_debmod_extensions, &ext) != DRC_OK )
    ext = nullptr;
  return ext;
}
inline drc_t debugger_t::update_call_stack(thid_t tid, call_stack_t *trace)
{
  return notify_drc(ev_update_call_stack, tid, trace);
}
inline ea_t debugger_t::appcall(
        ea_t func_ea,
        thid_t tid,
        const struct func_type_data_t *fti,
        int nargs,
        const struct regobjs_t *regargs,
        struct relobj_t *stkargs,
        struct regobjs_t *retregs,
        qstring *errbuf,
        debug_event_t *event,
        int options)
{
  ea_t blob_ea;
  if ( notify_drc(ev_appcall, &blob_ea, func_ea, tid, fti, nargs, regargs, stkargs, retregs, errbuf, event, options) != DRC_OK )
  {
    blob_ea = BADADDR;
    if ( errbuf != nullptr )
      *errbuf = "Debugger plugin does not support an application function call";
  }
  return blob_ea;
}
inline drc_t debugger_t::cleanup_appcall(thid_t tid)
{
  return notify_drc(ev_cleanup_appcall, tid);
}
inline drc_t debugger_t::eval_lowcnd(thid_t tid, ea_t ea, qstring *errbuf)
{
  return notify_drc(ev_eval_lowcnd, tid, ea, errbuf);
}
inline drc_t debugger_t::send_ioctl(int fn, const void *buf, size_t size, void **poutbuf, ssize_t *poutsize, qstring *errbuf)
{
  return notify_drc(ev_send_ioctl, fn, buf, size, poutbuf, poutsize, errbuf);
}
inline bool debugger_t::dbg_enable_trace(thid_t tid, bool enable, int trace_flags)
{
  return notify_drc(ev_dbg_enable_trace, tid, enable, trace_flags) == DRC_OK;
}
inline bool debugger_t::is_tracing_enabled(thid_t tid, int tracebit)
{
  return notify_drc(ev_is_tracing_enabled, tid, tracebit) == DRC_OK;
}
inline int debugger_t::rexec(const char *cmdline)
{
  return int(notify(ev_rexec, cmdline));
}
inline bool debugger_t::get_srcinfo_path(qstring *path, ea_t base)
{
  return notify_drc(ev_get_srcinfo_path, path, base) == DRC_OK;
}
inline drc_t debugger_t::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 notify_drc(ev_bin_search, out, start_ea, end_ea, &data, srch_flags, errbuf);
}
inline bool debugger_t::get_dynamic_register_set(dynamic_register_set_t *regset)
{
  return notify_drc(ev_get_dynamic_register_set, regset) == DRC_OK;
}
inline drc_t debugger_t::set_dbg_options(const char **res, const char *keyword, int pri, int value_type, const void *value)
{
  return notify_drc(ev_set_dbg_options, res, keyword, pri, value_type, value);
}
inline bool debugger_t::have_set_options() const
{
  return const_cast<debugger_t *>(this)->notify_drc(ev_set_dbg_options, nullptr, " ", 0, 0, nullptr) != DRC_NONE;
}

idaman int ida_export cpu2ieee(fpvalue_t *ieee_out, const void *cpu_fpval, int size);

idaman int ida_export ieee2cpu(void *cpu_fpval_out, const fpvalue_t &ieee, int size);
 
#endif // _IDD_HPP