fixup.hpp

Go to the documentation of this file.

/*
 *      Interactive disassembler (IDA).
 *      Copyright (c) 1990-2026 Hex-Rays
 *      ALL RIGHTS RESERVED.
 *
 */
 
#ifndef FIXUP_HPP
#define FIXUP_HPP
 
#include <nalt.hpp>
#include <segment.hpp>
struct kdata_t;

 
//--------------------------------------------------------------------------
 
typedef uint16 fixup_type_t;  
#define FIXUP_OFF8       13     
#define FIXUP_OFF16       1     
#define FIXUP_SEG16       2     
#define FIXUP_PTR16       3     
#define FIXUP_OFF32       4     
#define FIXUP_PTR32       5     
#define FIXUP_HI8         6     
#define FIXUP_HI16        7     
#define FIXUP_LOW8        8     
#define FIXUP_LOW16       9     
#define V695_FIXUP_VHIGH 10     
#define V695_FIXUP_VLOW  11     
#define FIXUP_OFF64      12     
#define FIXUP_OFF8S      14     
#define FIXUP_OFF16S     15     
#define FIXUP_OFF32S     16     
//#define FIXUP_          0xE
#define FIXUP_CUSTOM 0x8000     

inline THREAD_SAFE bool is_fixup_custom(fixup_type_t type)
{
  return (type & FIXUP_CUSTOM) != 0;
}


#define FIXUPF_REL         0x0001
#define FIXUPF_EXTDEF      0x0002
#define FIXUPF_UNUSED      0x0004
#define FIXUPF_CREATED     0x0008
#define FIXUPF_LOADER_MASK 0xF0000000
 
struct fixup_handler_t;
struct fixup_data_t
{
protected:
  fixup_type_t type = 0;    // fixup type
  uint32 flags = 0;         // FIXUPF_... bits
  uval_t base = 0;          // base for relative fixups
 
public:
  sel_t sel = BADSEL;       
 
  ea_t off = 0;             
 
  adiff_t displacement = 0; 
 
public:
  fixup_data_t() {}
  fixup_data_t(fixup_type_t type_, uint32 flags_ = 0)
    : type(type_),
      flags(flags_) {}

  fixup_type_t get_type(void) const { return type; }
  void set_type(fixup_type_t type_) { type = type_; }
  void set_type_and_flags(fixup_type_t type_, uint32 flags_ = 0)
  {
    type = type_;
    flags = flags_;
  }
 
  bool is_custom(void) const;       

  uint32 get_flags() const { return flags; }
 
  bool is_extdef(void) const { return (flags & FIXUPF_EXTDEF) != 0; }
  void set_extdef(void) { flags |= FIXUPF_EXTDEF; }
  void clr_extdef(void) { flags &= ~FIXUPF_EXTDEF; }
 
  bool is_unused(void) const { return (flags & FIXUPF_UNUSED) != 0; }
  void set_unused(void) { flags |= FIXUPF_UNUSED; }
  void clr_unused(void) { flags &= ~FIXUPF_UNUSED; }

  bool has_base(void) const { return (flags & FIXUPF_REL) != 0; }

  bool was_created(void) const { return (flags & FIXUPF_CREATED) != 0; }

  ea_t get_base() const
  {
    return has_base() ? base : sel != BADSEL ? sel2ea(sel) : 0;
  }

  void set_base(ea_t new_base)
  {
    ea_t target = get_base() + off;
    flags |= FIXUPF_REL;
    base = new_base;
    off = target - base;
  }
 
  void set_sel(sel_t _sel)
  {
    sel = _sel;
  }

  DEPRECATED void set_sel(const segment_t *seg)
  {
    set_sel(seg == nullptr ? BADSEL : seg->sel);
  }

  void set_target_sel()
  {
    ea_t target = get_base() + off;
    segment_info_t seg;
    if ( get_segment_info(&seg, target) )
      set_sel(seg.get_sel());
    else
      set_sel(BADSEL);
    flags &= ~FIXUPF_REL;
    base = 0; // just in case
    off = target - get_base();
  }
 
  void set(ea_t source) const;      
  bool get(ea_t source);            

  const fixup_handler_t *get_handler() const;

  const char *get_desc(qstring *buf, ea_t source) const;
 
  // TODO rewrite to the inline implementation which uses
  // fixup_handler_t::size
  int calc_size() const;            
  uval_t get_value(ea_t ea) const;  
  bool patch_value(ea_t ea) const;  
 
#ifndef SWIG
  friend kdata_t;
  friend void unpack_fixup_ub(fixup_data_t *fd, memory_deserializer_t &mmdsr);
  friend size_t pack_fixup(uchar *buf, size_t bufsize, const fixup_data_t &fd);
  friend void convert_fixups_to_700(dbctx_t &db);
  fixup_data_t(const fixup_data_t &) = default;
  fixup_data_t &operator=(const fixup_data_t &) = default;
  bool operator==(const fixup_data_t &r) const
  {
    return type == r.type
        && flags == r.flags
        && base == r.base
        && sel == r.sel
        && off == r.off
        && displacement == r.displacement;
  }
#endif // SWIG
};

 
idaman bool ida_export get_fixup(fixup_data_t *fd, ea_t source);
 

 
inline bool exists_fixup(ea_t source)
{
  return get_fixup(nullptr, source);
}
 

 
idaman void ida_export set_fixup(ea_t source, const fixup_data_t &fd);
 

 
idaman void ida_export del_fixup(ea_t source);
 

idaman ea_t ida_export get_first_fixup_ea(void);

idaman ea_t ida_export get_next_fixup_ea(ea_t ea);

idaman ea_t ida_export get_prev_fixup_ea(ea_t ea);
 

 
idaman const fixup_handler_t * ida_export get_fixup_handler(fixup_type_t type);
 

 
idaman bool ida_export apply_fixup(ea_t item_ea, ea_t fixup_ea, int n, bool is_macro);
 

 
idaman uval_t ida_export get_fixup_value(ea_t ea, fixup_type_t type);
 

 
idaman bool ida_export patch_fixup_value(ea_t ea, const fixup_data_t &fd);
 

 
idaman const char *ida_export get_fixup_desc(
        qstring *buf,
        ea_t source,
        const fixup_data_t &fd);
 

 
idaman int ida_export calc_fixup_size(fixup_type_t type);
 
 
//--------------------------------------------------------------------------
// inline implementation
inline bool fixup_data_t::is_custom(void) const
{
  return is_fixup_custom(type);
}
inline void fixup_data_t::set(ea_t source) const
{
  set_fixup(source, *this);
}
 
inline bool fixup_data_t::get(ea_t source)
{
  return get_fixup(this, source);
}
 
inline const char *fixup_data_t::get_desc(qstring *buf, ea_t source) const
{
  return get_fixup_desc(buf, source, *this);
}
 
inline int fixup_data_t::calc_size() const
{
  return calc_fixup_size(type);
}
 
inline uval_t fixup_data_t::get_value(ea_t ea) const
{
  return get_fixup_value(ea, type);
}
 
inline bool fixup_data_t::patch_value(ea_t ea) const
{
  return patch_fixup_value(ea, *this);
}
 
inline const fixup_handler_t *fixup_data_t::get_handler() const
{
  return get_fixup_handler(type);
}
 

 
//--------------------------------------------------------------------------
struct fixup_handler_t
{
  int32 cbsize;       
  const char *name;   
  uint32 props;       
#define FHF_VERIFY     0x0001 
#define FHF_CODE       0x0002 
#define FHF_FORCE_CODE 0x0004 
#define FHF_ABS_OPVAL  0x0008 
#define FHF_SIGNED     0x0010 
  bool is_signed() const { return (props & FHF_SIGNED) != 0; }

  uint8 size;         
  uint8 width;        
  uint8 shift;        
  uint8 rsrv4;        // reserved
 
  uint32 reftype;     

  bool (idaapi *apply)(
          const fixup_handler_t *fh,
          ea_t item_ea,
          ea_t fixup_ea,
          int opnum,
          bool is_macro,
          const fixup_data_t &fd);

  uval_t (idaapi *get_value)(const fixup_handler_t *fh, ea_t ea);

  bool (idaapi *patch_value)(
          const fixup_handler_t *fh,
          ea_t ea,
          const fixup_data_t &fd);
 
#ifndef SWIG
  DECLARE_COMPARISONS(fixup_handler_t);
#endif
};
 



 

 
idaman fixup_type_t ida_export register_custom_fixup(
        const fixup_handler_t *cfh);
 

 
idaman bool ida_export unregister_custom_fixup(fixup_type_t type);
 

 
idaman fixup_type_t ida_export find_custom_fixup(const char *name);

 
 
//--------------------------------------------------------------------------
 
struct fixup_info_t
{
  ea_t ea;
  fixup_data_t fd;
};
DECLARE_TYPE_AS_MOVABLE(fixup_info_t);
typedef qvector<fixup_info_t> fixups_t;
 
idaman bool ida_export get_fixups(fixups_t *out, ea_t ea, asize_t size);
 

 
inline bool contains_fixups(ea_t ea, asize_t size)
{
  return get_fixups(nullptr, ea, size);
}
 

 
idaman void ida_export gen_fix_fixups(ea_t from, ea_t to, asize_t size);
 

 
idaman bool ida_export handle_fixups_in_macro(
        refinfo_t *ri,
        ea_t ea,
        fixup_type_t other,
        uint32 macro_reft_and_flags);
 
 
#endif // FIXUP_HPP