funcs.hpp

Go to the documentation of this file.

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

 
struct stkpnt_t;                // #include <frame.hpp>
struct regvar_t;                // #include <frame.hpp>
struct llabel_core_t;
class insn_t;                   // #include <ua.hpp>
 
idaman void ida_export free_regarg(struct regarg_t *v);
 
struct regarg_t;
#define DECLARE_REGARG_T_HELPERS(decl)\
decl int ida_export regarg_t__compare(const regarg_t &l, const regarg_t &r); \
 
DECLARE_REGARG_T_HELPERS(idaman)
 

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);
  }
 
  DECLARE_COMPARISONS(regarg_t) { return regarg_t__compare(*this, r); }
 
  void serialize(bytevec_t *out) const
  {
    out->pack_dd(reg);
    out->pack_ds((char*)type);
    out->pack_ds(name);
  }
  bool deserialize(memory_deserializer_t &mmdsr)
  {
    reg  = mmdsr.unpack_dd();
    type = (type_t*)mmdsr.unpack_ds(true);
    name = mmdsr.unpack_ds(true);
    return true;
  }
  DECLARE_REGARG_T_HELPERS(friend)
};
DECLARE_TYPE_AS_MOVABLE(regarg_t);
typedef qvector<regarg_t> regargs_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_core_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);

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

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

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

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

 
idaman DEPRECATED 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 DEPRECATED func_t *ida_export get_prev_func(ea_t ea);
 

 
idaman DEPRECATED func_t *ida_export get_next_func(ea_t ea);
 

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

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

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

 
idaman DEPRECATED bool ida_export update_func(func_t *pfn);
 

 
idaman DEPRECATED bool ida_export add_func_ex(func_t *pfn);
 

 
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 DEPRECATED void ida_export reanalyze_function(
        func_t *pfn,
        ea_t ea1=0,
        ea_t ea2=BADADDR,
        bool analyze_parents=false);
 

 
idaman DEPRECATED 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 DEPRECATED asize_t ida_export calc_func_size(func_t *pfn);
 

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

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

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

 
idaman DEPRECATED 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 DEPRECATED func_t *ida_export get_fchunk(ea_t ea);
 

 
idaman DEPRECATED 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 DEPRECATED func_t *ida_export get_prev_fchunk(ea_t ea);
 

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

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

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

 
idaman DEPRECATED bool ida_export set_tail_owner(func_t *fnt, ea_t new_owner);
 
 
//--------------------------------------------------------------------
idaman void ida_export read_regargs(func_t *pfn);
idaman DEPRECATED 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               
 
//--------------------------------------------------------------------
//      E A - B A S E D   F U N C T I O N   A P I
//--------------------------------------------------------------------



 
idaman ea_t ida_export get_func_start(ea_t ea);
 

 
idaman ea_t ida_export get_prev_func_ea(ea_t ea);
 

 
idaman ea_t ida_export get_next_func_ea(ea_t ea);
 

 
idaman ea_t ida_export get_fchunk_start(ea_t ea);
 

 
idaman ea_t ida_export get_prev_fchunk_ea(ea_t ea);
 

 
idaman ea_t ida_export get_next_fchunk_ea(ea_t ea);
 

 
idaman ea_t ida_export get_func_ea_by_num(size_t n);
 

 
idaman ea_t ida_export get_fchunk_ea_by_num(int n);



 
idaman uint64 ida_export get_func_flags(ea_t ea);
 

 
inline bool is_visible_func(ea_t ea)
{
  return get_func_start(ea) != BADADDR && (get_func_flags(ea) & FUNC_HIDDEN) == 0;
}
 

inline bool is_finally_visible_func(ea_t ea)
{
  return (inf_get_cmtflg() & SCF_SHHID_FUNC) != 0 || is_visible_func(ea);
}
 

DEPRECATED inline bool is_visible_func(func_t *pfn) { return pfn != nullptr && is_visible_func(pfn->start_ea); }
 

DEPRECATED inline bool is_finally_visible_func(func_t *pfn) { return pfn != nullptr && is_finally_visible_func(pfn->start_ea); }
 

 
idaman bool ida_export set_func_flags(ea_t ea, uint64 flags);
 

 
idaman bool ida_export set_func_flag(ea_t ea, uint64 flag, bool on_off=true);
 

 
idaman bool ida_export is_function_entry(ea_t ea);
 

 
idaman bool ida_export is_function_tail(ea_t ea);
 

 
idaman ea_t ida_export get_tail_owner(ea_t tail_ea);
 



 
idaman ssize_t ida_export get_func_cmt_ea(qstring *buf, ea_t ea, bool repeatable);
 

 
idaman bool ida_export set_func_cmt_ea(ea_t ea, const char *cmt, bool repeatable);
 

 
idaman int ida_export get_func_bitness_ea(ea_t ea);
 

inline int idaapi get_func_bits_ea(ea_t ea)
{
  return 1 << (get_func_bitness_ea(ea)+4);
}
 

inline int idaapi get_func_bytes_ea(ea_t ea)
{
  return get_func_bits_ea(ea)/8;
}
 

DEPRECATED inline int idaapi get_func_bits(const func_t *pfn) { return pfn != nullptr ? get_func_bits_ea(pfn->start_ea) : 16; }
 

DEPRECATED inline int idaapi get_func_bytes(const func_t *pfn) { return pfn != nullptr ? get_func_bytes_ea(pfn->start_ea) : 2; }
 

 
idaman asize_t ida_export calc_func_size_ea(ea_t ea);
 

 
idaman ea_t ida_export get_func_ranges_ea(rangeset_t *ranges, ea_t ea);
 

 
idaman void ida_export set_visible_func_ea(ea_t ea, bool visible);
 

 
idaman bool ida_export set_function_name_if_jumpfunc(ea_t func_ea, const char *oldname);
 

 
idaman void ida_export reanalyze_function_ea(
        ea_t func_ea,
        ea_t ea1=0,
        ea_t ea2=BADADDR,
        bool analyze_parents=false);
 

 
idaman void ida_export add_func_regarg(ea_t func_ea, int reg, const tinfo_t &tif, const char *name);
 

 
idaman size_t ida_export get_func_regarg_qty(ea_t func_ea);
 

 
idaman bool ida_export get_func_regarg(regarg_t *out, ea_t func_ea, size_t n);
 

 
idaman bool ida_export get_func_regargs(regargs_t *out, ea_t func_ea);



 
idaman bool ida_export append_func_tail_ea(ea_t func_ea, ea_t ea1, ea_t ea2);
 

 
idaman bool ida_export remove_func_tail_ea(ea_t func_ea, ea_t tail_ea);
 

 
idaman bool ida_export set_tail_owner_ea(ea_t tail_ea, ea_t new_owner);
 

 
idaman int ida_export get_func_chunknum_ea(ea_t func_ea, ea_t ea);
 

 
idaman size_t ida_export get_func_tail_qty(ea_t func_ea);
 

 
idaman bool ida_export get_func_tails(rangevec_t *out, ea_t func_ea);
 

inline bool function_contains(ea_t func_ea, ea_t ea)
{
  return get_func_chunknum_ea(func_ea, ea) >= 0;
}
 

inline bool is_same_func(ea_t ea1, ea_t ea2) { return function_contains(ea1, ea2); }
 

 
idaman bool ida_export is_same_fchunk(ea_t ea1, ea_t ea2);
 

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

typedef std::function<void(ea_t chunk_start, ea_t chunk_end)> func_chunk_visitor_t;
 

 
idaman void ida_export iterate_func_chunks_ea(
        ea_t fchunk_ea,
        const func_chunk_visitor_t &visitor,
        bool include_parents=false);
 

 
idaman ea_t ida_export get_prev_function_addr(ea_t func_ea, ea_t ea);
 

 
idaman ea_t ida_export get_next_function_addr(ea_t func_ea, ea_t ea);



 
idaman void ida_export lock_func_range_ea(ea_t ea, bool lock);
 

 
idaman bool ida_export is_func_locked_ea(ea_t ea);
 

class lock_func_ea
{
  ea_t func_ea;
public:
  lock_func_ea(ea_t ea) : func_ea(ea) { lock_func_range_ea(ea, true); }
  ~lock_func_ea() { lock_func_range_ea(func_ea, false); }
};

class DEPRECATED lock_func
{
  ea_t ea = BADADDR;
public:
  lock_func(const func_t *pfn)
  {
    if ( pfn != nullptr )
    {
      ea = pfn->start_ea;
      lock_func_range_ea(ea, true);
    }
  }
  ~lock_func(void)
  {
    if ( ea != BADADDR )
      lock_func_range_ea(ea, 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)
  {
    for ( const auto &r : func_ranges )
      lock_func_range_ea(r.start_ea, lock);
  }
 
public:
  DEPRECATED lock_func_with_tails_t(func_t *pfn)
  {
    if ( pfn != nullptr )
    {
      get_func_ranges_ea(&func_ranges, pfn->start_ea);
      lock_ranges(true);
    }
  }
  lock_func_with_tails_t(ea_t ea)
  {
    get_func_ranges_ea(&func_ranges, ea);
    lock_ranges(true);
  }
  ~lock_func_with_tails_t() { lock_ranges(false); }
};

 
 
//--------------------------------------------------------------------
// I T E R A T O R S
 
// 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;
class function_tail_iterator_t;
class function_parent_iterator_t;
class function_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); \
prefix bool ida_export function_tail_iterator_set(function_tail_iterator_t *fti, ea_t func_ea, ea_t ea); \
prefix bool ida_export function_tail_iterator_set_ea(function_tail_iterator_t *fti, ea_t ea); \
prefix bool ida_export function_tail_iterator_set_range(function_tail_iterator_t *fti, ea_t ea1, ea_t ea2); \
prefix void ida_export function_tail_iterator_chunk(range_t *out, const function_tail_iterator_t *fti); \
prefix bool ida_export function_tail_iterator_first(function_tail_iterator_t *fti); \
prefix bool ida_export function_tail_iterator_last(function_tail_iterator_t *fti); \
prefix bool ida_export function_tail_iterator_next(function_tail_iterator_t *fti); \
prefix bool ida_export function_tail_iterator_prev(function_tail_iterator_t *fti); \
prefix bool ida_export function_tail_iterator_main(function_tail_iterator_t *fti); \
prefix bool ida_export function_parent_iterator_set(function_parent_iterator_t *fpi, ea_t tail_ea); \
prefix ea_t ida_export function_parent_iterator_parent(const function_parent_iterator_t *fpi); \
prefix bool ida_export function_parent_iterator_first(function_parent_iterator_t *fpi); \
prefix bool ida_export function_parent_iterator_last(function_parent_iterator_t *fpi); \
prefix bool ida_export function_parent_iterator_next(function_parent_iterator_t *fpi); \
prefix bool ida_export function_parent_iterator_prev(function_parent_iterator_t *fpi); \
prefix bool ida_export function_item_iterator_next(function_item_iterator_t *fii, testf_t *testf, void *ud); \
prefix bool ida_export function_item_iterator_prev(function_item_iterator_t *fii, testf_t *testf, void *ud); \
prefix bool ida_export function_item_iterator_succ(function_item_iterator_t *fii, testf_t *testf, void *ud); \
prefix bool ida_export function_item_iterator_decode_prev_insn(function_item_iterator_t *fii, insn_t *out); \
prefix bool ida_export function_item_iterator_decode_preceding_insn(function_item_iterator_t *fii, eavec_t *visited, bool *p_farref, insn_t *out); \
 
DECLARE_FUNC_ITERATORS(idaman)
 

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

class DEPRECATED func_tail_iterator_t
{
  friend struct kdata_t;
  friend class func_item_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_ea(pfn->start_ea, 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 DEPRECATED 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 DEPRECATED func_item_iterator_t
{
  friend struct kdata_t;
  GCC_DIAG_OFF(deprecated-declarations)
  MSC_DIAG_OFF(4996)  // member type and methods are deprecated; suppress
                      // C4996 across the whole class body -- external uses of
                      // the class still emit the deprecation warning.
  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); }
  MSC_DIAG_ON(4996)
  GCC_DIAG_ON(deprecated-declarations)
};

class DEPRECATED func_parent_iterator_t
{
  friend struct kdata_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_ea(fnt->start_ea, 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 fnt != nullptr && is_function_tail(fnt->start_ea) && 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 DEPRECATED ea_t ida_export get_prev_func_addr(func_t *pfn, ea_t ea);

idaman DEPRECATED ea_t ida_export get_next_func_addr(func_t *pfn, ea_t ea);
 
//--------------------------------------------------------------------
//      C O P Y - B A S E D   F U N C T I O N   I N F O   T Y P E S
//--------------------------------------------------------------------

#define GFI_NAME     0x0001  
#define GFI_CMT      0x0002  
#define GFI_CMT_RPT  0x0004  
#define GFI_COMMENTS (GFI_CMT|GFI_CMT_RPT)  
#define GFI_ALL      (GFI_NAME|GFI_COMMENTS) 

class fchunk_info_t : public range_t
{
public:
  fchunk_info_t(ea_t start=0, ea_t end=0)
    : range_t(start, end)
  {}

  bool is_valid() const { return !empty(); }

  bool is_tail() const { return (flags_ & FUNC_TAIL) != 0; }

  bool is_entry() const { return !is_tail(); }

  uint64 get_flags() const { return flags_; }
  void set_flags(uint64 v) { flags_ = v; }

  bool is_far() const { return (flags_ & FUNC_FAR) != 0; }
  bool does_return() const { return (flags_ & FUNC_NORET) == 0; }
  bool analyzed_sp() const { return (flags_ & FUNC_SP_READY) != 0; }
  bool need_prolog_analysis() const { return (flags_ & FUNC_PROLOG_OK) == 0; }
 
protected:
  uint64 flags_ = 0;
 
  friend struct kdata_t;
};
 

 
idaman bool ida_export get_fchunk_info(fchunk_info_t *out, ea_t ea);
 

 
idaman bool ida_export get_prev_fchunk_info(fchunk_info_t *out, ea_t ea);
 

 
idaman bool ida_export get_next_fchunk_info(fchunk_info_t *out, ea_t ea);
 

class func_entry_info_t : public fchunk_info_t
{
public:
  func_entry_info_t(ea_t start=0, ea_t end=0)
    : fchunk_info_t(start, end)
  { flags_ = FUNC_NORET_PENDING; }

  bool has(int gfi_flags) const { return (filled_ & gfi_flags) == gfi_flags; }

  void set_flags(uint64 v) { flags_ = v; updated_ |= FEI_FLAGS; }

  void set_flag(uint64 v, bool cnd=true) { setflag(flags_, v, cnd); updated_ |= FEI_FLAGS; }

  uval_t get_frame_id() const { return frame_; }

  asize_t get_frsize() const { return frsize_; }
  void set_frsize(asize_t v) { frsize_ = v; updated_ |= FEI_FRSIZE; }

  ushort get_frregs() const { return frregs_; }
  void set_frregs(ushort v) { frregs_ = v; updated_ |= FEI_FRREGS; }

  asize_t get_argsize() const { return argsize_; }
  void set_argsize(asize_t v) { argsize_ = v; updated_ |= FEI_ARGSIZE; }

  asize_t get_fpd() const { return fpd_; }
  void set_fpd(asize_t v) { fpd_ = v; updated_ |= FEI_FPD; }

  bgcolor_t get_color() const { return color_; }
  void set_color(bgcolor_t v) { color_ = v; updated_ |= FEI_COLOR; }

  const char *get_name() const { return name_.c_str(); }

  const char *get_cmt() const { return cmt_.c_str(); }

  const char *get_cmt_rpt() const { return cmt_rpt_.c_str(); }
 
private:
  uint64 updated_ = 0;
  int filled_ = 0;
  uval_t frame_ = BADNODE;
  asize_t frsize_ = 0;
  ushort frregs_ = 0;
  asize_t argsize_ = 0;
  asize_t fpd_ = 0;
  bgcolor_t color_ = DEFCOLOR;
  qstring name_;
  qstring cmt_;
  qstring cmt_rpt_;
 
  friend struct kdata_t;

  enum
  {
    FEI_FLAGS   = 0x01,  
    FEI_FRSIZE  = 0x02,  
    FEI_FRREGS  = 0x04,  
    FEI_ARGSIZE = 0x08,  
    FEI_FPD     = 0x10,  
    FEI_COLOR   = 0x20,  
    FEI_ENTIRE  = 0x3F,  
  };
};
 

 
idaman bool ida_export get_func_entry_info(func_entry_info_t *out, ea_t ea, int flags=0);
 

 
idaman bool ida_export get_func_entry_info_by_num(func_entry_info_t *out, size_t n, int flags=0);
 

 
idaman bool ida_export set_func_entry_info(const func_entry_info_t *fi);
 

 
idaman bool ida_export add_function_ex(func_entry_info_t *fi);
 

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

 
idaman int ida_export find_function_bounds(func_entry_info_t *fi, int flags);
 

 
idaman ea_t ida_export calc_thunk_function_target(func_entry_info_t *fi, ea_t *fptr);
 

class func_tail_info_t : public fchunk_info_t
{
public:
  func_tail_info_t(ea_t start=0, ea_t end=0)
    : fchunk_info_t(start, end)
  {}

  ea_t get_owner() const { return owner_; }

  int get_refqty() const { return refqty_; }
 
private:
  using fchunk_info_t::set_flags;
  ea_t owner_ = BADADDR;
  int refqty_ = 0;
 
  friend struct kdata_t;
};
 

 
idaman bool ida_export get_func_tail_info(func_tail_info_t *out, ea_t ea);
 

 
idaman size_t ida_export get_tail_referer_qty(ea_t tail_ea);
 

 
idaman ea_t ida_export get_tail_referer(ea_t tail_ea, size_t n);
 

 
idaman bool ida_export get_tail_referers(eavec_t *out, ea_t tail_ea);
 

class function_tail_iterator_t
{
  ea_t func_ea_ = BADADDR;
  int idx_ = -1;
  range_t seglim_;
  range_t main_;
  rangevec_t tails_;
  friend struct kdata_t;
 
public:
  function_tail_iterator_t() {}
  function_tail_iterator_t(ea_t func_ea, ea_t ea=BADADDR) { set(func_ea, ea); }
  ~function_tail_iterator_t()
  {
    if ( func_ea_ != BADADDR )
      lock_func_range_ea(func_ea_, false);
  }
  bool set(ea_t func_ea, ea_t ea=BADADDR) { return function_tail_iterator_set(this, func_ea, ea); }
  bool set_ea(ea_t ea) { return function_tail_iterator_set_ea(this, ea); }
  bool set_range(ea_t ea1, ea_t ea2) { return function_tail_iterator_set_range(this, ea1, ea2); }
  void chunk(range_t *out) const { function_tail_iterator_chunk(out, this); }
  bool first() { return function_tail_iterator_first(this); }
  bool last() { return function_tail_iterator_last(this); }
  bool next() { return function_tail_iterator_next(this); }
  bool prev() { return function_tail_iterator_prev(this); }
  bool main() { return function_tail_iterator_main(this); }
};
 

class function_parent_iterator_t
{
  ea_t tail_ea_ = BADADDR;
  int idx_ = 0;
  eavec_t parents_;
  friend struct kdata_t;
 
public:
  function_parent_iterator_t() {}
  function_parent_iterator_t(ea_t tail_ea) { set(tail_ea); }
  ~function_parent_iterator_t()
  {
    if ( tail_ea_ != BADADDR )
      lock_func_range_ea(tail_ea_, false);
  }
  bool set(ea_t tail_ea) { return function_parent_iterator_set(this, tail_ea); }
  ea_t parent() const { return function_parent_iterator_parent(this); }
  bool first() { return function_parent_iterator_first(this); }
  bool last() { return function_parent_iterator_last(this); }
  bool next() { return function_parent_iterator_next(this); }
  bool prev() { return function_parent_iterator_prev(this); }
};
 

class function_item_iterator_t
{
  function_tail_iterator_t fti_;
  ea_t ea_ = BADADDR;
  friend struct kdata_t;
 
public:
  function_item_iterator_t() {}
  function_item_iterator_t(ea_t func_ea, ea_t ea=BADADDR) { set(func_ea, ea); }
  bool set(ea_t func_ea, ea_t ea=BADADDR)
  {
    func_ea = get_func_start(func_ea);
    ea_ = (ea != BADADDR || func_ea == BADADDR) ? ea : func_ea;
    return fti_.set(func_ea, ea_);
  }

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

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

 
#endif