name.hpp

Go to the documentation of this file.

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

 
class func_t;                   // funcs.hpp
typedef uchar color_t;          // lines.hpp

#define MAXNAMELEN      512
 

#define FUNC_IMPORT_PREFIX "__imp_"
 

 
idaman bool ida_export set_name(ea_t ea, const char *name, int flags=0);

#define SN_CHECK        0x00    
#define SN_NOCHECK      0x01    
#define SN_PUBLIC       0x02    
#define SN_NON_PUBLIC   0x04    
#define SN_WEAK         0x08    
#define SN_NON_WEAK     0x10    
#define SN_AUTO         0x20    
#define SN_NON_AUTO     0x40    
#define SN_NOLIST       0x80    
#define SN_NOWARN       0x100   
#define SN_LOCAL        0x200   
#define SN_IDBENC       0x400   
#define SN_FORCE        0x800   
#define SN_NODUMMY      0x1000  
#define SN_DELTAIL      0x2000  
#define SN_MULTI        0x4000  
#define SN_MULTI_FORCE  0x8000  
 
inline bool force_name(ea_t ea, const char *name, int flags=0)
{
  return set_name(ea, name, flags|SN_FORCE|SN_NODUMMY);
}

inline bool del_global_name(ea_t ea) { return set_name(ea,"", SN_NOWARN); }
inline bool del_local_name(ea_t ea)  { return set_name(ea,"", SN_LOCAL|SN_NOWARN); }

 
idaman bool ida_export set_dummy_name(ea_t from, ea_t ea); // give dummy name
 

idaman bool ida_export make_name_auto(ea_t ea);
idaman bool ida_export make_name_user(ea_t ea);
 
 
enum ucdr_kind_t
{
  UCDR_STRLIT  = 0x01,   
  UCDR_NAME    = 0x02,   
  UCDR_MANGLED = 0x04,   
  UCDR_TYPE    = 0x08,   
};
 
enum nametype_t
{
  VNT_IDENT = UCDR_NAME|UCDR_MANGLED, 
  VNT_TYPE = UCDR_TYPE,               
  VNT_UDTMEM = UCDR_NAME,             
  VNT_STRLIT = UCDR_STRLIT,           
  VNT_VISIBLE = VNT_UDTMEM,           
};

 
idaman bool ida_export validate_name(
        qstring *name,
        nametype_t type,
        int flags = SN_NOCHECK);
 

 
idaman bool ida_export is_valid_cp(wchar32_t cp, nametype_t kind, void *data=nullptr);
 

 
idaman void ida_export set_cp_validity(ucdr_kind_t kind, wchar32_t cp, wchar32_t endcp=BADCP, bool valid=true);
 

 
idaman bool ida_export get_cp_validity(ucdr_kind_t kind, wchar32_t cp, wchar32_t endcp=BADCP);
 

 
inline bool is_ident_cp(wchar32_t cp) { return is_valid_cp(cp, VNT_IDENT); }
 

 
inline bool is_strlit_cp(wchar32_t cp, const rangeset_crefvec_t *specific_ranges=nullptr)
{ return is_valid_cp(cp, VNT_STRLIT, (void *) specific_ranges); }
 

 
inline bool is_visible_cp(wchar32_t cp)
{ return is_valid_cp(cp, VNT_VISIBLE); }
 

 
idaman bool ida_export is_ident(const char *name);
 

 
idaman bool ida_export is_uname(const char *name);
 

 
idaman bool ida_export is_valid_typename(const char *name);
 

 
idaman ea_t ida_export dummy_name_ea(const char *name);
 

 
idaman ssize_t ida_export extract_name(qstring *out, const char *line, int x);
 

 
idaman void ida_export hide_name(ea_t ea);
 

 
idaman void ida_export show_name(ea_t ea);
 

 
idaman ea_t ida_export get_name_ea(ea_t from, const char *name);
 

 
idaman ea_t ida_export get_name_base_ea(ea_t from, ea_t to);
 

 
idaman int ida_export get_name_value(uval_t *value, ea_t from, const char *name);

#define NT_NONE         0       
#define NT_BYTE         1       
#define NT_LOCAL        2       
#define NT_STKVAR       3       
#define NT_ENUM         4       
#define NT_ABS          5       
#define NT_SEG          6       
#define NT_STROFF       7       
#define NT_BMASK        8       
#define NT_REGVAR       9       
 

struct getname_info_t
{
  size_t cb;            
  int32 inhibitor;      
  int32 demform;        
  int32 demcode;         
  getname_info_t(void) : cb(sizeof(*this)), inhibitor(0), demform(0), demcode(0) {}
};
 

 
idaman ssize_t ida_export get_ea_name(
        qstring *out,
        ea_t ea,
        int gtn_flags=0,
        getname_info_t *gtni=nullptr);

#define GN_VISIBLE   0x0001 
#define GN_COLORED   0x0002 
#define GN_DEMANGLED 0x0004 
#define GN_STRICT    0x0008 
#define GN_SHORT     0x0010 
#define GN_LONG      0x0020 
#define GN_LOCAL     0x0040 
#define GN_ISRET     0x0080 
#define GN_NOT_ISRET 0x0100 
#define GN_NOT_DUMMY 0x0200 

 
// Convenience functions for get_ea_name returning ssize_t
 
inline ssize_t get_name(qstring *out, ea_t ea, int gtn_flags=0)
{
  return get_ea_name(out, ea, gtn_flags);
}
 
inline ssize_t idaapi get_visible_name(qstring *out, ea_t ea, int gtn_flags=0)
{
  return get_ea_name(out, ea, GN_VISIBLE|gtn_flags);
}
 
inline ssize_t idaapi get_colored_name(qstring *out, ea_t ea, int gtn_flags=0)
{
  return get_ea_name(out, ea, GN_VISIBLE|GN_COLORED|gtn_flags);
}
 
inline ssize_t idaapi get_short_name(qstring *out, ea_t ea, int gtn_flags=0)
{
  return get_ea_name(out, ea, GN_VISIBLE|GN_DEMANGLED|GN_SHORT|gtn_flags);
}
 
inline ssize_t idaapi get_long_name(qstring *out, ea_t ea, int gtn_flags=0)
{
  return get_ea_name(out, ea, GN_VISIBLE|GN_DEMANGLED|GN_LONG|gtn_flags);
}
 
inline ssize_t idaapi get_colored_short_name(qstring *out, ea_t ea, int gtn_flags=0)
{
  return get_ea_name(out, ea, GN_VISIBLE|GN_COLORED|GN_DEMANGLED|GN_SHORT|gtn_flags);
}
 
inline ssize_t idaapi get_colored_long_name(qstring *out, ea_t ea, int gtn_flags=0)
{
  return get_ea_name(out, ea, GN_VISIBLE|GN_COLORED|GN_DEMANGLED|GN_LONG|gtn_flags);
}
 
inline ssize_t idaapi get_demangled_name(
        qstring *out,
        ea_t ea,
        int32 inhibitor,
        int demform,
        int gtn_flags=0)
{
  getname_info_t gtni;
  gtni.inhibitor = inhibitor;
  gtni.demform = demform;
  gtn_flags |= GN_VISIBLE | GN_DEMANGLED;
  return get_ea_name(out, ea, gtn_flags, &gtni);
}
 
inline ssize_t idaapi get_colored_demangled_name(
        qstring *out,
        ea_t ea,
        int32 inhibitor,
        int demform,
        int gtn_flags=0)
{
  return get_demangled_name(out, ea, inhibitor, demform, gtn_flags|GN_COLORED);
}
 
// Convenience functions for get_ea_name returning qstring
 
inline qstring get_name(ea_t ea, int gtn_flags=0)
{
  qstring out;
  get_ea_name(&out, ea, gtn_flags);
  return out;
}
 
inline qstring get_visible_name(ea_t ea, int gtn_flags=0)
{
  qstring out;
  get_ea_name(&out, ea, GN_VISIBLE|gtn_flags);
  return out;
}
 
inline qstring idaapi get_colored_name(ea_t ea, int gtn_flags=0)
{
  qstring out;
  get_ea_name(&out, ea, GN_VISIBLE|GN_COLORED|gtn_flags);
  return out;
}
 
inline qstring idaapi get_short_name(ea_t ea, int gtn_flags=0)
{
  qstring out;
  get_ea_name(&out, ea, GN_VISIBLE|GN_DEMANGLED|GN_SHORT|gtn_flags);
  return out;
}
 
inline qstring idaapi get_long_name(ea_t ea, int gtn_flags=0)
{
  qstring out;
  get_ea_name(&out, ea, GN_VISIBLE|GN_DEMANGLED|GN_LONG|gtn_flags);
  return out;
}
 
inline qstring idaapi get_colored_short_name(ea_t ea, int gtn_flags=0)
{
  qstring out;
  get_ea_name(&out, ea, GN_VISIBLE|GN_COLORED|GN_DEMANGLED|GN_SHORT|gtn_flags);
  return out;
}
 
inline qstring idaapi get_colored_long_name(ea_t ea, int gtn_flags=0)
{
  qstring out;
  get_ea_name(&out, ea, GN_VISIBLE|GN_COLORED|GN_DEMANGLED|GN_LONG|gtn_flags);
  return out;
}
 
inline qstring idaapi get_demangled_name(
        ea_t ea,
        int32 inhibitor,
        int demform,
        int gtn_flags=0)
{
  qstring out;
  getname_info_t gtni;
  gtni.inhibitor = inhibitor;
  gtni.demform = demform;
  gtn_flags |= GN_VISIBLE | GN_DEMANGLED;
  get_ea_name(&out, ea, gtn_flags, &gtni);
  return out;
}
 
inline qstring idaapi get_colored_demangled_name(
        ea_t ea,
        int32 inhibitor,
        int demform,
        int gtn_flags=0)
{
  qstring out;
  get_demangled_name(&out, ea, inhibitor, demform, gtn_flags|GN_COLORED);
  return out;
}

#ifdef FUNCS_HPP
inline int calc_gtn_flags(ea_t from, ea_t ea)
{
  return func_contains(get_func(from), ea) ? GN_LOCAL : 0;
}
#endif

 
idaman color_t ida_export get_name_color(ea_t from, ea_t ea);
 

#define GETN_APPZERO  0x0001  
#define GETN_NOFIXUP  0x0002  
#define GETN_NODUMMY  0x0004  

 
idaman ssize_t ida_export get_name_expr(
        qstring *out,
        ea_t from,
        int n,
        ea_t ea,
        uval_t off,
        int flags=GETN_APPZERO);

 
idaman ssize_t ida_export get_nice_colored_name(
        qstring *buf,
        ea_t ea,
        int flags=0);

#define GNCN_NOSEG    0x0001 
#define GNCN_NOCOLOR  0x0002 
#define GNCN_NOLABEL  0x0004 
#define GNCN_NOFUNC   0x0008 
#define GNCN_SEG_FUNC 0x0010 
#define GNCN_SEGNUM   0x0020 
#define GNCN_REQFUNC  0x0040 
#define GNCN_REQNAME  0x0080 
#define GNCN_NODBGNM  0x0100 
#define GNCN_PREFDBG  0x0200 
 

 
idaman flags64_t ida_export append_struct_fields(
        qstring *out,
        adiff_t *disp,
        int n,
        const tid_t *path,
        int plen,
        flags64_t flags,
        adiff_t delta,
        bool appzero);
 

 
idaman int ida_export get_struct_operand(
        adiff_t *disp,
        adiff_t *delta,
        tid_t *path,
        ea_t ea,
        int n);
 

idaman bool ida_export is_public_name(ea_t ea);
idaman void ida_export make_name_public(ea_t ea);
idaman void ida_export make_name_non_public(ea_t ea);
 

idaman bool ida_export is_weak_name(ea_t ea);
idaman void ida_export make_name_weak(ea_t ea);
idaman void ida_export make_name_non_weak(ea_t ea);


 
idaman size_t ida_export get_nlist_size(void);

 
idaman size_t ida_export get_nlist_idx(ea_t ea);

 
idaman bool ida_export is_in_nlist(ea_t ea);

 
idaman ea_t ida_export get_nlist_ea(size_t idx);

 
idaman const char *ida_export get_nlist_name(size_t idx);

 
idaman void ida_export rebuild_nlist(void);

 
idaman void ida_export reorder_dummy_names(void);

enum debug_name_how_t
{
  DEBNAME_EXACT,        
  DEBNAME_LOWER,        
  DEBNAME_UPPER,        
  DEBNAME_NICE,         
};

struct ea_name_t
{
  ea_t ea;
  qstring name;
  ea_name_t(void) : ea(BADADDR) {}
  ea_name_t(ea_t _ea, const qstring &_name) : ea(_ea), name(_name) {}
};
DECLARE_TYPE_AS_MOVABLE(ea_name_t);
typedef qvector<ea_name_t> ea_name_vec_t; 

idaman int  ida_export set_debug_names(const ea_t *addrs, const char *const *names, int qty);
idaman bool ida_export set_debug_name(ea_t ea, const char *name);
idaman ssize_t ida_export get_debug_name(
        qstring *out,
        ea_t *ea_ptr,
        debug_name_how_t how);
idaman void ida_export del_debug_names(ea_t ea1, ea_t ea2);
idaman ea_t ida_export get_debug_name_ea(const char *name);
idaman void ida_export get_debug_names(ea_name_vec_t *names, ea_t ea1, ea_t ea2);
 
 
enum demreq_type_t
{
  DQT_NPURGED_8 = -8, 
  DQT_NPURGED_4 = -4, 
  DQT_NPURGED_2 = -2, 
  DQT_COMPILER  = 0,  
  DQT_NAME_TYPE = 1,  
  DQT_FULL      = 2,  
};

 
idaman int32 ida_export demangle_name(
        qstring *out,
        const char *name,
        uint32 disable_mask,
        demreq_type_t demreq=DQT_FULL);

inline qstring idaapi demangle_name(
        const char *name,
        uint32 disable_mask,
        demreq_type_t demreq=DQT_FULL)
{
  qstring out;
  demangle_name(&out, name, disable_mask, demreq);
  return out;
}
 
 
inline int32 detect_compiler_using_demangler(const char *name)
{
  return demangle_name(nullptr, name, 0, DQT_COMPILER);
}

typedef int ignore_name_def_t;
const ignore_name_def_t
  ignore_none   = 0,
  ignore_regvar = 1,
  ignore_llabel = 2,
  ignore_stkvar = 3,
  ignore_glabel = 4;

idaman bool ida_export is_name_defined_locally(
        func_t *pfn,
        const char *name,
        ignore_name_def_t ignore_name_def,
        ea_t ea1=BADADDR,
        ea_t ea2=BADADDR);
 
// Clean a name.
// This function removes punctuation marks (underscores and dots) from both
// ends of the name, and other typical prefixes/suffixes. Name is assumed to
// have the following format: [j_][@][.][_*][imp_]name[@digits][_NN]
// \param out     output buffer
// \param ea      address of the name (used to remove the module name)
//                if != BADADDR, the optional prefix (module name) will be
//                removed
// \param name    name to clean
// \param flags   combination of CN_... bits
// \return true if returned a non-empty name
idaman bool ida_export cleanup_name(
        qstring *out,
        ea_t ea,
        const char *name,
        uint32 flags=0);
 
#define CN_KEEP_TRAILING_DIGITS 0x01 
#define CN_KEEP_UNDERSCORES     0x02 
 
 
#endif // _NAME_HPP