funcs.hpp

Go to the documentation of this file.

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

 
struct stkpnt_t;                // #include <frame.hpp>
struct regvar_t;                // #include <frame.hpp>
struct llabel_t;                // #include <frame.hpp>
class insn_t;                   // #include <ua.hpp>
 
idaman void ida_export free_regarg(struct regarg_t *v);

struct regarg_t
{
  int reg = 0;
  type_t *type = nullptr;
  char *name = nullptr;
 
  regarg_t() {}
  regarg_t(const regarg_t &r) : reg(r.reg)
  {
    type = (type_t *)::qstrdup((char *)r.type);
    name = ::qstrdup(r.name);
  }
  ~regarg_t() { free_regarg(this); }
  regarg_t &operator=(const regarg_t &r)
  {
    if ( this != &r )
    {
      free_regarg(this);
      new (this) regarg_t(r);
    }
    return *this;
  }
  void swap(regarg_t &r)
  {
    std::swap(reg, r.reg);
    std::swap(type, r.type);
    std::swap(name, r.name);
  }
#ifndef SWIG
  DECLARE_COMPARISONS(regarg_t);
#endif
 
};
DECLARE_TYPE_AS_MOVABLE(regarg_t);
 
//------------------------------------------------------------------------
class func_t : public range_t
{
public:
  uint64 flags;                        
#define FUNC_NORET      0x00000001     
#define FUNC_FAR        0x00000002     
#define FUNC_LIB        0x00000004     
 
#define FUNC_STATICDEF  0x00000008     
 
#define FUNC_FRAME      0x00000010     
#define FUNC_USERFAR    0x00000020     
#define FUNC_HIDDEN     0x00000040     
#define FUNC_THUNK      0x00000080     
#define FUNC_BOTTOMBP   0x00000100     
#define FUNC_NORET_PENDING 0x00200     
#define FUNC_SP_READY   0x00000400     
#define FUNC_FUZZY_SP   0x00000800     
#define FUNC_PROLOG_OK  0x00001000     
#define FUNC_PURGED_OK  0x00004000     
#define FUNC_TAIL       0x00008000     
#define FUNC_LUMINA     0x00010000     
#define FUNC_OUTLINE    0x00020000     
#define FUNC_REANALYZE  0x00040000     
#define FUNC_UNWIND     0x00080000     
#define FUNC_CATCH      0x00100000     
 
#define FUNC_RESERVED   0x8000000000000000LL 

  bool is_far(void) const { return (flags & FUNC_FAR) != 0; }
  bool does_return(void) const { return (flags & FUNC_NORET) == 0; }
  bool analyzed_sp(void) const { return (flags & FUNC_SP_READY) != 0; }
  bool need_prolog_analysis(void) const { return (flags & FUNC_PROLOG_OK) == 0; }
#ifndef SWIG
  union
  {
    struct
    {
#endif // SWIG
      //
      // Stack frame of the function. It is represented as a structure:
      //
      //    +------------------------------------------------+
      //    | function arguments                             |
      //    +------------------------------------------------+
      //    | return address (isn't stored in func_t)        |
      //    +------------------------------------------------+
      //    | saved registers (SI, DI, etc - func_t::frregs) |
      //    +------------------------------------------------+ <- typical BP
      //    |                                                |  |
      //    |                                                |  | func_t::fpd
      //    |                                                |  |
      //    |                                                | <- real BP
      //    | local variables (func_t::frsize)               |
      //    |                                                |
      //    |                                                |
      //    +------------------------------------------------+ <- SP
      //
      uval_t frame;        
      asize_t frsize;      
      ushort frregs;       
      asize_t argsize;     
      asize_t fpd;         
 
      bgcolor_t color;     
 
        // the following fields should not be accessed directly:
 
      uint32 pntqty;       
      stkpnt_t *points;    
 
      int regvarqty;       
      regvar_t *regvars;   
 
      int llabelqty;       
      llabel_t *llabels;   
 
      int regargqty;       
      regarg_t *regargs;   
 
      int tailqty;         
      range_t *tails;      
#ifndef SWIG
    };
    struct
    {
#endif // SWIG
      ea_t owner;          
      int refqty;          
      ea_t *referers;      
#ifndef SWIG
    };
  };
#endif // SWIG
 
  func_t(ea_t start=0, ea_t end=0, flags64_t f=0)
    : range_t(start, end), flags(f|FUNC_NORET_PENDING), frame(BADNODE),
      frsize(0), frregs(0), argsize(0), fpd(0), color(DEFCOLOR),
      pntqty(0), points(nullptr),
      regvarqty(0), regvars(nullptr),
      llabelqty(0), llabels(nullptr),
      regargqty(0), regargs(nullptr),
      tailqty(0), tails(nullptr)
  {
  }
#ifndef SWIG
  DECLARE_COMPARISONS(func_t);
#endif
};
DECLARE_TYPE_AS_MOVABLE(func_t);

inline bool is_func_entry(const func_t *pfn) { return pfn != nullptr && (pfn->flags & FUNC_TAIL) == 0; }
inline bool is_func_tail(const func_t *pfn) { return pfn != nullptr && (pfn->flags & FUNC_TAIL) != 0; }
 

 
idaman void ida_export lock_func_range(const func_t *pfn, bool lock);

class lock_func
{
  const func_t *pfn;
public:
  lock_func(const func_t *_pfn) : pfn(_pfn)
  {
    lock_func_range(pfn, true);
  }
  ~lock_func(void)
  {
    lock_func_range(pfn, false);
  }
};
 
//lint -esym(1788, lock_func_with_tails_t) referenced only by ctr/dtr
class lock_func_with_tails_t
{
  rangeset_t func_ranges;
  void lock_ranges(bool lock);
 
public:
  lock_func_with_tails_t(func_t *pfn);
  ~lock_func_with_tails_t() { lock_ranges(false); }
};

 
idaman bool ida_export is_func_locked(const func_t *pfn);
 
//--------------------------------------------------------------------
//      F U N C T I O N S
//--------------------------------------------------------------------
 
idaman func_t *ida_export get_func(ea_t ea);
 

 
idaman int ida_export get_func_chunknum(func_t *pfn, ea_t ea);

 
inline bool func_contains(func_t *pfn, ea_t ea)
{
  return get_func_chunknum(pfn, ea) >= 0;
}

inline bool is_same_func(ea_t ea1, ea_t ea2)
{
  func_t *pfn = get_func(ea1);
  return pfn != nullptr && func_contains(pfn, ea2);
}

 
idaman func_t *ida_export getn_func(size_t n);
 

 
idaman size_t ida_export get_func_qty(void);
 

 
idaman int ida_export get_func_num(ea_t ea);
 

 
idaman func_t *ida_export get_prev_func(ea_t ea);
 

 
idaman func_t *ida_export get_next_func(ea_t ea);
 

 
idaman ea_t ida_export get_func_ranges(rangeset_t *ranges, func_t *pfn);
 

 
idaman ssize_t ida_export get_func_cmt(qstring *buf, const func_t *pfn, bool repeatable);
 

 
idaman bool ida_export set_func_cmt(const func_t *pfn, const char *cmt, bool repeatable);
 

 
idaman bool ida_export update_func(func_t *pfn);
 

 
idaman bool ida_export add_func_ex(func_t *pfn);
 

 
inline bool add_func(ea_t ea1, ea_t ea2=BADADDR)
{
  func_t fn(ea1, ea2);
  return add_func_ex(&fn);
}
 

 
idaman bool ida_export del_func(ea_t ea);
 

 
idaman int ida_export set_func_start(ea_t ea, ea_t newstart);
#define MOVE_FUNC_OK            0  
#define MOVE_FUNC_NOCODE        1  
#define MOVE_FUNC_BADSTART      2  
#define MOVE_FUNC_NOFUNC        3  
#define MOVE_FUNC_REFUSED       4  
 

 
idaman bool ida_export set_func_end(ea_t ea, ea_t newend);
 

 
idaman void ida_export reanalyze_function(
        func_t *pfn,
        ea_t ea1=0,
        ea_t ea2=BADADDR,
        bool analyze_parents=false);
 

 
idaman int ida_export find_func_bounds(func_t *nfn, int flags);

#define FIND_FUNC_NORMAL   0x0000 
#define FIND_FUNC_DEFINE   0x0001 
#define FIND_FUNC_IGNOREFN 0x0002 
#define FIND_FUNC_KEEPBD   0x0004 

#define FIND_FUNC_UNDEF 0         
#define FIND_FUNC_OK    1         
#define FIND_FUNC_EXIST 2         
 

 
idaman ssize_t ida_export get_func_name(qstring *out, ea_t ea);
 

 
idaman asize_t ida_export calc_func_size(func_t *pfn);
 

 
idaman int ida_export get_func_bitness(const func_t *pfn);

inline int idaapi get_func_bits(const func_t *pfn) { return 1 << (get_func_bitness(pfn)+4); }

inline int idaapi get_func_bytes(const func_t *pfn) { return get_func_bits(pfn)/8; }
 

 
inline bool is_visible_func(func_t *pfn) { return pfn != nullptr && (pfn->flags & FUNC_HIDDEN) == 0; }

inline bool is_finally_visible_func(func_t *pfn)
{
  return (inf_get_cmtflg() & SCF_SHHID_FUNC) != 0 || is_visible_func(pfn);
}

 
idaman void ida_export set_visible_func(func_t *pfn, bool visible);
 

 
idaman int ida_export set_func_name_if_jumpfunc(func_t *pfn, const char *oldname);
 

 
idaman ea_t ida_export calc_thunk_func_target(func_t *pfn, ea_t *fptr);
 

 
idaman bool ida_export func_does_return(ea_t callee);
 

 
idaman bool ida_export reanalyze_noret_flag(ea_t ea);
 

 
idaman bool ida_export set_noret_insn(ea_t insn_ea, bool noret);
 
 
//--------------------------------------------------------------------
//      F U N C T I O N   C H U N K S
//--------------------------------------------------------------------
 
idaman func_t *ida_export get_fchunk(ea_t ea);
 

 
idaman func_t *ida_export getn_fchunk(int n);
 

 
idaman size_t ida_export get_fchunk_qty(void);
 

 
idaman int ida_export get_fchunk_num(ea_t ea);
 

 
idaman func_t *ida_export get_prev_fchunk(ea_t ea);
 

 
idaman func_t *ida_export get_next_fchunk(ea_t ea);
 
 
//--------------------------------------------------------------------
// Functions to manipulate function chunks

 
idaman bool ida_export append_func_tail(func_t *pfn, ea_t ea1, ea_t ea2);
 

 
idaman bool ida_export remove_func_tail(func_t *pfn, ea_t tail_ea);
 

 
idaman bool ida_export set_tail_owner(func_t *fnt, ea_t new_owner);
 
 
// Auxiliary function(s) to be used in func_..._iterator_t
 
class func_parent_iterator_t;
class func_tail_iterator_t;
class func_item_iterator_t;

#define DECLARE_FUNC_ITERATORS(prefix) \
prefix bool ida_export func_tail_iterator_set(func_tail_iterator_t *fti, func_t *pfn, ea_t ea);\
prefix bool ida_export func_tail_iterator_set_ea(func_tail_iterator_t *fti, ea_t ea);\
prefix bool ida_export func_parent_iterator_set(func_parent_iterator_t *fpi, func_t *pfn);\
prefix bool ida_export func_item_iterator_next(func_item_iterator_t *fii, testf_t *testf, void *ud);\
prefix bool ida_export func_item_iterator_prev(func_item_iterator_t *fii, testf_t *testf, void *ud);\
prefix bool ida_export func_item_iterator_decode_prev_insn(func_item_iterator_t *fii, insn_t *out); \
prefix bool ida_export func_item_iterator_decode_preceding_insn(func_item_iterator_t *fii, eavec_t *visited, bool *p_farref, insn_t *out); \
prefix bool ida_export func_item_iterator_succ(func_item_iterator_t *fii, testf_t *testf, void *ud);
DECLARE_FUNC_ITERATORS(idaman)
 

inline THREAD_SAFE bool idaapi f_any(flags64_t, void *) { return true; }

class func_tail_iterator_t
{
  func_t *pfn;
  int idx;
  range_t seglim;        // valid and used only if pfn == nullptr
public:
  func_tail_iterator_t(void) : pfn(nullptr), idx(-1) {}
  func_tail_iterator_t(func_t *_pfn, ea_t ea=BADADDR) : pfn(nullptr) { set(_pfn, ea); }
  ~func_tail_iterator_t(void)
  {
    // if was iterating over function chunks, unlock the main chunk
    if ( pfn != nullptr )
      lock_func_range(pfn, false);
  }
  bool set(func_t *_pfn, ea_t ea=BADADDR) { return func_tail_iterator_set(this, _pfn, ea); }
  bool set_ea(ea_t ea) { return func_tail_iterator_set_ea(this, ea); }
  // set an arbitrary range
  bool set_range(ea_t ea1, ea_t ea2)
  {
    this->~func_tail_iterator_t();
    pfn = nullptr;
    idx = -1;
    seglim = range_t(ea1, ea2);
    return !seglim.empty();
  }
  const range_t &chunk(void) const
  {
    if ( pfn == nullptr )
      return seglim;
    return idx >= 0 && idx < pfn->tailqty ? pfn->tails[idx] : *(range_t*)pfn;
  }
  bool first(void) { if ( pfn != nullptr ) { idx = 0; return pfn->tailqty > 0; } return false; } // get only tail chunks
  bool last(void) { if ( pfn != nullptr ) { idx = pfn->tailqty - 1; return true; } return false; }  // get all chunks (the entry chunk last)
  bool next(void) { if ( pfn != nullptr && idx+1 < pfn->tailqty ) { idx++; return true; } return false; }
  bool prev(void) { if ( idx >= 0 ) { idx--; return true; } return false; }
  bool main(void) { idx = -1; return pfn != nullptr; }  // get all chunks (the entry chunk first)
};
 

 
idaman void ida_export iterate_func_chunks(
        func_t *pfn,
        void (idaapi *func)(ea_t ea1, ea_t ea2, void *ud),
        void *ud=nullptr,
        bool include_parents=false);
 

class func_item_iterator_t
{
  func_tail_iterator_t fti;
  ea_t ea;
public:
  func_item_iterator_t(void) : ea(BADADDR) {}
  func_item_iterator_t(func_t *pfn, ea_t _ea=BADADDR) { set(pfn, _ea); }
  bool set(func_t *pfn, ea_t _ea=BADADDR)
  {
    ea = (_ea != BADADDR || pfn == nullptr) ? _ea : pfn->start_ea;
    return fti.set(pfn, _ea);
  }

  bool set_range(ea_t ea1, ea_t ea2) { ea = ea1; return fti.set_range(ea1, ea2); }
  bool first(void) { if ( !fti.main() ) return false; ea=fti.chunk().start_ea; return true; }
  bool last(void) { if ( !fti.last() ) return false; ea=fti.chunk().end_ea; return true; }
  ea_t current(void) const { return ea; }
  bool set_ea(ea_t _ea)
  {
    if ( !fti.set_ea(_ea) )
      return false;
    ea = _ea;
    return true;
  }
  const range_t &chunk(void) const { return fti.chunk(); }
  bool next(testf_t *func, void *ud) { return func_item_iterator_next(this, func, ud); }
  bool prev(testf_t *func, void *ud) { return func_item_iterator_prev(this, func, ud); }
  bool next_addr(void) { return next(f_any, nullptr); }
  bool next_head(void) { return next(f_is_head, nullptr); }
  bool next_code(void) { return next(f_is_code, nullptr); }
  bool next_data(void) { return next(f_is_data, nullptr); }
  bool next_not_tail(void) { return next(f_is_not_tail, nullptr); }
  bool prev_addr(void) { return prev(f_any, nullptr); }
  bool prev_head(void) { return prev(f_is_head, nullptr); }
  bool prev_code(void) { return prev(f_is_code, nullptr); }
  bool prev_data(void) { return prev(f_is_data, nullptr); }
  bool prev_not_tail(void) { return prev(f_is_not_tail, nullptr); }
  bool decode_prev_insn(insn_t *out) { return func_item_iterator_decode_prev_insn(this, out); }
  bool decode_preceding_insn(eavec_t *visited, bool *p_farref, insn_t *out)
    { return func_item_iterator_decode_preceding_insn(this, visited, p_farref, out); }

  bool succ(testf_t *func, void *ud) { return func_item_iterator_succ(this, func, ud); }
  bool succ_code(void) { return succ(f_is_code, nullptr); }
};

class func_parent_iterator_t
{
  func_t *fnt;
  int idx;
public:
  func_parent_iterator_t(void) : fnt(nullptr), idx(0) {}
  func_parent_iterator_t(func_t *_fnt) : fnt(nullptr) { set(_fnt); }
  ~func_parent_iterator_t(void)
  {
    if ( fnt != nullptr )
      lock_func_range(fnt, false);
  }
  bool set(func_t *_fnt) { return func_parent_iterator_set(this, _fnt); }
  ea_t parent(void) const { return fnt->referers[idx]; }
  bool first(void) { idx = 0; return is_func_tail(fnt) && fnt->refqty > 0; }
  bool last(void) { idx = fnt->refqty - 1; return idx >= 0; }
  bool next(void) { if ( idx+1 < fnt->refqty ) { idx++; return true; } return false; }
  bool prev(void) { if ( idx > 0 ) { idx--; return true; } return false; }
  void reset_fnt(func_t *_fnt) { fnt = _fnt; } // for internal use only!
};
 

idaman ea_t ida_export get_prev_func_addr(func_t *pfn, ea_t ea);
idaman ea_t ida_export get_next_func_addr(func_t *pfn, ea_t ea);
 
//--------------------------------------------------------------------
idaman void ida_export read_regargs(func_t *pfn);
idaman void ida_export add_regarg(func_t *pfn, int reg, const tinfo_t &tif, const char *name);
 
//--------------------------------------------------------------------
//      L I B R A R Y   M O D U L E   S I G N A T U R E S
//--------------------------------------------------------------------

#define IDASGN_OK       0       
#define IDASGN_BADARG   1       
#define IDASGN_APPLIED  2       
#define IDASGN_CURRENT  3       
#define IDASGN_PLANNED  4       

 
idaman int ida_export plan_to_apply_idasgn(const char *fname); // plan to use library
 

 
idaman int ida_export apply_idasgn_to(const char *signame, ea_t ea, bool is_startup);
 

 
idaman int ida_export get_idasgn_qty(void);
 

 
idaman int ida_export get_current_idasgn(void);
 

 
idaman int ida_export calc_idasgn_state(int n);
 

 
idaman int ida_export del_idasgn(int n);
 

 
idaman int32 ida_export get_idasgn_desc(
        qstring *signame,
        qstring *optlibs,
        int n);

 
idaman ssize_t ida_export get_idasgn_title(
        qstring *buf,
        const char *name);

 
idaman void ida_export determine_rtl(void);
 

 
idaman bool ida_export apply_startup_sig(ea_t ea, const char *startup);
 

 
idaman int ida_export try_to_add_libfunc(ea_t ea);
 

#define LIBFUNC_FOUND   0               
#define LIBFUNC_NONE    1               
#define LIBFUNC_DELAY   2               
 
inline lock_func_with_tails_t::lock_func_with_tails_t(func_t *pfn)
{
  get_func_ranges(&func_ranges, pfn);
  lock_ranges(true);
}
 
inline void lock_func_with_tails_t::lock_ranges(bool lock)
{
  for ( const auto &r : func_ranges )
    lock_func_range(get_fchunk(r.start_ea), lock);
}
 
 
#endif