merge.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 2005-2025 Hex-Rays SA <support@hex-rays.com>
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef _MERGE_HPP
#define _MERGE_HPP
 
#include <functional>
#include <queue>
#include <nalt.hpp>
#include <diff3.hpp>

 
#ifdef switch_dbctx
  #define ui_switch_dbctx_guard switch_dbctx
  #undef switch_dbctx
#endif
 
//------------------------------------------------------------------------
enum merge_kind_t ENUM_SIZE(uint32)
{
  MERGE_KIND_NETNODE,           
  MERGE_KIND_AUTOQ,             
  MERGE_KIND_INF,               
  MERGE_KIND_ENCODINGS,         
  MERGE_KIND_ENCODINGS2,        
  MERGE_KIND_SCRIPTS2,          
  MERGE_KIND_SCRIPTS,           
  MERGE_KIND_CUSTDATA,          
  MERGE_KIND_CUSTCNV,           
  MERGE_KIND_ENUMS,             
  MERGE_KIND_STRUCTS,           
  MERGE_KIND_TILS,              
  MERGE_KIND_TINFO,             
  MERGE_KIND_STRMEM,            
  MERGE_KIND_UDTMEM,            
  MERGE_KIND_GHSTRCMT,          
  MERGE_KIND_STRMEMCMT,         
  MERGE_KIND_SELECTORS,         
  MERGE_KIND_STT,               
  MERGE_KIND_SEGMENTS,          
  MERGE_KIND_SEGGRPS,           
  MERGE_KIND_SEGREGS,           
  MERGE_KIND_ORPHANS,           
  MERGE_KIND_BYTEVAL,           
  MERGE_KIND_FIXUPS,            
  MERGE_KIND_MAPPING,           
  MERGE_KIND_EXPORTS,           
  MERGE_KIND_IMPORTS,           
  MERGE_KIND_PATCHES,           
  MERGE_KIND_FLAGS,             
  MERGE_KIND_EXTRACMT,          
  MERGE_KIND_AFLAGS_EA,         
  MERGE_KIND_IGNOREMICRO,       
  MERGE_KIND_FILEREGIONS,       
  MERGE_KIND_HIDDENRANGES,      
  MERGE_KIND_SOURCEFILES,       
  MERGE_KIND_FUNC,              
  MERGE_KIND_FRAMEMGR,          
  MERGE_KIND_FRAME,             
  MERGE_KIND_STKPNTS,           
  MERGE_KIND_FLOWS,             
  MERGE_KIND_CREFS,             
  MERGE_KIND_DREFS,             
  MERGE_KIND_BPTS,              
  MERGE_KIND_WATCHPOINTS,       
  MERGE_KIND_BOOKMARKS,         
  MERGE_KIND_TRYBLKS,           
  MERGE_KIND_DIRTREE,           
  MERGE_KIND_VFTABLES,          
  MERGE_KIND_SIGNATURES,        
  MERGE_KIND_PROBLEMS,          
  MERGE_KIND_UI,                
  MERGE_KIND_DEKSTOPS,          
  MERGE_KIND_NOTEPAD,           
  MERGE_KIND_LOADER,            
  MERGE_KIND_DEBUGGER,          
  MERGE_KIND_DBG_MEMREGS,       
  MERGE_KIND_LUMINA,            
  MERGE_KIND_LAST,              
  MERGE_KIND_END = merge_kind_t(-2),
  MERGE_KIND_NONE = merge_kind_t(-1)
};
 
//------------------------------------------------------------------------
class merge_handler_t;
class merge_data_t;
using merge_handlers_t = qvector<merge_handler_t *>;
//--------------------------------------------------------------------------
idaman bool ida_export is_diff_merge_mode();
 
//--------------------------------------------------------------------------
class merge_data_t
{
public:
  struct item_block_locator_t
  {
    virtual ea_t get_block_head(merge_data_t &md, diff_source_idx_t idx, ea_t item_head) = 0;

    virtual bool setup_blocks(
        merge_data_t &md,
        diff_source_idx_t from,
        diff_source_idx_t to,
        const diff_range_t &region) = 0;
 
    virtual ~item_block_locator_t() {}
  };
 
  class merge_mappers_t &mappers;
 
  int dbctx_ids[3] = { -1, -1, -1 };  
  int nbases = 0;                     
  merge_handlers_t ev_handlers;       
  item_block_locator_t *item_block_locator = nullptr;
  merge_handler_t *last_udt_related_merger = nullptr;
 
  merge_data_t();
  virtual ~merge_data_t();
  merge_data_t(const merge_data_t &) = delete;
  void operator=(const merge_data_t &) = delete;
 
  void set_dbctx_ids(int local, int remote, int base)
  {
    dbctx_ids[LOCAL_IDX] = local;
    dbctx_ids[REMOTE_IDX] = remote;
    dbctx_ids[BASE_IDX] = base;
    nbases = base != -1 ? 3 : 2;
  }
 
  int local_id()  const { return dbctx_ids[LOCAL_IDX]; }
  int remote_id() const { return dbctx_ids[REMOTE_IDX]; }
  int base_id()   const { return dbctx_ids[BASE_IDX]; }
 
  void add_event_handler(merge_handler_t *handler) { ev_handlers.push_back(handler); }
  void remove_event_handler(merge_handler_t *handler) { ev_handlers.del(handler); }
 
  ea_t get_block_head(diff_source_idx_t idx, ea_t item_head)
  {
    return item_block_locator == nullptr
         ? item_head
         : item_block_locator->get_block_head(*this, idx, item_head);
  }
  bool setup_blocks(diff_source_idx_t dst_idx, diff_source_idx_t src_idx, const diff_range_t &region)
  {
    return item_block_locator != nullptr
        && item_block_locator->setup_blocks(*this, dst_idx, src_idx, region);
  }
 
  // make these functions virtual to be available from plugins

  virtual bool has_existing_node(const char *nodename) const;

  virtual bool map_privrange_id(
        tid_t *tid,
        ea_t ea,
        diff_source_idx_t from,
        diff_source_idx_t to,
        bool strict=true);

  virtual bool map_tinfo(
        tinfo_t *tif,
        diff_source_idx_t from,
        diff_source_idx_t to,
        bool strict=true);

  virtual int compare_merging_tifs(
        const tinfo_t &tif1,
        diff_source_idx_t diffidx1,
        const tinfo_t &tif2,
        diff_source_idx_t diffidx2) const;
};
 
//------------------------------------------------------------------------
struct merge_handler_params_t
{
  merge_data_t &md;
  qstring label;
  merge_kind_t kind;            
  merge_kind_t insert_after;    
  uint32 mh_flags;
#define MH_LISTEN           0x00000001 
#define MH_TERSE            0x00000002 
#define MH_UI_NODETAILS     0x00000100 
#define MH_UI_COMPLEX       0x00000200 
#define MH_UI_DP_NOLINEDIFF 0x00000400 
#define MH_UI_DP_SHORTNAME  0x00000800 
#define MH_UI_INDENT        0x00001000 
#define MH_UI_SPLITNAME     0x00800000 
#define MH_UI_CHAR_MASK     0x007F0000 
#define MH_UI_DEF_CHAR(v)   ((((v) & 0x7F) << 16) | MH_UI_SPLITNAME)
#ifndef SWIG
#define MH_UI_COMMANAME     MH_UI_DEF_CHAR(',')
#else
#define MH_UI_COMMANAME     0x00AC0000
#endif
#ifndef SWIG
#define MH_UI_COLONNAME     MH_UI_DEF_CHAR(':')
#else
#define MH_UI_COLONNAME     0x00BA0000
#endif
#define MH_DUMMY            0x80000000 
 
  merge_handler_params_t(
        merge_data_t &_md,
        const qstring &_label,
        merge_kind_t _kind,
        merge_kind_t _insert_after,
        uint32 _mh_flags)
    : md(_md),
      label(_label),
      kind(_kind),
      insert_after(_insert_after),
      mh_flags(_mh_flags)
  {}

  static bool ui_has_details(uint32 _mh_flags)      { return (_mh_flags & MH_UI_NODETAILS) == 0; }
  bool ui_has_details() const                       { return ui_has_details(mh_flags); }

  static bool ui_complex_details(uint32 _mh_flags)  { return (_mh_flags & MH_UI_COMPLEX) != 0; }
  bool ui_complex_details() const                   { return ui_complex_details(mh_flags); }

  static bool ui_complex_name(uint32 _mh_flags)     { return (_mh_flags & MH_UI_SPLITNAME) != 0; }
  bool ui_complex_name() const                      { return ui_complex_name(mh_flags); }
  static char ui_split_char(uint32 _mh_flags)       { return (_mh_flags >> 16) & 0x7F; }
  char ui_split_char() const                        { return ui_split_char(mh_flags); }
  static qstring ui_split_str(uint32 _mh_flags)     { return qstring(1, ui_split_char(_mh_flags)); }
  qstring ui_split_str() const                      { return ui_split_str(mh_flags); }

  static bool ui_dp_shortname(uint32 _mh_flags)     { return (_mh_flags & MH_UI_DP_SHORTNAME) != 0; }
  bool ui_dp_shortname() const                      { return ui_dp_shortname(mh_flags); }

  static bool ui_linediff(uint32 _mh_flags)         { return (_mh_flags & MH_UI_DP_NOLINEDIFF) == 0; }
  bool ui_linediff() const                          { return ui_linediff(mh_flags); }

  static bool ui_indent(uint32 _mh_flags)           { return (_mh_flags & MH_UI_INDENT) != 0; }
  bool ui_indent() const                            { return ui_indent(mh_flags); }
};
 
//------------------------------------------------------------------------

struct moddata_diff_helper_t
{
  const char *module_name = nullptr;      
  const char *netnode_name = nullptr;     
  const idbattr_info_t *fields = nullptr; 
  size_t nfields = 0;                     
  uint32 additional_mh_flags = MH_UI_NODETAILS;
 
  moddata_diff_helper_t(
        const char *_module_name,
        const char *_netnode_name,
        const idbattr_info_t *_fields,
        size_t _nfields)
    : module_name(_module_name),
      netnode_name(_netnode_name),
      fields(_fields),
      nfields(_nfields)
  {
  }
  virtual ~moddata_diff_helper_t() {}
 
  virtual void merge_starting(diff_source_idx_t /*diffidx*/, void * /*module_data*/) {}
  virtual void merge_ending(diff_source_idx_t /*diffidx*/, void * /*module_data*/) {}
  virtual void *get_struc_ptr(merge_data_t &/*md*/, diff_source_idx_t /*diffidx*/, const idbattr_info_t &/*fi*/) { INTERR(2048); }
  virtual void print_diffpos_details(qstrvec_t * /*out*/, const idbattr_info_t &/*fi*/) {}
  virtual bool val2str(qstring * /*out*/, const idbattr_info_t &/*fi*/, uint64 /*value*/) { return false; }
  virtual bool str2val(uint64 * /*out*/, const idbattr_info_t &/*fi*/, const char * /*strvals*/) { return false; }
};

enum nds_flags_t
{
  NDS_IS_BOOL     = 0x0001,   
  NDS_IS_EA       = 0x0002,   
  NDS_IS_RELATIVE = 0x0004,   
  NDS_IS_STR      = 0x0008,   
  NDS_SUPVAL      = 0x0010,   
  NDS_BLOB        = 0x0020,   
  NDS_EV_RANGE    = 0x0040,   
  NDS_EV_FUNC     = 0x0080,   
  NDS_MAP_IDX     = 0x0100,   
  NDS_MAP_VAL     = 0x0200,   
  NDS_VAL8        = 0x1000,   
  NDS_INC         = 0x2000,   
  NDS_UI_ND       = 0x4000,   
};
 
//--------------------------------------------------------------------------
struct merge_node_helper_t
{
  virtual ~merge_node_helper_t() {}

  virtual qstring print_entry_name(uchar /*tag*/, nodeidx_t /*ndx*/, void * /*module_data*/) const { return qstring(); }

  virtual void print_entry_details(qstrvec_t * /*out*/, uchar /*tag*/, nodeidx_t /*ndx*/, void * /*module_data*/) const {}

  virtual void get_column_headers(qstrvec_t * /*headers*/, uchar /*tag*/, void * /*module_data*/) const {}

  virtual bool is_mergeable(uchar /*tag*/, nodeidx_t /*ndx*/) const { return true; }

  virtual netnode get_netnode() const { return BADNODE; }

  virtual void map_scalar(
        nodeidx_t * /*scalar_value*/,
        void * /*module_data*/,
        diff_source_idx_t /*from*/,
        diff_source_idx_t /*to*/) const
  {
  }
  virtual void map_string(
        qstring * /*string_value*/,
        void * /*module_data*/,
        diff_source_idx_t /*from*/,
        diff_source_idx_t /*to*/) const
  {
  }
  virtual void map_value(
        bytevec_t * /*value*/,
        void * /*module_data*/,
        diff_source_idx_t /*from*/,
        diff_source_idx_t /*to*/) const
  {
  }

  virtual void refresh(uchar /*tag*/, void * /*module_data*/) {}

  virtual const char *get_logname() const { return nullptr; }

  static void append_eavec(qstring *s, const char *prefix, const eavec_t &eas)
  {
    s->append(prefix);
    s->append(" [");
    if ( !eas.empty() )
    {
      for ( const auto ea : eas )
        s->cat_sprnt("%a,", ea);
      s->remove_last();
    }
    s->append(']');
  }
};
typedef merge_node_helper_t *merge_node_helper_creator_t(merge_data_t &md, int dbctx_id);
using merge_node_hlpfunc_creator_t = std::function<merge_node_helper_creator_t>;
 
//--------------------------------------------------------------------------
struct merge_node_info_t
{
  const char *name; 
  uchar tag;        
  uint32 nds_flags; 
  merge_node_helper_creator_t *nhc;
};
DECLARE_TYPE_AS_MOVABLE(merge_node_info_t);
struct merge_node_info2_t
{
  const char *name; 
  uchar tag;        
  uint32 nds_flags; 
  merge_node_helper_t *node_helper;
};
DECLARE_TYPE_AS_MOVABLE(merge_node_info2_t);

idaman merge_handler_t *ida_export create_nodeval_merge_handler(
        const merge_handler_params_t &mhp,
        const char *label,
        int moddata_id,
        const char *nodename,
        uchar tag,
        uint32 nds_flags,
        merge_node_hlpfunc_creator_t nhc = nullptr,
        bool skip_empty_nodes = true);
idaman merge_handler_t *ida_export create_nodeval_merge_handler2(
        const merge_handler_params_t &mhp,
        const char *label,
        int moddata_id,
        const char *nodename,
        uchar tag,
        uint32 nds_flags,
        merge_node_helper_t *node_helper = nullptr,    // owned by the caller
        bool skip_empty_nodes = true);

idaman void ida_export create_nodeval_merge_handlers(
        merge_handlers_t *out,
        const merge_handler_params_t &mhp,
        int moddata_id,
        const char *nodename,
        const merge_node_info_t *valdesc,
        size_t nvals,
        bool skip_empty_nodes = true);
idaman void ida_export create_nodeval_merge_handlers2(
        merge_handlers_t *out,
        const merge_handler_params_t &mhp,
        int moddata_id,
        const char *nodename,
        const merge_node_info2_t *valdesc,
        size_t nvals,
        bool skip_empty_nodes = true);
 
//------------------------------------------------------------------------
// macros for convenience to be used in modules:

#define IDI_FLDENTRY(struc, field, mask, valmap, name)                  \
  { name,                              /* field description          */ \
    qoffsetof(struc, field),           /* offset                     */ \
    sizeof(struc::field),              /* width                      */ \
    mask,                              /* bitmask                    */ \
    0,                                 /* tag (for node values only) */ \
    valmap,                            /* vmap                       */ \
    nullptr,                           /* individual_node            */ \
    IDI_STRUCFLD|IDI_SCALAR }          /* flags                      */

#define IDI_FLDQSTR(struc, field, name) \
  { name, qoffsetof(struc, field), 0, 0, 0, nullptr, nullptr, IDI_STRUCFLD|IDI_QSTRING }

#define IDI_ALTENTRY(altidx, tag, width, mask, valmap, name)            \
  { name,                              /* field description          */ \
    uintptr_t(altidx),                 /* altval index               */ \
    width,                             /* width                      */ \
    mask,                              /* bitmask                    */ \
    tag,                               /* tag (for node values only) */ \
    valmap,                            /* vmap                       */ \
    nullptr,                           /* individual_node            */ \
    IDI_ALTVAL|IDI_SCALAR }            /* flags                      */

#define IDI_HASHENTRY(hashname, tag, width, mask, flag, valmap, name)   \
  { name,                              /* field description          */ \
    uintptr_t(hashname),               /* hash name                  */ \
    width,                             /* width                      */ \
    mask,                              /* bitmask                    */ \
    tag,                               /* tag (for node values only) */ \
    valmap,                            /* vmap                       */ \
    nullptr,                           /* individual_node            */ \
    IDI_HASH|(flag) }                  /* flags                      */

#define IDI_SUPSTR(altidx, tag, name) \
  { name, uintptr_t(altidx), 0, 0, tag, nullptr, nullptr, IDI_SUPVAL|IDI_CSTR }

#define IDI_DEVICE_ENTRY IDI_SUPSTR(-1, stag, "device")

#define MNI_ENTRY(tag, flags, name, helper) \
  { name, tag, NDS_MAP_IDX|NDS_EV_RANGE|(flags), helper }

#define MNI_FUNCENTRY(tag, flags, name) \
  MNI_ENTRY(tag, NDS_EV_FUNC|(flags), name, nullptr)

#define MNI_STDENTRY(tag, flags, name) MNI_ENTRY(tag, flags, name, nullptr)
//------------------------------------------------------------------------
idaman void ida_export destroy_moddata_merge_handlers(int data_id);
 
#ifdef ui_switch_dbctx_guard
  #define switch_dbctx ui_switch_dbctx_guard
#endif
 
//------------------------------------------------------------------------
idaman ssize_t ida_export get_ea_diffpos_name(qstring *out, ea_t ea);
#endif // _MERGE_HPP