fixup.hpp

Go to the documentation of this file.

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

 
//--------------------------------------------------------------------------
 
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;    // fixup type
  uint32 flags;         // FIXUPF_... bits
  uval_t base;          // base for relative fixups
 
public:
  sel_t sel;            
 
  ea_t off;             
 
  adiff_t displacement; 
 
public:
  fixup_data_t()
    : type(0),
      flags(0),
      base(0),
      sel(BADSEL),
      off(0),
      displacement(0) {}
  fixup_data_t(fixup_type_t type_, uint32 flags_ = 0)
    : type(type_),
      flags(flags_),
      base(0),
      sel(BADSEL),
      off(0),
      displacement(0) {}

  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(const segment_t *seg)
  {
    sel = seg == nullptr ? BADSEL : seg->sel;
  }

  void set_target_sel()
  {
    ea_t target = get_base() + off;
    set_sel(getseg(target));
    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;  
 
};

 
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