frame.hpp

Go to the documentation of this file.

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

 
// name of stkvar to denote the return address slot
#define FRAME_UDM_NAME_R "__return_address"
// name of stkvar to denote the saved register slots
#define FRAME_UDM_NAME_S "__saved_registers"
 
class op_t;
 
// We need to trace value of SP register. For this we introduce
// an array of SP register change points.
 
// SP register change point
//
// NOTE: To manipulate/modify stack points, please use the specialized
// functions provided below in this file (stack pointer change points)
 
struct stkpnt_t
{
  ea_t ea;              // linear address
  sval_t spd;           // here we keep a cumulative difference from [BP-frsize]
 
  DECLARE_COMPARISONS(stkpnt_t)
  {
    if ( ea < r.ea )
      return -1;
    if ( ea > r.ea )
      return 1;
    return 0;
  }
};
DECLARE_TYPE_AS_MOVABLE(stkpnt_t);
// we declare a struct to be able to forward declare it in other files
struct stkpnts_t : public qvector<stkpnt_t>
{
  DECLARE_COMPARISONS(stkpnts_t) { return compare_containers(*this, r); }
};

struct llabel_t
{
  ea_t ea = BADADDR;          
  qstring name;               
 
  DECLARE_COMPARISONS(llabel_t)
  {
    if ( ea < r.ea )
      return -1;
    if ( ea > r.ea )
      return 1;
    return 0;
  }
};
DECLARE_TYPE_AS_MOVABLE(llabel_t);
typedef qvector<llabel_t> llabels_t;
 
//--------------------------------------------------------------------------
//      F R A M E   M A N I P U L A T I O N
//--------------------------------------------------------------------------

 
idaman DEPRECATED bool ida_export add_frame(
        func_t *pfn,
        sval_t frsize,
        ushort frregs,
        asize_t argsize);
 

 
idaman DEPRECATED bool ida_export del_frame(func_t *pfn);
 

 
idaman DEPRECATED bool ida_export set_frame_size(
        func_t *pfn,
        asize_t frsize,
        ushort frregs,
        asize_t argsize);
 

 
idaman DEPRECATED asize_t ida_export get_frame_size(const func_t *pfn);
 

 
idaman DEPRECATED int ida_export get_frame_retsize(const func_t *pfn);

enum frame_part_t
{
  FPC_ARGS,
  FPC_RETADDR,
  FPC_SAVREGS,
  FPC_LVARS,
};

 
idaman DEPRECATED void ida_export get_frame_part(range_t *range, const func_t *pfn, frame_part_t part);

 
idaman DEPRECATED bool ida_export get_func_frame(tinfo_t *out, const func_t *pfn);
 

 
DEPRECATED inline sval_t soff_to_fpoff(func_t *pfn, uval_t soff)
{
  return pfn != nullptr ? soff - pfn->frsize + pfn->fpd : soff;
}
 

 
idaman DEPRECATED bool ida_export update_fpd(func_t *pfn, asize_t fpd);
 

 
idaman bool ida_export set_purged(ea_t ea, int nbytes, bool override_old_value);
 
 
//--------------------------------------------------------------------------
//      S T A C K   V A R I A B L E S
//--------------------------------------------------------------------------

 
idaman bool ida_export add_stkvar(
        const insn_t &insn,
        const op_t &x,
        sval_t v,
        int stkvar_flags);

#define STKVAR_VALID_SIZE       0x0001 
#define STKVAR_KEEP_EXISTING    0x0002 

 
idaman DEPRECATED bool ida_export define_stkvar(
        func_t *pfn,
        const char *name,
        sval_t off,
        const tinfo_t &tif,
        const struct value_repr_t *repr=nullptr);
 

 
idaman DEPRECATED bool ida_export add_frame_member(
        const func_t *pfn,
        const char *name,
        uval_t offset,
        const tinfo_t &tif,
        const struct value_repr_t *repr=nullptr,
        uint etf_flags=0);
 

 
inline THREAD_SAFE bool is_anonymous_member_name(const char *name)
{
  return name == nullptr
      || strncmp(name, "anonymous", 9) == 0;
}
 

 
inline THREAD_SAFE bool is_dummy_member_name(const char *name)
{
  return name == nullptr
      || strncmp(name, "arg_", 4) == 0
      || strncmp(name, "var_", 4) == 0
      || is_anonymous_member_name(name);
}
 

 
idaman bool ida_export is_special_frame_member(tid_t tid);
 

 
idaman DEPRECATED bool ida_export set_frame_member_type(
        const func_t *pfn,
        uval_t offset,
        const tinfo_t &tif,
        const struct value_repr_t *repr=nullptr,
        uint etf_flags=0);
 

 
idaman DEPRECATED bool ida_export delete_frame_members(
        const func_t *pfn,
        uval_t start_offset,
        uval_t end_offset);
 

 
idaman DEPRECATED ssize_t ida_export build_stkvar_name(
        qstring *buf,
        const func_t *pfn,
        sval_t v);
 

 
idaman DEPRECATED ea_t ida_export calc_stkvar_struc_offset(
        func_t *pfn,
        const insn_t &insn,
        int n);
 

 
idaman DEPRECATED sval_t ida_export calc_frame_offset(
        func_t *pfn,
        sval_t off,
        const insn_t *insn = nullptr,
        const op_t *op = nullptr);
 

 
idaman DEPRECATED int ida_export delete_wrong_frame_info(
        func_t *pfn,
        bool idaapi should_reanalyze(const insn_t &insn));
 
 
//--------------------------------------------------------------------------
//      R E G I S T E R   V A R I A B L E S
//--------------------------------------------------------------------------
struct regvar_t;
#define DECLARE_REGVAR_T_HELPERS(decl)\
decl int ida_export regvar_t__compare(const regvar_t &l, const regvar_t &r); \
 
DECLARE_REGVAR_T_HELPERS(idaman)
 

 
idaman void ida_export free_regvar(struct regvar_t *v);

struct regvar_t : public range_t
{
  char *canon = nullptr; 
  char *user = nullptr;  
  char *cmt = nullptr;   
 
  regvar_t() {}
  regvar_t(const regvar_t &r) : range_t(r)
  {
    canon = ::qstrdup(r.canon);
    user = ::qstrdup(r.user);
    cmt = ::qstrdup(r.cmt);
  }
  ~regvar_t() { free_regvar(this); }
  regvar_t &operator=(const regvar_t &r)
  {
    if ( this != &r )
    {
      free_regvar(this);
      new (this) regvar_t(r);
    }
    return *this;
  }
  void swap(regvar_t &r)
  {
    std::swap(start_ea, r.start_ea);
    std::swap(end_ea, r.end_ea);
    std::swap(canon, r.canon);
    std::swap(user, r.user);
    std::swap(cmt, r.cmt);
  }
 
  DECLARE_COMPARISONS(regvar_t) { return regvar_t__compare(*this, r); }
 
  DECLARE_REGVAR_T_HELPERS(friend)
};
DECLARE_TYPE_AS_MOVABLE(regvar_t);
typedef qvector<regvar_t> regvars_t;

 
idaman DEPRECATED int ida_export add_regvar(
        func_t *pfn,
        ea_t ea1,
        ea_t ea2,
        const char *canon,
        const char *user,
        const char *cmt);

 
idaman DEPRECATED regvar_t *ida_export find_regvar(func_t *pfn, ea_t ea1, ea_t ea2, const char *canon, const char *user);
 

 
DEPRECATED inline regvar_t *find_regvar(func_t *pfn, ea_t ea, const char *canon)
{
  if ( pfn == nullptr )
    return nullptr;
GCC_DIAG_OFF(deprecated-declarations)
MSC_DIAG_OFF(4996)
  return find_regvar(pfn, ea, ea+1, canon, nullptr);
MSC_DIAG_ON(4996)
GCC_DIAG_ON(deprecated-declarations)
}
 

 
idaman DEPRECATED int ida_export rename_regvar(func_t *pfn, regvar_t *v, const char *user);
 

 
idaman DEPRECATED int ida_export set_regvar_cmt(func_t *pfn, regvar_t *v, const char *cmt);
 

 
idaman DEPRECATED int ida_export del_regvar(func_t *pfn, ea_t ea1, ea_t ea2, const char *canon);

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

 
idaman DEPRECATED bool ida_export add_auto_stkpnt(func_t *pfn, ea_t ea, sval_t delta);
 

 
idaman bool ida_export add_user_stkpnt(ea_t ea, sval_t delta);
 

 
idaman DEPRECATED bool ida_export del_stkpnt(func_t *pfn, ea_t ea);
 

 
idaman DEPRECATED sval_t ida_export get_spd(func_t *pfn, ea_t ea);
 

 
idaman DEPRECATED sval_t ida_export get_effective_spd(func_t *pfn, ea_t ea);
 

 
idaman DEPRECATED sval_t ida_export get_sp_delta(func_t *pfn, ea_t ea);
 

 
idaman DEPRECATED bool ida_export set_auto_spd(func_t *pfn, ea_t ea, sval_t new_spd);
 

 
idaman bool ida_export recalc_spd(ea_t cur_ea);
 

 
idaman DEPRECATED bool ida_export recalc_spd_for_basic_block(func_t *pfn, ea_t cur_ea);
 

struct xreflist_entry_t
{
  ea_t ea;     
  uchar opnum; 
  uchar type;  
 
  DECLARE_COMPARISONS(xreflist_entry_t)
  {
    int code = ::compare(ea, r.ea);
    if ( code == 0 )
    {
      code = ::compare(type, r.type);
      if ( code == 0 )
        code = ::compare(opnum, r.opnum);
    }
    return code;
  }
};
DECLARE_TYPE_AS_MOVABLE(xreflist_entry_t);
typedef qvector<xreflist_entry_t> xreflist_t; 

 
idaman DEPRECATED void ida_export build_stkvar_xrefs(xreflist_t *out, func_t *pfn, uval_t start_offset, uval_t end_offset);
 
 
//--------------------------------------------------------------------
//      E A - B A S E D   F R A M E   A P I
//--------------------------------------------------------------------
 
//--------------------------------------------------------------------------
//      E A - B A S E D   F R A M E   M A N I P U L A T I O N
//--------------------------------------------------------------------------

 
idaman bool ida_export add_frame_ea(
        ea_t func_ea,
        sval_t frsize,
        ushort frregs,
        asize_t argsize);
 

 
idaman bool ida_export del_frame_ea(ea_t func_ea);
 

 
idaman bool ida_export set_frame_size_ea(
        ea_t func_ea,
        asize_t frsize,
        ushort frregs,
        asize_t argsize);
 

 
idaman asize_t ida_export get_frame_size_ea(ea_t func_ea);
 

 
idaman int ida_export get_frame_retsize_ea(ea_t func_ea);
 

 
idaman bool ida_export get_frame_part_ea(range_t *range, ea_t func_ea, frame_part_t part);
 

 
inline ea_t frame_off_args_ea(ea_t func_ea)
{
  range_t range;
  if ( !get_frame_part_ea(&range, func_ea, FPC_ARGS) )
    return BADADDR;
  return range.start_ea;
}

 
inline ea_t frame_off_retaddr_ea(ea_t func_ea)
{
  range_t range;
  if ( !get_frame_part_ea(&range, func_ea, FPC_RETADDR) )
    return BADADDR;
  return range.start_ea;
}

 
inline ea_t frame_off_savregs_ea(ea_t func_ea)
{
  range_t range;
  if ( !get_frame_part_ea(&range, func_ea, FPC_SAVREGS) )
    return BADADDR;
  return range.start_ea;
}

 
inline ea_t frame_off_lvars_ea(ea_t func_ea)
{
  range_t range;
  if ( !get_frame_part_ea(&range, func_ea, FPC_LVARS) )
    return BADADDR;
  return range.start_ea;
}

 
inline bool processor_t::is_funcarg_off_ea(ea_t func_ea, uval_t frameoff) const
{
  range_t args;
  if ( !get_frame_part_ea(&args, func_ea, FPC_ARGS) )
    return false;
  return stkup()
       ? frameoff < args.end_ea
       : frameoff >= args.start_ea;
}

 
inline sval_t processor_t::lvar_off_ea(ea_t func_ea, uval_t frameoff) const
{
  range_t lvars;
  if ( !get_frame_part_ea(&lvars, func_ea, FPC_LVARS) )
    return 0;
  return stkup()
       ? frameoff - lvars.start_ea
       : lvars.end_ea - frameoff;
}

 
DEPRECATED inline ea_t frame_off_args(const func_t *pfn) { return pfn != nullptr ? frame_off_args_ea(pfn->start_ea) : BADADDR; }

 
DEPRECATED inline ea_t frame_off_retaddr(const func_t *pfn) { return pfn != nullptr ? frame_off_retaddr_ea(pfn->start_ea) : BADADDR; }

 
DEPRECATED inline ea_t frame_off_savregs(const func_t *pfn) { return pfn != nullptr ? frame_off_savregs_ea(pfn->start_ea) : BADADDR; }

 
DEPRECATED inline ea_t frame_off_lvars(const func_t *pfn) { return pfn != nullptr ? frame_off_lvars_ea(pfn->start_ea) : BADADDR; }

 
DEPRECATED inline bool processor_t::is_funcarg_off(const func_t *pfn, uval_t frameoff) const
{
  if ( pfn == nullptr )
    return false;
  range_t args;
  if ( !get_frame_part_ea(&args, pfn->start_ea, FPC_ARGS) )
    return false;
  return stkup()
       ? frameoff < args.end_ea
       : frameoff >= args.start_ea;
}

 
DEPRECATED inline sval_t processor_t::lvar_off(const func_t *pfn, uval_t frameoff) const
{
  if ( pfn == nullptr )
    return 0;
  range_t lvars;
  if ( !get_frame_part_ea(&lvars, pfn->start_ea, FPC_LVARS) )
    return 0;
  return stkup()
       ? frameoff - lvars.start_ea
       : lvars.end_ea - frameoff;
}

 
idaman bool ida_export get_func_frame_ea(tinfo_t *out, ea_t func_ea);
 
inline bool get_func_frame(tinfo_t *tif, ea_t ea) { return get_func_frame_ea(tif, ea); }
 

 
idaman sval_t ida_export soff_to_fpoff_ea(ea_t func_ea, uval_t soff);
 

 
idaman bool ida_export update_fpd_ea(ea_t func_ea, asize_t fpd);

 
 
//--------------------------------------------------------------------------
//      E A - B A S E D   S T A C K   V A R I A B L E S
//--------------------------------------------------------------------------

 
idaman bool ida_export define_stkvar_ea(
        ea_t func_ea,
        const char *name,
        sval_t off,
        const tinfo_t &tif,
        const struct value_repr_t *repr=nullptr);
 

 
idaman bool ida_export add_frame_member_ea(
        ea_t func_ea,
        const char *name,
        uval_t offset,
        const tinfo_t &tif,
        const struct value_repr_t *repr=nullptr,
        uint etf_flags=0);
 

 
idaman bool ida_export set_frame_member_type_ea(
        ea_t func_ea,
        uval_t offset,
        const tinfo_t &tif,
        const struct value_repr_t *repr=nullptr,
        uint etf_flags=0);
 

 
idaman bool ida_export delete_frame_members_ea(
        ea_t func_ea,
        uval_t start_offset,
        uval_t end_offset);
 

 
idaman ssize_t ida_export build_stkvar_name_ea(
        qstring *buf,
        ea_t func_ea,
        sval_t v);
 

 
idaman ea_t ida_export calc_stkvar_struc_offset_ea(
        ea_t func_ea,
        const insn_t &insn,
        int n);
 

 
idaman sval_t ida_export calc_frame_offset_ea(
        ea_t func_ea,
        sval_t off,
        const insn_t *insn=nullptr,
        const op_t *op=nullptr);
 

 
idaman int ida_export delete_wrong_frame_info_ea(
        ea_t func_ea,
        bool idaapi should_reanalyze(const insn_t &insn));
 

 
idaman void ida_export build_stkvar_xrefs_ea(
        xreflist_t *out,
        ea_t func_ea,
        uval_t start_offset,
        uval_t end_offset);

 
 
//--------------------------------------------------------------------------
//      E A - B A S E D   R E G I S T E R   V A R I A B L E S
//--------------------------------------------------------------------------

 
idaman int ida_export add_func_regvar(
        ea_t func_ea,
        ea_t ea1,
        ea_t ea2,
        const char *canon,
        const char *user,
        const char *cmt);
#define REGVAR_ERROR_OK         0     
#define REGVAR_ERROR_ARG        (-1)  
#define REGVAR_ERROR_RANGE      (-2)  
#define REGVAR_ERROR_NAME       (-3)  
 

 
idaman ssize_t ida_export find_func_regvar(
        regvar_t *rv,
        ea_t func_ea,
        ea_t ea1,
        ea_t ea2,
        const char *canon,
        const char *user);
 

 
inline ssize_t find_func_regvar(regvar_t *rv, ea_t func_ea, ea_t ea, const char *canon)
{
  return find_func_regvar(rv, func_ea, ea, ea+1, canon, nullptr);
}
 

 
inline bool has_func_regvar(ea_t func_ea, ea_t ea)
{
  return find_func_regvar(nullptr, func_ea, ea, ea+1, nullptr, nullptr) != -1;
}
 

 
DEPRECATED inline bool has_regvar(func_t *pfn, ea_t ea) { return pfn != nullptr && has_func_regvar(pfn->start_ea, ea); }
 

 
idaman int ida_export rename_func_regvar(ea_t func_ea, ssize_t index, const char *user);
 

 
idaman int ida_export set_func_regvar_cmt(ea_t func_ea, ssize_t index, const char *cmt);
 

 
idaman int ida_export set_func_regvar_range(ea_t func_ea, ssize_t index, const range_t &range);
 

 
idaman int ida_export del_func_regvar(ea_t func_ea, ea_t ea1, ea_t ea2, const char *canon);
 

 
idaman size_t ida_export get_func_regvar_qty(ea_t func_ea);
 

 
idaman bool ida_export get_func_regvars(regvars_t *out, ea_t func_ea);
 

 
idaman bool ida_export get_func_regvar(regvar_t *out, ea_t func_ea, ssize_t index);
 

 
 
//--------------------------------------------------------------------------
//      E A - B A S E D   S P   C H A N G E   P O I N T S
//--------------------------------------------------------------------------

 
idaman bool ida_export add_func_auto_stkpnt(ea_t func_ea, ea_t ea, sval_t delta);
 

 
idaman bool ida_export del_func_stkpnt(ea_t func_ea, ea_t ea);
 

 
idaman sval_t ida_export get_func_spd(ea_t func_ea, ea_t ea);
 

 
idaman sval_t ida_export get_func_effective_spd(ea_t func_ea, ea_t ea);
 

 
idaman sval_t ida_export get_func_sp_delta(ea_t func_ea, ea_t ea);
 

 
idaman bool ida_export set_func_auto_spd(ea_t func_ea, ea_t ea, sval_t new_spd);
 

 
idaman bool ida_export recalc_func_spd_for_basic_block(ea_t func_ea, ea_t cur_ea);
 

 
idaman size_t ida_export get_func_stkpnt_qty(ea_t func_ea);
 

 
idaman bool ida_export get_func_stkpnts(stkpnts_t *out, ea_t func_ea);

 
 
//--------------------------------------------------------------------------
//      E A - B A S E D   L O C A L   L A B E L S
//--------------------------------------------------------------------------

 
idaman size_t ida_export get_func_llabel_qty(ea_t func_ea);
 

 
idaman bool ida_export get_func_llabels(llabels_t *out, ea_t func_ea);


 
#endif // _FRAME_HPP