typeinf_8hpp_source.html

/*

 *      Interactive disassembler (IDA)

 *      Copyright (c) 1990-2025 Hex-Rays

 *      ALL RIGHTS RESERVED.

 */


#ifndef _TYPEINF_HPP

#define _TYPEINF_HPP

#include <functional>

#include <idp.hpp>

#include <name.hpp>


typedef uchar type_t;

typedef uchar p_string;

typedef uchar p_list;

typedef uint64 bmask64_t;

#define DEFMASK64 bmask64_t(-1)


struct til_t;             // type information library

class lexer_t;            // lexical analyzer

class argloc_t;           // argument location

class tinfo_t;            // type info object

class func_t;             // function


struct func_type_data_t;

struct til_bucket_t;

struct til_stream_t;

struct value_repr_t;

struct udm_t;

struct edm_t;

struct tinfo_changes_t;


//------------------------------------------------------------------------

#define RESERVED_BYTE 0xFF

//------------------------------------------------------------------------


const type_t TYPE_BASE_MASK  = 0x0F;

const type_t TYPE_FLAGS_MASK = 0x30;

const type_t TYPE_MODIF_MASK = 0xC0;


const type_t TYPE_FULL_MASK = (TYPE_BASE_MASK | TYPE_FLAGS_MASK);


const type_t  BT_UNK         = 0x00;

const type_t  BT_VOID        = 0x01;

const type_t    BTMT_SIZE0   = 0x00;

const type_t    BTMT_SIZE12  = 0x10;

const type_t    BTMT_SIZE48  = 0x20;

const type_t    BTMT_SIZE128 = 0x30;


const type_t  BT_INT8        = 0x02;

const type_t  BT_INT16       = 0x03;

const type_t  BT_INT32       = 0x04;

const type_t  BT_INT64       = 0x05;

const type_t  BT_INT128      = 0x06;

const type_t  BT_INT         = 0x07;

const type_t    BTMT_UNKSIGN = 0x00;

const type_t    BTMT_SIGNED  = 0x10;

const type_t    BTMT_USIGNED = 0x20;

const type_t    BTMT_UNSIGNED = BTMT_USIGNED;

const type_t    BTMT_CHAR    = 0x30;


const type_t    BT_BOOL      = 0x08;

const type_t    BTMT_DEFBOOL = 0x00;

const type_t    BTMT_BOOL1   = 0x10;

const type_t    BTMT_BOOL2   = 0x20;

const type_t    BTMT_BOOL8   = 0x20;

const type_t    BTMT_BOOL4   = 0x30;


const type_t    BT_FLOAT     = 0x09;

const type_t    BTMT_FLOAT   = 0x00;

const type_t    BTMT_DOUBLE  = 0x10;

const type_t    BTMT_LNGDBL  = 0x20;

const type_t    BTMT_SPECFLT = 0x30;


const type_t _BT_LAST_BASIC  = BT_FLOAT;


const type_t    BT_PTR       = 0x0A;

const type_t    BTMT_DEFPTR  = 0x00;

const type_t    BTMT_NEAR    = 0x10;

const type_t    BTMT_FAR     = 0x20;

const type_t    BTMT_CLOSURE = 0x30;


const type_t  BT_ARRAY       = 0x0B;

const type_t  BTMT_NONBASED  = 0x10;

const type_t  BTMT_ARRESERV  = 0x20;


const type_t  BT_FUNC        = 0x0C;


const type_t    BTMT_DEFCALL  = 0x00;

const type_t    BTMT_NEARCALL = 0x10;

const type_t    BTMT_FARCALL  = 0x20;

const type_t    BTMT_INTCALL  = 0x30;


const type_t    BT_COMPLEX   = 0x0D;

const type_t    BTMT_STRUCT  = 0x00;

const type_t    BTMT_UNION   = 0x10;

const type_t    BTMT_ENUM    = 0x20;

const type_t    BTMT_TYPEDEF = 0x30;


const type_t BT_BITFIELD     = 0x0E;

const type_t BTMT_BFLDI8    = 0x00;

const type_t BTMT_BFLDI16   = 0x10;

const type_t BTMT_BFLDI32   = 0x20;

const type_t BTMT_BFLDI64   = 0x30;


const type_t BT_RESERVED     = 0x0F;


//------------------------------------------------------------------------

const type_t  BTM_CONST      = 0x40;

const type_t  BTM_VOLATILE   = 0x80;


//------------------------------------------------------------------------

typedef uchar bte_t;


const bte_t   BTE_SIZE_MASK = 0x07;

const bte_t   BTE_RESERVED    = 0x08;

const bte_t   BTE_BITMASK     = 0x10;

const bte_t   BTE_OUT_MASK    = 0x60;

const bte_t   BTE_HEX         = 0x00;

const bte_t   BTE_CHAR        = 0x20;

const bte_t   BTE_SDEC        = 0x40;

const bte_t   BTE_UDEC        = 0x60;

const bte_t   BTE_ALWAYS      = 0x80;


const type_t BT_SEGREG    = (BT_INT | BTMT_CHAR);


const type_t BT_UNK_BYTE  = (BT_VOID | BTMT_SIZE12);

const type_t BT_UNK_WORD  = (BT_UNK  | BTMT_SIZE12);

const type_t BT_UNK_DWORD = (BT_VOID | BTMT_SIZE48);

const type_t BT_UNK_QWORD = (BT_UNK  | BTMT_SIZE48);

const type_t BT_UNK_OWORD = (BT_VOID | BTMT_SIZE128);

const type_t BT_UNKNOWN   = (BT_UNK  | BTMT_SIZE128);


//------------------------------------------------------------------------

const type_t BTF_BYTE    = BT_UNK_BYTE;

const type_t BTF_UNK     = BT_UNKNOWN;

const type_t BTF_VOID    = BT_VOID | BTMT_SIZE0;


const type_t BTF_INT8    = BT_INT8 | BTMT_SIGNED;

const type_t BTF_CHAR    = BT_INT8 | BTMT_CHAR;

const type_t BTF_UCHAR   = BT_INT8 | BTMT_USIGNED;

const type_t BTF_UINT8   = BT_INT8 | BTMT_USIGNED;


const type_t BTF_INT16   = BT_INT16 | BTMT_SIGNED;

const type_t BTF_UINT16  = BT_INT16 | BTMT_USIGNED;


const type_t BTF_INT32   = BT_INT32 | BTMT_SIGNED;

const type_t BTF_UINT32  = BT_INT32 | BTMT_USIGNED;


const type_t BTF_INT64   = BT_INT64 | BTMT_SIGNED;

const type_t BTF_UINT64  = BT_INT64 | BTMT_USIGNED;


const type_t BTF_INT128   = BT_INT128 | BTMT_SIGNED;

const type_t BTF_UINT128  = BT_INT128 | BTMT_USIGNED;


const type_t BTF_INT     = BT_INT | BTMT_UNKSIGN;

const type_t BTF_UINT    = BT_INT | BTMT_USIGNED;

const type_t BTF_SINT    = BT_INT | BTMT_SIGNED;


const type_t BTF_BOOL    = BT_BOOL;


const type_t BTF_FLOAT   = BT_FLOAT | BTMT_FLOAT;

const type_t BTF_DOUBLE  = BT_FLOAT | BTMT_DOUBLE;

const type_t BTF_LDOUBLE = BT_FLOAT | BTMT_LNGDBL;

const type_t BTF_TBYTE   = BT_FLOAT | BTMT_SPECFLT;


const type_t BTF_STRUCT  = BT_COMPLEX | BTMT_STRUCT;

const type_t BTF_UNION   = BT_COMPLEX | BTMT_UNION;

const type_t BTF_ENUM    = BT_COMPLEX | BTMT_ENUM;

const type_t BTF_TYPEDEF = BT_COMPLEX | BTMT_TYPEDEF;


//------------------------------------------------------------------------

// convenience functions:


inline THREAD_SAFE bool is_type_const(type_t t)    { return (t & BTM_CONST) != 0; }


inline THREAD_SAFE bool is_type_volatile(type_t t) { return (t & BTM_VOLATILE) != 0; }


inline THREAD_SAFE type_t get_base_type(type_t t)  { return (t & TYPE_BASE_MASK); }


inline THREAD_SAFE type_t get_type_flags(type_t t) { return (t & TYPE_FLAGS_MASK); }


inline THREAD_SAFE type_t get_full_type(type_t t)  { return (t & TYPE_FULL_MASK); }


inline THREAD_SAFE bool is_typeid_last(type_t t)   { return(get_base_type(t) <= _BT_LAST_BASIC); }


inline THREAD_SAFE bool is_type_partial(type_t t)  { return(get_base_type(t) <= BT_VOID) && get_type_flags(t) != 0; }


inline THREAD_SAFE bool is_type_void(type_t t)     { return(get_full_type(t) == BTF_VOID); }


inline THREAD_SAFE bool is_type_unknown(type_t t)  { return(get_full_type(t) == BT_UNKNOWN); }


inline THREAD_SAFE bool is_type_ptr(type_t t)      { return(get_base_type(t) == BT_PTR); }


inline THREAD_SAFE bool is_type_complex(type_t t)  { return(get_base_type(t) == BT_COMPLEX); }


inline THREAD_SAFE bool is_type_func(type_t t)     { return(get_base_type(t) == BT_FUNC); }


inline THREAD_SAFE bool is_type_array(type_t t)    { return(get_base_type(t) == BT_ARRAY); }


inline THREAD_SAFE bool is_type_typedef(type_t t)  { return(get_full_type(t) == BTF_TYPEDEF); }


inline THREAD_SAFE bool is_type_sue(type_t t)      { return is_type_complex(t) && !is_type_typedef(t); }


inline THREAD_SAFE bool is_type_struct(type_t t)   { return(get_full_type(t) == BTF_STRUCT); }


inline THREAD_SAFE bool is_type_union(type_t t)    { return(get_full_type(t) == BTF_UNION); }


inline THREAD_SAFE bool is_type_struni(type_t t)   { return(is_type_struct(t) || is_type_union(t)); }


inline THREAD_SAFE bool is_type_enum(type_t t)     { return(get_full_type(t) == BTF_ENUM); }


inline THREAD_SAFE bool is_type_bitfld(type_t t)   { return(get_base_type(t) == BT_BITFIELD); }


inline THREAD_SAFE bool is_type_int(type_t bt) { bt = get_base_type(bt); return bt >= BT_INT8 && bt <= BT_INT; }


inline THREAD_SAFE bool is_type_int128(type_t t)

{

  return get_full_type(t) == (BT_INT128|BTMT_UNKSIGN)

      || get_full_type(t) == (BT_INT128|BTMT_SIGNED);

}


inline THREAD_SAFE bool is_type_int64(type_t t)

{

  return get_full_type(t) == (BT_INT64|BTMT_UNKSIGN)

      || get_full_type(t) == (BT_INT64|BTMT_SIGNED);

}


inline THREAD_SAFE bool is_type_int32(type_t t)

{

  return get_full_type(t) == (BT_INT32|BTMT_UNKSIGN)

      || get_full_type(t) == (BT_INT32|BTMT_SIGNED);

}


inline THREAD_SAFE bool is_type_int16(type_t t)

{

  return get_full_type(t) == (BT_INT16|BTMT_UNKSIGN)

      || get_full_type(t) == (BT_INT16|BTMT_SIGNED);

}


inline THREAD_SAFE bool is_type_char(type_t t) // chars are signed by default(?)

{

  return get_full_type(t) == (BT_INT8|BTMT_CHAR)

      || get_full_type(t) == (BT_INT8|BTMT_SIGNED);

}


inline THREAD_SAFE bool is_type_paf(type_t t)

{

  t = get_base_type(t);

  return t >= BT_PTR && t <= BT_FUNC;

}


inline THREAD_SAFE bool is_type_ptr_or_array(type_t t) { t = get_base_type(t); return t == BT_PTR || t == BT_ARRAY; }

inline THREAD_SAFE bool is_type_floating(type_t t) { return get_base_type(t) == BT_FLOAT; } // any floating type

inline THREAD_SAFE bool is_type_integral(type_t t) { return get_full_type(t) > BT_VOID && get_base_type(t) <= BT_BOOL; }

inline THREAD_SAFE bool is_type_ext_integral(type_t t) { return is_type_integral(t) || is_type_enum(t); }

inline THREAD_SAFE bool is_type_arithmetic(type_t t) { return get_full_type(t) > BT_VOID && get_base_type(t) <= BT_FLOAT; }

inline THREAD_SAFE bool is_type_ext_arithmetic(type_t t) { return is_type_arithmetic(t) || is_type_enum(t); }


inline THREAD_SAFE bool is_type_uint(type_t t)    { return get_full_type(t) == BTF_UINT; }


inline THREAD_SAFE bool is_type_uchar(type_t t)   { return get_full_type(t) == BTF_UCHAR; }


inline THREAD_SAFE bool is_type_uint16(type_t t)  { return get_full_type(t) == BTF_UINT16; }


inline THREAD_SAFE bool is_type_uint32(type_t t)  { return get_full_type(t) == BTF_UINT32; }


inline THREAD_SAFE bool is_type_uint64(type_t t)  { return get_full_type(t) == BTF_UINT64; }


inline THREAD_SAFE bool is_type_uint128(type_t t) { return get_full_type(t) == BTF_UINT128; }


inline THREAD_SAFE bool is_type_ldouble(type_t t) { return get_full_type(t) == BTF_LDOUBLE; }


inline THREAD_SAFE bool is_type_double(type_t t)  { return get_full_type(t) == BTF_DOUBLE; }


inline THREAD_SAFE bool is_type_float(type_t t)   { return get_full_type(t) == BTF_FLOAT; }


inline THREAD_SAFE bool is_type_tbyte(type_t t)   { return get_full_type(t) == BTF_TBYTE; }


inline THREAD_SAFE bool is_type_bool(type_t t)    { return get_base_type(t) == BT_BOOL; }


#define TAH_BYTE        0xFE

#define FAH_BYTE        0xFF


#define MAX_DECL_ALIGN  0x000F


#define TAH_HASATTRS    0x0010


#define TAUDT_UNALIGNED 0x0040

#define TAUDT_MSSTRUCT  0x0020

#define TAUDT_CPPOBJ    0x0080

#define TAUDT_VFTABLE   0x0100

#define TAUDT_FIXED     0x0400

#define TAUDT_TUPLE     0x0800


#define TAFLD_BASECLASS 0x0020

#define TAFLD_UNALIGNED 0x0040

#define TAFLD_VIRTBASE  0x0080

#define TAFLD_VFTABLE   0x0100

#define TAFLD_METHOD    0x0200

#define TAFLD_GAP       0x0400

#define TAFLD_REGCMT    0x0800

#define TAFLD_FRAME_R   0x1000

#define TAFLD_FRAME_S   0x2000

#define TAFLD_BYTIL     0x4000


#define TAPTR_PTR32     0x0020

#define TAPTR_PTR64     0x0040

#define TAPTR_RESTRICT  0x0060

#define TAPTR_SHIFTED   0x0080


#define TAENUM_64BIT    0x0020

#define TAENUM_UNSIGNED 0x0040

#define TAENUM_SIGNED   0x0080

#define TAENUM_OCT      0x0100

#define TAENUM_BIN      0x0200

#define TAENUM_NUMSIGN  0x0400

#define TAENUM_LZERO    0x0800


#define TAH_ALL         0x7FF0


inline THREAD_SAFE bool is_tah_byte(type_t t)

{

  return t == TAH_BYTE;

}


inline THREAD_SAFE bool is_sdacl_byte(type_t t)

{

  return ((t & ~TYPE_FLAGS_MASK) ^ TYPE_MODIF_MASK) <= BT_VOID;

}


#ifndef SWIG


inline THREAD_SAFE bool operator <(const bytevec_t &v1, const bytevec_t &v2)

{

  size_t n = qmin(v1.size(), v2.size());

  for ( size_t i=0; i < n; i++ )

  {

    uchar k1 = v1[i];

    uchar k2 = v2[i];

    if ( k1 < k2 )

      return true;

    if ( k1 > k2 )

      return false;

  }

  return v1.size() < v2.size();

}


#endif


struct type_attr_t

{

  qstring key;

#define TA_ORG_TYPEDEF "__org_typedef"

#define TA_ORG_ARRDIM  "__org_arrdim"

#define TA_FORMAT      "format"

#define TA_VALUE_REPR  "\x01"

  bytevec_t value;

  bool operator < (const type_attr_t &r) const { return key < r.key; }

  bool operator >= (const type_attr_t &r) const { return !(*this < r); }

};


DECLARE_TYPE_AS_MOVABLE(type_attr_t);


typedef qvector<type_attr_t> type_attrs_t;


typedef int type_sign_t;

const type_sign_t

  no_sign       = 0,

  type_signed   = 1,

  type_unsigned = 2;


//---------------------------------------------------------------------------

idaman bool ida_export append_argloc(qtype *out, const argloc_t &vloc);

idaman bool ida_export extract_argloc(argloc_t *vloc, const type_t **ptype, bool forbid_stkoff);


idaman const type_t *ida_export resolve_typedef(const til_t *til, const type_t *type);


// low level functions to be used in predicate_t::should_display()

// in other places please use tinfo_t


inline bool is_restype_void(const til_t *til, const type_t *type)

{

  type = resolve_typedef(til, type);

  return type != nullptr && is_type_void(*type);

}


inline bool is_restype_enum(const til_t *til, const type_t *type)

{

  type = resolve_typedef(til, type);

  return type != nullptr && is_type_enum(*type);

}


inline bool is_restype_struni(const til_t *til, const type_t *type)

{

  type = resolve_typedef(til, type);

  return type != nullptr && is_type_struni(*type);

}


inline bool is_restype_struct(const til_t *til, const type_t *type)

{

  type = resolve_typedef(til, type);

  return type != nullptr && is_type_struct(*type);

}


// Get a base type for the specified size.

// This function prefers to return integer types

// \param size size in bytes; should be 1,2,4,8,16 or sizeof(floating point)

// \return BT_INT.. or BT_FLOAT... or BT_UNK


idaman type_t ida_export get_scalar_bt(int size);


//------------------------------------------------------------------------

//------------------------------------------------------------------------


struct til_t

{

  char *name = nullptr;

  char *desc = nullptr;

  int nbases = 0;

  til_t **base = nullptr;

  uint32 flags = 0;

#define TIL_ZIP 0x0001

#define TIL_MAC 0x0002

#define TIL_ESI 0x0004

#define TIL_UNI 0x0008

#define TIL_ORD 0x0010

#define TIL_ALI 0x0020

#define TIL_MOD 0x0040

#define TIL_STM 0x0080

#define TIL_SLD 0x0100

#define TIL_ECC 0x0200

  inline bool is_dirty() const { return (flags & TIL_MOD) != 0; }

  inline void set_dirty() { flags |= TIL_MOD; }


  inline til_t *find_base(const char *n)

  {

    if ( n != nullptr )

    {

      for ( int i = 0; i < nbases; ++i )

        if ( streq(base[i]->name, n) )

          return base[i];

    }

    return nullptr;

  }


  compiler_info_t cc;

  til_bucket_t *syms = nullptr;

  til_bucket_t *types = nullptr;

  til_bucket_t *macros = nullptr;

  int nrefs = 0;

  int nstreams = 0;

  til_stream_t **streams = nullptr;

};


idaman til_t *ida_export new_til(const char *name, const char *desc);


idaman int ida_export add_base_tils(qstring *errbuf, til_t *ti, const char *tildir, const char *bases, bool gen_events);


#define TIL_ADD_FAILED  0

#define TIL_ADD_OK      1

#define TIL_ADD_ALREADY 2


idaman til_t *ida_export load_til(const char *name, qstring *errbuf, const char *tildir=nullptr);


idaman bool ida_export sort_til(til_t *ti);


idaman bool ida_export compact_til(til_t *ti);


idaman bool ida_export store_til(til_t *ti, const char *tildir, const char *name);


idaman void ida_export free_til(til_t *ti);


idaman til_t *ida_export load_til_header(const char *tildir, const char *name, qstring *errbuf);


//------------------------------------------------------------------------


const cm_t CM_MASK = 0x03;

const cm_t  CM_UNKNOWN   = 0x00;

const cm_t  CM_N8_F16    = 0x01;

const cm_t  CM_N64       = 0x01;

const cm_t  CM_N16_F32   = 0x02;

const cm_t  CM_N32_F48   = 0x03;

const cm_t CM_M_MASK = 0x0C;

const cm_t  CM_M_NN      = 0x00;

const cm_t  CM_M_FF      = 0x04;

const cm_t  CM_M_NF      = 0x08;

const cm_t  CM_M_FN      = 0x0C;


inline THREAD_SAFE bool is_code_far(cm_t cm) { return((cm & 4) != 0); }

inline THREAD_SAFE bool is_data_far(cm_t cm) { return((cm &= CM_M_MASK) && cm != CM_M_FN); }


const callcnv_t CM_CC_MASK = 0xF0;

const callcnv_t  CM_CC_INVALID  = 0x00;

const callcnv_t  CM_CC_UNKNOWN  = 0x10;

const callcnv_t  CM_CC_VOIDARG  = 0x20;

const callcnv_t  CM_CC_CDECL    = 0x30;

const callcnv_t  CM_CC_ELLIPSIS = 0x40;

const callcnv_t  CM_CC_STDCALL  = 0x50;

const callcnv_t  CM_CC_PASCAL   = 0x60;

const callcnv_t  CM_CC_FASTCALL = 0x70;

const callcnv_t  CM_CC_THISCALL = 0x80;

const callcnv_t  CM_CC_SWIFT    = 0x90;

const callcnv_t  CM_CC_SPOILED  = 0xA0;

const callcnv_t  CM_CC_GOLANG   = 0xB0;

const callcnv_t  CM_CC_RESERVE3 = 0xC0;

const callcnv_t  CM_CC_SPECIALE = 0xD0;

const callcnv_t  CM_CC_SPECIALP = 0xE0;

const callcnv_t  CM_CC_SPECIAL  = 0xF0;

const callcnv_t  CM_CC_LAST_USERCALL = 0xFF;


const callcnv_t  CM_CC_GOSTK         = 0x100;


const callcnv_t  CM_CC_FIRST_PLAIN_CUSTOM = 0x200; // please note that variadic or usercall

                                                   // codes have their own ranges

// recommendation:

//   use 0x100 and higher for new calling convention codes.

//   max calling convention code is MAX_DT.

//   however, for calling conventions with special traits the following code may be used:

//     - usercall variations may use values between 0xD0..0xFF.

//     - ellipsis variations may use values 0x40..0x4F and 0xD0..0xDF.


const type_t BFA_NORET   = 0x01;

const type_t BFA_PURE    = 0x02;

const type_t BFA_HIGH    = 0x04;

const type_t BFA_STATIC  = 0x08;

const type_t BFA_VIRTUAL = 0x10;


const cm_t   BFA_FUNC_MARKER     = 0x0F;

const type_t BFA_FUNC_EXT_FORMAT = 0x80;


#ifndef SWIG

#define ARGLOC_HELPER_DEFINITIONS(decl) \

decl void ida_export copy_argloc(argloc_t *dst, const argloc_t *src); \

decl void ida_export cleanup_argloc(argloc_t *vloc);\

decl int ida_export compare_arglocs(const argloc_t &a, const argloc_t &b);

#else

#define ARGLOC_HELPER_DEFINITIONS(decl)

#endif // SWIG

ARGLOC_HELPER_DEFINITIONS(idaman)


typedef int argloc_type_t;

const argloc_type_t

  ALOC_NONE   = 0,

  ALOC_STACK  = 1,

  ALOC_DIST   = 2,

  ALOC_REG1   = 3,

  ALOC_REG2   = 4,

  ALOC_RREL   = 5,

  ALOC_STATIC = 6,

  ALOC_CUSTOM = 7;


struct rrel_t

{

  sval_t off;

  int reg;

};


class scattered_aloc_t;


struct custloc_desc_t

{

  size_t cbsize;

  const char *name;


  void (idaapi *copy)(argloc_t *empty_dst, const argloc_t &src);


  void (idaapi *cleanup)(argloc_t *loc);


  bool (idaapi *verify)(

        const argloc_t &loc,

        int size,

        const rangeset_t *gaps,

        bool part_of_scattered);


  int (idaapi *compare)(const argloc_t &a, const argloc_t &b);


  size_t (idaapi *print)(

        char *buf,

        size_t bufsize,

        const argloc_t &loc,

        asize_t size,

        int praloc_flags); // PRALOC_...


  bool (idaapi *deref_field)(

        argloc_t *out,

        tinfo_t *tif,

        const argloc_t &strloc,

        const tinfo_t &struct_tif,

        asize_t off,

        const qstring &name);


  bool (idaapi *deref_array)(

        argloc_t *out,

        tinfo_t *tif,

        const argloc_t &arrloc,

        const tinfo_t &array_tif,

        asize_t n,

        asize_t elsize);


  bool (idaapi *deref_ptr)(

        argloc_t *out,

        tinfo_t *tif,

        const argloc_t &ptrloc);


  bool (idaapi *read_value)(

        value_union_t *value,

        const argloc_t &loc,

        int size,

        const tinfo_t &tif);


  bool (idaapi *write_value)(

        const argloc_t &loc,

        const idc_value_t &idcv,

        const value_union_t &scalar_value,

        int size,

        qstring *errbuf);


  asize_t (idaapi *calc_string_length)(

        const argloc_t &loc,

        const tinfo_t &string_tif);


  bool (idaapi *get_string)(

        qstring *out,

        tinfo_t *elem_tif,

        const argloc_t &loc,

        const tinfo_t &string_tif,

        size_t len);


  asize_t (idaapi *guess_array_size)(

        const argloc_t &loc,

        const tinfo_t &array_tif);


  bool (idaapi *get_tinfo)(

        tinfo_t *out,

        const argloc_t &loc);


  int (idaapi *calc_number_of_children)(const argloc_t &loc, const tinfo_t &tif);


  size_t (idaapi *print_ptr_value)(

        char *buf,

        size_t bufsize,

        bool *is_valid_ptr,

        const argloc_t &loc,

        const tinfo_t &tif);

};


idaman int ida_export install_custom_argloc(const custloc_desc_t *custloc);

idaman bool ida_export remove_custom_argloc(int idx);

idaman const custloc_desc_t *ida_export retrieve_custom_argloc(int idx);


class argloc_t // #argloc

{

public:

  typedef size_t biggest_t;


private:

  argloc_type_t type;

  union

  {

    sval_t sval;                // ::ALOC_STACK, ::ALOC_STATIC

    uint32 reginfo;             // ::ALOC_REG1, ::ALOC_REG2

    rrel_t *rrel;               // ::ALOC_RREL

    scattered_aloc_t *dist;     // ::ALOC_DIST

    void *custom;               // ::ALOC_CUSTOM

    biggest_t biggest;          // to facilitate manipulation of this union

  };

  ARGLOC_HELPER_DEFINITIONS(friend)


public:

  argloc_t() : type(ALOC_NONE), biggest(0) {}

  argloc_t(const argloc_t &r) : type(ALOC_NONE) { copy_argloc(this, &r); }

  ~argloc_t() { cleanup_argloc(this); }

  argloc_t &operator=(const argloc_t &r) { copy_argloc(this, &r); return *this; }

  DEFINE_MEMORY_ALLOCATION_FUNCS()


  void swap(argloc_t &r)

  {

    biggest_t tmp = biggest; biggest = r.biggest; r.biggest = tmp;

    argloc_type_t t = type; type = r.type; r.type = t;

  }


  const char *dstr() const;


  argloc_type_t atype() const { return type; }

  bool is_reg1()       const { return type == ALOC_REG1; }

  bool is_reg2()       const { return type == ALOC_REG2; }

  bool is_reg()        const { return type == ALOC_REG1 || type == ALOC_REG2; }

  bool is_rrel()       const { return type == ALOC_RREL; }

  bool is_ea()         const { return type == ALOC_STATIC; }

  bool is_stkoff()     const { return type == ALOC_STACK; }

  bool is_scattered()  const { return type == ALOC_DIST; }

  inline bool has_reg() const;

  inline bool has_stkoff() const;

  inline bool is_mixed_scattered() const;

  inline bool in_stack() const;

  bool is_fragmented() const { return type == ALOC_DIST || type == ALOC_REG2; }

  bool is_custom()     const { return type >= ALOC_CUSTOM; }

  bool is_badloc()     const { return type == ALOC_NONE; }


  int reg1() const { return uint16(reginfo); }


  int regoff() const { return uint16(reginfo >> 16); }


  int reg2() const { return uint16(reginfo >> 16); }


  uint32 get_reginfo() const { return reginfo; }


  sval_t stkoff() const { return sval; }


  ea_t get_ea() const { return sval; }


        scattered_aloc_t &scattered()       { return *dist; }

  const scattered_aloc_t &scattered() const { return *dist; }


        rrel_t &get_rrel()       { return *rrel; }

  const rrel_t &get_rrel() const { return *rrel; }


  void *get_custom() const { return custom; }


  biggest_t get_biggest() const { return biggest; }


  // be careful with these functions, they do not cleanup!

  void _set_badloc() { type = ALOC_NONE; }

  void _set_reg1(int reg, int off=0) { type = ALOC_REG1; reginfo = reg | (off << 16); }

  void _set_reg2(int _reg1, int _reg2) { type = ALOC_REG2; reginfo = _reg1 | (_reg2 << 16); }

  void _set_stkoff(sval_t off) { type = ALOC_STACK; sval = off; }

  void _set_ea(ea_t _ea) { type = ALOC_STATIC; sval = _ea; }

  bool _consume_rrel(rrel_t *p) //lint -sem(argloc_t::_consume_rrel, custodial(1))

  {

    if ( p == nullptr )

      return false;

    type = ALOC_RREL;

    rrel = p;

    return true;

  }

  bool _consume_scattered(scattered_aloc_t *p)

  {

    if ( p == nullptr )

      return false;

    type = ALOC_DIST;

    dist = p;

    return true;

  }


  void _set_custom(argloc_type_t ct, void *pdata) { type = ct; custom = pdata; }


  void _set_biggest(argloc_type_t ct, biggest_t data) { type = ct; biggest = data; }


  void set_reg1(int reg, int off=0) { cleanup_argloc(this); _set_reg1(reg, off); }


  void set_reg2(int _reg1, int _reg2) { cleanup_argloc(this); _set_reg2(_reg1, _reg2); }


  void set_stkoff(sval_t off) { cleanup_argloc(this); _set_stkoff(off); }


  void set_ea(ea_t _ea) { cleanup_argloc(this); _set_ea(_ea); }


  void consume_rrel(rrel_t *p) { cleanup_argloc(this); _consume_rrel(p); }


  void consume_scattered(scattered_aloc_t *p) { cleanup_argloc(this); _consume_scattered(p); }


  void set_badloc() { cleanup_argloc(this); }


  sval_t calc_offset() const

  {

    switch ( type )

    {

      default:

      case ALOC_NONE:

      case ALOC_DIST:

      case ALOC_REG2:

        return -1;

      case ALOC_RREL:

        return rrel->off;

      case ALOC_STACK:

      case ALOC_STATIC:

        return sval;

      case ALOC_REG1:

        return reg1();

    }

  }


  bool advance(int delta)

  {

    switch ( type )

    {

      case ALOC_REG1:

        _set_reg1(reg1()+delta, regoff());

        break;

      case ALOC_STACK:

      case ALOC_STATIC:

        sval += delta;

        break;

      case ALOC_RREL:

        rrel->off += delta;

        break;

      default:

        return false;

    }

    return true;

  }


  void align_reg_high(size_t size, size_t _slotsize)

  {

    if ( is_reg1() )

      _set_reg1(reg1(), size < _slotsize ? _slotsize - size : 0);

  }


  void align_stkoff_high(size_t size, size_t _slotsize)

  {

    if ( is_stkoff() )

    {

      sval_t off = align_down(stkoff(), _slotsize);

      if ( size < _slotsize )

        off += _slotsize - size;

      _set_stkoff(off);

    }

  }


  DECLARE_COMPARISONS(argloc_t)

  {

    return compare_arglocs(*this, r);

  }

};


DECLARE_TYPE_AS_MOVABLE(argloc_t);

typedef qvector<argloc_t> arglocs_t;


struct argpart_t : public argloc_t

{

  ushort off;

  ushort size;

  DEFINE_MEMORY_ALLOCATION_FUNCS()

  argpart_t(const argloc_t &a) : argloc_t(a), off(0xFFFF), size(0) {}


  argpart_t() : off(0xFFFF), size(0) {}

  argpart_t &copy_from(const argloc_t &a) { *(argloc_t*)this = a; return *this; }


  bool bad_offset() const { return off == 0xFFFF; }


  bool bad_size() const { return size == 0; }


  bool operator < (const argpart_t &r) const { return off < r.off; }


  void swap(argpart_t &r)

  {

    argloc_t::swap(r);

    qswap(off, r.off);

    qswap(size, r.size);

  }


};

DECLARE_TYPE_AS_MOVABLE(argpart_t);

typedef qvector<argpart_t> argpartvec_t;


class scattered_aloc_t : public argpartvec_t

{

public:

  DEFINE_MEMORY_ALLOCATION_FUNCS()

};


DECLARE_TYPE_AS_MOVABLE(scattered_aloc_t);


idaman int ida_export verify_argloc(const argloc_t &vloc, int size, const rangeset_t *gaps);


idaman bool ida_export optimize_argloc(argloc_t *vloc, int size, const rangeset_t *gaps);


idaman size_t ida_export print_argloc(

        char *buf,

        size_t bufsize,

        const argloc_t &vloc,

        int size=0,

        int vflags=0);

#define PRALOC_VERIFY 0x01

#define PRALOC_STKOFF 0x02


struct aloc_visitor_t

{

  virtual int idaapi visit_location(argloc_t &v, int off, int size) = 0;

  virtual ~aloc_visitor_t() {}

};


idaman int ida_export for_all_arglocs(aloc_visitor_t &vv, argloc_t &vloc, int size, int off=0);


struct const_aloc_visitor_t

{

  virtual int idaapi visit_location(const argloc_t &v, int off, int size) = 0;

  virtual ~const_aloc_visitor_t() {}

};


inline int idaapi for_all_const_arglocs(const_aloc_visitor_t &vv, const argloc_t &vloc, int size, int off=0)

{

  return for_all_arglocs(*(aloc_visitor_t*)(&vv),

                         CONST_CAST(argloc_t&)(vloc),

                         size,

                         off);

}


//--------------------------------------------------------------------------

const cm_t C_PC_TINY    = (CM_N16_F32 | CM_M_NN);

const cm_t C_PC_SMALL   = (CM_N16_F32 | CM_M_NN);

const cm_t C_PC_COMPACT = (CM_N16_F32 | CM_M_NF);

const cm_t C_PC_MEDIUM  = (CM_N16_F32 | CM_M_FN);

const cm_t C_PC_LARGE   = (CM_N16_F32 | CM_M_FF);

const cm_t C_PC_HUGE    = (CM_N16_F32 | CM_M_FF);

const cm_t C_PC_FLAT    = (CM_N32_F48 | CM_M_NN);


// Helper functions that maintain binary compatibility with old plugins

// (when possible) yet let us work with 32-bit calling convention codes.


inline callcnv_t helper_get_cc(cm_t cm, callcnv_t new_callcnv)

{

  cm_t cc = cm & CM_CC_MASK;

  if ( cc == CM_CC_RESERVE3 )

    return new_callcnv;

  else

    return cc;

}


inline void helper_set_cc(cm_t *cm, callcnv_t *new_callcnv, callcnv_t cc)

{

  *cm &= ~CM_CC_MASK;

  if ( (cc & ~CM_CC_MASK) == 0 && cc != CM_CC_RESERVE3 )

  {

    *cm |= cc;

    *new_callcnv = 0;

  }

  else

  {

    *cm |= CM_CC_RESERVE3;

    *new_callcnv = cc;

  }

}


inline callcnv_t compiler_info_t::get_cc() const { return helper_get_cc(cm, _new_callcnv); }

inline void compiler_info_t::set_cc(callcnv_t cc) { helper_set_cc(&cm, &_new_callcnv, cc); }


inline callcnv_t get_effective_cc(callcnv_t cc)

{

  // if the calling convention is not specified, use the default one

  if ( cc <= CM_CC_UNKNOWN )

    cc = inf_get_callcnv();

  return cc;

}


inline constexpr THREAD_SAFE bool is_user_cc(callcnv_t cc)

{

  return cc >= CM_CC_SPECIALE && cc <= CM_CC_LAST_USERCALL;

}


inline constexpr THREAD_SAFE bool is_vararg_cc(callcnv_t cc)

{

  cc &= ~0xF; // the range of vararg codes is 0x40..0x4F and 0xD0..0xDF.

  return cc == CM_CC_ELLIPSIS || cc == CM_CC_SPECIALE;

}


inline constexpr THREAD_SAFE bool is_purging_cc(callcnv_t cc)

{

  cc &= ~0xF; // mask out the last 4 bits

  return cc == CM_CC_STDCALL

      || cc == CM_CC_PASCAL

      || cc == CM_CC_SPECIALP

      || cc == CM_CC_FASTCALL

      || cc == CM_CC_THISCALL

      || cc == CM_CC_SWIFT;

}


inline constexpr bool is_golang_cc(callcnv_t cc)

{

  return cc == CM_CC_GOLANG || cc == CM_CC_GOSTK;

}


inline bool is_custom_callcnv(callcnv_t cc)

{

  if ( cc >= CM_CC_FIRST_PLAIN_CUSTOM )

    return true;

  if ( cc <= 0xFF && (cc & ~CM_CC_MASK) != 0 )

    return true;

  return false;

}


inline constexpr bool is_swift_cc(callcnv_t cc)

{

  return cc == CM_CC_SWIFT;

}


//-------------------------------------------------------------------------

idaman bool ida_export get_stkarg_area_info(

        stkarg_area_info_t *out,

        callcnv_t cc);


struct stkarg_area_info_t

{

  size_t cb = sizeof(stkarg_area_info_t);


  sval_t stkarg_offset = 0;


  sval_t shadow_size = 0;


  sval_t linkage_area = 0;


  stkarg_area_info_t() = default;

  stkarg_area_info_t(callcnv_t cc) { get_info(cc); }

  bool get_info(callcnv_t cc) { return get_stkarg_area_info(this, cc); }

};


//--------------------------------------------------------------------------


struct custom_callcnv_t

{

  int cbsize = sizeof(*this);

  uint64 flags = 0;

#define CCI_VARARG 0x0001

#define CCI_PURGE  0x0002

#define CCI_USER   0x0004

  qstring name;

  uint32 abibits = 0;


  bool is_vararg() const { return (flags & CCI_VARARG) != 0; }

  bool is_purging() const { return (flags & CCI_PURGE) != 0; }

  bool is_usercall() const { return (flags & CCI_USER) != 0; }


  virtual bool validate_func(const func_type_data_t &fti, qstring *reterr) const

  {

    qnotused(fti);

    qnotused(reterr);

    return true;

  }


  virtual bool calc_retloc(func_type_data_t *fti) const = 0;


  virtual bool calc_arglocs(func_type_data_t *fti) const = 0;


  virtual ssize_t find_varargs(

        func_type_data_t *fti,

        ea_t call_ea,

        class mblock_t *blk) const

  {

    qnotused(call_ea);

    qnotused(fti);

    qnotused(blk);

    return 0;

  }


  virtual bool calc_varglocs(

        func_type_data_t *fti,

        regobjs_t *regs,

        relobj_t *stkargs,

        int nfixed) const

  {

    qnotused(fti);

    qnotused(regs);

    qnotused(stkargs);

    qnotused(nfixed);

    return false;

  }


  virtual bool get_cc_regs(callregs_t *out) const

  {

    qnotused(out);

    return false;

  }


  virtual bool get_stkarg_area_info(stkarg_area_info_t *out) const

  {

    qnotused(out);

    return false;

  }


  virtual int calc_purged_bytes(

        const func_type_data_t &fti,

        ea_t call_ea=BADADDR) const

  {

    qnotused(fti);

    qnotused(call_ea);

    return 0;

  }


  inline virtual bool decorate_name(

        qstring *outbuf,

        const char *name,

        bool should_decorate,

        callcnv_t cc,

        const tinfo_t &type) const;


  virtual int lower_func_type(func_type_data_t *fti) const

  {

    qnotused(fti);

    return 0;

  }


  custom_callcnv_t() = default;


  custom_callcnv_t(const char *_name, uint64 f, uint32 _abibits)

    : flags(f), name(_name), abibits(_abibits)

  {}


  virtual ~custom_callcnv_t() {}

#ifndef SWIG

  DECLARE_COMPARISONS(custom_callcnv_t);

#endif

};


DECLARE_TYPE_AS_MOVABLE(custom_callcnv_t);


idaman callcnv_t ida_export register_custom_callcnv(const custom_callcnv_t &ccinf);


idaman bool ida_export unregister_custom_callcnv(callcnv_t callcnv);


idaman const custom_callcnv_t *ida_export get_custom_callcnv(callcnv_t callcnv);


idaman callcnv_t ida_export find_custom_callcnv(const char *name);


idaman size_t ida_export get_custom_callcnvs(qstrvec_t *names, callcnvs_t *codes);


//--------------------------------------------------------------------------


enum argreg_policy_t

{

  ARGREGS_POLICY_UNDEFINED,

  ARGREGS_GP_ONLY,

  ARGREGS_INDEPENDENT,

  ARGREGS_BY_SLOTS,

  ARGREGS_FP_MASKS_GP,

  ARGREGS_MIPS_O32,

  ARGREGS_RISCV,

};


class callregs_t

{

  bool set_inds(int *p_ind1, int *p_ind2, int ind) const

  {

    if ( ind == -1 )

      return false;

    *p_ind1 = ind;

    *p_ind2 = by_slots() ? ind : -1;

    return true;

  }


  // copy -1-terminated array to a vector

  static void set_regarray(intvec_t *regvec, const int *regarray)

  {

    regvec->clear();

    if ( regarray != nullptr )

      while ( *regarray != -1 )

        regvec->push_back(*regarray++);

  }

  void calc_nregs()

  {

    nregs = gpregs.size();

    if ( policy == ARGREGS_INDEPENDENT

      || policy == ARGREGS_FP_MASKS_GP

      || policy == ARGREGS_RISCV )

    {

      nregs += int(fpregs.size());

    }

  }


public:

  argreg_policy_t policy = ARGREGS_POLICY_UNDEFINED;

  int nregs = 0;

  intvec_t gpregs;

  intvec_t fpregs;


  callregs_t() {}


  callregs_t(callcnv_t cc) { init_regs(cc); }


  void swap(callregs_t &r)

  {

    std::swap(policy, r.policy);

    std::swap(nregs, r.nregs);

    gpregs.swap(r.gpregs);

    fpregs.swap(r.fpregs);

  }


  bool init_regs(callcnv_t cc)

  {

    if ( is_custom_callcnv(cc) )

    {

      const custom_callcnv_t *ccc = get_custom_callcnv(cc);

      if ( ccc == nullptr )

        return false;

      return ccc->get_cc_regs(this);

    }

    return processor_t::get_cc_regs(this, cc) > 0;

  }


  // policy-specific options

  bool by_slots() const { return policy == ARGREGS_BY_SLOTS; }


  void set(argreg_policy_t _policy, const int *gprs, const int *fprs)

  {

    policy = _policy;

    set_regarray(&gpregs, gprs);

    set_regarray(&fpregs, fprs);

    calc_nregs();

  }


  enum reg_kind_t { GPREGS, FPREGS };


  void append_registers(reg_kind_t kind, int first_reg, int last_reg)

  {

    intvec_t &regvec = kind == FPREGS ? fpregs : gpregs;

    size_t n = regvec.size();

    regvec.resize(n + last_reg - first_reg + 1);

    for ( int i = first_reg; i <= last_reg; ++i )

      regvec[n + i - first_reg] = i;

  }


  void set_registers(reg_kind_t kind, int first_reg, int last_reg)

  {

    intvec_t &regvec = kind == FPREGS ? fpregs : gpregs;

    regvec.clear();

    append_registers(kind, first_reg, last_reg);

  }


  void reset()

  {

    set(ARGREGS_POLICY_UNDEFINED, nullptr, nullptr);

  }


  static int regcount(callcnv_t cc)

  {

    callregs_t vr(cc);

    return vr.nregs;

  }


  // return index of register, -1 else


  static int findreg(const intvec_t &regs, int r)

  {

    intvec_t::const_iterator p = regs.find(r);

    return p == regs.end() ? -1 : (p-regs.begin());

  }


  bool reginds(int *gp_ind, int *fp_ind, int r) const

  {

    return findregs(gp_ind, fp_ind, r, gpregs, fpregs);

  }


protected:


  bool findregs(int *gp_ind, int *fp_ind, int r, const intvec_t &gprs, const intvec_t &fprs) const

  {

    *gp_ind = *fp_ind = -1;

    return set_inds(gp_ind, fp_ind, findreg(gprs, r))

        || set_inds(fp_ind, gp_ind, findreg(fprs, r));

  }


};


//--------------------------------------------------------------------------


const comp_t  COMP_MASK    = 0x0F;

const comp_t  COMP_UNK     = 0x00;

const comp_t  COMP_MS      = 0x01;

const comp_t  COMP_BC      = 0x02;

const comp_t  COMP_WATCOM  = 0x03;

// const comp_t  COMP_         = 0x04

// const comp_t  COMP_         = 0x05

const comp_t  COMP_GNU     = 0x06;

const comp_t  COMP_VISAGE  = 0x07;

const comp_t  COMP_BP      = 0x08;

//----

const comp_t  COMP_UNSURE  = 0x80;


inline THREAD_SAFE comp_t get_comp(comp_t comp) { return(comp & COMP_MASK); }


idaman const char *ida_export get_compiler_name(comp_t id);


idaman const char *ida_export get_compiler_abbr(comp_t id);


typedef qvector<comp_t> compvec_t;


idaman void ida_export get_compilers(compvec_t *ids, qstrvec_t *names, qstrvec_t *abbrs);


inline THREAD_SAFE comp_t is_comp_unsure(comp_t comp) { return (comp & COMP_UNSURE); }


inline comp_t default_compiler() { return get_comp(inf_get_cc_id()); }


inline bool is_gcc() { return default_compiler() == COMP_GNU; }


inline bool is_gcc32() { return is_gcc() && !inf_is_64bit(); }


inline bool is_gcc64() { return is_gcc() && inf_is_64bit(); }


inline bool gcc_layout() { return is_gcc() || (inf_get_abibits() & ABI_GCC_LAYOUT) != 0; }


idaman bool ida_export set_compiler(

        const compiler_info_t &cc,

        int flags,

        const char *abiname=nullptr);


#define SETCOMP_OVERRIDE 0x0001

#define SETCOMP_ONLY_ID  0x0002

#define SETCOMP_ONLY_ABI 0x0004

#define SETCOMP_BY_USER  0x0008


inline bool idaapi set_compiler_id(comp_t id, const char *abiname=nullptr)

{

  compiler_info_t cc;

  cc.id = id;

  return set_compiler(cc, SETCOMP_ONLY_ID, abiname);

}


inline bool idaapi set_abi_name(const char *abiname, bool user_level = false)

{

  compiler_info_t cc;

  cc.id = 0;

  int flags = SETCOMP_ONLY_ABI | (user_level ? SETCOMP_BY_USER : 0);

  return set_compiler(cc, flags, abiname);

}


idaman ssize_t ida_export get_abi_name(qstring *out);


idaman bool ida_export append_abi_opts(const char *abi_opts, bool user_level = false);

idaman bool ida_export remove_abi_opts(const char *abi_opts, bool user_level = false);


idaman bool ida_export set_compiler_string(const char *compstr, bool user_level);


inline bool use_golang_cc()

{

  return is_golang_cc(inf_get_callcnv());

}


inline void switch_to_golang()

{

  inf_set_callcnv(CM_CC_GOLANG);

  if ( default_compiler() == COMP_UNK )

    set_compiler_id(COMP_GNU);

}


//--------------------------------------------------------------------------

const size_t BADSIZE = size_t(-1);

#define MAX_FUNC_ARGS   256


//--------------------------------------------------------------------------


enum abs_t

{

  ABS_UNK,

  ABS_NO,

  ABS_YES

};


enum sclass_t

{

  SC_UNK    = 0,

  SC_TYPE   = 1,

  SC_EXT    = 2,

  SC_STAT   = 3,

  SC_REG    = 4,

  SC_AUTO   = 5,

  SC_FRIEND = 6,

  SC_VIRT   = 7,

};


#define HTI_CPP         0x00000001

#define HTI_INT         0x00000002

#define HTI_EXT         0x00000004

#define HTI_LEX         0x00000008

#define HTI_UNP         0x00000010

#define HTI_TST         0x00000020

#define HTI_FIL         0x00000040

#define HTI_MAC         0x00000080

#define HTI_NWR         0x00000100

#define HTI_NER         0x00000200

#define HTI_DCL         0x00000400

#define HTI_NDC         0x00000800

#define HTI_PAK         0x00007000

#define HTI_PAK_SHIFT 12

#define HTI_PAKDEF      0x00000000

#define HTI_PAK1        0x00001000

#define HTI_PAK2        0x00002000

#define HTI_PAK4        0x00003000

#define HTI_PAK8        0x00004000

#define HTI_PAK16       0x00005000

#define HTI_HIGH        0x00008000

#define HTI_LOWER       0x00010000

#define HTI_RAWARGS     0x00020000

#define HTI_RELAXED     0x00080000

#define HTI_NOBASE      0x00100000

#define HTI_SEMICOLON   0x00200000

#define HTI_STANDALONE  0x00400000


typedef int idaapi h2ti_type_cb(

        const char *name,

        const tinfo_t &tif,

        const char *cmt,

        const uint64 *value,

        void *cb_data);


typedef AS_PRINTF(1, 2) int printer_t(const char *format, ...);


idaman int ida_export h2ti(

        til_t *ti,

        lexer_t *lx,

        const char *input,

        int flags=HTI_HIGH,

        h2ti_type_cb *type_cb=nullptr,

        h2ti_type_cb *var_cb=nullptr,

        printer_t *print_cb=nullptr,

        void *_cb_data=nullptr,

        abs_t _isabs=ABS_UNK);


inline THREAD_SAFE int convert_pt_flags_to_hti(int pt_flags)

{

  return ((pt_flags >> 4) & 0x1f) << HTI_PAK_SHIFT;

}


idaman bool ida_export parse_decl(

        tinfo_t *out_tif,

        qstring *out_name,

        til_t *til,

        const char *decl,

        int pt_flags);


#define PT_SIL       0x0001

#define PT_NDC       0x0002

#define PT_TYP       0x0004

#define PT_VAR       0x0008

#define PT_PACKMASK  0x0070

#define PT_HIGH      0x0080

#define PT_LOWER     0x0100

#define PT_REPLACE   0x0200

#define PT_RAWARGS   0x0400

#define PT_RELAXED   0x1000

#define PT_EMPTY     0x2000

#define PT_SEMICOLON 0x4000

#define PT_SYMBOL    0x8000


idaman int ida_export parse_decls(

        til_t *til,

        const char *input,

        printer_t *printer,

        int hti_flags);


idaman bool ida_export print_type(qstring *out, ea_t ea, int prtype_flags);


#define PRTYPE_1LINE   0x00000

#define PRTYPE_MULTI   0x00001

#define PRTYPE_TYPE    0x00002

#define PRTYPE_PRAGMA  0x00004

#define PRTYPE_SEMI    0x00008

#define PRTYPE_CPP     0x00010

#define PRTYPE_DEF     0x00020

#define PRTYPE_NOARGS  0x00040

#define PRTYPE_NOARRS  0x00080

#define PRTYPE_NORES   0x00100

#define PRTYPE_RESTORE 0x00200

#define PRTYPE_NOREGEX 0x00400

#define PRTYPE_COLORED 0x00800

#define PRTYPE_METHODS 0x01000

#define PRTYPE_1LINCMT 0x02000

#define PRTYPE_HEADER  0x04000

#define PRTYPE_OFFSETS 0x08000

#define PRTYPE_MAXSTR  0x10000

#define PRTYPE_TAIL    0x20000

#define PRTYPE_ARGLOCS 0x40000


idaman int ida_export get_named_type(

        const til_t *ti,

        const char *name,

        int ntf_flags,

        const type_t **type=nullptr,

        const p_list **fields=nullptr,

        const char **cmt=nullptr,

        const p_list **fieldcmts=nullptr,

        sclass_t *sclass=nullptr,

        uint32 *value=nullptr);


#define NTF_TYPE       0x0001

#define NTF_SYMU       0x0008

#define NTF_SYMM       0x0000

#define NTF_NOBASE     0x0002

#define NTF_REPLACE    0x0004

#define NTF_UMANGLED   0x0008

#define NTF_NOCUR      0x0020

#define NTF_64BIT      0x0040

#define NTF_FIXNAME    0x0080

#define NTF_IDBENC     0x0100

#define NTF_CHKSYNC    0x0200

#define NTF_NO_NAMECHK 0x0400

#define NTF_COPY       0x1000


inline int idaapi get_named_type64(

        const til_t *ti,

        const char *name,

        int ntf_flags,

        const type_t **type=nullptr,

        const p_list **fields=nullptr,

        const char **cmt=nullptr,

        const p_list **fieldcmts=nullptr,

        sclass_t *sclass=nullptr,

        uint64 *value=nullptr)

{

  return get_named_type(ti, name, ntf_flags | NTF_64BIT,

                        type, fields, cmt, fieldcmts, sclass, (uint32 *)value);

}


enum tinfo_code_t

{

  TERR_OK          =   0,

  TERR_SAVE_ERROR  =  -1,

  TERR_SERIALIZE   =  -2,

  TERR_BAD_NAME    =  -3,

  TERR_BAD_ARG     =  -4,

  TERR_BAD_TYPE    =  -5,

  TERR_BAD_SIZE    =  -6,

  TERR_BAD_INDEX   =  -7,

  TERR_BAD_ARRAY   =  -8,

  TERR_BAD_BF      =  -9,

  TERR_BAD_OFFSET  = -10,

  TERR_BAD_UNIVAR  = -11,

  TERR_BAD_VARLAST = -12,

  TERR_OVERLAP     = -13,

  TERR_BAD_SUBTYPE = -14,

  TERR_BAD_VALUE   = -15,

  TERR_NO_BMASK    = -16,

  TERR_BAD_BMASK   = -17,

  TERR_BAD_MSKVAL  = -18,

  TERR_BAD_REPR    = -19,

  TERR_GRP_NOEMPTY = -20,

  TERR_DUPNAME     = -21,

  TERR_UNION_BF    = -22,

  TERR_BAD_TAH     = -23,

  TERR_BAD_BASE    = -24,

  TERR_BAD_GAP     = -25,

  TERR_NESTED      = -26,

  TERR_NOT_COMPAT  = -27,

  TERR_BAD_LAYOUT  = -28,

  TERR_BAD_GROUPS  = -29,

  TERR_BAD_SERIAL  = -30,

  TERR_ALIEN_NAME  = -31,

  TERR_STOCK       = -32,

  TERR_ENUM_SIZE   = -33,

  TERR_NOT_IMPL    = -34,

  TERR_TYPE_WORSE  = -35,

  TERR_BAD_FX_SIZE = -36,

  TERR_STRUCT_SIZE = -37,

  TERR_NOT_FOUND   = -38,

  TERR_COUNT       =  39,

};


idaman const char *ida_export tinfo_errstr(tinfo_code_t code);


idaman bool ida_export del_named_type(til_t *ti, const char *name, int ntf_flags);


idaman const char *ida_export first_named_type(const til_t *ti, int ntf_flags);


idaman const char *ida_export next_named_type(

        const til_t *ti,

        const char *name,

        int ntf_flags);


idaman uint32 ida_export copy_named_type(

        til_t *dsttil,

        const til_t *srctil,

        const char *name);


idaman bool ida_export decorate_name(

        qstring *out,

        const char *name,

        bool should_decorate,

        callcnv_t cc=CM_CC_UNKNOWN,

        const tinfo_t *type = nullptr);


idaman bool ida_export gen_decorate_name(

        qstring *out,

        const char *name,

        bool should_decorate,

        callcnv_t cc,

        const tinfo_t *type);


inline bool custom_callcnv_t::decorate_name(

        qstring *out,

        const char *_name,

        bool should_decorate,

        callcnv_t /*cc*/,

        const tinfo_t &type) const

{

  return gen_decorate_name(out, _name, should_decorate, CM_CC_FASTCALL, &type);

}


idaman ssize_t ida_export calc_c_cpp_name(

        qstring *out,

        const char *name,

        const tinfo_t *type,

        int ccn_flags);

#define CCN_C         0x00   // prepare C name

#define CCN_CPP       0x01   // prepare C++ name


//--------------------------------------------------------------------------


idaman bool ida_export enable_numbered_types(til_t *ti, bool enable);


idaman bool ida_export get_numbered_type(

        const til_t *ti,

        uint32 ordinal,

        const type_t **type=nullptr,

        const p_list **fields=nullptr,

        const char **cmt=nullptr,

        const p_list **fieldcmts=nullptr,

        sclass_t *sclass=nullptr);


idaman uint32 ida_export alloc_type_ordinals(til_t *ti, int qty);


inline uint32 alloc_type_ordinal(til_t *ti) { return alloc_type_ordinals(ti, 1); }


idaman uint32 ida_export get_ordinal_limit(const til_t *ti=nullptr);


inline uint32 get_ordinal_count(const til_t *ti=nullptr)

{

  uint32 maxord = get_ordinal_limit(ti);

  return maxord == 0 || maxord == uint32(-1) ? 0 : maxord - 1;

}


idaman bool ida_export del_numbered_type(til_t *ti, uint32 ordinal);


idaman bool ida_export set_type_alias(til_t *ti, uint32 src_ordinal, uint32 dst_ordinal);


idaman uint32 ida_export get_alias_target(const til_t *ti, uint32 ordinal);


idaman int32 ida_export get_type_ordinal(const til_t *ti, const char *name);


idaman const char *ida_export get_numbered_type_name(const til_t *ti, uint32 ordinal);


idaman ssize_t ida_export create_numbered_type_name(qstring *buf, int32 ord);


idaman bool ida_export is_ordinal_name(const char *name, uint32 *ord=nullptr);


idaman void ida_export build_anon_type_name(

        qstring *buf,

        const type_t *type,

        const p_list *fields);


idaman int ida_export compact_numbered_types(

        til_t *ti,

        uint32 min_ord=0,

        intvec_t *p_ordmap=nullptr,

        int flags=0);


idaman bool ida_export is_type_choosable(const til_t *ti, uint32 ordinal);


idaman void ida_export set_type_choosable(til_t *ti, uint32 ordinal, bool value);


//--------------------------------------------------------------------------


idaman ea_t ida_export get_vftable_ea(uint32 ordinal);


idaman uint32 ida_export get_vftable_ordinal(ea_t vftable_ea);


idaman bool ida_export set_vftable_ea(uint32 ordinal, ea_t vftable_ea);


inline bool del_vftable_ea(uint32 ordinal) { return set_vftable_ea(ordinal, BADADDR); }


//--------------------------------------------------------------------------

// ALIGNMENT


inline size_t get_default_align() { return inf_get_cc_defalign(); }


inline THREAD_SAFE void align_size(size_t &cur_tot_size, size_t elem_size, size_t algn)

{

  size_t al = elem_size;

  if ( algn != 0 && algn < al )

    al = algn;

  cur_tot_size = align_up(cur_tot_size, al);

}


idaman bool ida_export deref_ptr(

        ea_t *ptr_ea,

        const tinfo_t &tif,

        ea_t *closure_obj=nullptr);


idaman bool ida_export remove_tinfo_pointer(tinfo_t *tif, const char **pname, const til_t *til=nullptr);


idaman int ida_export add_til(const char *name, int flags);


#define ADDTIL_DEFAULT  0x0000

#define ADDTIL_INCOMP   0x0001

#define ADDTIL_SILENT   0x0002


#define ADDTIL_FAILED   0

#define ADDTIL_OK       1

#define ADDTIL_COMP     2

#define ADDTIL_ABORTED  3


idaman bool ida_export del_til(const char *name);


idaman bool ida_export apply_named_type(ea_t ea, const char *name);


idaman bool ida_export apply_tinfo(

        ea_t ea,

        const tinfo_t &tif,

        uint32 flags);


#define TINFO_GUESSED    0x0000

#define TINFO_DEFINITE   0x0001

#define TINFO_DELAYFUNC  0x0002

#define TINFO_STRICT     0x0004


idaman bool ida_export apply_cdecl(til_t *til, ea_t ea, const char *decl, int flags=0);


idaman bool ida_export apply_callee_tinfo(ea_t caller, const tinfo_t &tif);


idaman bool ida_export get_arg_addrs(eavec_t *out, ea_t caller);


idaman bool ida_export apply_once_tinfo_and_name(

        ea_t dea,

        const tinfo_t &tif,

        const char *name);


// To retrieve the type information attach to an address, use get_tinfo() function

// (see nalt.hpp)


idaman int ida_export guess_tinfo(tinfo_t *out, tid_t id);


#define GUESS_FUNC_FAILED   0

#define GUESS_FUNC_TRIVIAL  1

#define GUESS_FUNC_OK       2


// The following functions should eventually be replaced by exported functions

#ifndef __KERNEL__

inline void set_c_header_path(const char *incdir)           { setinf_buf(INF_H_PATH, incdir); }


inline ssize_t get_c_header_path(qstring *buf)              { return getinf_str(buf, INF_H_PATH); }


inline void set_c_macros(const char *macros)                { setinf_buf(INF_C_MACROS, macros); }


inline ssize_t get_c_macros(qstring *buf)                   { return getinf_str(buf, INF_C_MACROS); }

#endif


//------------------------------------------------------------------------

// HIGH LEVEL FUNCTIONS TO SUPPORT TILS IN THE IDA KERNEL


idaman til_t *ida_export get_idati();


idaman bool ida_export get_idainfo_by_type(

        size_t *out_size,

        flags64_t *out_flags,

        opinfo_t *out_mt,

        const tinfo_t &tif,

        size_t *out_alsize=nullptr);


idaman bool ida_export get_tinfo_by_flags(tinfo_t *out, flags64_t flags);


//------------------------------------------------------------------------

// Type information object: tinfo_t


struct ptr_type_data_t;

struct udt_type_data_t;

struct enum_type_data_t;

struct array_type_data_t;

struct typedef_type_data_t;

struct bitfield_type_data_t;

struct udtmembervec_t;


enum stock_type_id_t

{

  STI_PCHAR,

  STI_PUCHAR,

  STI_PCCHAR,

  STI_PCUCHAR,

  STI_PBYTE,

  STI_PINT,

  STI_PUINT,

  STI_PVOID,

  STI_PPVOID,

  STI_PCVOID,

  STI_ACHAR,

  STI_AUCHAR,

  STI_ACCHAR,

  STI_ACUCHAR,

  STI_FPURGING,

  STI_FDELOP,

  STI_MSGSEND,

  STI_AEABI_LCMP,

  STI_AEABI_ULCMP,

  STI_DONT_USE,

  STI_SIZE_T,

  STI_SSIZE_T,

  STI_AEABI_MEMCPY,

  STI_AEABI_MEMSET,

  STI_AEABI_MEMCLR,

  STI_RTC_CHECK_2,

  STI_RTC_CHECK_4,

  STI_RTC_CHECK_8,

  STI_COMPLEX64,

  STI_COMPLEX128,

  STI_PUNKNOWN,

  STI_LAST

};


enum etf_flag_t : uint

{

  ETF_NO_SAVE     = 0x00000001,

  ETF_NO_LAYOUT   = 0x00000002,

  ETF_MAY_DESTROY = 0x00000004,

  ETF_COMPATIBLE  = 0x00000008,

  ETF_FUNCARG     = 0x00000010,

  ETF_FORCENAME   = 0x00000020,

  ETF_AUTONAME    = 0x00000040,

  ETF_BYTIL       = 0x00000080,

  ETF_NO_ARRAY    = 0x00000100,

};


enum gtd_udt_t

{

  GTD_CALC_LAYOUT = 0,

  GTD_NO_LAYOUT   = BTM_VOLATILE,

  GTD_DEL_BITFLDS = BTM_CONST,

};


enum gtd_func_t

{

  GTD_CALC_ARGLOCS = 0,

  GTD_NO_ARGLOCS = BTM_VOLATILE,

};


enum gts_code_t

{

  GTS_NESTED = 0x01,

  GTS_BASECLASS = 0x02,

};


#define SUDT_SORT     0x0001

#define SUDT_ALIGN    0x0002

#define SUDT_GAPS     0x0004

#define SUDT_UNEX     0x0008

#define SUDT_FAST     0x0010


#define SUDT_CONST    0x0040

#define SUDT_VOLATILE 0x0080


#define SUDT_TRUNC    0x0100

#define SUDT_SERDEF   0x0200


typedef uint64 typid_t;


#define DECLARE_TINFO_HELPERS(decl)\

decl void ida_export copy_tinfo_t(tinfo_t *_this, const tinfo_t &r); \

decl bool ida_export detach_tinfo_t(tinfo_t *_this); \

decl void ida_export clear_tinfo_t(tinfo_t *_this);\

decl bool ida_export create_tinfo(tinfo_t *_this, type_t bt, type_t bt2, void *ptr);\

decl int  ida_export verify_tinfo(typid_t typid);\

decl bool ida_export get_tinfo_details(typid_t typid, type_t bt2, void *buf);\

decl size_t ida_export get_tinfo_size(uint32 *p_effalign, typid_t typid, int gts_code);\

decl size_t ida_export get_tinfo_pdata(void *outptr, typid_t typid, int what);\

decl size_t ida_export get_tinfo_property(typid_t typid, int gta_prop);\

decl size_t ida_export get_tinfo_property4(typid_t typid, int gta_prop, size_t p1, size_t p2, size_t p3, size_t p4);\

decl size_t ida_export set_tinfo_property(tinfo_t *tif, int sta_prop, size_t x);\

decl size_t ida_export set_tinfo_property4(tinfo_t *tif, int sta_prop, size_t p1, size_t p2, size_t p3, size_t p4);\

decl bool ida_export serialize_tinfo(qtype *type, qtype *fields, qtype *fldcmts, const tinfo_t *tif, int sudt_flags);\

decl bool ida_export deserialize_tinfo(tinfo_t *tif, const til_t *til, const type_t **ptype, const p_list **pfields, const p_list **pfldcmts, const char *cmt);\

decl int  ida_export find_tinfo_udt_member(udm_t *udm, typid_t typid, int strmem_flags);\

decl bool ida_export print_tinfo(qstring *result, const char *prefix, int indent, int cmtindent, int flags, const tinfo_t *tif, const char *name, const char *cmt);\

decl const char *ida_export dstr_tinfo(const tinfo_t *tif);\

decl int  ida_export visit_subtypes(struct tinfo_visitor_t *visitor, struct type_mods_t *out, const tinfo_t &tif, const char *name, const char *cmt);\

decl bool ida_export compare_tinfo(typid_t t1, typid_t t2, int tcflags);\

decl int  ida_export lexcompare_tinfo(typid_t t1, typid_t t2, int);\

decl bool ida_export get_stock_tinfo(tinfo_t *tif, stock_type_id_t id);\

decl uint64 ida_export read_tinfo_bitfield_value(typid_t typid, uint64 v, int bitoff);\

decl uint64 ida_export write_tinfo_bitfield_value(typid_t typid, uint64 dst, uint64 v, int bitoff);\

decl bool ida_export get_tinfo_attr(typid_t typid, const qstring &key, bytevec_t *bv, bool all_attrs);\

decl bool ida_export set_tinfo_attr(tinfo_t *tif, const type_attr_t &ta, bool may_overwrite);\

decl bool ida_export del_tinfo_attr(tinfo_t *tif, const qstring &key, bool make_copy);\

decl bool ida_export get_tinfo_attrs(typid_t typid, type_attrs_t *tav, bool include_ref_attrs);\

decl bool ida_export set_tinfo_attrs(tinfo_t *tif, type_attrs_t *ta);\

decl uint32 ida_export score_tinfo(const tinfo_t *tif);\

decl tinfo_code_t ida_export save_tinfo(tinfo_t *tif, til_t *til, size_t ord, const char *name, int ntf_flags);\

decl bool ida_export append_tinfo_covered(rangeset_t *out, typid_t typid, uint64 offset);\

decl bool ida_export calc_tinfo_gaps(rangeset_t *out, typid_t typid);\

decl bool ida_export name_requires_qualifier(qstring *out, typid_t typid, const char *name, uint64 offset);\

decl bool ida_export value_repr_t__from_opinfo(value_repr_t *_this, flags64_t flags, aflags_t afl, const opinfo_t *opinfo, const array_parameters_t *ap); \

decl size_t ida_export value_repr_t__print_(const value_repr_t *_this, qstring *result, bool colored); \

decl bool ida_export value_repr_t__parse_value_repr(value_repr_t *_this, const qstring &attr, type_t target_type); \

decl ssize_t ida_export udt_type_data_t__find_member(const udt_type_data_t *_this, udm_t *udm, int strmem_flags); \

decl ssize_t ida_export udt_type_data_t__get_best_fit_member(const udt_type_data_t *_this, asize_t disp); \

decl uchar ida_export enum_type_data_t__get_max_serial(const enum_type_data_t *ei, uint64 value); \

decl tinfo_code_t ida_export enum_type_data_t__set_value_repr(enum_type_data_t *ei, const value_repr_t &repr); \

decl tinfo_code_t ida_export enum_type_data_t__get_value_repr(const enum_type_data_t *ei, value_repr_t *repr); \

decl void ida_export tinfo_get_innermost_udm(tinfo_t *itif, const tinfo_t *tif, uint64 offset, size_t *udm_idx, uint64 *bit_offset, bool return_member_type); \

decl ssize_t ida_export get_udm_by_tid(tinfo_t *tif, udm_t *udm, tid_t tid); \

decl ssize_t ida_export get_edm_by_tid(tinfo_t *tif, edm_t *edm, tid_t tid); \

decl bool ida_export get_type_by_tid(tinfo_t *tif, tid_t tid); \

decl tid_t ida_export get_tinfo_tid(tinfo_t *tif, bool force_tid); \

decl ssize_t ida_export get_tinfo_by_edm_name(tinfo_t *tif, const til_t *til, const char *mname); \

decl ssize_t ida_export get_frame_var(tinfo_t *tif, sval_t *actval, const insn_t &insn, const op_t *x, sval_t v); \

decl bool ida_export tinfo_get_func_frame(tinfo_t *tif, const func_t *pfn); \


DECLARE_TINFO_HELPERS(idaman)


const int FIRST_NONTRIVIAL_TYPID = 0x100;

const int TYPID_ISREF = 0x100;

const int TYPID_SHIFT = 9;


class tinfo_t // #tinfo_t #tif

{

  typid_t typid;

  bool create_type(type_t decl_type, type_t bt2, void *details)

  {

    return create_tinfo(this, decl_type, bt2, details);

  }

  bool get_type_details(type_t bt2, void *buf) const { return get_tinfo_details(typid, bt2, buf); }

  void copy(const tinfo_t &r) { copy_tinfo_t(this, r); }

  DECLARE_TINFO_HELPERS(friend)

  friend struct type_detail_t;

  friend tinfo_t remove_pointer(const tinfo_t &tif);

  enum gta_prop_t

  {

    GTA_DECLALIGN,

    GTA_RESOLVE,

    GTA_REALTYPE,

    GTA_TYPE_SIGN,

    GTA_FROM_SUBTIL,

    GTA_IS_FORWARD,

    GTA_IS_FUNCPTR,

    GTA_ORDINAL,

    GTA_FINAL_ORDINAL,

    GTA_PTR_OBJ,

    GTA_SAFE_PTR_OBJ,

    GTA_ARRAY_ELEM,

    GTA_ARRAY_NELEMS,

    GTA_PTRARR_SUBTIF,

    GTA_PTRARR_SIZE,

    GTA_UNPADDED_SIZE,

    GTA_UDT_NMEMBERS,

    GTA_IS_SMALL_UDT,

    GTA_ONEMEM_TYPE,

    GTA_ENUM_BASE_TYPE,

    GTA_FUNC_CC,

    GTA_PURGED_BYTES,

    GTA_IS_HIGH_TYPE,

    GTA_FUNC_NARGS,

    GTA_FUNC_RET,

    GTA_FUNC_ARG,

    GTA_LAST_FUNC_ARG = GTA_FUNC_ARG + 255,

    GTA_IS_SSE_TYPE,

    GTA_IS_ANON_UDT,

    GTA_OBSOLETE1,

    GTA_HAS_VFTABLE,

    GTA_IS_SHIFTED_PTR,

    GTA_IS_VARSTRUCT,

    GTA_IS_VARMEMBER,

    GTA_IS_TYPEDEF,

    GTA_FINAL_ELEM,

    GTA_FORWARD_TYPE,

    GTA_BITMASK,

    GTA_ENUM_RADIX,

    GTA_EDM,

    GTA_EDM_BYVAL,

    GTA_EDM_BYNAME,

    GTA_HAS_UNION,

    GTA_UDM_TID,

    GTA_ALIAS,

    GTA_EDM_TID,

    GTA_FRAME_FUNC,

    GTA_UDM_IS_BYTIL,

    GTA_OBSOLETE2,

    GTA_EDT_NMEMBERS,

    GTA_ENUM_WIDTH,

    GTA_ENUM_REPR,

    GTA_UDT_BITS,

  };

  enum sta_prop_t

  {

    STA_DECLALIGN,

    STA_TYPE_SIGN,

    STA_UDT_ALIGN,

    STA_UDT_METHODS,

    STA_RENAME,

    STA_COMMENT,

    STA_CLR_MODIFS,

    STA_SET_SDA,

    STA_SET_PACK,

    STA_ADD_UDM,

    STA_DEL_UDMS,

    STA_UDM_NAME,

    STA_UDM_TYPE,

    STA_UDM_CMT,

    STA_UDM_REPR,

    STA_EXPAND_UDT,

    STA_ENUM_WIDTH,

    STA_ENUM_SIGN,

    STA_BITMASK,

    STA_ENUM_REPR,

    STA_ADD_EDM,

    STA_DEL_EDMS,

    STA_EDM_NAME,

    STA_EDM_CMT,

    STA_EDIT_EDM,

    STA_ALIAS,

    STA_ALIGNMENT,

    STA_UDM_SET_BYTIL,

    STA_FIXED_STRUCT,

    STA_STRUCT_SIZE,

    STA_FUNCARG_NAME,

    STA_FUNCARG_TYPE,

    STA_FUNC_RETTYPE,

    STA_DEL_FUNCARGS,

    STA_ADD_FUNCARG,

    STA_FUNC_CC,

    STA_ENUM_RADIX,

    STA_FUNCARG_LOC,

    STA_FUNC_RETLOC,

    STA_TUPLE,

  };

  enum gta_pdata_t

  {

    GTP_NAME,

    GTP_NEXT_NAME,

    GTP_FINAL_NAME,

    GTP_TIL,

    GTP_UDT_METHODS,

    GTP_COMMENT,

    GTP_RPTCMT,

    GTP_BIT_BUCKETS,

    GTP_NICE_NAME,

  };


public:

  tinfo_t() : typid(BT_UNK) {}

  explicit tinfo_t(type_t decl_type) : typid(decl_type) {}


  explicit tinfo_t(const char *decl, til_t *til=nullptr, int pt_flags=0)

     : typid(0)

  {

    parse(decl, til, pt_flags);

  }


  tinfo_t(const tinfo_t &r) : typid(0) { copy(r); }

  tinfo_t &operator=(const tinfo_t &r) { copy(r); return *this; }

  ~tinfo_t() { clear(); }

  void clear() { clear_tinfo_t(this); }

  void swap(tinfo_t &r) { typid_t tmp = typid; typid = r.typid; r.typid = tmp; }

  DEFINE_MEMORY_ALLOCATION_FUNCS()


  inline bool get_named_type(

        const til_t *til,

        const char *name,

        type_t decl_type=BTF_TYPEDEF,

        bool resolve=true,

        bool try_ordinal=true);


  inline bool get_named_type(const char *name, type_t decl_type=BTF_TYPEDEF, bool resolve=true, bool try_ordinal=true) { return get_named_type(nullptr, name, decl_type, resolve, try_ordinal); }


  inline bool get_numbered_type(

        const til_t *til,

        uint32 ordinal,

        type_t decl_type=BTF_TYPEDEF,

        bool resolve=true);


  inline bool get_numbered_type(uint32 ordinal, type_t decl_type=BTF_TYPEDEF, bool resolve=true) { return get_numbered_type(nullptr, ordinal, decl_type, resolve); }


  bool detach() { return detach_tinfo_t(this); }


  bool serialize(

        qtype *type,

        qtype *fields=nullptr,

        qtype *fldcmts=nullptr,

        int sudt_flags=SUDT_FAST|SUDT_TRUNC) const

  {

    return serialize_tinfo(type, fields, fldcmts, this, sudt_flags);

  }


  bool deserialize(

        const til_t *til,

        const type_t **ptype,

        const p_list **pfields=nullptr,

        const p_list **pfldcmts=nullptr,

        const char *cmt=nullptr)

  {

    return deserialize_tinfo(this, til, ptype, pfields, pfldcmts, cmt);

  }


  bool deserialize(

        const til_t *til,

        const qtype *ptype,

        const qtype *pfields=nullptr,

        const qtype *pfldcmts=nullptr,

        const char *cmt=nullptr)

  {

    const type_t *tp = ptype->begin();

    const p_list *fp = pfields == nullptr ? nullptr : pfields->begin();

    const p_list *cp = pfldcmts == nullptr ? nullptr : pfldcmts->begin();

    const p_list **pfp = fp == nullptr ? nullptr : &fp;

    const p_list **pcp = cp == nullptr ? nullptr : &cp;

    return deserialize(til, &tp, pfp, pcp, cmt);

  }


  bool is_correct() const { return verify_tinfo(typid) == 0; }


  type_t get_realtype(bool full=false) const { return (type_t)get_tinfo_property(typid, full ? GTA_RESOLVE : GTA_REALTYPE); }


  THREAD_SAFE type_t get_decltype() const { return type_t(typid); }


  THREAD_SAFE bool empty() const { return get_decltype() == BT_UNK; }


  bool present() const { return get_realtype() != BT_UNK; }


  size_t get_size(uint32 *p_effalign=nullptr, int gts_code=0) const { return get_tinfo_size(p_effalign, typid, gts_code); }


  size_t get_unpadded_size() const { return get_tinfo_property(typid, GTA_UNPADDED_SIZE); }


  uint32 get_alignment() const

  {

    uint32 alignment = 0;

    get_size(&alignment);

    return alignment;

  }


  type_sign_t get_sign() const { return get_tinfo_property(typid, GTA_TYPE_SIGN); }


  bool is_signed() const { return get_sign() == type_signed; }


  bool is_unsigned() const { return get_sign() == type_unsigned; }


  uchar get_declalign() const { return uchar(get_tinfo_property(typid, GTA_DECLALIGN)); }


  THREAD_SAFE bool is_typeref() const { return (typid & TYPID_ISREF) != 0; }


  THREAD_SAFE bool has_details() const { return typid >= FIRST_NONTRIVIAL_TYPID; }


  bool get_type_name(qstring *out) const { return is_typeref() && get_tinfo_pdata(out, typid, GTP_NAME); }


  bool get_nice_type_name(qstring *out) const { return is_typeref() && get_tinfo_pdata(out, typid, GTP_NICE_NAME); }


  tinfo_code_t rename_type(const char *name, int ntf_flags=0) { return tinfo_code_t(set_tinfo_property4(this, STA_RENAME, size_t(name), size_t(NTF_TYPE|ntf_flags), 0, 0)); }


  bool get_final_type_name(qstring *out) const { return is_typeref() && get_tinfo_pdata(out, typid, GTP_FINAL_NAME); }


  bool get_next_type_name(qstring *out) const { return is_typeref() && get_tinfo_pdata(out, typid, GTP_NEXT_NAME); }


  tid_t get_tid() const { return get_tinfo_tid((tinfo_t *)this, false); }


  tid_t force_tid() { return get_tinfo_tid(this, true); }


  uint32 get_ordinal() const { return get_tinfo_property(typid, GTA_ORDINAL); }


  uint32 get_final_ordinal() const { return get_tinfo_property(typid, GTA_FINAL_ORDINAL); }


  til_t *get_til() const { til_t *til; get_tinfo_pdata(&til, typid, GTP_TIL); return til; }


  bool is_from_subtil() const { return is_typeref() && get_tinfo_property(typid, GTA_FROM_SUBTIL); }


  bool is_forward_decl() const { return bool(get_tinfo_property(typid, GTA_IS_FORWARD)); }


  type_t get_forward_type() const { return get_tinfo_property(typid, GTA_FORWARD_TYPE); }

  bool is_forward_struct() const { return is_type_struct(get_forward_type()); }

  bool is_forward_union() const { return is_type_union(get_forward_type()); }

  bool is_forward_enum() const { return is_type_enum(get_forward_type()); }


  bool is_typedef() const { return get_tinfo_property(typid, GTA_IS_TYPEDEF) != 0; }


  int get_type_cmt(qstring *out) const { return has_details() ? get_tinfo_pdata(out, typid, GTP_COMMENT) : 0; }


  bool get_type_rptcmt(qstring *out) const { return has_details() && get_tinfo_pdata(out, typid, GTP_RPTCMT); }


  THREAD_SAFE bool is_decl_const() const    { return is_type_const(get_decltype());  }


  THREAD_SAFE bool is_decl_volatile() const { return is_type_volatile(get_decltype()); }


  THREAD_SAFE bool is_decl_void() const     { return is_type_void(get_decltype());     }


  THREAD_SAFE bool is_decl_partial() const  { return is_type_partial(get_decltype());  }


  THREAD_SAFE bool is_decl_unknown() const  { return is_type_unknown(get_decltype());  }


  THREAD_SAFE bool is_decl_last() const     { return is_typeid_last(get_decltype());   }


  THREAD_SAFE bool is_decl_ptr() const      { return is_type_ptr(get_decltype());      }


  THREAD_SAFE bool is_decl_array() const    { return is_type_array(get_decltype());    }


  THREAD_SAFE bool is_decl_func() const     { return is_type_func(get_decltype());     }


  THREAD_SAFE bool is_decl_complex() const  { return is_type_complex(get_decltype());  }


  THREAD_SAFE bool is_decl_typedef() const  { return is_type_typedef(get_decltype());  }


  THREAD_SAFE bool is_decl_sue() const      { return is_type_sue(get_decltype());      }


  THREAD_SAFE bool is_decl_struct() const   { return is_type_struct(get_decltype());   }


  THREAD_SAFE bool is_decl_union() const    { return is_type_union(get_decltype());    }


  THREAD_SAFE bool is_decl_udt() const      { return is_type_struni(get_decltype());   }


  THREAD_SAFE bool is_decl_enum() const     { return is_type_enum(get_decltype());     }


  THREAD_SAFE bool is_decl_bitfield() const { return is_type_bitfld(get_decltype());   }


  THREAD_SAFE bool is_decl_int128() const   { return is_type_int128(get_decltype());   }


  THREAD_SAFE bool is_decl_int64() const    { return is_type_int64(get_decltype());    }


  THREAD_SAFE bool is_decl_int32() const    { return is_type_int32(get_decltype());    }


  THREAD_SAFE bool is_decl_int16() const    { return is_type_int16(get_decltype());    }


  THREAD_SAFE bool is_decl_int() const      { return is_type_int(get_decltype());      }


  THREAD_SAFE bool is_decl_char() const     { return is_type_char(get_decltype());     }


  THREAD_SAFE bool is_decl_uint() const     { return is_type_uint(get_decltype());     }


  THREAD_SAFE bool is_decl_uchar() const    { return is_type_uchar(get_decltype());    }


  THREAD_SAFE bool is_decl_uint16() const   { return is_type_uint16(get_decltype());   }


  THREAD_SAFE bool is_decl_uint32() const   { return is_type_uint32(get_decltype());   }


  THREAD_SAFE bool is_decl_uint64() const   { return is_type_uint64(get_decltype());   }


  THREAD_SAFE bool is_decl_uint128() const  { return is_type_uint128(get_decltype());  }


  THREAD_SAFE bool is_decl_ldouble() const  { return is_type_ldouble(get_decltype());  }


  THREAD_SAFE bool is_decl_double() const   { return is_type_double(get_decltype());   }


  THREAD_SAFE bool is_decl_float() const    { return is_type_float(get_decltype());    }


  THREAD_SAFE bool is_decl_tbyte() const    { return is_type_tbyte(get_decltype());    }


  THREAD_SAFE bool is_decl_floating() const { return is_type_floating(get_decltype()); }


  THREAD_SAFE bool is_decl_bool() const     { return is_type_bool(get_decltype());     }


  THREAD_SAFE bool is_decl_paf() const      { return is_type_paf(get_decltype());      }


  THREAD_SAFE bool is_well_defined() const  { return !empty() && !is_decl_partial() && !is_punknown(); }


  // Probe the resolved type for various attributes:


  bool is_const() const    { return is_type_const(get_realtype()); }


  bool is_volatile() const { return is_type_volatile(get_realtype()); }


  bool is_void() const     { return is_type_void(get_realtype());     }


  bool is_partial() const  { return is_type_partial(get_realtype());  }


  bool is_unknown() const  { return is_type_unknown(get_realtype());  }


  bool is_ptr() const      { return is_type_ptr(get_realtype());      }


  bool is_array() const    { return is_type_array(get_realtype());    }


  bool is_func() const     { return is_type_func(get_realtype());     }


  bool is_complex() const  { return is_type_complex(get_realtype());  }


  bool is_struct() const   { return is_type_struct(get_realtype());   }


  bool is_union() const    { return is_type_union(get_realtype());    }


  bool is_udt() const      { return is_type_struni(get_realtype());   }


  bool is_enum() const     { return is_type_enum(get_realtype());     }


  bool is_sue() const      { return is_type_sue(get_realtype());      }


  bool is_bitfield() const { return is_type_bitfld(get_realtype());   }


  bool is_int128() const   { return is_type_int128(get_realtype());   }


  bool is_int64() const    { return is_type_int64(get_realtype());    }


  bool is_int32() const    { return is_type_int32(get_realtype());    }


  bool is_int16() const    { return is_type_int16(get_realtype());    }


  bool is_int() const      { return is_type_int(get_realtype());      }


  bool is_char() const     { return is_type_char(get_realtype());     }


  bool is_uint() const     { return is_type_uint(get_realtype());     }


  bool is_uchar() const    { return is_type_uchar(get_realtype());    }


  bool is_uint16() const   { return is_type_uint16(get_realtype());   }


  bool is_uint32() const   { return is_type_uint32(get_realtype());   }


  bool is_uint64() const   { return is_type_uint64(get_realtype());   }


  bool is_uint128() const  { return is_type_uint128(get_realtype());  }


  bool is_ldouble() const  { return is_type_ldouble(get_realtype());  }


  bool is_double() const   { return is_type_double(get_realtype());   }


  bool is_float() const    { return is_type_float(get_realtype());    }


  bool is_tbyte() const    { return is_type_tbyte(get_realtype());    }


  bool is_bool() const     { return is_type_bool(get_realtype());     }


  bool is_paf() const      { return is_type_paf(get_realtype());      }


  bool is_ptr_or_array() const   { return is_type_ptr_or_array(get_realtype()); }


  bool is_integral() const       { return is_type_integral(get_realtype()); }


  bool is_ext_integral() const   { return is_type_ext_integral(get_realtype()); }


  bool is_floating() const       { return is_type_floating(get_realtype()); }


  bool is_arithmetic() const     { return is_type_arithmetic(get_realtype()); }


  bool is_ext_arithmetic() const { return is_type_ext_arithmetic(get_realtype()); }

  bool is_scalar() const  { type_t bt = get_realtype(); return get_base_type(bt) <= BT_PTR || is_type_enum(bt); }


  bool get_ptr_details(ptr_type_data_t *pi) const

  {

    return get_type_details(BT_PTR, pi);

  }


  bool get_array_details(array_type_data_t *ai) const

  {

    return get_type_details(BT_ARRAY, ai);

  }


  bool get_enum_details(enum_type_data_t *ei) const

  {

    return get_type_details(BTF_ENUM, ei);

  }


  bool get_bitfield_details(bitfield_type_data_t *bi) const

  {

    return get_type_details(BT_BITFIELD, bi);

  }


  bool get_udt_details(udt_type_data_t *udt, gtd_udt_t gtd=GTD_CALC_LAYOUT) const

  {

    return get_type_details(BTF_STRUCT|gtd, udt);

  }


  bool get_func_details(func_type_data_t *fi, gtd_func_t gtd=GTD_CALC_ARGLOCS) const

  {

    return get_type_details(BT_FUNC|gtd, fi);

  }


  bool is_funcptr() const { return get_tinfo_property(typid, GTA_IS_FUNCPTR) != 0; }


  bool is_shifted_ptr() const { return get_tinfo_property(typid, GTA_IS_SHIFTED_PTR) != 0; }


  bool is_varstruct() const { return get_tinfo_property(typid, GTA_IS_VARSTRUCT) != 0; }


  bool is_varmember() const { return get_tinfo_property(typid, GTA_IS_VARMEMBER) != 0; }


  int get_ptrarr_objsize() const { return get_tinfo_property(typid, GTA_PTRARR_SIZE); }


  tinfo_t get_ptrarr_object() const { tinfo_t r; r.typid = get_tinfo_property(typid, GTA_PTRARR_SUBTIF); return r; }


  tinfo_t get_pointed_object() const { tinfo_t r; r.typid = get_tinfo_property(typid, GTA_PTR_OBJ); return r; }


  bool is_pvoid() const { return get_pointed_object().is_void(); }


  bool is_punknown() const { return get_pointed_object().is_unknown(); }


  tinfo_t get_array_element() const { tinfo_t r; r.typid = get_tinfo_property(typid, GTA_ARRAY_ELEM); return r; }


  tinfo_t get_final_element() const { tinfo_t r; r.typid = get_tinfo_property(typid, GTA_FINAL_ELEM); return r; }


  int get_array_nelems() const { return get_tinfo_property(typid, GTA_ARRAY_NELEMS); }


  tinfo_t get_nth_arg(int n) const

  {

    tinfo_t r;

    if ( n >= -1 && n < MAX_FUNC_ARGS )

      r.typid = get_tinfo_property(typid, GTA_FUNC_ARG+n);

    return r;

  }


  tinfo_t get_rettype() const { return get_nth_arg(-1); }


  int get_nargs() const { return get_tinfo_property(typid, GTA_FUNC_NARGS); }


  callcnv_t get_cc() const { return (callcnv_t)get_tinfo_property(typid, GTA_FUNC_CC); }

  bool is_user_cc() const { return ::is_user_cc(get_cc()); }


  bool is_vararg_cc() const { return ::is_vararg_cc(get_cc()); }


  bool is_purging_cc() const { return ::is_purging_cc(get_cc()); }


  int calc_purged_bytes() const { return get_tinfo_property(typid, GTA_PURGED_BYTES); }


  bool is_high_func() const { return get_tinfo_property(typid, GTA_IS_HIGH_TYPE) != 0; }


  bool get_methods(udtmembervec_t *methods) const { return get_tinfo_pdata(methods, typid, GTP_UDT_METHODS) != 0; }


  bool get_bit_buckets(range64vec_t *buckets) const { return get_tinfo_pdata(buckets, typid, GTP_BIT_BUCKETS) != 0; }


  int find_udm(udm_t *udm, int strmem_flags) const { return find_tinfo_udt_member(udm, typid, strmem_flags); }

#define STRMEM_MASK    0x000F

#define   STRMEM_OFFSET 0x0000

#define   STRMEM_INDEX  0x0001

#define   STRMEM_AUTO   0x0002

#define   STRMEM_NAME   0x0003

#define   STRMEM_TYPE   0x0004

#define   STRMEM_SIZE   0x0005

#define   STRMEM_MINS   0x0006

#define   STRMEM_MAXS   0x0007

#define   STRMEM_LOWBND 0x0008

#define   STRMEM_NEXT   0x0009


#define STRMEM_VFTABLE     0x10000000

#define STRMEM_SKIP_EMPTY  0x20000000

#define STRMEM_CASTABLE_TO 0x40000000

#define STRMEM_ANON        0x80000000

#define STRMEM_SKIP_GAPS   0x01000000


  inline int find_udm(uint64 offset, int strmem_flags=0) const;


  inline int find_udm(const char *name, int strmem_flags=0) const;


  inline int get_udm(udm_t *out, const char *name) const;


  inline int get_udm(udm_t *out, size_t index) const;


  inline int get_udm_by_offset(udm_t *out, uint64 offset) const;


  int get_udt_nmembers() const { return get_tinfo_property(typid, GTA_UDT_NMEMBERS); }


  bool is_empty_udt() const { return get_udt_nmembers() == 0; }


  bool is_small_udt() const { return get_tinfo_property(typid, GTA_IS_SMALL_UDT) != 0; }


  uint32 get_udt_taudt_bits() const { return get_tinfo_property(typid, GTA_UDT_BITS); }


  bool is_unaligned_struct() const { return (get_udt_taudt_bits() & TAUDT_UNALIGNED) != 0; }


  bool is_msstruct() const { return (get_udt_taudt_bits() & TAUDT_MSSTRUCT) != 0; }


  bool is_cpp_struct() const { return (get_udt_taudt_bits() & TAUDT_CPPOBJ) != 0; }


  bool is_vftable() const { return (get_udt_taudt_bits() & TAUDT_VFTABLE) != 0; }


  bool is_fixed_struct() const  { return (get_udt_taudt_bits() & TAUDT_FIXED) != 0; }


  bool is_tuple() const  { return (get_udt_taudt_bits() & TAUDT_TUPLE) != 0; }


  bool requires_qualifier(qstring *out, const char *name, uint64 offset) const { return name_requires_qualifier(out, typid, name, offset); }


  bool append_covered(rangeset_t *out, uint64 offset=0) const { return append_tinfo_covered(out, typid, offset); }


  bool calc_gaps(rangeset_t *out) const { return calc_tinfo_gaps(out, typid); }


  bool is_one_fpval() const { return get_onemember_type().is_floating(); }


  bool is_sse_type() const { return get_tinfo_property(typid, GTA_IS_SSE_TYPE) != 0; }


  bool is_anonymous_udt() const { return get_tinfo_property(typid, GTA_IS_ANON_UDT) != 0; }


  bool has_vftable() const { return get_tinfo_property(typid, GTA_HAS_VFTABLE) != 0; }


  bool has_union() const { return get_tinfo_property(typid, GTA_HAS_UNION) != 0; }


  size_t get_enum_nmembers() const { return get_tinfo_property(typid, GTA_EDT_NMEMBERS); }


  bool is_empty_enum() const { return get_enum_nmembers() == 0; }


  type_t get_enum_base_type() const { return (type_t)get_tinfo_property(typid, GTA_ENUM_BASE_TYPE); }


  bool is_bitmask_enum() const { return get_tinfo_property(typid, GTA_BITMASK) != 0; }


  int get_enum_radix() const { return get_tinfo_property(typid, GTA_ENUM_RADIX); }


  tinfo_code_t get_enum_repr(value_repr_t *repr) const { return tinfo_code_t(get_tinfo_property4(typid, GTA_ENUM_REPR, size_t(repr), 0, 0, 0)); }


  int get_enum_width() const { return get_tinfo_property(typid, GTA_ENUM_WIDTH); }

  uint64 calc_enum_mask() const { return make_mask<uint64>(get_enum_width()*8); }


  ssize_t get_edm(edm_t *out, const char *name) const { return get_tinfo_property4(typid, GTA_EDM_BYNAME, size_t(out), size_t(name), 0, 0); }


  tinfo_code_t get_edm(edm_t *edm, size_t idx) const { return tinfo_code_t(get_tinfo_property4(typid, GTA_EDM, size_t(edm), idx, 0, 0)); }


  ssize_t get_edm_by_value(edm_t *out, uint64 value, bmask64_t bmask=DEFMASK64, uchar serial=0) const { return get_tinfo_property4(typid, GTA_EDM_BYVAL, size_t(out), value, bmask, serial); }


  tid_t get_edm_tid(size_t idx) const { return get_tinfo_property4(typid, GTA_EDM_TID, idx, 0, 0, 0); }


  tinfo_t get_onemember_type() const { tinfo_t r; r.typid = get_tinfo_property(typid, GTA_ONEMEM_TYPE); return r; }


  tinfo_t get_innermost_udm(uint64 bitoffset, size_t *out_index=nullptr, uint64 *out_bitoffset=nullptr) const { tinfo_t itif; tinfo_get_innermost_udm(&itif, this, bitoffset, out_index, out_bitoffset, false); return itif; }


  tinfo_t get_innermost_member_type(uint64 bitoffset, uint64 *out_bitoffset=nullptr) const { tinfo_t itif; tinfo_get_innermost_udm(&itif, this, bitoffset, nullptr, out_bitoffset, true); return itif; }


  uint32 calc_score() const { return score_tinfo(this); }


  bool print(

        qstring *out,

        const char *name=nullptr,

        int prtype_flags=PRTYPE_1LINE,

        int indent=0,

        int cmtindent=0,

        const char *prefix=nullptr,

        const char *cmt=nullptr) const

  {

    return print_tinfo(out, prefix, indent, cmtindent, prtype_flags, this, name, cmt);

  }


  const char *dstr() const { return dstr_tinfo(this); }


  bool get_attrs(type_attrs_t *tav, bool all_attrs=false) const { return get_tinfo_attrs(typid, tav, all_attrs); }


  bool get_attr(const qstring &key, bytevec_t *bv, bool all_attrs=true) const { return get_tinfo_attr(typid, key, bv, all_attrs); }


  bool set_attrs(type_attrs_t *tav) { return set_tinfo_attrs(this, tav); }


  bool set_attr(const type_attr_t &ta, bool may_overwrite=true) { return set_tinfo_attr(this, ta, may_overwrite); }


  void del_attrs() { set_tinfo_attrs(this, nullptr); }


  bool del_attr(const qstring &key, bool make_copy=true) { return del_tinfo_attr(this, key, make_copy); }


  bool create_simple_type(type_t decl_type) { return create_type(decl_type, BT_INT, nullptr); }

  bool create_ptr(const ptr_type_data_t &p, type_t decl_type=BT_PTR) { return create_type(decl_type, BT_PTR, (void*)&p); }

  bool create_array(const array_type_data_t &p, type_t decl_type=BT_ARRAY) { return create_type(decl_type, BT_ARRAY, (void*)&p); }

  bool create_bitfield(const bitfield_type_data_t &p, type_t decl_type=BT_BITFIELD) { return create_type(decl_type, BT_BITFIELD, (void*)&p); }


  bool create_typedef(const typedef_type_data_t &p, type_t decl_type=BTF_TYPEDEF, bool try_ordinal=true)

  {

    type_t bt2 = try_ordinal ? BTF_TYPEDEF : BTF_TYPEDEF|BTM_VOLATILE;

    return create_type(decl_type, bt2, (void *)&p);

  }


  inline bool create_ptr(const tinfo_t &tif, uchar bps=0, type_t decl_type=BT_PTR);

  inline bool create_array(const tinfo_t &tif, uint32 nelems=0, uint32 base=0, type_t decl_type=BT_ARRAY);

  inline void create_typedef(const til_t *til, const char *name, type_t decl_type=BTF_TYPEDEF, bool try_ordinal=true) { get_named_type(til, name, decl_type, false, try_ordinal); }

  inline void create_typedef(const til_t *til, uint ord, type_t decl_type=BTF_TYPEDEF) { get_numbered_type(til, ord, decl_type, false); }

  inline bool create_bitfield(uchar nbytes, uchar width, bool is_unsigned=false, type_t decl_type=BT_BITFIELD);


  bool parse(const char *decl, til_t *til=nullptr, int pt_flags=0)

  {

    return ::parse_decl(this, nullptr, til, decl, pt_flags | PT_SEMICOLON);

  }


  inline bool create_udt(bool is_union=false);


  inline bool create_enum(bte_t bte=BTE_ALWAYS|BTE_HEX);


  inline bool create_udt(udt_type_data_t &p);

  bool create_udt(udt_type_data_t &p, type_t decl_type) { return create_type(decl_type, BTF_STRUCT, &p); }

  bool create_enum(enum_type_data_t &p, type_t decl_type=BTF_ENUM) { return create_type(decl_type, BTF_ENUM, &p); }

  bool create_func(func_type_data_t &p, type_t decl_type=BT_FUNC) { return create_type(decl_type, BT_FUNC, &p); }


  ssize_t get_udm_by_tid(udm_t *udm, tid_t tid) { return ::get_udm_by_tid(this, udm, tid); }

  ssize_t get_edm_by_tid(edm_t *edm, tid_t tid) { return ::get_edm_by_tid(this, edm, tid); }

  bool get_type_by_tid(tid_t tid) { return ::get_type_by_tid(this, tid); }


  ssize_t get_by_edm_name(const char *mname, const til_t *til=nullptr) { return ::get_tinfo_by_edm_name(this, til, mname); }


  tinfo_code_t set_named_type(til_t *til, const char *name, int ntf_flags=0) { return save_tinfo(this, til, 0, name, ntf_flags|NTF_TYPE); }

  tinfo_code_t set_symbol_type(til_t *til, const char *name, int ntf_flags=0) { return save_tinfo(this, til, 0, name, ntf_flags); } // NTF_SYMM and NTF_SYMU are permitted

  tinfo_code_t set_numbered_type(til_t *til, uint32 ord, int ntf_flags=0, const char *name=nullptr) { return save_tinfo(this, til, ord, name, ntf_flags); }

  tinfo_code_t save_type(int ntf_flags=NTF_TYPE|NTF_REPLACE) { return save_tinfo(this, nullptr, 0, nullptr, ntf_flags); }

  tinfo_code_t copy_type(til_t *til, const char *name, int ntf_flags=NTF_TYPE|NTF_COPY) { return save_tinfo(this, til, 0, name, ntf_flags); }


  tinfo_code_t create_forward_decl(til_t *til, type_t decl_type, const char *name, int ntf_flags=0)

  {

    create_typedef(til, "", decl_type, false);

    return set_named_type(til, name, ntf_flags);

  }


  static tinfo_t get_stock(stock_type_id_t id) { tinfo_t t; get_stock_tinfo(&t, id); return t; }


  inline bool convert_array_to_ptr();


  inline bool remove_ptr_or_array()

  {

    tinfo_t tif = get_ptrarr_object();

    if ( tif.empty() )

      return false;

    swap(tif);

    return true;

  }


  uint64 read_bitfield_value(uint64 v, int bitoff) const { return read_tinfo_bitfield_value(typid, v, bitoff); }

  uint64 write_bitfield_value(uint64 dst, uint64 v, int bitoff) const { return write_tinfo_bitfield_value(typid, dst, v, bitoff); }


  type_t get_modifiers() const { return typid & TYPE_MODIF_MASK; }

  void set_modifiers(type_t mod) { if ( !empty() ) typid = (typid & ~TYPE_MODIF_MASK) | (mod & TYPE_MODIF_MASK); }

  void set_const() { if ( !empty() ) typid |= BTM_CONST; }

  void set_volatile() { if ( !empty() ) typid |= BTM_VOLATILE; }

  // remove modifiers for trivial types, without resolving the type

  void clr_decl_const_volatile() { typid &= ~TYPE_MODIF_MASK; }

  // remove modifiers from non-trivial types. for example, if the type was defined

  // as "const struct s { int field; }", the "const" modifier will be removed.

  // however, these function cannot remove modifiers from typedefs (ex: typedef const int constint)

  bool clr_const() { return bool(set_tinfo_property(this, STA_CLR_MODIFS, BTM_CONST)); }

  bool clr_volatile() { return bool(set_tinfo_property(this, STA_CLR_MODIFS, BTM_VOLATILE)); }

  bool clr_const_volatile() { return bool(set_tinfo_property(this, STA_CLR_MODIFS, BTM_CONST|BTM_VOLATILE)); }


  tinfo_code_t set_type_alignment(uchar declalign, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_ALIGNMENT, declalign, 0, 0, etf_flags));

  }


#ifndef NO_OBSOLETE_FUNCS

  DEPRECATED bool set_declalign(uchar declalign) { return set_tinfo_property(this, STA_DECLALIGN, declalign) != 0; }

#endif


  bool change_sign(type_sign_t sign) { return set_tinfo_property(this, STA_TYPE_SIGN, sign) != 0; }


  bool calc_udt_aligns(int sudt_flags=SUDT_GAPS)

    { return set_tinfo_property(this, STA_UDT_ALIGN, sudt_flags) != 0; }


  bool set_methods(udtmembervec_t &methods)

  {

    return set_tinfo_property(this, STA_UDT_METHODS, size_t(&methods)) != 0;

  }


  tinfo_code_t set_type_cmt(const char *cmt, bool is_regcmt=false, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_COMMENT, size_t(cmt), is_regcmt, etf_flags, 0));

  }


  uint32 get_alias_target() const

  {

    return get_tinfo_property(typid, GTA_ALIAS);

  }


  bool is_aliased() const { return get_alias_target() != 0; }


  bool set_type_alias(uint32 dest_ord)

  {

    return set_tinfo_property4(this, STA_ALIAS, dest_ord, 0, 0, 0) != 0;

  }


  tinfo_code_t set_udt_alignment(int sda, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_SET_SDA, sda, 0, 0, etf_flags));

  }


  tinfo_code_t set_udt_pack(int pack, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_SET_PACK, pack, 0, 0, etf_flags));

  }


  tid_t get_udm_tid(size_t idx) const { return get_tinfo_property4(typid, GTA_UDM_TID, idx, 0, 0, 0); }


  tinfo_code_t add_udm(const udm_t &udm, uint etf_flags=0, size_t times=1, ssize_t idx=-1)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_ADD_UDM, size_t(&udm), times, idx, etf_flags));

  }


  inline tinfo_code_t add_udm(

        const char *name,

        const tinfo_t &type,

        uint64 offset=0,

        uint etf_flags=0,

        size_t times=1,

        ssize_t idx=-1);


  inline tinfo_code_t add_udm(

        const char *name,

        type_t type,

        uint64 offset=0,

        uint etf_flags=0,

        size_t times=1,

        ssize_t idx=-1);


  inline tinfo_code_t add_udm(

        const char *name,

        const char *type,

        uint64 offset=0,

        uint etf_flags=0,

        size_t times=1,

        ssize_t idx=-1);


  tinfo_code_t del_udm(size_t index, uint etf_flags=0)

  {

    return del_udms(index, index+1, etf_flags);

  }


  tinfo_code_t del_udms(size_t idx1, size_t idx2, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_DEL_UDMS, idx1, idx2, 0, etf_flags));

  }


  tinfo_code_t rename_udm(size_t index, const char *name, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_UDM_NAME, index, size_t(name), 0, etf_flags));

  }


  tinfo_code_t set_udm_type(size_t index, const tinfo_t &tif, uint etf_flags=0, const value_repr_t *repr=nullptr)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_UDM_TYPE, index, size_t(&tif), size_t(repr), etf_flags));

  }


  tinfo_code_t set_udm_cmt(size_t index, const char *cmt, bool is_regcmt=false, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_UDM_CMT, index, size_t(cmt), is_regcmt, etf_flags));

  }


  tinfo_code_t set_udm_repr(size_t index, const value_repr_t &repr, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_UDM_REPR, index, size_t(&repr), 0, etf_flags));

  }


  bool is_udm_by_til(size_t idx) const { return get_tinfo_property4(typid, GTA_UDM_IS_BYTIL, idx, 0, 0, 0) != 0; }


  tinfo_code_t set_udm_by_til(size_t idx, bool on=true, uint etf_flags=0) { return tinfo_code_t(set_tinfo_property4(this, STA_UDM_SET_BYTIL, idx, on, 0, etf_flags)); }


  tinfo_code_t set_fixed_struct(bool on=true) { return tinfo_code_t(set_tinfo_property4(this, STA_FIXED_STRUCT, on, 0, 0, 0)); }


  tinfo_code_t set_struct_size(size_t new_size) { return tinfo_code_t(set_tinfo_property4(this, STA_STRUCT_SIZE, new_size, 0, 0, 0)); }


  tinfo_code_t expand_udt(size_t idx, adiff_t delta, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_EXPAND_UDT, idx, delta, 0, etf_flags));

  }


  tinfo_code_t set_tuple(bool on=true) { return tinfo_code_t(set_tinfo_property4(this, STA_TUPLE, on, 0, 0, 0)); }


  bool get_func_frame(const func_t *pfn) { return tinfo_get_func_frame(this, pfn); }


  bool is_frame() const { return get_frame_func() != BADADDR; }


  ea_t get_frame_func() const { return get_tinfo_property4(typid, GTA_FRAME_FUNC, 0, 0, 0, 0); }


  ssize_t get_stkvar(

        sval_t *actval,

        const insn_t &insn,

        const op_t *x,

        sval_t v)

  {

    return ::get_frame_var(this, actval, insn, x, v);

  }


  tinfo_code_t set_enum_width(int nbytes, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_ENUM_WIDTH, nbytes, 0, 0, etf_flags));

  }


  tinfo_code_t set_enum_sign(type_sign_t sign, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_ENUM_SIGN, sign, 0, 0, etf_flags));

  }


  enum bitmask_cvt_stance_t

  {

    ENUMBM_OFF  = 0,

    ENUMBM_ON   = 1,

    ENUMBM_AUTO = 2,

  };


  tinfo_code_t set_enum_is_bitmask(bitmask_cvt_stance_t stance=ENUMBM_ON, uint etf_flags=0) { return tinfo_code_t(set_tinfo_property4(this, STA_BITMASK, stance, 0, 0, etf_flags)); }


  tinfo_code_t set_enum_repr(const value_repr_t &repr, uint etf_flags=0) { return tinfo_code_t(set_tinfo_property4(this, STA_ENUM_REPR, size_t(&repr), 0, 0, etf_flags)); }


  tinfo_code_t set_enum_radix(int radix, bool sign, uint etf_flags=0) { return tinfo_code_t(set_tinfo_property4(this, STA_ENUM_RADIX, radix, sign, 0, etf_flags)); }


  tinfo_code_t add_edm(const edm_t &edm, bmask64_t bmask=DEFMASK64, uint etf_flags=0, ssize_t idx=-1)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_ADD_EDM, size_t(&edm), bmask, idx, etf_flags));

  }


  inline tinfo_code_t add_edm(

        const char *name,

        uint64 value,

        bmask64_t bmask=DEFMASK64,

        uint etf_flags=0,

        ssize_t idx=-1);


  tinfo_code_t del_edms(size_t idx1, size_t idx2, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_DEL_EDMS, idx1, idx2, 0, etf_flags));

  }


  tinfo_code_t del_edm(size_t idx, uint etf_flags=0) { return del_edms(idx, idx+1, etf_flags); }


  inline tinfo_code_t del_edm(const char *name, uint etf_flags=0);


  inline tinfo_code_t del_edm_by_value(uint64 value, uint etf_flags=0, bmask64_t bmask=DEFMASK64, uchar serial=0);


  tinfo_code_t rename_edm(size_t idx, const char *name, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_EDM_NAME, idx, size_t(name), 0, etf_flags));

  }


  tinfo_code_t set_edm_cmt(size_t idx, const char *cmt, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_EDM_CMT, idx, size_t(cmt), 0, etf_flags));

  }


  tinfo_code_t edit_edm(size_t idx, uint64 value, bmask64_t bmask=DEFMASK64, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_EDIT_EDM, idx, value, bmask, etf_flags));

  }


  tinfo_code_t rename_funcarg(size_t index, const char *name, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_FUNCARG_NAME, index, size_t(name), 0, etf_flags));

  }


  tinfo_code_t set_funcarg_type(size_t index, const tinfo_t &tif, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_FUNCARG_TYPE, index, size_t(&tif), 0, etf_flags));

  }


  tinfo_code_t set_func_rettype(const tinfo_t &tif, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_FUNC_RETTYPE, size_t(&tif), 0, 0, etf_flags));

  }


  tinfo_code_t del_funcargs(size_t idx1, size_t idx2, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_DEL_FUNCARGS, idx1, idx2, 0, etf_flags));

  }


  tinfo_code_t del_funcarg(size_t idx, uint etf_flags=0) { return del_funcargs(idx, idx+1, etf_flags); }


  tinfo_code_t add_funcarg(const funcarg_t &farg, uint etf_flags=0, ssize_t idx=-1)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_ADD_FUNCARG, size_t(&farg), idx, 0, etf_flags));

  }


  tinfo_code_t set_func_cc(callcnv_t cc, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_FUNC_CC, cc, 0, 0, etf_flags));

  }


  tinfo_code_t set_funcarg_loc(size_t index, const argloc_t &argloc, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_FUNCARG_LOC, index, size_t(&argloc), 0, etf_flags));

  }


  tinfo_code_t set_func_retloc(const argloc_t &argloc, uint etf_flags=0)

  {

    return tinfo_code_t(set_tinfo_property4(this, STA_FUNC_RETLOC, size_t(&argloc), 0, 0, etf_flags));

  }


  DECLARE_COMPARISONS(tinfo_t)

  { // simple comparison: good enough to organize std::map, etc

    // for this function "unsigned char" and "uchar" are different

    // for deeper comparison see compare_with()

    return lexcompare_tinfo(typid, r.typid, 0);

  }


#define TCMP_EQUAL    0x0000

#define TCMP_IGNMODS  0x0001

#define TCMP_AUTOCAST 0x0002

#define TCMP_MANCAST  0x0004

#define TCMP_CALL     0x0008

#define TCMP_DELPTR   0x0010

#define TCMP_DECL     0x0020

#define TCMP_ANYBASE  0x0040

#define TCMP_SKIPTHIS 0x0080

#define TCMP_DEEP_UDT 0x0100

  bool compare_with(const tinfo_t &r, int tcflags=0) const { return compare_tinfo(typid, r.typid, tcflags); }

  bool equals_to(const tinfo_t &r) const { return compare_with(r, 0); }

  bool is_castable_to(const tinfo_t &target) const { return compare_with(target, TCMP_AUTOCAST); }

  bool is_manually_castable_to(const tinfo_t &target) const { return compare_with(target, TCMP_MANCAST); }

};

DECLARE_TYPE_AS_MOVABLE(tinfo_t);

typedef qvector<tinfo_t> tinfovec_t;


//------------------------------------------------------------------------


struct simd_info_t

{

  const char *name;

  tinfo_t tif;

  uint16 size;

  type_t memtype;


  simd_info_t(const char *nm = nullptr, uint16 sz = 0, type_t memt = BTF_UNK)

    : name(nm), size(sz), memtype(memt) {}


  bool match_pattern(const simd_info_t *pattern)

  {

    if ( pattern == nullptr )

      return true;

    if ( pattern->size != 0 && pattern->size != size

      || pattern->name != nullptr && !streq(pattern->name, name)

      || !pattern->tif.empty() && !pattern->tif.compare_with(tif) )

    {

      return false;

    }

    if ( pattern->memtype == BTF_UNK || pattern->memtype == memtype )

      return true;

    return pattern->memtype == BTF_TBYTE && is_type_float(memtype)

        || pattern->memtype == BTF_INT   && is_type_int(memtype);

  }


};


DECLARE_TYPE_AS_MOVABLE(simd_info_t);

typedef qvector<simd_info_t> simd_info_vec_t;


//------------------------------------------------------------------------

idaman callcnv_t ida_export guess_func_cc(

        const func_type_data_t &fti,

        int npurged,

        int cc_flags);

idaman bool ida_export dump_func_type_data(

        qstring *out,

        const func_type_data_t &fti,

        int praloc_bits);

idaman bool ida_export calc_retloc(func_type_data_t *fti);

idaman bool ida_export calc_arglocs(func_type_data_t *fti);

idaman bool ida_export calc_varglocs(

        func_type_data_t *fti,

        regobjs_t *regs,

        relobj_t *stkargs,

        int nfixed);


//------------------------------------------------------------------------


struct ptr_type_data_t          // #ptr

{

  tinfo_t obj_type;

  tinfo_t closure;

  tinfo_t parent;

  int32 delta;

  uchar based_ptr_size;

  uchar taptr_bits = 0;


  ptr_type_data_t(

        tinfo_t c=tinfo_t(),

        uchar bps=0,

        tinfo_t p=tinfo_t(),

        int32 d=0)

    : closure(c), parent(p), delta(d), based_ptr_size(bps) {}


  DEFINE_MEMORY_ALLOCATION_FUNCS()

  void swap(ptr_type_data_t &r) { qswap(*this, r); }


  bool operator == (const ptr_type_data_t &r) const

  {

    return obj_type == r.obj_type

        && closure == r.closure

        && based_ptr_size == r.based_ptr_size;

  }


  bool operator != (const ptr_type_data_t &r) const { return !(*this == r); }

  bool is_code_ptr() const { return obj_type.is_func(); }

  bool is_shifted() const { return delta != 0; }

};


DECLARE_TYPE_AS_MOVABLE(ptr_type_data_t);


//------------------------------------------------------------------------


struct array_type_data_t // #array

{

  tinfo_t elem_type;

  uint32 base;

  uint32 nelems;

  array_type_data_t(size_t b=0, size_t n=0) : base(b), nelems(n) {}


  DEFINE_MEMORY_ALLOCATION_FUNCS()

  void swap(array_type_data_t &r) { qswap(*this, r); }

};

DECLARE_TYPE_AS_MOVABLE(array_type_data_t);


//-------------------------------------------------------------------------


struct funcarg_t

{

  argloc_t argloc;

  qstring name;

  qstring cmt;

  tinfo_t type;

  uint32 flags = 0;

#define FAI_HIDDEN  0x0001

#define FAI_RETPTR  0x0002

#define FAI_STRUCT  0x0004

#define FAI_ARRAY   0x0008

#define FAI_UNUSED  0x0010


  funcarg_t() = default;


  funcarg_t(const char *_name, const tinfo_t &_type, const argloc_t &_argloc=argloc_t())

    : argloc(_argloc), name(_name), type(_type)

  {

  }


  funcarg_t(const char *_name, const type_t _type, const argloc_t &_argloc=argloc_t())

    : argloc(_argloc), name(_name), type(_type)

  {

  }


  funcarg_t(const char *_name, const char *_type, const argloc_t &_argloc=argloc_t())

    : argloc(_argloc), name(_name)

  {

    type.parse(_type, nullptr, PT_SEMICOLON);

  }


  bool operator == (const funcarg_t &r) const

  {

    return argloc == r.argloc

        && name == r.name

//        && cmt == r.cmt

        && type == r.type;

  }


  bool operator != (const funcarg_t &r) const { return !(*this == r); }


};


DECLARE_TYPE_AS_MOVABLE(funcarg_t);

typedef qvector<funcarg_t> funcargvec_t;


struct func_type_data_t : public funcargvec_t // #func

{

  int flags = 0;

#define FTI_SPOILED  0x0001

#define FTI_NORET    0x0002

#define FTI_PURE     0x0004

#define FTI_HIGH     0x0008

#define FTI_STATIC   0x0010

#define FTI_VIRTUAL  0x0020

#define FTI_CALLTYPE 0x00C0

#define FTI_DEFCALL  0x0000

#define FTI_NEARCALL 0x0040

#define FTI_FARCALL  0x0080

#define FTI_INTCALL  0x00C0

#define FTI_ARGLOCS  0x0100

#define FTI_EXPLOCS  0x0200

#define FTI_CONST    0x0400

#define FTI_CTOR     0x0800

#define FTI_DTOR     0x1000

#define FTI_ALL      0x1FFF

  callcnv_t _new_callcnv = 0;// Do not access directly, use get_cc/set_cc

  tinfo_t rettype;

  argloc_t retloc;

  uval_t stkargs = 0;

  reginfovec_t spoiled;

  cm_t _old_cc = CM_CC_UNKNOWN; // calling convention, legacy codes. do not access

  callcnv_t get_explicit_cc() const { return helper_get_cc(_old_cc, _new_callcnv); }

  callcnv_t get_cc() const { return get_effective_cc(get_explicit_cc()); }

  void set_cc(callcnv_t cc) { helper_set_cc(&_old_cc, &_new_callcnv, cc); }

  void swap(func_type_data_t &r) { qswap(*this, r); }

  bool is_high() const        { return (flags & FTI_HIGH) != 0; }

  bool is_noret() const       { return (flags & FTI_NORET) != 0; }

  bool is_pure() const        { return (flags & FTI_PURE) != 0; }

  bool is_static() const      { return (flags & FTI_STATIC) != 0; }

  bool is_virtual() const     { return (flags & FTI_VIRTUAL) != 0; }

  bool is_const() const       { return (flags & FTI_CONST) != 0; }

  bool is_ctor() const        { return (flags & FTI_CTOR) != 0; }

  bool is_dtor() const        { return (flags & FTI_DTOR) != 0; }

  int get_call_method() const { return flags & FTI_CALLTYPE; }

  bool is_vararg_cc() const   { return ::is_vararg_cc(get_cc()); }

  bool is_golang_cc() const   { return ::is_golang_cc(get_cc()); }

  bool is_swift_cc() const    { return ::is_swift_cc(get_cc()); }

  bool is_user_cc() const     { return ::is_user_cc(get_explicit_cc()); }


  callcnv_t guess_cc(int purged, int cc_flags) const

  {

    return guess_func_cc(*this, purged, cc_flags);

  }


#define CC_CDECL_OK        0x01

#define CC_ALLOW_ARGPERM   0x02

#define CC_ALLOW_REGHOLES  0x04

#define CC_HAS_ELLIPSIS    0x08

#define CC_GOLANG_OK       0x10


  bool dump(qstring *out, int praloc_bits=PRALOC_STKOFF) const

  {

    return dump_func_type_data(out, *this, praloc_bits);

  }


  ssize_t find_argument(const char *name, size_t from=0, size_t to=size_t(-1)) const

  {

    if ( from < size() )

    {

      const_iterator e = begin() + qmin(size(), to);

      for ( const_iterator p=begin()+from; p != e; ++p )

        if ( p->name == name )

          return p - begin();

    }

    return -1;

  }


};


//-------------------------------------------------------------------------


enum format_functype_t

{

  FMTFUNC_PRINTF,

  FMTFUNC_SCANF,

  FMTFUNC_STRFTIME,

  FMTFUNC_STRFMON,

};


//-------------------------------------------------------------------------


struct edm_t // #edm

{

  qstring name;

  qstring cmt;    // repeatable comment

  uint64 value;


  edm_t() = default;


  edm_t(const char *_name, uint64 _value, const char *_cmt=nullptr)

    : name(_name), cmt(_cmt), value(_value) {}


  // a enum constant must at least have a name

  bool empty() const { return name.empty(); }


  bool operator == (const edm_t &r) const

  {

    return name == r.name

//        && cmt == r.cmt

        && value == r.value;

  }


  bool operator != (const edm_t &r) const { return !(*this == r); }

  void swap(edm_t &r) { qswap(*this, r); }

  inline tid_t get_tid() const;


  DEFINE_MEMORY_ALLOCATION_FUNCS()

};


DECLARE_TYPE_AS_MOVABLE(edm_t);

typedef qvector<edm_t> edmvec_t;


struct enum_type_data_t : public edmvec_t // #enum

{

  intvec_t group_sizes;

  uint32 taenum_bits = 0;

  bte_t bte;

  enum_type_data_t(bte_t _bte=BTE_ALWAYS|BTE_HEX) : bte(_bte) {}


  DEFINE_MEMORY_ALLOCATION_FUNCS()


  // How the enum members should be printed in the enum definition

  int get_enum_radix() const

  {

    switch ( bte & BTE_OUT_MASK )

    {

      case BTE_CHAR:

        return 1;

      case BTE_HEX:

        if ( (taenum_bits & TAENUM_BIN) != 0 )

          return 2;

        if ( (taenum_bits & TAENUM_OCT) != 0 )

          return 8;

        break;

      case BTE_SDEC:

      case BTE_UDEC:

        return 10;

    }

    return 16;

  }


  bool is_number_signed() const

  {

    return (bte & BTE_OUT_MASK) == BTE_SDEC

        || (bte & BTE_OUT_MASK) == BTE_HEX && (taenum_bits & TAENUM_NUMSIGN) != 0;

  }


  void set_enum_radix(int radix, bool sign)

  {

    bte = (bte & ~BTE_OUT_MASK) | BTE_HEX;

    taenum_bits &= ~(TAENUM_BIN|TAENUM_OCT);

    setflag(taenum_bits, TAENUM_NUMSIGN, sign);

    switch ( radix )

    {

      case 1: bte |= BTE_CHAR; break;

      case 2: taenum_bits |= TAENUM_BIN; break;

      case 8: taenum_bits |= TAENUM_OCT; break;

      case 10: bte |= sign ? BTE_SDEC : BTE_UDEC; break;

    }

  }


  bool is_char() const { return (bte & BTE_OUT_MASK) == BTE_CHAR; }

  bool is_dec() const  { return (bte & BTE_OUT_MASK) == BTE_SDEC; }

  bool is_hex() const  { return get_enum_radix() == 16; }

  bool is_oct() const  { return get_enum_radix() == 8; }

  bool is_bin() const  { return get_enum_radix() == 2; }

  bool is_udec() const { return (bte & BTE_OUT_MASK) == BTE_UDEC; }

  bool is_shex() const { return is_number_signed() && is_hex(); }

  bool is_soct() const { return is_number_signed() && is_oct(); }

  bool is_sbin() const { return is_number_signed() && is_bin(); }


  bool has_lzero() const { return (taenum_bits & TAENUM_LZERO) != 0; }

  void set_lzero(bool on) { setflag(taenum_bits, TAENUM_LZERO, on); }


  uint64 calc_mask() const { return make_mask<uint64>(calc_nbytes()*8); }

  bool store_64bit_values() const { return (taenum_bits & TAENUM_64BIT) != 0; }


  bool is_bf() const { return (bte & BTE_BITMASK) != 0; }


  int calc_nbytes() const

  {

    int emsize = bte & BTE_SIZE_MASK;

    return emsize != 0 ? 1 << (emsize-1) : inf_get_cc_size_e();

  }


  bool set_nbytes(int nbytes)

  {

    if ( nbytes < 0 || nbytes > 8 || !is_pow2(nbytes) )

      return false;      // bad width

    int idb_width = 0;

    if ( nbytes != 0 )

      idb_width = log2ceil(nbytes) + 1;

    bte = (bte & ~BTE_SIZE_MASK) | idb_width;

    return true;

  }


  bool get_constant_group(size_t *group_start_index, size_t *group_size, size_t idx) const

  {

    if ( !group_sizes.empty() )

    {

      size_t grp_start = 0;

      for ( auto grp_size : group_sizes )

      {

        if ( grp_start + grp_size > idx )

        {

          if ( group_start_index != nullptr )

            *group_start_index = grp_start;

          if ( group_size != nullptr )

            *group_size = grp_size;

          return true;

        }

        grp_start += grp_size;

      }

    }

    return false;

  }


  bool is_group_mask_at(size_t idx) const

  {

    size_t grp_start;

    size_t grp_size;

    return get_constant_group(&grp_start, &grp_size, idx)

        && grp_start == idx && grp_size > 1;

  }


  bool is_valid_group_sizes() const

  {

    if ( !group_sizes.empty() )

    {

      size_t sum = 0;

      for ( int s : group_sizes )

      {

        if ( s == 0 )

          return false;

        sum += s;

      }

      return sum == size();

    }

    return true;

  }


  ssize_t find_member(const char *name, size_t from=0, size_t to=size_t(-1)) const

  {

    if ( from < size() )

    {

      const_iterator e = begin() + qmin(size(), to);

      for ( const_iterator p=begin()+from; p != e; ++p )

        if ( p->name == name )

          return p - begin();

    }

    return -1;

  }


  ssize_t find_member(uint64 value, uchar serial, size_t from=0, size_t to=size_t(-1), uint64 vmask=uint64(-1)) const

  {

    if ( from < size() )

    {

      if ( vmask == uint64(-1) )

        vmask = calc_mask();

      value &= vmask;

      uint64 value_signed = value | ~vmask;

      const_iterator e = begin() + qmin(size(), to);

      for ( const_iterator p=begin()+from; p != e; ++p )

        if ( (p->value == value || p->value == value_signed) && serial-- == 0 )

          return p - begin();

    }

    return -1;

  }


  void swap(enum_type_data_t &r) { qswap(*this, r); }


  void add_constant(const char *name, uint64 value, const char *cmt=nullptr)

  {

    auto &c = push_back();

    c.name = name;

    c.value = value;

    c.cmt = cmt;

  }


  tinfo_code_t get_value_repr(value_repr_t *repr) const { return enum_type_data_t__get_value_repr(this, repr); }


  tinfo_code_t set_value_repr(const value_repr_t &repr) { return enum_type_data_t__set_value_repr(this, repr); }


  uchar get_serial(size_t index) const

  {

    uchar serial = 0;

    if ( index < size() )

    {

      uint64 value = at(index).value;

      for ( size_t i=0; i < index; ++i )

        if ( at(i).value == value )

          serial++;

    }

    return serial;

  }


  uchar get_max_serial(uint64 value) const { return enum_type_data_t__get_max_serial(this, value); }


#ifndef SWIG


  int for_all_constants(std::function<int(size_t idx, size_t grp_start, int grp_size)> v) const

  {

    if ( !group_sizes.empty() )

    {

      auto gv = [v](size_t grp_start, int grp_size)

      {

        if ( grp_size == 1 )

          return v(grp_start, grp_start, grp_size);

        size_t grp_end = grp_start + grp_size;

        for ( size_t idx=grp_start+1; idx < grp_end; ++idx )

        {

          int code = v(idx, grp_start, grp_size);

          if ( code != 0 )

            return code;

        }

        return 0;

      };

      return for_all_groups(gv);

    }

    else

    {

      size_t sz = size();

      for ( size_t idx=0; idx < sz; ++idx )

      {

        int code = v(idx, 0, sz);

        if ( code != 0 )

          return code;

      }

    }

    return 0;

  }


  int for_all_groups(std::function<int(size_t grp_start, int grp_size)> v, bool skip_trivial=false) const

  {

    if ( !group_sizes.empty() && is_valid_group_sizes() )

    {

      size_t grp_start = 0;

      for ( auto grp_size : group_sizes )

      {

        if ( !skip_trivial || grp_size != 1 )

        {

          int code = v(grp_start, grp_size);

          if ( code != 0 )

            return code;

        }

        grp_start += grp_size;

      }

    }

    return 0;

  }


#endif


};


DECLARE_TYPE_AS_MOVABLE(enum_type_data_t);


//-------------------------------------------------------------------------

const uchar MAX_ENUM_SERIAL = 255;


//-------------------------------------------------------------------------


struct typedef_type_data_t // #typedef

{

  const til_t *til;

  union

  {

    const char *name;

    uint32 ordinal;

  };

  bool is_ordref;

  bool resolve;


  typedef_type_data_t(const til_t *_til, const char *_name, bool _resolve=false)

    : is_ordref(false), resolve(_resolve)

  {

    name = _name;

    til = _til == nullptr ? get_idati() : _til;

  }


  typedef_type_data_t(const til_t *_til, uint32 ord, bool _resolve=false)

    : is_ordref(true), resolve(_resolve)

  {

    name = nullptr;

    ordinal = ord;

    til = _til == nullptr ? get_idati() : _til;

  }


  DEFINE_MEMORY_ALLOCATION_FUNCS()

  void swap(typedef_type_data_t &r) { qswap(*this, r); }


};


DECLARE_TYPE_AS_MOVABLE(typedef_type_data_t);


//-------------------------------------------------------------------------

// A high level variant of custom_data_type_ids_t


struct custom_data_type_info_t

{

  int16 dtid;

  int16 fid;

};


struct value_repr_t // #repr

{

  uint64 bits = 0;

#define FRB_MASK   0xF

#define FRB_UNK    0x0

#define FRB_NUMB   0x1

#define FRB_NUMO   0x2

#define FRB_NUMH   0x3

#define FRB_NUMD   0x4

#define FRB_FLOAT  0x5

#define FRB_CHAR   0x6

#define FRB_SEG    0x7

#define FRB_ENUM   0x8

#define FRB_OFFSET 0x9

#define FRB_STRLIT 0xA

#define FRB_STROFF 0xB

#define FRB_CUSTOM 0xC

#define FRB_INVSIGN  0x0100

#define FRB_INVBITS  0x0200

#define FRB_SIGNED   0x0400

#define FRB_LZERO    0x0800

#define FRB_TABFORM  0x1000

  union

  {

    refinfo_t ri;

    int32 strtype;

    struct

    {

      adiff_t delta;

      uint32 type_ordinal;

    };

    custom_data_type_info_t cd;

  };

  array_parameters_t ap;


public:

  void swap(value_repr_t &r) { ::qswap(*this, r); }


  DEFINE_MEMORY_ALLOCATION_FUNCS()


  void clear() { bits = 0; }


  bool empty()       const { return bits == 0; }

  bool is_enum()     const { return (bits & FRB_MASK) == FRB_ENUM; }

  bool is_offset()   const { return (bits & FRB_MASK) == FRB_OFFSET; }

  bool is_strlit()   const { return (bits & FRB_MASK) == FRB_STRLIT; }

  bool is_custom()   const { return (bits & FRB_MASK) == FRB_CUSTOM; }

  bool is_stroff()   const { return (bits & FRB_MASK) == FRB_STROFF; }

  bool is_typref()   const { return is_enum() || is_stroff(); }

  bool is_signed()   const { return (bits & FRB_SIGNED) != 0; }

  bool has_tabform() const { return (bits & FRB_TABFORM) != 0; }

  bool has_lzeroes() const { return (bits & FRB_LZERO) != 0; }


  uint64 get_vtype() const { return bits & FRB_MASK; }

  void set_vtype(uint64 vt) { bits &= ~FRB_MASK; bits |= (vt & FRB_MASK); }

  void set_signed(bool on)  { setflag(bits, FRB_SIGNED, on); }

  void set_tabform(bool on) { setflag(bits, FRB_TABFORM, on); }

  void set_lzeroes(bool on) { setflag(bits, FRB_LZERO, on); }


  void set_ap(const array_parameters_t &_ap)

  {

    ap = _ap;

    set_signed((ap.flags & AP_SIGNED) != 0);

    ap.flags &= ~AP_SIGNED;

    set_tabform(!ap.is_default());

  }


  void init_ap(array_parameters_t *_ap) const

  {

    if ( _ap != nullptr )

    {

      if ( has_tabform() )

        *_ap = ap;

      setflag(_ap->flags, AP_SIGNED, is_signed());

    }

  }


  bool from_opinfo(flags64_t flags, aflags_t afl, const opinfo_t *opinfo, const array_parameters_t *_ap)

  {

    return value_repr_t__from_opinfo(this, flags, afl, opinfo, _ap);

  }


  size_t print(qstring *result, bool colored=false) const

  {

    return value_repr_t__print_(this, result, colored);

  }


  bool parse_value_repr(const qstring &attr, type_t target_type=BTF_STRUCT)

  {

    return value_repr_t__parse_value_repr(this, attr, target_type);

  }


#ifndef SWIG

  DECLARE_COMPARISONS(value_repr_t);

#endif

};


//-------------------------------------------------------------------------


struct udm_t // #udm

{

  uint64 offset = 0;

  uint64 size = 0;

  qstring name;

  qstring cmt;

  tinfo_t type;

  value_repr_t repr;

  int effalign = 0;

  uint32 tafld_bits = 0;

  uchar fda = 0;


  udm_t() = default;


  udm_t(const char *_name, const tinfo_t &_type, uint64 _offset = 0)

    : offset(_offset), name(_name), type(_type)

  {

    size = _type.get_size() * 8;

  }


  udm_t(const char *_name, const type_t _type, uint64 _offset = 0)

    : offset(_offset), name(_name)

  {

    if ( is_type_arithmetic(_type) )

    {

      type = tinfo_t(_type);

      size = type.get_size() * 8;

    }

  }


  udm_t(const char *_name, const char *_type, uint64 _offset = 0)

    : offset(_offset), name(_name)

  {

    if ( type.parse(_type, nullptr, PT_SEMICOLON) )

      size = type.get_size() * 8;

  }


  // a udt member must at least have a type

  bool empty() const { return type.empty(); }


  bool is_bitfield() const { return type.is_decl_bitfield(); }

  bool is_zero_bitfield() const { return size == 0 && is_bitfield(); }

  bool is_unaligned() const { return (tafld_bits & TAFLD_UNALIGNED) != 0; }

  bool is_baseclass() const { return (tafld_bits & TAFLD_BASECLASS) != 0; }

  bool is_virtbase()  const { return (tafld_bits & TAFLD_VIRTBASE) != 0; }

  bool is_vftable()   const { return (tafld_bits & TAFLD_VFTABLE) != 0; }

  bool is_method()    const { return (tafld_bits & TAFLD_METHOD) != 0; }

  bool is_gap()       const { return (tafld_bits & TAFLD_GAP) != 0; }

  bool is_regcmt()    const { return (tafld_bits & TAFLD_REGCMT) != 0; }

  bool is_retaddr()   const { return (tafld_bits & TAFLD_FRAME_R) != 0; }

  bool is_savregs()   const { return (tafld_bits & TAFLD_FRAME_S) != 0; }

  bool is_special_member() const { return is_retaddr() || is_savregs(); }

  bool is_by_til()    const { return (tafld_bits & TAFLD_BYTIL) != 0; }


  void set_unaligned(bool on=true) { setflag(tafld_bits, TAFLD_UNALIGNED, on); }

  void set_baseclass(bool on=true) { setflag(tafld_bits, TAFLD_BASECLASS, on); }

  void set_virtbase(bool on=true)  { setflag(tafld_bits, TAFLD_VIRTBASE, on); }

  void set_vftable(bool on=true)   { setflag(tafld_bits, TAFLD_VFTABLE, on); }

  void set_method(bool on=true)    { setflag(tafld_bits, TAFLD_METHOD, on); }

  void set_regcmt(bool on=true)    { setflag(tafld_bits, TAFLD_REGCMT, on); }

  void set_retaddr(bool on=true)   { setflag(tafld_bits, TAFLD_FRAME_R, on); }

  void set_savregs(bool on=true)   { setflag(tafld_bits, TAFLD_FRAME_S, on); }

  void set_by_til(bool on=true)    { setflag(tafld_bits, TAFLD_BYTIL, on); }

  void clr_unaligned() { tafld_bits &= ~TAFLD_UNALIGNED; }

  void clr_baseclass() { tafld_bits &= ~TAFLD_BASECLASS; }

  void clr_virtbase()  { tafld_bits &= ~TAFLD_VIRTBASE; }

  void clr_vftable()   { tafld_bits &= ~TAFLD_VFTABLE; }

  void clr_method()    { tafld_bits &= ~TAFLD_METHOD; }

  uint64 begin() const { return offset; }

  uint64 end() const { return offset + size; }


  bool operator < (const udm_t &r) const

  {

    return offset < r.offset;

  }


  bool operator == (const udm_t &r) const

  {

    return compare_with(r, 0);

  }


  bool compare_with(const udm_t &r, int tcflags) const

  {

    return offset == r.offset

        && size == r.size

        && name == r.name

//        && cmt == r.cmt

        && type.compare_with(r.type, tcflags)

        && fda == r.fda

        && tafld_bits == r.tafld_bits

        && effalign == r.effalign;

  }


  bool operator != (const udm_t &r) const { return !(*this == r); }


  DEFINE_MEMORY_ALLOCATION_FUNCS()

  void swap(udm_t &r) { qswap(*this, r); }


  // the user cannot enter anonymous fields in ida (they can come only from tils),

  // so we use the following trick: if the field type starts with $ and the name

  // with __, then we consider the field as anonymous


  bool is_anonymous_udm() const

  {

    return name[0] == '_' && name[1] == '_' && type.is_anonymous_udt();

  }


  void set_value_repr(const value_repr_t &r) { repr = r; }

  bool can_be_dtor() const { return name[0] == '~'; }


  bool can_rename() const

  {

    return !is_gap() && !is_baseclass() && !can_be_dtor();

  }


};


DECLARE_TYPE_AS_MOVABLE(udm_t);

struct udtmembervec_t : public qvector<udm_t> {};


struct udt_type_data_t : public udtmembervec_t // #udt

{

  static constexpr int VERSION = 1;

  size_t total_size = 0;

  size_t unpadded_size = 0;

  uint32 effalign = 0;

  uint32 taudt_bits = 0;

  uchar version = VERSION;

  uchar sda = 0;

  uchar pack = 0;

  bool is_union = false;


  void swap(udt_type_data_t &r) { qswap(*this, r); }


  DEFINE_MEMORY_ALLOCATION_FUNCS()

  bool is_unaligned() const { return (taudt_bits & TAUDT_UNALIGNED) != 0; }


  bool is_msstruct() const { return (taudt_bits & TAUDT_MSSTRUCT) != 0; }

  bool is_cppobj() const { return (taudt_bits & TAUDT_CPPOBJ) != 0; }

  bool is_vftable() const { return (taudt_bits & TAUDT_VFTABLE) != 0; }

  bool is_fixed() const { return (taudt_bits & TAUDT_FIXED) != 0; }

  bool is_tuple() const { return (taudt_bits & TAUDT_TUPLE) != 0; }


  void set_vftable(bool on=true)   { setflag(taudt_bits, TAUDT_VFTABLE, on); }

  void set_fixed(bool on=true)     { setflag(taudt_bits, TAUDT_FIXED, on); }

  void set_tuple(bool on=true)     { setflag(taudt_bits, TAUDT_TUPLE, on); }


  bool is_last_baseclass(size_t idx) // we assume idx is valid

  {

    return at(idx).is_baseclass()

        && (idx+1 == size() || !at(idx+1).is_baseclass());

  }


  udm_t &add_member(const char *_name, const tinfo_t &_type, uint64 _offset = 0)

  {

    udm_t &udm = push_back();

    udm.name = _name;

    udm.type = _type;

    udm.size = _type.get_size() * 8;

    udm.offset = _offset;

    return udm;

  }


  ssize_t find_member(udm_t *pattern_udm, int strmem_flags) const { return udt_type_data_t__find_member(this, pattern_udm, strmem_flags); }


  ssize_t find_member(const char *name) const

  {

    udm_t udm;

    udm.name = name;

    return find_member(&udm, STRMEM_NAME);

  }


  ssize_t find_member(uint64 bit_offset) const

  {

    udm_t udm;

    udm.offset = bit_offset;

    return find_member(&udm, STRMEM_OFFSET);

  }


  ssize_t get_best_fit_member(asize_t disp) const { return udt_type_data_t__get_best_fit_member(this, disp); }


  inline ssize_t get_best_fit_member(udm_t *out, asize_t disp) const;


};


DECLARE_TYPE_AS_MOVABLE(udt_type_data_t);


// separator to construct full udm name

#define STRUC_SEPARATOR '.'


// The type name of a virtual function table (__vftable) of a class is

// constructed by appending the following suffix to the class name.

// In the case of multiple inheritance we append the vft offset

// to the class name (with format %04X)

// Example: CLS_0024_vtbl is used for the vft located at the offset 0x24 of CLS


#define VTBL_SUFFIX "_vtbl"


// The member name of a virtual function table

// Complex cases are not handled yet.


#define VTBL_MEMNAME "__vftable"


//--------------------------------------------------------------------------


inline bool stroff_as_size(int plen, const tinfo_t &tif, asize_t value)

{

  return plen == 1

      && value > 0

      && !tif.is_varstruct()

      && value == tif.get_size();

}


//--------------------------------------------------------------------------


struct udm_visitor_t

{

  virtual int idaapi visit_udm(

        tid_t tid,

        const tinfo_t *tif,

        const udt_type_data_t *udt,

        ssize_t idx) = 0;

  virtual ~udm_visitor_t() {}

};


//--------------------------------------------------------------------------

idaman int ida_export visit_stroff_udms(

        udm_visitor_t &sfv,

        const tid_t *path,

        int plen,

        adiff_t *disp,

        bool appzero);


//-------------------------------------------------------------------------


struct bitfield_type_data_t // #bitfield

{

  uchar nbytes;

  uchar width;

  bool is_unsigned;


  bitfield_type_data_t(uchar _nbytes=0, uchar _width=0, bool _is_unsigned=false)

    : nbytes(_nbytes), width(_width), is_unsigned(_is_unsigned)

  {

  }


  bool serialize(qtype *type, type_t mods) const;


  DECLARE_COMPARISONS(bitfield_type_data_t)

  {

    if ( nbytes != r.nbytes )

      return nbytes > r.nbytes ? 1 : -1;

    if ( width != r.width )

      return width > r.width ? 1 : -1;

    if ( is_unsigned )

    {

      if ( !r.is_unsigned )

        return 1;

    }

    else

    {

      if ( r.is_unsigned )

        return -1;

    }

    return 0;

  }


  void swap(bitfield_type_data_t &r) { qswap(*this, r); }


  bool is_valid_bitfield() const

  {

    if ( nbytes != 1 && nbytes != 2 && nbytes != 4 && nbytes != 8 )

      return false;

    if ( width > nbytes*8 )

      return false;

    return true;

  }


};


DECLARE_TYPE_AS_MOVABLE(bitfield_type_data_t);


//--------------------------------------------------------------------------

// This tag can be used at the beginning of

//   udm_t::cmt

//   funcarg_t::cmt

//   edm_t::cmt

// to specify the line number where it is defined.

// Example: "\x05123." means the line number 123

#define TPOS_LNNUM  "\x05"


// Tag to denote a regular comment in serialized form.

// If a comment has it as its first character, it is a regular comment,

// otherwise it is a repeatable comment. The comments returned by

// ::get_named_type and ::get_numbered_type may have this symbol.

#define TPOS_REGCMT '\x06'


//-------------------------------------------------------------------------


inline THREAD_SAFE bool is_one_bit_mask(uval_t mask)

{

  return is_pow2(mask);

}


//-------------------------------------------------------------------------


inline bool inf_pack_stkargs(callcnv_t cc)

{

  return is_golang_cc(get_effective_cc(cc)) || inf_pack_stkargs();

}


//-------------------------------------------------------------------------


inline bool inf_big_arg_align(callcnv_t cc)

{

  return !is_golang_cc(get_effective_cc(cc)) && inf_big_arg_align();

}


//-------------------------------------------------------------------------


inline bool inf_huge_arg_align(callcnv_t cc)

{

  return !is_golang_cc(get_effective_cc(cc)) && inf_huge_arg_align();

}


//-------------------------------------------------------------------------

// return argument alignment (depends on ABI, CC and natural type alignment)


inline int get_arg_align(int type_align, int slotsize, callcnv_t cc=CM_CC_UNKNOWN)

{

  QASSERT(2858, is_pow2(type_align));

  if ( type_align > slotsize*2 )

  {

    if ( inf_huge_arg_align(cc) )

      return type_align;

    type_align = slotsize*2;

  }

  return type_align < slotsize

       ? inf_pack_stkargs(cc)  ? type_align : slotsize

       : inf_big_arg_align(cc) ? type_align : slotsize;

}


inline int get_arg_align(const tinfo_t &tif, int slotsize, callcnv_t cc=CM_CC_UNKNOWN)

{

  uint32 align = 0;

  tif.get_size(&align);

  return get_arg_align(align, slotsize, cc);

}


//-------------------------------------------------------------------------


inline sval_t align_stkarg_up(sval_t spoff, int type_align, int slotsize, callcnv_t cc=CM_CC_UNKNOWN)

{

  uint32 align = get_arg_align(type_align, slotsize, cc);

  return align_up(spoff, align);

}


inline sval_t align_stkarg_up(sval_t spoff, const tinfo_t &tif, int slotsize, callcnv_t cc=CM_CC_UNKNOWN)

{

  uint32 align = get_arg_align(tif, slotsize, cc);

  return align_up(spoff, align);

}


inline bool argloc_t::has_reg() const

{

  if ( !is_scattered() )

    return is_reg();

  for ( const auto &part : scattered() )

    if ( part.is_reg() )

      return true;

  return false;

};


inline bool argloc_t::has_stkoff() const

{

  if ( !is_scattered() )

    return is_stkoff();

  for ( const auto &part : scattered() )

    if ( part.is_stkoff() )

      return true;

  return false;

};


inline bool argloc_t::in_stack() const

{

  if ( !is_scattered() )

    return is_stkoff();

  for ( const auto &part : scattered() )

    if ( !part.is_stkoff() )

      return false;

  return true;

}


inline bool argloc_t::is_mixed_scattered() const

{

  if ( !is_scattered() )

    return false;

  bool reg_found = false;

  bool stkoff_found = false;

  for ( const auto &part : scattered() )

  {

    if ( part.is_reg() )

      reg_found = true;

    if ( part.is_stkoff() )

      stkoff_found = true;

  }

  return reg_found && stkoff_found;

}


inline bool tinfo_t::get_named_type(

        const til_t *til,

        const char *name,

        type_t decl_type,

        bool resolve,

        bool try_ordinal)

{

  if ( name == nullptr )

    return false;

  typedef_type_data_t tp(til, name, resolve);

  return create_typedef(tp, decl_type, try_ordinal);

}


inline bool tinfo_t::get_numbered_type(

        const til_t *til,

        uint32 ordinal,

        type_t decl_type,

        bool resolve)

{

  typedef_type_data_t tp(til, ordinal, resolve);

  return create_typedef(tp, decl_type, false);

}


inline bool tinfo_t::create_udt(bool is_union)

{

  udt_type_data_t p;

  p.is_union = is_union;

  return create_udt(p);

}


inline bool tinfo_t::create_udt(udt_type_data_t &p)

{

  return create_udt(p, p.is_union ? BTF_UNION : BTF_STRUCT);

}


inline bool tinfo_t::create_enum(bte_t bte)

{

  enum_type_data_t p;

  p.bte = BTE_ALWAYS | bte;

  return create_enum(p);

}


inline bool tinfo_t::create_ptr(

        const tinfo_t &tif,

        uchar bps,

        type_t decl_type)

{

  ptr_type_data_t pi(tinfo_t(), bps);

  pi.obj_type = tif;

  return create_ptr(pi, decl_type);

}


inline bool tinfo_t::create_array(

        const tinfo_t &tif,

        uint32 nelems,

        uint32 base,

        type_t decl_type)

{

  array_type_data_t ai(base, nelems);

  ai.elem_type = tif;

  return create_array(ai, decl_type);

}


inline bool tinfo_t::create_bitfield(

        uchar nbytes,

        uchar width,

        bool _is_unsigned,

        type_t decl_type)

{

  bitfield_type_data_t bi(nbytes, width, _is_unsigned);

  return create_bitfield(bi, decl_type);

}


inline bool tinfo_t::convert_array_to_ptr()

{

  bool ok = false;

  array_type_data_t ai;

  if ( get_array_details(&ai) )

  {

    ptr_type_data_t pi;

    pi.obj_type.swap(ai.elem_type);

    create_ptr(pi);

    ok = true;

  }

  return ok;

}


inline tinfo_code_t tinfo_t::add_udm(

        const char *name,

        const tinfo_t &type,

        uint64 offset,

        uint etf_flags,

        size_t times,

        ssize_t idx)

{

  return add_udm(udm_t(name, type, offset), etf_flags, times, idx);

}


inline tinfo_code_t tinfo_t::add_udm(

        const char *name,

        type_t type,

        uint64 offset,

        uint etf_flags,

        size_t times,

        ssize_t idx)

{

  return add_udm(udm_t(name, type, offset), etf_flags, times, idx);

}


inline tinfo_code_t tinfo_t::add_udm(

        const char *name,

        const char *type,

        uint64 offset,

        uint etf_flags,

        size_t times,

        ssize_t idx)

{

  return add_udm(udm_t(name, type, offset), etf_flags, times, idx);

}


inline int tinfo_t::find_udm(uint64 offset, int strmem_flags) const

{

  udm_t udm;

  udm.offset = offset;

  return find_tinfo_udt_member(&udm, typid, STRMEM_OFFSET|strmem_flags);

}


inline int tinfo_t::find_udm(const char *name, int strmem_flags) const

{

  udm_t udm;

  udm.name = name;

  return find_tinfo_udt_member(&udm, typid, STRMEM_NAME|strmem_flags);

}


inline int tinfo_t::get_udm(udm_t *out, const char *name) const

{

  udm_t tmp;

  tmp.name = name;

  int rc = find_udm(&tmp, STRMEM_NAME);

  if ( rc >= 0 )

    out->swap(tmp);

  return rc;

}


inline int tinfo_t::get_udm(udm_t *out, size_t index) const

{

  udm_t tmp;

  tmp.offset = index;

  int rc = find_udm(&tmp, STRMEM_INDEX);

  if ( rc >= 0 )

    out->swap(tmp);

  return rc;


}


inline int tinfo_t::get_udm_by_offset(udm_t *out, uint64 offset) const

{

  udm_t tmp;

  tmp.offset = offset;

  int rc = find_udm(&tmp, STRMEM_OFFSET);

  if ( rc >= 0 )

    out->swap(tmp);

  return rc;

}


inline tinfo_code_t tinfo_t::add_edm(

        const char *name,

        uint64 value,

        bmask64_t bmask,

        uint etf_flags,

        ssize_t idx)

{

  return add_edm(edm_t(name, value), bmask, etf_flags, idx);

}


inline tinfo_code_t tinfo_t::del_edm(

        const char *name,

        uint etf_flags)

{

  edm_t edm;

  ssize_t idx = get_edm(&edm, name);

  return idx < 0 ? TERR_NOT_FOUND : del_edm(idx, etf_flags);

}


inline tinfo_code_t tinfo_t::del_edm_by_value(

        uint64 value,

        uint etf_flags,

        bmask64_t bmask,

        uchar serial)

{

  edm_t edm;

  ssize_t idx = get_edm_by_value(&edm, value, bmask, serial);

  return idx < 0 ? TERR_NOT_FOUND : del_edm(idx, etf_flags);

}


inline ssize_t udt_type_data_t::get_best_fit_member(udm_t *out, asize_t disp) const

{

  ssize_t rc = get_best_fit_member(disp);

  if ( rc >= 0 )

    *out = at(rc);

  return rc;

}


inline tinfo_t remove_pointer(const tinfo_t &tif)

{

  tinfo_t r;

  r.typid = get_tinfo_property(tif.typid, tinfo_t::GTA_SAFE_PTR_OBJ);

  return r;

}


struct type_mods_t

{

  tinfo_t type;

  qstring name;

  qstring cmt;

  int flags = 0;

#define TVIS_TYPE   0x0001

#define TVIS_NAME   0x0002

#define TVIS_CMT    0x0004

#define TVIS_RPTCMT 0x0008

  void clear() { flags = 0; }


  void set_new_type(const tinfo_t &t) { type = t; flags |= TVIS_TYPE; }

  void set_new_name(const qstring &n) { name = n; flags |= TVIS_NAME; }


  void set_new_cmt(const qstring &c, bool rptcmt)

  {

    cmt = c;

    flags |= TVIS_CMT;

    setflag(flags, TVIS_RPTCMT, rptcmt);

  }


  bool has_type() const { return (flags & TVIS_TYPE) != 0; }

  bool has_name() const { return (flags & TVIS_NAME) != 0; }

  bool has_cmt()  const { return (flags & TVIS_CMT) != 0; }

  bool is_rptcmt() const { return (flags & TVIS_RPTCMT) != 0; }

  bool has_info() const { return flags != 0; }

};


struct tinfo_visitor_t

{

  int state;

#define TVST_PRUNE 0x01

#define TVST_DEF   0x02

#define TVST_LEVEL 0x04 // has level member (internal use)

  int level;            // recursion level (internal use)

  tinfo_visitor_t(int s=0) : state(s|TVST_LEVEL), level(0) {}


  virtual ~tinfo_visitor_t() {}


  virtual int idaapi visit_type(

        type_mods_t *out,

        const tinfo_t &tif,

        const char *name,

        const char *cmt) = 0;


  void prune_now() { state |= TVST_PRUNE; }


  int apply_to(const tinfo_t &tif, type_mods_t *out=nullptr, const char *name=nullptr, const char *cmt=nullptr)

  {

    return visit_subtypes(this, out, tif, name, cmt);

  }


};


//------------------------------------------------------------------------

// Definitions for packing/unpacking idc objects


struct regobj_t

{

  int regidx;

  int relocate;

  bytevec_t value;

  size_t size() const { return value.size(); }

};


DECLARE_TYPE_AS_MOVABLE(regobj_t);

typedef qvector<regobj_t> regobjvec_t;


struct regobjs_t : public regobjvec_t {};


idaman error_t ida_export unpack_idcobj_from_idb(

        idc_value_t *obj,

        const tinfo_t &tif,

        ea_t ea,

        const bytevec_t *off0,  // if !nullptr: bytevec that represents object at 'ea'

        int pio_flags=0);

#define PIO_NOATTR_FAIL 0x0004

#define PIO_IGNORE_PTRS 0x0008


idaman error_t ida_export unpack_idcobj_from_bv(

        idc_value_t *obj,

        const tinfo_t &tif,

        const bytevec_t &bytes,

        int pio_flags=0);


idaman error_t ida_export pack_idcobj_to_idb(

        const idc_value_t *obj,

        const tinfo_t &tif,

        ea_t ea,

        int pio_flags=0);


idaman error_t ida_export pack_idcobj_to_bv(

        const idc_value_t *obj,

        const tinfo_t &tif,

        relobj_t *bytes,

        void *objoff,         // nullptr - append object to 'bytes'

                              // if not nullptr:

                              //   in: int32*: offset in 'bytes' for the object

                              //       -1 means 'do not store the object itself in bytes

                              //                 store only pointed objects'

                              //   out: data for object (if *(int32*)objoff == -1)

        int pio_flags=0);


idaman bool ida_export apply_tinfo_to_stkarg(

        const insn_t &insn,

        const op_t &x,

        uval_t v,

        const tinfo_t &tif,

        const char *name);


//------------------------------------------------------------------------

// Helper struct for the processor modules: process call arguments


struct argtinfo_helper_t

{

  size_t reserved = 0;


  virtual ~argtinfo_helper_t() {}


  virtual bool idaapi set_op_tinfo(

        const insn_t &insn,

        const op_t &x,

        const tinfo_t &tif,

        const char *name) = 0;


  virtual bool idaapi is_stkarg_load(const insn_t &insn, int *src, int *dst) = 0;


  virtual bool idaapi has_delay_slot(ea_t /*caller*/) { return false; }


  inline void use_arg_tinfos(ea_t caller, func_type_data_t *fti, funcargvec_t *rargs);

};


idaman void ida_export gen_use_arg_tinfos(

        struct argtinfo_helper_t *_this,

        ea_t caller,

        func_type_data_t *fti,

        funcargvec_t *rargs);


inline void argtinfo_helper_t::use_arg_tinfos(

        ea_t caller,

        func_type_data_t *fti,

        funcargvec_t *rargs)

{

  gen_use_arg_tinfos(this, caller, fti, rargs);

}


//-------------------------------------------------------------------------


idaman bool ida_export func_has_stkframe_hole(ea_t ea, const func_type_data_t &fti);


//-------------------------------------------------------------------------


class lowertype_helper_t

{

public:

  virtual ~lowertype_helper_t() {}

  virtual bool idaapi func_has_stkframe_hole(

        const tinfo_t &candidate,

        const func_type_data_t &candidate_data) = 0;


  virtual int idaapi get_func_purged_bytes(

        const tinfo_t &candidate,

        const func_type_data_t &candidate_data) = 0;

};


//-------------------------------------------------------------------------


class ida_lowertype_helper_t : public lowertype_helper_t

{

  const tinfo_t &tif;

  ea_t ea;

  int purged_bytes;


public:


  ida_lowertype_helper_t(const tinfo_t &_tif, ea_t _ea, int _pb)

    : tif(_tif), ea(_ea), purged_bytes(_pb) {}


  virtual bool idaapi func_has_stkframe_hole(

        const tinfo_t &candidate,

        const func_type_data_t &candidate_data) override

  {

    return candidate == tif

         ? ::func_has_stkframe_hole(ea, candidate_data)

         : false;

  }


  virtual int idaapi get_func_purged_bytes(

        const tinfo_t &candidate,

        const func_type_data_t &) override

  {

    return candidate == tif

         ? purged_bytes

         : -1;

  }


};


//-------------------------------------------------------------------------


idaman int ida_export lower_type(

        til_t *til,

        tinfo_t *tif,

        const char *name=nullptr,

        lowertype_helper_t *_helper=nullptr);


idaman int ida_export replace_ordinal_typerefs(til_t *til, tinfo_t *tif);


enum update_type_t

{

  UTP_ENUM,

  UTP_STRUCT,

};


idaman void ida_export begin_type_updating(update_type_t utp);


idaman void ida_export end_type_updating(update_type_t utp);


//-------------------------------------------------------------------------


idaman tid_t ida_export get_named_type_tid(const char *name);


inline tid_t edm_t::get_tid() const { return get_named_type_tid(name.c_str()); }


idaman bool ida_export get_tid_name(qstring *out, tid_t tid);


idaman uint32 ida_export get_tid_ordinal(tid_t tid);


idaman ssize_t ida_export get_udm_by_fullname(udm_t *udm, const char *fullname);


idaman bool ida_export get_idainfo_by_udm(

        flags64_t *flags,

        opinfo_t *ti,

        const udm_t &udm,

        ea_t refinfo_ea=BADADDR);


inline tid_t create_enum_type(

        const char *enum_name,

        enum_type_data_t &ei,

        int enum_width,

        type_sign_t sign,

        bool convert_to_bitmask,

        const char *enum_cmt=nullptr)

{

  if ( sign == type_signed )

    ei.taenum_bits |= TAENUM_SIGNED;

  else if ( sign == type_unsigned )

    ei.taenum_bits |= TAENUM_UNSIGNED;

  ei.set_nbytes(enum_width);


  tid_t tid = BADADDR;

  tinfo_t tif;

  if ( tif.create_enum(ei)

    && (enum_cmt == nullptr || tif.set_type_cmt(enum_cmt) == TERR_OK)

    && tif.set_enum_is_bitmask(convert_to_bitmask ? tinfo_t::ENUMBM_ON : tinfo_t::ENUMBM_OFF) == TERR_OK

    && tif.set_named_type(nullptr, enum_name, NTF_TYPE|NTF_REPLACE) == TERR_OK )

  {

    tid = get_named_type_tid(enum_name);

  }

  return tid;

}


//-------------------------------------------------------------------------


struct format_data_info_t

{

  int ptvf;

#define PTV_DEREF  0x0001

#define PTV_QUEST  0x0002

#define PTV_EMPTY  0x0004

#define PTV_CSTR   0x0008

#define PTV_EXPAND 0x0010

#define PTV_LZERO  0x0020

#define PTV_STPFLT 0x0040

#define PTV_SPACE  0x0080

#define PTV_DEBUG  0x0100

#define PTV_NOPTR  0x0200

#define PTV_NTOP   0x40000000

#define PTV_KEEP   0x80000000

  int radix;

  int max_length;

  int arrbase;

  int arrnelems;

  int margin;

  int indent;


  format_data_info_t()

    : ptvf(PTV_EMPTY|PTV_CSTR|PTV_SPACE), radix(10), max_length(0),

      arrbase(0), arrnelems(0),

      margin(80), indent(2) {}


};


struct valinfo_t

{

  argloc_t loc;

  qstring label;

  tinfo_t type;


  valinfo_t(argloc_t l=argloc_t(), const char *name=nullptr, const tinfo_t &tif=tinfo_t())

    : loc(l), label(name), type(tif) {}


  void swap(valinfo_t &r)

  {

    loc.swap(r.loc);

    label.swap(r.label);

    type.swap(r.type);

  }


  DEFINE_MEMORY_ALLOCATION_FUNCS()

};


DECLARE_TYPE_AS_MOVABLE(valinfo_t);


class valstr_t

{

public:

  qstring oneline;

  size_t length;

  struct valstrs_t *members;

  valinfo_t *info;

  int props;

#define VALSTR_OPEN 0x01


  valstr_t() : length(0), members(nullptr), info(nullptr), props(0) {}

  ~valstr_t();

  DEFINE_MEMORY_ALLOCATION_FUNCS()

private:

  struct flatten_args_t

  {

    const valstr_t *may_not_collapse;

    int ptvf;

    int max_length;

    int margin;

    int indent;

  };

  friend struct valstr_sink_t;

  void update_length(int ptvf);


  void set_oneline(const char *line, int len)

  {

    oneline.append(line, len);

    length = oneline.length();

  }


  void consume_oneline(const qstring &line)

  {

    oneline.append(line);

    length = oneline.length();

  }


  bool append_char(char c, int max_length);

  bool convert_to_one_line(int ptvf, int max_length);

  bool flatten(const flatten_args_t &flargs, int level);

};


DECLARE_TYPE_AS_MOVABLE(valstr_t);

typedef qvector<valstr_t> valstrvec_t;


struct valstrs_t : public valstrvec_t {};


inline valstr_t::~valstr_t()

{

  delete members;

  delete info;

}


idaman bool ida_export format_cdata(

        qstrvec_t *outvec,

        const idc_value_t &idc_value,

        const tinfo_t *tif,

        valstr_t *vtree=nullptr,

        const format_data_info_t *fdi=nullptr);


struct text_sink_t

{

  virtual ~text_sink_t() {}

  virtual int idaapi print(const char *str) = 0;

};


idaman int ida_export print_cdata(

        text_sink_t &printer,

        const idc_value_t &idc_value,

        const tinfo_t *tif,

        const format_data_info_t *fdi=nullptr);


//-------------------------------------------------------------------------

#define PDF_INCL_DEPS  0x1

#define PDF_DEF_FWD    0x2

#define PDF_DEF_BASE   0x4

#define PDF_HEADER_CMT 0x8


typedef qvector<uint32> ordvec_t;


idaman int ida_export print_decls(

        text_sink_t &printer,

        const til_t *til,

        const ordvec_t *ordinals,

        uint32 pdf_flags);


idaman int ida_export calc_number_of_children(

        const argloc_t &loc,

        const tinfo_t &tif,

        bool dont_deref_ptr=false);


idaman bool ida_export get_enum_member_expr(

        qstring *buf,

        const tinfo_t &tif,

        int serial,

        uint64 value);


//-------------------------------------------------------------------------

// Dialogs to choose a symbol from a type library

//------------------------------------------------------------------------


struct til_symbol_t

{

  const char *name;

  const til_t *til;

  til_symbol_t(const char *n = nullptr, const til_t *t = nullptr): name(n), til(t) {}

};


DECLARE_TYPE_AS_MOVABLE(til_symbol_t);


struct predicate_t

{

  virtual bool idaapi should_display(

        const til_t *til,

        const char *name,

        const type_t *type,

        const p_list *fields) = 0;

  virtual ~predicate_t() {}

};


idaman bool ida_export choose_named_type(

        til_symbol_t *out_sym,

        const til_t *root_til,

        const char *title,

        int ntf_flags,

        predicate_t *predicate=nullptr);


typedef int idaapi local_tinfo_predicate_t(uint32 ord, const tinfo_t &type, void *ud);


idaman uint32 ida_export choose_local_tinfo(

        const til_t *ti,

        const char *title,

        local_tinfo_predicate_t *func = nullptr,

        uint32 def_ord = 0,

        void *ud = nullptr);


idaman uint32 ida_export choose_local_tinfo_and_delta(

        int32 *delta,

        const til_t *ti,

        const char *title,

        local_tinfo_predicate_t *func = nullptr,

        uint32 def_ord = 0,

        void *ud = nullptr);


using enum_type_visitor_t = std::function<ssize_t(const struct enum_type_data_t &ei, size_t idx, uint64 value, uint64 bmask)>;


idaman ssize_t ida_export visit_edms(

        const tinfo_t &tif,

        uint64 value,

        int nbytes,

        uchar serial,

        const enum_type_visitor_t &visitor);


//-------------------------------------------------------------------------


inline ssize_t processor_t::equal_reglocs(const argloc_t &a1, const argloc_t &a2)

{

  if ( PH.ti() )

    return notify(ev_equal_reglocs, &a1, &a2);

  else

    return a1.compare(a2);

}


//-------------------------------------------------------------------------


inline ssize_t processor_t::_decorate_name(

        qstring *outbuf,

        const char *name,

        bool mangle,

        callcnv_t cc,

        const tinfo_t &type)

{

  ssize_t code = notify(ev_decorate_name, outbuf, name, mangle, cc, &type);

  if ( code == 0 )

    code = gen_decorate_name(outbuf, name, mangle, cc, &type);

  return code;

}


//-------------------------------------------------------------------------


inline bool calc_retloc(argloc_t *retloc, const tinfo_t &rettype, callcnv_t cc)

{

  func_type_data_t fti;

  fti.set_cc(cc);

  fti.rettype = rettype;

  if ( !calc_retloc(&fti) )

    return false;

  retloc->swap(fti.retloc);

  return true;

}


//-------------------------------------------------------------------------

// this structure is used to hold context data for the 'types' view


struct til_type_ref_t

{

  size_t cb = sizeof(til_type_ref_t);

  tinfo_t tif;                             //< type info, !empty() during runtime

  tif_cursor_t cursor = TIF_CURSOR_HEADER; //< 'pointer' inside a type

  uint32 ordinal = 0;                      //< cached value of tif.get_ordinal()

  bool is_writable = false;                //< can we modify the type? (either in a RW til, or writable backend)

  bool is_detached = false;                //< type is not backed by a backend that will cause views to be updated automatically

  bool is_forward = false;                 //< is the type a forward declaration?

  type_t kind = BT_UNK;                    //< one of BTF_TYPEDEF, BTF_STRUCT, BTF_UNION, BTF_ENUM, BT_FUNC

  ssize_t memidx = -1;                     //< index of the current BTF_STRUCT, BTF_UNION, BTF_ENUM member or BT_FUNC argument

  size_t nmembers = 0;                     //< number of members in the BTF_STRUCT, BTF_UNION, BTF_ENUM or number of arguments in the BT_FUNC


  udm_t udm;

  size_t total_size = 0;

  size_t unpadded_size = 0;

  uint64 last_udm_offset = 0;

  uint64 bucket_start = uint64(-1);        //< bucket offset (equal to 'offset' except for bitfields)

  int bf_bitoff = -1;                      //< for bitfields, bit offset from bucket_start

  uint64 offset = uint64(-1);              //< the current offset (regardless if

                                           //< we have a defined member at the current

                                           //< offset or not)


  edm_t edm;


  const funcarg_t *fa = nullptr;


  void clear() { *this = til_type_ref_t(); }

  bool on_member() const { return memidx != -1; }

  bool is_typedef() const { return kind == BTF_TYPEDEF; }

  bool is_struct() const { return kind == BTF_STRUCT; }

  bool is_union() const { return kind == BTF_UNION; }

  bool is_enum() const { return kind == BTF_ENUM; }

  bool is_func() const { return kind == BT_FUNC; }

  bool is_udt() const { return kind == BTF_STRUCT || kind == BTF_UNION; }

};


#endif // _TYPEINF_HPP


_qstring::begin
iterator begin(void)
Get a pointer to the beginning of the qstring.
Definition pro.h:3177

argloc_t
Describes an argument location.
Definition typeinf.hpp:1101

argloc_t::rrel
rrel_t * rrel
Definition typeinf.hpp:1111

argloc_t::reginfo
uint32 reginfo
Definition typeinf.hpp:1110

argloc_t::dist
scattered_aloc_t * dist
Definition typeinf.hpp:1112

argloc_t::custom
void * custom
Definition typeinf.hpp:1113

argloc_t::biggest
biggest_t biggest
Definition typeinf.hpp:1114

argloc_t::biggest_t
size_t biggest_t
Definition typeinf.hpp:1103

argloc_t::sval
sval_t sval
Definition typeinf.hpp:1109

bytevec_t
Vector of bytes (use for dynamic memory)
Definition pro.h:3773

callregs_t
Register allocation calling convention.
Definition typeinf.hpp:1733

callregs_t::callregs_t
callregs_t(callcnv_t cc)
Constructor - initialize with the given request (see init_regs())
Definition typeinf.hpp:1772

callregs_t::reg_kind_t
reg_kind_t
Init registers (sequential)
Definition typeinf.hpp:1809

callregs_t::FPREGS
@ FPREGS
Definition typeinf.hpp:1809

callregs_t::GPREGS
@ GPREGS
Definition typeinf.hpp:1809

callregs_t::swap
void swap(callregs_t &r)
swap two instances
Definition typeinf.hpp:1775

callregs_t::policy
argreg_policy_t policy
argument policy
Definition typeinf.hpp:1763

callregs_t::findreg
static int findreg(const intvec_t &regs, int r)
Definition typeinf.hpp:1839

callregs_t::reginds
bool reginds(int *gp_ind, int *fp_ind, int r) const
Get register indexes within GP/FP arrays.
Definition typeinf.hpp:1847

callregs_t::reset
void reset()
Set policy and registers to invalid values.
Definition typeinf.hpp:1826

callregs_t::set_registers
void set_registers(reg_kind_t kind, int first_reg, int last_reg)
Definition typeinf.hpp:1818

callregs_t::init_regs
bool init_regs(callcnv_t cc)
Init policy & registers for given CC.
Definition typeinf.hpp:1784

callregs_t::set
void set(argreg_policy_t _policy, const int *gprs, const int *fprs)
Init policy & registers (arrays are -1-terminated)
Definition typeinf.hpp:1800

callregs_t::regcount
static int regcount(callcnv_t cc)
Get max number of registers may be used in a function call.
Definition typeinf.hpp:1832

callregs_t::fpregs
intvec_t fpregs
array of fp registers (floating point)
Definition typeinf.hpp:1766

callregs_t::findregs
bool findregs(int *gp_ind, int *fp_ind, int r, const intvec_t &gprs, const intvec_t &fprs) const
Search for register r in gprs and fprs.
Definition typeinf.hpp:1855

callregs_t::nregs
int nregs
max number of registers that can be used in a call
Definition typeinf.hpp:1764

callregs_t::gpregs
intvec_t gpregs
array of gp registers (general purpose)
Definition typeinf.hpp:1765

callregs_t::callregs_t
callregs_t()
Constructor.
Definition typeinf.hpp:1769

callregs_t::append_registers
void append_registers(reg_kind_t kind, int first_reg, int last_reg)
Definition typeinf.hpp:1810

callregs_t::by_slots
bool by_slots() const
Definition typeinf.hpp:1797

func_t
A function is a set of continuous ranges of addresses with characteristics.
Definition funcs.hpp:85

ida_lowertype_helper_t::get_func_purged_bytes
virtual int idaapi get_func_purged_bytes(const tinfo_t &candidate, const func_type_data_t &) override
Definition typeinf.hpp:6193

ida_lowertype_helper_t::func_has_stkframe_hole
virtual bool idaapi func_has_stkframe_hole(const tinfo_t &candidate, const func_type_data_t &candidate_data) override
Definition typeinf.hpp:6184

ida_lowertype_helper_t::ida_lowertype_helper_t
ida_lowertype_helper_t(const tinfo_t &_tif, ea_t _ea, int _pb)
Definition typeinf.hpp:6181

idc_value_t
Class to hold idc values.
Definition expr.hpp:315

lowertype_helper_t
Interface class - see ida_lowertype_helper_t.
Definition typeinf.hpp:6159

lowertype_helper_t::get_func_purged_bytes
virtual int idaapi get_func_purged_bytes(const tinfo_t &candidate, const func_type_data_t &candidate_data)=0

lowertype_helper_t::func_has_stkframe_hole
virtual bool idaapi func_has_stkframe_hole(const tinfo_t &candidate, const func_type_data_t &candidate_data)=0

lowertype_helper_t::~lowertype_helper_t
virtual ~lowertype_helper_t()
Definition typeinf.hpp:6161

mblock_t
Microcode of one basic block.
Definition hexrays.hpp:4184

op_t
Operand of an instruction.
Definition ua.hpp:170

qvector
Reimplementation of vector class from STL.
Definition pro.h:2250

qvector::clear
void clear(void)
Destroy all elements and free memory.
Definition pro.h:2439

qvector< argpart_t >::DEFINE_MEMORY_ALLOCATION_FUNCS
DEFINE_MEMORY_ALLOCATION_FUNCS() void push_back(const argpart_t &x)
Definition pro.h:2349

qvector< int >::const_iterator
const int * const_iterator
Definition pro.h:2607

qvector::end
iterator end(void)
Get an iterator that points to the end of the qvector (NOT the last element)
Definition pro.h:2610

qvector::resize
void resize(size_t _newsize, const T &x)
Resize to the given size.
Definition pro.h:2469

qvector< edm_t >::at
const edm_t & at(size_t _idx) const
Definition pro.h:2427

qvector::find
iterator find(const T &x)
Find an element in the qvector.
Definition pro.h:2703

qvector< udm_t >::qvector
qvector(void)
Definition pro.h:2328

qvector< edm_t >::push_back
edm_t & push_back(void)
Definition pro.h:2402

qvector::begin
iterator begin(void)
Get an iterator that points to the first element in the qvector.
Definition pro.h:2609

qvector::push_back
void push_back(T &&x)
Append a new element to the end the qvector with a move semantics.
Definition pro.h:2361

qvector::size
size_t size(void) const
Get the number of elements in the qvector.
Definition pro.h:2423

qvector< edm_t >::index
ssize_t index(const edm_t &x) const
Definition pro.h:2723

scattered_aloc_t
Used to manage arguments that are described by multiple locations (also see ALOC_DIST)
Definition typeinf.hpp:1343

tinfo_t
Primary mechanism for managing type information.
Definition typeinf.hpp:3046

tinfo_t::remove_ptr_or_array
bool remove_ptr_or_array()
Replace the current type with the ptr obj or array element.
Definition typeinf.hpp:3993

tinfo_t::get_edm
tinfo_code_t get_edm(edm_t *edm, size_t idx) const
Get enum member by its index.
Definition typeinf.hpp:3807

tinfo_t::get_forward_type
type_t get_forward_type() const
Get type of a forward declaration.
Definition typeinf.hpp:3417

tinfo_t::is_decl_udt
THREAD_SAFE bool is_decl_udt() const
is_type_struni(get_decltype())
Definition typeinf.hpp:3448

tinfo_t::DECLARE_COMPARISONS
DECLARE_COMPARISONS(tinfo_t)
Definition typeinf.hpp:4552

tinfo_t::is_decl_uint128
THREAD_SAFE bool is_decl_uint128() const
is_type_uint128(get_decltype())
Definition typeinf.hpp:3462

tinfo_t::is_int64
bool is_int64() const
is_type_int64(get_realtype())
Definition typeinf.hpp:3489

tinfo_t::is_decl_floating
THREAD_SAFE bool is_decl_floating() const
is_type_floating(get_decltype())
Definition typeinf.hpp:3467

tinfo_t::set_udm_by_til
tinfo_code_t set_udm_by_til(size_t idx, bool on=true, uint etf_flags=0)
The member is created due to the type system.
Definition typeinf.hpp:4241

tinfo_t::is_scalar
bool is_scalar() const
Does the type represent a single number?
Definition typeinf.hpp:3513

tinfo_t::is_decl_tbyte
THREAD_SAFE bool is_decl_tbyte() const
is_type_tbyte(get_decltype())
Definition typeinf.hpp:3466

tinfo_t::set_udm_repr
tinfo_code_t set_udm_repr(size_t index, const value_repr_t &repr, uint etf_flags=0)
Set the representation of a structure/union member.
Definition typeinf.hpp:4228

tinfo_t::create_typedef
void create_typedef(const til_t *til, uint ord, type_t decl_type=BTF_TYPEDEF)
Definition typeinf.hpp:3904

tinfo_t::get_array_details
bool get_array_details(array_type_data_t *ai) const
Get the array specific info.
Definition typeinf.hpp:3522

tinfo_t::create_typedef
bool create_typedef(const typedef_type_data_t &p, type_t decl_type=BTF_TYPEDEF, bool try_ordinal=true)
Definition typeinf.hpp:3893

tinfo_t::set_enum_radix
tinfo_code_t set_enum_radix(int radix, bool sign, uint etf_flags=0)
Set enum radix to display constants.
Definition typeinf.hpp:4371

tinfo_t::set_enum_width
tinfo_code_t set_enum_width(int nbytes, uint etf_flags=0)
Set the width of enum base type.
Definition typeinf.hpp:4324

tinfo_t::get_rettype
tinfo_t get_rettype() const
BT_FUNC or BT_PTR BT_FUNC: Get the function's return type
Definition typeinf.hpp:3602

tinfo_t::set_declalign
DEPRECATED bool set_declalign(uchar declalign)
Definition typeinf.hpp:4032

tinfo_t::is_fixed_struct
bool is_fixed_struct() const
Is a structure with fixed offsets?
Definition typeinf.hpp:3730

tinfo_t::get_type_cmt
int get_type_cmt(qstring *out) const
Get type comment.
Definition typeinf.hpp:3429

tinfo_t::set_named_type
tinfo_code_t set_named_type(til_t *til, const char *name, int ntf_flags=0)
Definition typeinf.hpp:3958

tinfo_t::get_numbered_type
bool get_numbered_type(uint32 ordinal, type_t decl_type=BTF_TYPEDEF, bool resolve=true)
Definition typeinf.hpp:3234

tinfo_t::has_vftable
bool has_vftable() const
Has a vftable?
Definition typeinf.hpp:3762

tinfo_t::set_attrs
bool set_attrs(type_attrs_t *tav)
Set type attributes.
Definition typeinf.hpp:3878

tinfo_t::get_onemember_type
tinfo_t get_onemember_type() const
For objects consisting of one member entirely: return type of the member.
Definition typeinf.hpp:3825

tinfo_t::del_attr
bool del_attr(const qstring &key, bool make_copy=true)
Del a type attribute. typerefs cannot be modified by this function.
Definition typeinf.hpp:3887

tinfo_t::get_bit_buckets
bool get_bit_buckets(range64vec_t *buckets) const
BT_STRUCT: get bit buckets Bit buckets are used to layout bitfields
Definition typeinf.hpp:3626

tinfo_t::get_alignment
uint32 get_alignment() const
Get type alignment This function returns the effective type alignment.
Definition typeinf.hpp:3325

tinfo_t::set_udt_alignment
tinfo_code_t set_udt_alignment(int sda, uint etf_flags=0)
Set declared structure alignment (sda) This alignment supersedes the alignment returned by get_declal...
Definition typeinf.hpp:4078

tinfo_t::get_innermost_member_type
tinfo_t get_innermost_member_type(uint64 bitoffset, uint64 *out_bitoffset=nullptr) const
Get the innermost member type at the given offset.
Definition typeinf.hpp:3840

tinfo_t::get_enum_nmembers
size_t get_enum_nmembers() const
Get number of enum members.
Definition typeinf.hpp:3769

tinfo_t::get_named_type
bool get_named_type(const char *name, type_t decl_type=BTF_TYPEDEF, bool resolve=true, bool try_ordinal=true)
Definition typeinf.hpp:3216

tinfo_t::is_decl_complex
THREAD_SAFE bool is_decl_complex() const
is_type_complex(get_decltype())
Definition typeinf.hpp:3443

tinfo_t::get_final_ordinal
uint32 get_final_ordinal() const
Get final type ordinal (0 if none)
Definition typeinf.hpp:3400

tinfo_t::create_udt
bool create_udt(bool is_union=false)
Create an empty structure/union.
Definition typeinf.hpp:5765

tinfo_t::is_decl_uchar
THREAD_SAFE bool is_decl_uchar() const
is_type_uchar(get_decltype())
Definition typeinf.hpp:3458

tinfo_t::set_enum_sign
tinfo_code_t set_enum_sign(type_sign_t sign, uint etf_flags=0)
Set enum sign.
Definition typeinf.hpp:4332

tinfo_t::get_type_name
bool get_type_name(qstring *out) const
Does a type refer to a name?
Definition typeinf.hpp:3355

tinfo_t::is_one_fpval
bool is_one_fpval() const
Floating value or an object consisting of one floating member entirely.
Definition typeinf.hpp:3752

tinfo_t::is_decl_uint32
THREAD_SAFE bool is_decl_uint32() const
is_type_uint32(get_decltype())
Definition typeinf.hpp:3460

tinfo_t::is_ext_arithmetic
bool is_ext_arithmetic() const
is_type_ext_arithmetic(get_realtype())
Definition typeinf.hpp:3511

tinfo_t::get_sign
type_sign_t get_sign() const
Get type sign.
Definition typeinf.hpp:3333

tinfo_t::is_volatile
bool is_volatile() const
is_type_volatile(get_realtype())
Definition typeinf.hpp:3474

tinfo_t::is_decl_ldouble
THREAD_SAFE bool is_decl_ldouble() const
is_type_ldouble(get_decltype())
Definition typeinf.hpp:3463

tinfo_t::get_stock
static tinfo_t get_stock(stock_type_id_t id)
Get stock type information.
Definition typeinf.hpp:3982

tinfo_t::set_modifiers
void set_modifiers(type_t mod)
Definition typeinf.hpp:4013

tinfo_t::get_alias_target
uint32 get_alias_target() const
Get type alias If the type has no alias, return 0.
Definition typeinf.hpp:4059

tinfo_t::deserialize
bool deserialize(const til_t *til, const type_t **ptype, const p_list **pfields=nullptr, const p_list **pfldcmts=nullptr, const char *cmt=nullptr)
Deserialize a type string into a tinfo_t object.
Definition typeinf.hpp:3254

tinfo_t::get_udm_by_tid
ssize_t get_udm_by_tid(udm_t *udm, tid_t tid)
Retrive tinfo using type TID or struct/enum member MID.
Definition typeinf.hpp:3940

tinfo_t::is_ptr_or_array
bool is_ptr_or_array() const
is_type_ptr_or_array(get_realtype())
Definition typeinf.hpp:3506

tinfo_t::is_vararg_cc
bool is_vararg_cc() const
is_vararg_cc(get_cc())
Definition typeinf.hpp:3610

tinfo_t::set_type_alignment
tinfo_code_t set_type_alignment(uchar declalign, uint etf_flags=0)
Set type alignment.
Definition typeinf.hpp:4027

tinfo_t::is_uint
bool is_uint() const
is_type_uint(get_realtype())
Definition typeinf.hpp:3494

tinfo_t::get_enum_details
bool get_enum_details(enum_type_data_t *ei) const
Get the enum specific info.
Definition typeinf.hpp:3528

tinfo_t::get_ptrarr_object
tinfo_t get_ptrarr_object() const
BT_PTR & BT_ARRAY: get the pointed object or array element.
Definition typeinf.hpp:3570

tinfo_t::save_type
tinfo_code_t save_type(int ntf_flags=NTF_TYPE|NTF_REPLACE)
Definition typeinf.hpp:3961

tinfo_t::is_user_cc
bool is_user_cc() const
is_user_cc(get_cc())
Definition typeinf.hpp:3609

tinfo_t::get_til
til_t * get_til() const
Get the type library for tinfo_t.
Definition typeinf.hpp:3403

tinfo_t::get_declalign
uchar get_declalign() const
Get declared alignment of the type.
Definition typeinf.hpp:3342

tinfo_t::is_tuple
bool is_tuple() const
Is a tuple?
Definition typeinf.hpp:3733

tinfo_t::is_varmember
bool is_varmember() const
Can the type be of a variable struct member?
Definition typeinf.hpp:3563

tinfo_t::is_decl_union
THREAD_SAFE bool is_decl_union() const
is_type_union(get_decltype())
Definition typeinf.hpp:3447

tinfo_t::set_func_cc
tinfo_code_t set_func_cc(callcnv_t cc, uint etf_flags=0)
Set function calling convention.
Definition typeinf.hpp:4528

tinfo_t::get_attrs
bool get_attrs(type_attrs_t *tav, bool all_attrs=false) const
Get type attributes (all_attrs: include attributes of referenced types, if any)
Definition typeinf.hpp:3870

tinfo_t::get_udt_nmembers
int get_udt_nmembers() const
Get number of udt members. -1-error.
Definition typeinf.hpp:3706

tinfo_t::is_float
bool is_float() const
is_type_float(get_realtype())
Definition typeinf.hpp:3502

tinfo_t::get_edm_by_value
ssize_t get_edm_by_value(edm_t *out, uint64 value, bmask64_t bmask=DEFMASK64, uchar serial=0) const
Get enum member by its value.
Definition typeinf.hpp:3815

tinfo_t::dstr
const char * dstr() const
Function to facilitate debugging.
Definition typeinf.hpp:3867

tinfo_t::get_nice_type_name
bool get_nice_type_name(qstring *out) const
Get the beautified type name.
Definition typeinf.hpp:3359

tinfo_t::is_empty_enum
bool is_empty_enum() const
Is an empty enum? (has no constants)
Definition typeinf.hpp:3772

tinfo_t::get_by_edm_name
ssize_t get_by_edm_name(const char *mname, const til_t *til=nullptr)
Retrieve enum tinfo using enum member name.
Definition typeinf.hpp:3950

tinfo_t::is_arithmetic
bool is_arithmetic() const
is_type_arithmetic(get_realtype())
Definition typeinf.hpp:3510

tinfo_t::is_decl_char
THREAD_SAFE bool is_decl_char() const
is_type_char(get_decltype())
Definition typeinf.hpp:3456

tinfo_t::is_floating
bool is_floating() const
is_type_floating(get_realtype())
Definition typeinf.hpp:3509

tinfo_t::clr_const
bool clr_const()
Definition typeinf.hpp:4021

tinfo_t::set_funcarg_type
tinfo_code_t set_funcarg_type(size_t index, const tinfo_t &tif, uint etf_flags=0)
Set type of a function argument.
Definition typeinf.hpp:4490

tinfo_t::is_decl_enum
THREAD_SAFE bool is_decl_enum() const
is_type_enum(get_decltype())
Definition typeinf.hpp:3449

tinfo_t::get_tid
tid_t get_tid() const
Get the type tid Each type in the local type library has a so-called tid associated with it.
Definition typeinf.hpp:3386

tinfo_t::is_char
bool is_char() const
is_type_char(get_realtype())
Definition typeinf.hpp:3493

tinfo_t::set_const
void set_const()
Definition typeinf.hpp:4014

tinfo_t::tinfo_t
tinfo_t(const tinfo_t &r)
Constructor.
Definition typeinf.hpp:3187

tinfo_t::is_decl_uint
THREAD_SAFE bool is_decl_uint() const
is_type_uint(get_decltype())
Definition typeinf.hpp:3457

tinfo_t::create_simple_type
bool create_simple_type(type_t decl_type)
Definition typeinf.hpp:3889

tinfo_t::set_enum_repr
tinfo_code_t set_enum_repr(const value_repr_t &repr, uint etf_flags=0)
Set the representation of enum members.
Definition typeinf.hpp:4365

tinfo_t::is_int128
bool is_int128() const
is_type_int128(get_realtype())
Definition typeinf.hpp:3488

tinfo_t::calc_udt_aligns
bool calc_udt_aligns(int sudt_flags=SUDT_GAPS)
Calculate the udt alignments using the field offsets/sizes and the total udt size This function does ...
Definition typeinf.hpp:4040

tinfo_t::is_unaligned_struct
bool is_unaligned_struct() const
Is an unaligned struct.
Definition typeinf.hpp:3718

tinfo_t::rename_funcarg
tinfo_code_t rename_funcarg(size_t index, const char *name, uint etf_flags=0)
Rename a function argument.
Definition typeinf.hpp:4480

tinfo_t::is_decl_unknown
THREAD_SAFE bool is_decl_unknown() const
is_type_unknown(get_decltype())
Definition typeinf.hpp:3438

tinfo_t::is_decl_int64
THREAD_SAFE bool is_decl_int64() const
is_type_int64(get_decltype())
Definition typeinf.hpp:3452

tinfo_t::is_decl_int128
THREAD_SAFE bool is_decl_int128() const
is_type_int128(get_decltype())
Definition typeinf.hpp:3451

tinfo_t::is_int16
bool is_int16() const
is_type_int16(get_realtype())
Definition typeinf.hpp:3491

tinfo_t::set_type_alias
bool set_type_alias(uint32 dest_ord)
Set type alias Redirects all references to source type to the destination type.
Definition typeinf.hpp:4068

tinfo_t::get_pointed_object
tinfo_t get_pointed_object() const
BT_PTR: get type of pointed object.
Definition typeinf.hpp:3575

tinfo_t::del_udms
tinfo_code_t del_udms(size_t idx1, size_t idx2, uint etf_flags=0)
Delete structure/union members in the range [idx1, idx2)
Definition typeinf.hpp:4196

tinfo_t::is_forward_struct
bool is_forward_struct() const
Definition typeinf.hpp:3418

tinfo_t::decl_type
const char type_t decl_type
Definition typeinf.hpp:3212

tinfo_t::is_small_udt
bool is_small_udt() const
Is a small udt? (can fit a register or a pair of registers)
Definition typeinf.hpp:3712

tinfo_t::is_unsigned
bool is_unsigned() const
Is this an unsigned type?
Definition typeinf.hpp:3339

tinfo_t::remove_pointer
friend tinfo_t remove_pointer(const tinfo_t &tif)
BT_PTR: If the current type is a pointer, return the pointed object.
Definition typeinf.hpp:5948

tinfo_t::print
bool print(qstring *out, const char *name=nullptr, int prtype_flags=PRTYPE_1LINE, int indent=0, int cmtindent=0, const char *prefix=nullptr, const char *cmt=nullptr) const
Get a C-like string representation of the type.
Definition typeinf.hpp:3854

tinfo_t::tinfo_t
tinfo_t(type_t decl_type)
Constructor - can only be used to initialize simple types!
Definition typeinf.hpp:3178

tinfo_t::create_forward_decl
tinfo_code_t create_forward_decl(til_t *til, type_t decl_type, const char *name, int ntf_flags=0)
Create a forward declaration.
Definition typeinf.hpp:3967

tinfo_t::set_numbered_type
tinfo_code_t set_numbered_type(til_t *til, uint32 ord, int ntf_flags=0, const char *name=nullptr)
Definition typeinf.hpp:3960

tinfo_t::is_cpp_struct
bool is_cpp_struct() const
Is a c++ object, not simple pod type.
Definition typeinf.hpp:3724

tinfo_t::is_varstruct
bool is_varstruct() const
Is a variable-size structure?
Definition typeinf.hpp:3558

tinfo_t::is_msstruct
bool is_msstruct() const
Is gcc msstruct attribute applied.
Definition typeinf.hpp:3721

tinfo_t::deserialize
bool deserialize(const til_t *til, const qtype *ptype, const qtype *pfields=nullptr, const qtype *pfldcmts=nullptr, const char *cmt=nullptr)
Deserialize a type string into a tinfo_t object.
Definition typeinf.hpp:3264

tinfo_t::get_ordinal
uint32 get_ordinal() const
Get type ordinal (only if the type was created as a numbered type, 0 if none)
Definition typeinf.hpp:3397

tinfo_t::get_udt_details
bool get_udt_details(udt_type_data_t *udt, gtd_udt_t gtd=GTD_CALC_LAYOUT) const
Get the udt specific info.
Definition typeinf.hpp:3540

tinfo_t::try_ordinal
const char type_t bool bool try_ordinal
Definition typeinf.hpp:3214

tinfo_t::is_decl_array
THREAD_SAFE bool is_decl_array() const
is_type_array(get_decltype())
Definition typeinf.hpp:3441

tinfo_t::get_udm_tid
tid_t get_udm_tid(size_t idx) const
Get udt member TID.
Definition typeinf.hpp:4100

tinfo_t::write_bitfield_value
uint64 write_bitfield_value(uint64 dst, uint64 v, int bitoff) const
Definition typeinf.hpp:4006

tinfo_t::is_typedef
bool is_typedef() const
Is this a typedef?
Definition typeinf.hpp:3425

tinfo_t::empty
THREAD_SAFE bool empty() const
Was tinfo_t initialized with some type info or not?
Definition typeinf.hpp:3308

tinfo_t::create_enum
bool create_enum(enum_type_data_t &p, type_t decl_type=BTF_ENUM)
Definition typeinf.hpp:3928

tinfo_t::del_udm
tinfo_code_t del_udm(size_t index, uint etf_flags=0)
Delete a structure/union member.
Definition typeinf.hpp:4190

tinfo_t::del_funcarg
tinfo_code_t del_funcarg(size_t idx, uint etf_flags=0)
Definition typeinf.hpp:4513

tinfo_t::is_shifted_ptr
bool is_shifted_ptr() const
Is a shifted pointer?
Definition typeinf.hpp:3555

tinfo_t::get_ptr_details
bool get_ptr_details(ptr_type_data_t *pi) const
Get the pointer info.
Definition typeinf.hpp:3516

tinfo_t::is_sue
bool is_sue() const
is_type_sue(get_realtype())
Definition typeinf.hpp:3486

tinfo_t::get_ptrarr_objsize
int get_ptrarr_objsize() const
BT_PTR & BT_ARRAY: get size of pointed object or array element. On error returns -1
Definition typeinf.hpp:3566

tinfo_t::get_stkvar
ssize_t get_stkvar(sval_t *actval, const insn_t &insn, const op_t *x, sval_t v)
Retrieve frame tinfo for a stack variable.
Definition typeinf.hpp:4312

tinfo_t::set_func_rettype
tinfo_code_t set_func_rettype(const tinfo_t &tif, uint etf_flags=0)
Set function return type .
Definition typeinf.hpp:4499

tinfo_t::clr_volatile
bool clr_volatile()
Definition typeinf.hpp:4022

tinfo_t::is_decl_void
THREAD_SAFE bool is_decl_void() const
is_type_void(get_decltype())
Definition typeinf.hpp:3436

tinfo_t::is_decl_uint16
THREAD_SAFE bool is_decl_uint16() const
is_type_uint16(get_decltype())
Definition typeinf.hpp:3459

tinfo_t::get_udt_taudt_bits
uint32 get_udt_taudt_bits() const
Get udt_type_data_t::taudt_bits.
Definition typeinf.hpp:3715

tinfo_t::set_fixed_struct
tinfo_code_t set_fixed_struct(bool on=true)
Declare struct member offsets as fixed.
Definition typeinf.hpp:4248

tinfo_t::is_funcptr
bool is_funcptr() const
Is this pointer to a function?
Definition typeinf.hpp:3552

tinfo_t::is_forward_enum
bool is_forward_enum() const
Definition typeinf.hpp:3420

tinfo_t::expand_udt
tinfo_code_t expand_udt(size_t idx, adiff_t delta, uint etf_flags=0)
Expand/shrink a structure by adding/removing a gap before the specified member.
Definition typeinf.hpp:4279

tinfo_t::is_integral
bool is_integral() const
is_type_integral(get_realtype())
Definition typeinf.hpp:3507

tinfo_t::get_enum_base_type
type_t get_enum_base_type() const
Get enum base type (convert enum to integer type) Returns BT_UNK if failed to convert.
Definition typeinf.hpp:3776

tinfo_t::get_edm_by_tid
ssize_t get_edm_by_tid(edm_t *edm, tid_t tid)
Definition typeinf.hpp:3941

tinfo_t::has_details
THREAD_SAFE bool has_details() const
Does this type refer to a nontrivial type?
Definition typeinf.hpp:3348

tinfo_t::is_decl_int32
THREAD_SAFE bool is_decl_int32() const
is_type_int32(get_decltype())
Definition typeinf.hpp:3453

tinfo_t::is_high_func
bool is_high_func() const
BT_FUNC: Is high level type?
Definition typeinf.hpp:3617

tinfo_t::is_decl_float
THREAD_SAFE bool is_decl_float() const
is_type_float(get_decltype())
Definition typeinf.hpp:3465

tinfo_t::convert_array_to_ptr
bool convert_array_to_ptr()
Convert an array into a pointer.
Definition typeinf.hpp:5815

tinfo_t::is_bitfield
bool is_bitfield() const
is_type_bitfld(get_realtype())
Definition typeinf.hpp:3487

tinfo_t::equals_to
bool equals_to(const tinfo_t &r) const
Definition typeinf.hpp:4574

tinfo_t::is_decl_struct
THREAD_SAFE bool is_decl_struct() const
is_type_struct(get_decltype())
Definition typeinf.hpp:3446

tinfo_t::rename_udm
tinfo_code_t rename_udm(size_t index, const char *name, uint etf_flags=0)
Rename a structure/union member.
Definition typeinf.hpp:4204

tinfo_t::set_symbol_type
tinfo_code_t set_symbol_type(til_t *til, const char *name, int ntf_flags=0)
Definition typeinf.hpp:3959

tinfo_t::is_decl_sue
THREAD_SAFE bool is_decl_sue() const
is_type_sue(get_decltype())
Definition typeinf.hpp:3445

tinfo_t::create_typedef
void create_typedef(const til_t *til, const char *name, type_t decl_type=BTF_TYPEDEF, bool try_ordinal=true)
Definition typeinf.hpp:3903

tinfo_t::create_func
bool create_func(func_type_data_t &p, type_t decl_type=BT_FUNC)
Definition typeinf.hpp:3929

tinfo_t::edit_edm
tinfo_code_t edit_edm(size_t idx, uint64 value, bmask64_t bmask=DEFMASK64, uint etf_flags=0)
Change constant value and/or bitmask.
Definition typeinf.hpp:4469

tinfo_t::is_uchar
bool is_uchar() const
is_type_uchar(get_realtype())
Definition typeinf.hpp:3495

tinfo_t::add_udm
tinfo_code_t add_udm(const udm_t &udm, uint etf_flags=0, size_t times=1, ssize_t idx=-1)
Add a structure/union member.
Definition typeinf.hpp:4111

tinfo_t::create_udt
bool create_udt(udt_type_data_t &p, type_t decl_type)
Definition typeinf.hpp:3927

tinfo_t::change_sign
bool change_sign(type_sign_t sign)
Change the type sign. Works only for the types that may have sign.
Definition typeinf.hpp:4036

tinfo_t::present
bool present() const
Is the type really present? (not a reference to a missing type, for example)
Definition typeinf.hpp:3311

tinfo_t::set_struct_size
tinfo_code_t set_struct_size(size_t new_size)
Explicitly specify the struct size.
Definition typeinf.hpp:4255

tinfo_t::del_edms
tinfo_code_t del_edms(size_t idx1, size_t idx2, uint etf_flags=0)
Delete enum members.
Definition typeinf.hpp:4420

tinfo_t::is_manually_castable_to
bool is_manually_castable_to(const tinfo_t &target) const
Definition typeinf.hpp:4576

tinfo_t::read_bitfield_value
uint64 read_bitfield_value(uint64 v, int bitoff) const
Definition typeinf.hpp:4005

tinfo_t::has_union
bool has_union() const
Has a member of type "union"?
Definition typeinf.hpp:3765

tinfo_t::get_numbered_type
bool get_numbered_type(const til_t *til, uint32 ordinal, type_t decl_type=BTF_TYPEDEF, bool resolve=true)
Create a tinfo_t object for an existing ordinal type.
Definition typeinf.hpp:5755

tinfo_t::is_decl_int
THREAD_SAFE bool is_decl_int() const
is_type_int(get_decltype())
Definition typeinf.hpp:3455

tinfo_t::create_bitfield
bool create_bitfield(const bitfield_type_data_t &p, type_t decl_type=BT_BITFIELD)
Definition typeinf.hpp:3892

tinfo_t::get_array_nelems
int get_array_nelems() const
BT_ARRAY: get number of elements (-1 means error)
Definition typeinf.hpp:3590

tinfo_t::is_frame
bool is_frame() const
Is a function frame?
Definition typeinf.hpp:4297

tinfo_t::add_edm
tinfo_code_t add_edm(const edm_t &edm, bmask64_t bmask=DEFMASK64, uint etf_flags=0, ssize_t idx=-1)
Add a new enum member (a new symbolic constant)
Definition typeinf.hpp:4389

tinfo_t::append_covered
bool append_covered(rangeset_t *out, uint64 offset=0) const
Calculate set of covered bytes for the type.
Definition typeinf.hpp:3745

tinfo_t::clr_const_volatile
bool clr_const_volatile()
Definition typeinf.hpp:4023

tinfo_t::create_enum
bool create_enum(bte_t bte=BTE_ALWAYS|BTE_HEX)
Create an empty enum.
Definition typeinf.hpp:5777

tinfo_t::name
const char * name
Definition typeinf.hpp:3211

tinfo_t::is_well_defined
THREAD_SAFE bool is_well_defined() const
!(empty()) && !(is_decl_partial()) && !(is_punknown())
Definition typeinf.hpp:3470

tinfo_t::is_udm_by_til
bool is_udm_by_til(size_t idx) const
Was the member created due to the type system.
Definition typeinf.hpp:4235

tinfo_t::get_unpadded_size
size_t get_unpadded_size() const
Get the type size in bytes without the final padding, in bytes.
Definition typeinf.hpp:3321

tinfo_t::detach
bool detach()
Detach tinfo_t from the underlying type.
Definition typeinf.hpp:3241

tinfo_t::is_decl_volatile
THREAD_SAFE bool is_decl_volatile() const
is_type_volatile(get_decltype())
Definition typeinf.hpp:3435

tinfo_t::is_enum
bool is_enum() const
is_type_enum(get_realtype())
Definition typeinf.hpp:3485

tinfo_t::get_udm
int get_udm(udm_t *out, const char *name) const
Retrieve a structure/union member with the specified name.
Definition typeinf.hpp:5876

tinfo_t::get_final_element
tinfo_t get_final_element() const
repeat recursively: if an array, return the type of its element; else return the type itself.
Definition typeinf.hpp:3587

tinfo_t::is_array
bool is_array() const
is_type_array(get_realtype())
Definition typeinf.hpp:3479

tinfo_t::is_tbyte
bool is_tbyte() const
is_type_tbyte(get_realtype())
Definition typeinf.hpp:3503

tinfo_t::copy_type
tinfo_code_t copy_type(til_t *til, const char *name, int ntf_flags=NTF_TYPE|NTF_COPY)
Definition typeinf.hpp:3962

tinfo_t::create_ptr
bool create_ptr(const ptr_type_data_t &p, type_t decl_type=BT_PTR)
Definition typeinf.hpp:3890

tinfo_t::is_decl_const
THREAD_SAFE bool is_decl_const() const
is_type_const(get_decltype())
Definition typeinf.hpp:3434

tinfo_t::is_ext_integral
bool is_ext_integral() const
is_type_ext_integral(get_realtype())
Definition typeinf.hpp:3508

tinfo_t::is_int
bool is_int() const
is_type_int(get_realtype())
Definition typeinf.hpp:3492

tinfo_t::set_methods
bool set_methods(udtmembervec_t &methods)
BT_COMPLEX: set the list of member functions.
Definition typeinf.hpp:4045

tinfo_t::is_forward_union
bool is_forward_union() const
Definition typeinf.hpp:3419

tinfo_t::is_decl_func
THREAD_SAFE bool is_decl_func() const
is_type_func(get_decltype())
Definition typeinf.hpp:3442

tinfo_t::is_uint128
bool is_uint128() const
is_type_uint128(get_realtype())
Definition typeinf.hpp:3499

tinfo_t::is_decl_ptr
THREAD_SAFE bool is_decl_ptr() const
is_type_ptr(get_decltype())
Definition typeinf.hpp:3440

tinfo_t::is_decl_double
THREAD_SAFE bool is_decl_double() const
is_type_double(get_decltype())
Definition typeinf.hpp:3464

tinfo_t::calc_gaps
bool calc_gaps(rangeset_t *out) const
Calculate set of padding bytes for the type.
Definition typeinf.hpp:3749

tinfo_t::get_final_type_name
bool get_final_type_name(qstring *out) const
Use in the case of typedef chain (TYPE1 -> TYPE2 -> TYPE3...TYPEn).
Definition typeinf.hpp:3370

tinfo_t::is_from_subtil
bool is_from_subtil() const
Was the named type found in some base type library (not the top level type library)?
Definition typeinf.hpp:3408

tinfo_t::force_tid
tid_t force_tid()
Get the type tid.
Definition typeinf.hpp:3394

tinfo_t::is_decl_last
THREAD_SAFE bool is_decl_last() const
is_typeid_last(get_decltype())
Definition typeinf.hpp:3439

tinfo_t::create_array
bool create_array(const array_type_data_t &p, type_t decl_type=BT_ARRAY)
Definition typeinf.hpp:3891

tinfo_t::is_correct
bool is_correct() const
Is the type object correct?
Definition typeinf.hpp:3285

tinfo_t::tinfo_t
tinfo_t()
Constructor.
Definition typeinf.hpp:3176

tinfo_t::is_forward_decl
bool is_forward_decl() const
Is this a forward declaration?
Definition typeinf.hpp:3412

tinfo_t::is_int32
bool is_int32() const
is_type_int32(get_realtype())
Definition typeinf.hpp:3490

tinfo_t::is_bitmask_enum
bool is_bitmask_enum() const
Is bitmask enum?
Definition typeinf.hpp:3781

tinfo_t::del_funcargs
tinfo_code_t del_funcargs(size_t idx1, size_t idx2, uint etf_flags=0)
Delete function arguments.
Definition typeinf.hpp:4509

tinfo_t::del_attrs
void del_attrs()
Del all type attributes. typerefs cannot be modified by this function.
Definition typeinf.hpp:3884

tinfo_t::operator=
tinfo_t & operator=(const tinfo_t &r)
Copy contents of given tinfo into this one.
Definition typeinf.hpp:3189

tinfo_t::is_bool
bool is_bool() const
is_type_bool(get_realtype())
Definition typeinf.hpp:3504

tinfo_t::tinfo_t
tinfo_t(const char *decl, til_t *til=nullptr, int pt_flags=0)
Constructor - will attempt to parse the provided C declaration.
Definition typeinf.hpp:3180

tinfo_t::is_aliased
bool is_aliased() const
Definition typeinf.hpp:4063

tinfo_t::get_frame_func
ea_t get_frame_func() const
Get function address for the frame.
Definition typeinf.hpp:4300

tinfo_t::is_empty_udt
bool is_empty_udt() const
Is an empty struct/union? (has no fields)
Definition typeinf.hpp:3709

tinfo_t::set_enum_is_bitmask
tinfo_code_t set_enum_is_bitmask(bitmask_cvt_stance_t stance=ENUMBM_ON, uint etf_flags=0)
Definition typeinf.hpp:4360

tinfo_t::get_nargs
int get_nargs() const
BT_FUNC or BT_PTR BT_FUNC: Calculate number of arguments (-1 - error)
Definition typeinf.hpp:3605

tinfo_t::set_udm_cmt
tinfo_code_t set_udm_cmt(size_t index, const char *cmt, bool is_regcmt=false, uint etf_flags=0)
Set a comment for a structure/union member.
Definition typeinf.hpp:4222

tinfo_t::is_anonymous_udt
bool is_anonymous_udt() const
Is an anonymous struct/union?
Definition typeinf.hpp:3759

tinfo_t::get_innermost_udm
tinfo_t get_innermost_udm(uint64 bitoffset, size_t *out_index=nullptr, uint64 *out_bitoffset=nullptr) const
Get the innermost member at the given offset.
Definition typeinf.hpp:3833

tinfo_t::bitmask_cvt_stance_t
bitmask_cvt_stance_t
Set or clear the 'bitmask' attribute of an enum.
Definition typeinf.hpp:4355

tinfo_t::ENUMBM_ON
@ ENUMBM_ON
convert to bitmask enum
Definition typeinf.hpp:4357

tinfo_t::ENUMBM_OFF
@ ENUMBM_OFF
convert to ordinal enum
Definition typeinf.hpp:4356

tinfo_t::ENUMBM_AUTO
@ ENUMBM_AUTO
convert to bitmask if the outcome is nice and useful
Definition typeinf.hpp:4358

tinfo_t::get_modifiers
type_t get_modifiers() const
Definition typeinf.hpp:4012

tinfo_t::get_func_frame
bool get_func_frame(const func_t *pfn)
Create a tinfo_t object for the function frame.
Definition typeinf.hpp:4294

tinfo_t::add_funcarg
tinfo_code_t add_funcarg(const funcarg_t &farg, uint etf_flags=0, ssize_t idx=-1)
Add a function argument.
Definition typeinf.hpp:4522

tinfo_t::get_realtype
type_t get_realtype(bool full=false) const
Get the resolved base type.
Definition typeinf.hpp:3298

tinfo_t::set_func_retloc
tinfo_code_t set_func_retloc(const argloc_t &argloc, uint etf_flags=0)
Set location of function return value.
Definition typeinf.hpp:4547

tinfo_t::set_type_cmt
tinfo_code_t set_type_cmt(const char *cmt, bool is_regcmt=false, uint etf_flags=0)
Set type comment This function works only for non-trivial types.
Definition typeinf.hpp:4052

tinfo_t::calc_purged_bytes
int calc_purged_bytes() const
BT_FUNC: Calculate number of purged bytes
Definition typeinf.hpp:3614

tinfo_t::set_volatile
void set_volatile()
Definition typeinf.hpp:4015

tinfo_t::swap
void swap(tinfo_t &r)
Assign this = r and r = this.
Definition typeinf.hpp:3195

tinfo_t::clear
void clear()
Clear contents of this tinfo, and remove from the type system.
Definition typeinf.hpp:3193

tinfo_t::is_partial
bool is_partial() const
is_type_partial(get_realtype())
Definition typeinf.hpp:3476

tinfo_t::get_methods
bool get_methods(udtmembervec_t *methods) const
BT_COMPLEX: get a list of member functions declared in this udt.
Definition typeinf.hpp:3621

tinfo_t::is_pvoid
bool is_pvoid() const
Is "void *"?. This function does not check the pointer attributes and type modifiers.
Definition typeinf.hpp:3578

tinfo_t::get_udm_by_offset
int get_udm_by_offset(udm_t *out, uint64 offset) const
Retrieve a structure/union member with the specified offset.
Definition typeinf.hpp:5897

tinfo_t::is_ldouble
bool is_ldouble() const
is_type_ldouble(get_realtype())
Definition typeinf.hpp:3500

tinfo_t::parse
bool parse(const char *decl, til_t *til=nullptr, int pt_flags=0)
Convenience function to parse a string with a type declaration.
Definition typeinf.hpp:3912

tinfo_t::get_attr
bool get_attr(const qstring &key, bytevec_t *bv, bool all_attrs=true) const
Get a type attribute.
Definition typeinf.hpp:3873

tinfo_t::calc_score
uint32 calc_score() const
Calculate the type score (the higher - the nicer is the type)
Definition typeinf.hpp:3843

tinfo_t::get_array_element
tinfo_t get_array_element() const
BT_ARRAY: get type of array element. See also get_ptrarr_object()
Definition typeinf.hpp:3584

tinfo_t::is_const
bool is_const() const
is_type_const(get_realtype())
Definition typeinf.hpp:3473

tinfo_t::get_enum_width
int get_enum_width() const
Get enum width.
Definition typeinf.hpp:3795

tinfo_t::serialize
bool serialize(qtype *type, qtype *fields=nullptr, qtype *fldcmts=nullptr, int sudt_flags=SUDT_FAST|SUDT_TRUNC) const
Serialize tinfo_t object into a type string.
Definition typeinf.hpp:3244

tinfo_t::rename_type
tinfo_code_t rename_type(const char *name, int ntf_flags=0)
Rename a type.
Definition typeinf.hpp:3365

tinfo_t::DEFINE_MEMORY_ALLOCATION_FUNCS
DEFINE_MEMORY_ALLOCATION_FUNCS() inline bool get_named_type(const til_t *til
Create a tinfo_t object for an existing named type.

tinfo_t::is_sse_type
bool is_sse_type() const
Is a SSE vector type?
Definition typeinf.hpp:3755

tinfo_t::is_decl_uint64
THREAD_SAFE bool is_decl_uint64() const
is_type_uint64(get_decltype())
Definition typeinf.hpp:3461

tinfo_t::is_double
bool is_double() const
is_type_double(get_realtype())
Definition typeinf.hpp:3501

tinfo_t::is_func
bool is_func() const
is_type_func(get_realtype())
Definition typeinf.hpp:3480

tinfo_t::get_next_type_name
bool get_next_type_name(qstring *out) const
Use In the case of typedef chain (TYPE1 -> TYPE2 -> TYPE3...TYPEn).
Definition typeinf.hpp:3375

tinfo_t::is_uint64
bool is_uint64() const
is_type_uint64(get_realtype())
Definition typeinf.hpp:3498

tinfo_t::is_ptr
bool is_ptr() const
is_type_ptr(get_realtype())
Definition typeinf.hpp:3478

tinfo_t::get_type_by_tid
bool get_type_by_tid(tid_t tid)
Definition typeinf.hpp:3942

tinfo_t::requires_qualifier
bool requires_qualifier(qstring *out, const char *name, uint64 offset) const
Requires full qualifier?
Definition typeinf.hpp:3740

tinfo_t::find_udm
int find_udm(udm_t *udm, int strmem_flags) const
BTF_STRUCT,BTF_UNION: Find a udt member.
Definition typeinf.hpp:3635

tinfo_t::get_bitfield_details
bool get_bitfield_details(bitfield_type_data_t *bi) const
Get the bitfield specific info.
Definition typeinf.hpp:3534

tinfo_t::get_enum_repr
tinfo_code_t get_enum_repr(value_repr_t *repr) const
Set the representation of enum members.
Definition typeinf.hpp:3790

tinfo_t::get_edm
ssize_t get_edm(edm_t *out, const char *name) const
Get enum member by its name.
Definition typeinf.hpp:3802

tinfo_t::set_attr
bool set_attr(const type_attr_t &ta, bool may_overwrite=true)
Set a type attribute. If necessary, a new typid will be created.
Definition typeinf.hpp:3881

tinfo_t::is_struct
bool is_struct() const
is_type_struct(get_realtype())
Definition typeinf.hpp:3482

tinfo_t::get_size
size_t get_size(uint32 *p_effalign=nullptr, int gts_code=0) const
Get the type size in bytes.
Definition typeinf.hpp:3317

tinfo_t::is_purging_cc
bool is_purging_cc() const
is_purging_cc(get_cc())
Definition typeinf.hpp:3611

tinfo_t::is_decl_paf
THREAD_SAFE bool is_decl_paf() const
is_type_paf(get_decltype())
Definition typeinf.hpp:3469

tinfo_t::is_complex
bool is_complex() const
is_type_complex(get_realtype())
Definition typeinf.hpp:3481

tinfo_t::set_edm_cmt
tinfo_code_t set_edm_cmt(size_t idx, const char *cmt, uint etf_flags=0)
Set a comment for an enum member.
Definition typeinf.hpp:4458

tinfo_t::get_type_rptcmt
bool get_type_rptcmt(qstring *out) const
Get type comment only if it is repeatable.
Definition typeinf.hpp:3432

tinfo_t::get_func_details
bool get_func_details(func_type_data_t *fi, gtd_func_t gtd=GTD_CALC_ARGLOCS) const
Get only the function specific info for this tinfo_t.
Definition typeinf.hpp:3546

tinfo_t::del_edm_by_value
tinfo_code_t del_edm_by_value(uint64 value, uint etf_flags=0, bmask64_t bmask=DEFMASK64, uchar serial=0)
Delete enum member by its value.
Definition typeinf.hpp:5926

tinfo_t::is_paf
bool is_paf() const
is_type_paf(get_realtype())
Definition typeinf.hpp:3505

tinfo_t::is_punknown
bool is_punknown() const
Is "_UNKNOWN *"?. This function does not check the pointer attributes and type modifiers.
Definition typeinf.hpp:3581

tinfo_t::is_decl_bitfield
THREAD_SAFE bool is_decl_bitfield() const
is_type_bitfld(get_decltype())
Definition typeinf.hpp:3450

tinfo_t::set_tuple
tinfo_code_t set_tuple(bool on=true)
Declare struct as a tuple.
Definition typeinf.hpp:4290

tinfo_t::is_signed
bool is_signed() const
Is this a signed type?
Definition typeinf.hpp:3336

tinfo_t::is_decl_int16
THREAD_SAFE bool is_decl_int16() const
is_type_int16(get_decltype())
Definition typeinf.hpp:3454

tinfo_t::get_edm_tid
tid_t get_edm_tid(size_t idx) const
Get enum member TID.
Definition typeinf.hpp:3822

tinfo_t::rename_edm
tinfo_code_t rename_edm(size_t idx, const char *name, uint etf_flags=0)
Rename a enum member.
Definition typeinf.hpp:4448

tinfo_t::set_udm_type
tinfo_code_t set_udm_type(size_t index, const tinfo_t &tif, uint etf_flags=0, const value_repr_t *repr=nullptr)
Set type of a structure/union member.
Definition typeinf.hpp:4215

tinfo_t::del_edm
tinfo_code_t del_edm(size_t idx, uint etf_flags=0)
Definition typeinf.hpp:4424

tinfo_t::is_decl_partial
THREAD_SAFE bool is_decl_partial() const
is_type_partial(get_decltype())
Definition typeinf.hpp:3437

tinfo_t::is_uint32
bool is_uint32() const
is_type_uint32(get_realtype())
Definition typeinf.hpp:3497

tinfo_t::is_unknown
bool is_unknown() const
is_type_unknown(get_realtype())
Definition typeinf.hpp:3477

tinfo_t::is_decl_bool
THREAD_SAFE bool is_decl_bool() const
is_type_bool(get_decltype())
Definition typeinf.hpp:3468

tinfo_t::resolve
const char type_t bool resolve
Definition typeinf.hpp:3213

tinfo_t::get_enum_radix
int get_enum_radix() const
Get enum constant radix.
Definition typeinf.hpp:3786

tinfo_t::is_decl_typedef
THREAD_SAFE bool is_decl_typedef() const
is_type_typedef(get_decltype())
Definition typeinf.hpp:3444

tinfo_t::is_union
bool is_union() const
is_type_union(get_realtype())
Definition typeinf.hpp:3483

tinfo_t::set_funcarg_loc
tinfo_code_t set_funcarg_loc(size_t index, const argloc_t &argloc, uint etf_flags=0)
Set location of a function argument.
Definition typeinf.hpp:4538

tinfo_t::get_decltype
THREAD_SAFE type_t get_decltype() const
Get declared type (without resolving type references; they are returned as is).
Definition typeinf.hpp:3305

tinfo_t::is_vftable
bool is_vftable() const
Is a vftable type?
Definition typeinf.hpp:3727

tinfo_t::compare_with
bool compare_with(const tinfo_t &r, int tcflags=0) const
Compare two types, based on given flags (see tinfo_t comparison flags)
Definition typeinf.hpp:4573

tinfo_t::clr_decl_const_volatile
void clr_decl_const_volatile()
Definition typeinf.hpp:4017

tinfo_t::~tinfo_t
~tinfo_t()
Destructor.
Definition typeinf.hpp:3191

tinfo_t::get_cc
callcnv_t get_cc() const
BT_FUNC or BT_PTR BT_FUNC: Get calling convention
Definition typeinf.hpp:3608

tinfo_t::is_castable_to
bool is_castable_to(const tinfo_t &target) const
Definition typeinf.hpp:4575

tinfo_t::is_udt
bool is_udt() const
is_type_struni(get_realtype())
Definition typeinf.hpp:3484

tinfo_t::is_void
bool is_void() const
is_type_void(get_realtype())
Definition typeinf.hpp:3475

tinfo_t::get_nth_arg
tinfo_t get_nth_arg(int n) const
BT_FUNC or BT_PTR BT_FUNC: Get type of n-th arg (-1 means return type, see get_rettype())
Definition typeinf.hpp:3593

tinfo_t::is_typeref
THREAD_SAFE bool is_typeref() const
Is this type a type reference?.
Definition typeinf.hpp:3345

tinfo_t::set_udt_pack
tinfo_code_t set_udt_pack(int pack, uint etf_flags=0)
Set structure packing.
Definition typeinf.hpp:4090

tinfo_t::is_uint16
bool is_uint16() const
is_type_uint16(get_realtype())
Definition typeinf.hpp:3496

tinfo_t::calc_enum_mask
uint64 calc_enum_mask() const
Definition typeinf.hpp:3796

valstr_t
Text representation of a data value (value string).
Definition typeinf.hpp:6408

valstr_t::oneline
qstring oneline
result if printed on one line in UTF-8 encoding
Definition typeinf.hpp:6410

valstr_t::append_char
bool append_char(char c, int max_length)

valstr_t::flatten
bool flatten(const flatten_args_t &flargs, int level)

valstr_t::set_oneline
void set_oneline(const char *line, int len)
Definition typeinf.hpp:6431

valstr_t::convert_to_one_line
bool convert_to_one_line(int ptvf, int max_length)

valstr_t::~valstr_t
~valstr_t()
Definition typeinf.hpp:6450

valstr_t::members
struct valstrs_t * members
strings for members, each member separately
Definition typeinf.hpp:6412

valstr_t::consume_oneline
void consume_oneline(const qstring &line)
Definition typeinf.hpp:6436

valstr_t::update_length
void update_length(int ptvf)

valstr_t::props
int props
temporary properties, used internally
Definition typeinf.hpp:6414

valstr_t::info
valinfo_t * info
additional info
Definition typeinf.hpp:6413

valstr_t::valstr_t
valstr_t()
Definition typeinf.hpp:6417

valstr_t::valstr_sink_t
friend struct() private valstr_sink_t
Definition typeinf.hpp:6419

valstr_t::length
size_t length
length if printed on one line
Definition typeinf.hpp:6411

find_custom_callcnv
idaman callcnv_t ida_export find_custom_callcnv(const char *name)
Find a calling convention by its name.

get_custom_callcnvs
idaman size_t ida_export get_custom_callcnvs(qstrvec_t *names, callcnvs_t *codes)
Get all custom calling conventions.

argreg_policy_t
argreg_policy_t
Function argument passing: how GP & FP registers cooperate with each other.
Definition typeinf.hpp:1714

verify_argloc
idaman int ida_export verify_argloc(const argloc_t &vloc, int size, const rangeset_t *gaps)
Verify argloc_t.

is_purging_cc
constexpr THREAD_SAFE bool is_purging_cc(callcnv_t cc)
Does the calling convention clean the stack arguments upon return?
Definition typeinf.hpp:1474

helper_set_cc
void helper_set_cc(cm_t *cm, callcnv_t *new_callcnv, callcnv_t cc)
Definition typeinf.hpp:1432

is_vararg_cc
constexpr THREAD_SAFE bool is_vararg_cc(callcnv_t cc)
Does the calling convention use ellipsis?
Definition typeinf.hpp:1466

get_custom_callcnv
idaman const custom_callcnv_t *ida_export get_custom_callcnv(callcnv_t callcnv)
Retrieve custom calling convention details.

install_custom_argloc
idaman int ida_export install_custom_argloc(const custloc_desc_t *custloc)
Save a custom argloc.

for_all_const_arglocs
int idaapi for_all_const_arglocs(const_aloc_visitor_t &vv, const argloc_t &vloc, int size, int off=0)
See for_all_arglocs()
Definition typeinf.hpp:1399

ALOC_NONE
const argloc_type_t ALOC_NONE
none
Definition typeinf.hpp:953

helper_get_cc
callcnv_t helper_get_cc(cm_t cm, callcnv_t new_callcnv)
Definition typeinf.hpp:1423

argpartvec_t
qvector< argpart_t > argpartvec_t
Definition typeinf.hpp:1339

ALOC_CUSTOM
const argloc_type_t ALOC_CUSTOM
custom argloc (7 or higher)
Definition typeinf.hpp:960

ALOC_RREL
const argloc_type_t ALOC_RREL
register relative
Definition typeinf.hpp:958

ALOC_DIST
const argloc_type_t ALOC_DIST
distributed (scattered)
Definition typeinf.hpp:955

ALOC_REG2
const argloc_type_t ALOC_REG2
register pair
Definition typeinf.hpp:957

unregister_custom_callcnv
idaman bool ida_export unregister_custom_callcnv(callcnv_t callcnv)
Unregister a calling convention.

ALOC_STATIC
const argloc_type_t ALOC_STATIC
global address
Definition typeinf.hpp:959

get_stkarg_area_info
idaman bool ida_export get_stkarg_area_info(stkarg_area_info_t *out, callcnv_t cc)
Some calling conventions foresee special areas on the stack for call arguments.

ALOC_REG1
const argloc_type_t ALOC_REG1
one register (and offset within it)
Definition typeinf.hpp:956

retrieve_custom_argloc
idaman const custloc_desc_t *ida_export retrieve_custom_argloc(int idx)
Retrieve the custom argloc at the given index.

is_user_cc
constexpr THREAD_SAFE bool is_user_cc(callcnv_t cc)
Does the calling convention specify argument locations explicitly?
Definition typeinf.hpp:1460

print_argloc
idaman size_t ida_export print_argloc(char *buf, size_t bufsize, const argloc_t &vloc, int size=0, int vflags=0)
Convert an argloc to human readable form.

is_swift_cc
constexpr bool is_swift_cc(callcnv_t cc)
Swift calling convention (arguments and return values in registers)?
Definition typeinf.hpp:1503

for_all_arglocs
idaman int ida_export for_all_arglocs(aloc_visitor_t &vv, argloc_t &vloc, int size, int off=0)
Compress larger argloc types and initiate the aloc visitor.

is_golang_cc
constexpr bool is_golang_cc(callcnv_t cc)
GO language calling convention (return value in stack)?
Definition typeinf.hpp:1486

compiler_info_t::set_cc
void set_cc(callcnv_t cc)
Definition typeinf.hpp:1448

arglocs_t
qvector< argloc_t > arglocs_t
vector of argument locations
Definition typeinf.hpp:1309

register_custom_callcnv
idaman callcnv_t ida_export register_custom_callcnv(const custom_callcnv_t &ccinf)
Register a calling convention.

optimize_argloc
idaman bool ida_export optimize_argloc(argloc_t *vloc, int size, const rangeset_t *gaps)
Verify and optimize scattered argloc into simple form.

remove_custom_argloc
idaman bool ida_export remove_custom_argloc(int idx)
Delete the custom argloc at the given index.

ALOC_STACK
const argloc_type_t ALOC_STACK
stack offset
Definition typeinf.hpp:954

compiler_info_t::get_cc
callcnv_t get_cc() const
Definition typeinf.hpp:1447

is_custom_callcnv
bool is_custom_callcnv(callcnv_t cc)
Is custom calling convention?
Definition typeinf.hpp:1492

get_effective_cc
callcnv_t get_effective_cc(callcnv_t cc)
Get effective calling convention (with respect to default CC)
Definition typeinf.hpp:1451

ARGREGS_GP_ONLY
@ ARGREGS_GP_ONLY
GP registers used for all arguments.
Definition typeinf.hpp:1716

ARGREGS_POLICY_UNDEFINED
@ ARGREGS_POLICY_UNDEFINED
Definition typeinf.hpp:1715

ARGREGS_RISCV
@ ARGREGS_RISCV
Risc-V API FP arguments are passed in GP registers if FP registers are exhausted and GP ones are not.
Definition typeinf.hpp:1721

ARGREGS_FP_MASKS_GP
@ ARGREGS_FP_MASKS_GP
FP register also consumes one or more GP regs but not vice versa (aix ppc ABI)
Definition typeinf.hpp:1719

ARGREGS_BY_SLOTS
@ ARGREGS_BY_SLOTS
fixed FP/GP register per each slot (like vc64)
Definition typeinf.hpp:1718

ARGREGS_MIPS_O32
@ ARGREGS_MIPS_O32
MIPS ABI o32.
Definition typeinf.hpp:1720

ARGREGS_INDEPENDENT
@ ARGREGS_INDEPENDENT
FP/GP registers used separately (like gcc64)
Definition typeinf.hpp:1717

BFA_STATIC
const type_t BFA_STATIC
static
Definition typeinf.hpp:925

BFA_FUNC_EXT_FORMAT
const type_t BFA_FUNC_EXT_FORMAT
This is NOT a real attribute (used internally as marker for extended format)
Definition typeinf.hpp:929

BFA_NORET
const type_t BFA_NORET
__noreturn
Definition typeinf.hpp:922

BFA_FUNC_MARKER
const cm_t BFA_FUNC_MARKER
This is NOT a cc! (used internally as a marker)
Definition typeinf.hpp:928

BFA_VIRTUAL
const type_t BFA_VIRTUAL
virtual
Definition typeinf.hpp:926

BFA_HIGH
const type_t BFA_HIGH
high level prototype (with possibly hidden args)
Definition typeinf.hpp:924

BFA_PURE
const type_t BFA_PURE
__pure
Definition typeinf.hpp:923

C_PC_FLAT
const cm_t C_PC_FLAT
Definition typeinf.hpp:1417

C_PC_SMALL
const cm_t C_PC_SMALL
Definition typeinf.hpp:1412

C_PC_MEDIUM
const cm_t C_PC_MEDIUM
Definition typeinf.hpp:1414

C_PC_LARGE
const cm_t C_PC_LARGE
Definition typeinf.hpp:1415

C_PC_TINY
const cm_t C_PC_TINY
Definition typeinf.hpp:1411

C_PC_HUGE
const cm_t C_PC_HUGE
Definition typeinf.hpp:1416

C_PC_COMPACT
const cm_t C_PC_COMPACT
Definition typeinf.hpp:1413

is_gcc
bool is_gcc()
Is the target compiler COMP_GNU?
Definition typeinf.hpp:1923

set_abi_name
bool idaapi set_abi_name(const char *abiname, bool user_level=false)
Set abi name (see Compiler IDs)
Definition typeinf.hpp:1974

get_compilers
idaman void ida_export get_compilers(compvec_t *ids, qstrvec_t *names, qstrvec_t *abbrs)
Get names of all built-in compilers.

set_compiler_string
idaman bool ida_export set_compiler_string(const char *compstr, bool user_level)

use_golang_cc
bool use_golang_cc()
is GOLANG calling convention used by default?
Definition typeinf.hpp:2003

get_comp
THREAD_SAFE comp_t get_comp(comp_t comp)
Get compiler bits.
Definition typeinf.hpp:1890

is_gcc32
bool is_gcc32()
Is the target compiler 32 bit gcc?
Definition typeinf.hpp:1928

set_compiler
idaman bool ida_export set_compiler(const compiler_info_t &cc, int flags, const char *abiname=nullptr)
Change current compiler.

gcc_layout
bool gcc_layout()
Should use the struct/union layout as done by gcc?
Definition typeinf.hpp:1938

get_abi_name
idaman ssize_t ida_export get_abi_name(qstring *out)
Get ABI name.

default_compiler
comp_t default_compiler()
Get compiler specified by inf.cc.
Definition typeinf.hpp:1918

remove_abi_opts
idaman bool ida_export remove_abi_opts(const char *abi_opts, bool user_level=false)

is_comp_unsure
THREAD_SAFE comp_t is_comp_unsure(comp_t comp)
See COMP_UNSURE.
Definition typeinf.hpp:1913

get_compiler_name
idaman const char *ida_export get_compiler_name(comp_t id)
Get full compiler name.

compvec_t
qvector< comp_t > compvec_t
Collection of compiler descriptions.
Definition typeinf.hpp:1903

append_abi_opts
idaman bool ida_export append_abi_opts(const char *abi_opts, bool user_level=false)
Add/remove/check ABI option General form of full abi name: abiname-opt1-opt2-... or -opt1-opt2-....

switch_to_golang
void switch_to_golang()
switch to GOLANG calling convention (to be used as default CC)
Definition typeinf.hpp:2010

set_compiler_id
bool idaapi set_compiler_id(comp_t id, const char *abiname=nullptr)
Set the compiler id (see Compiler IDs)
Definition typeinf.hpp:1965

is_gcc64
bool is_gcc64()
Is the target compiler 64 bit gcc?
Definition typeinf.hpp:1933

get_compiler_abbr
idaman const char *ida_export get_compiler_abbr(comp_t id)
Get abbreviated compiler name.

CM_CC_PASCAL
const callcnv_t CM_CC_PASCAL
stack, purged, reverse order of args
Definition typeinf.hpp:886

CM_CC_SWIFT
const callcnv_t CM_CC_SWIFT
(Swift) arguments and return values in registers (compiler-dependent)
Definition typeinf.hpp:889

CM_CC_RESERVE3
const callcnv_t CM_CC_RESERVE3
reserved; used for internal needs
Definition typeinf.hpp:895

CM_CC_CDECL
const callcnv_t CM_CC_CDECL
stack
Definition typeinf.hpp:883

CM_CC_INVALID
const callcnv_t CM_CC_INVALID
this value is invalid
Definition typeinf.hpp:878

CM_CC_SPECIALP
const callcnv_t CM_CC_SPECIALP
Equal to CM_CC_SPECIAL, but with purged stack.
Definition typeinf.hpp:897

CM_CC_GOLANG
const callcnv_t CM_CC_GOLANG
(Go) arguments and return value reg/stack depending on version
Definition typeinf.hpp:894

CM_CC_FASTCALL
const callcnv_t CM_CC_FASTCALL
stack, purged (x86), first args are in regs (compiler-dependent)
Definition typeinf.hpp:887

CM_CC_STDCALL
const callcnv_t CM_CC_STDCALL
stack, purged
Definition typeinf.hpp:885

CM_CC_SPECIAL
const callcnv_t CM_CC_SPECIAL
usercall: locations of all arguments and the return value are explicitly specified
Definition typeinf.hpp:898

CM_CC_THISCALL
const callcnv_t CM_CC_THISCALL
stack, purged (x86), first arg is in reg (compiler-dependent)
Definition typeinf.hpp:888

CM_CC_VOIDARG
const callcnv_t CM_CC_VOIDARG
function without arguments if has other cc and argnum == 0, represent as f() - unknown list
Definition typeinf.hpp:880

CM_CC_GOSTK
const callcnv_t CM_CC_GOSTK
(Go) arguments and return value in stack
Definition typeinf.hpp:902

CM_CC_SPOILED
const callcnv_t CM_CC_SPOILED
This is NOT a cc!
Definition typeinf.hpp:890

CM_CC_MASK
const callcnv_t CM_CC_MASK
Definition typeinf.hpp:877

CM_CC_LAST_USERCALL
const callcnv_t CM_CC_LAST_USERCALL
Definition typeinf.hpp:900

CM_CC_UNKNOWN
const callcnv_t CM_CC_UNKNOWN
unknown calling convention
Definition typeinf.hpp:879

CM_CC_FIRST_PLAIN_CUSTOM
const callcnv_t CM_CC_FIRST_PLAIN_CUSTOM
Definition typeinf.hpp:904

CM_CC_ELLIPSIS
const callcnv_t CM_CC_ELLIPSIS
cdecl + ellipsis
Definition typeinf.hpp:884

CM_CC_SPECIALE
const callcnv_t CM_CC_SPECIALE
CM_CC_SPECIAL with ellipsis
Definition typeinf.hpp:896

CM_M_MASK
const cm_t CM_M_MASK
Definition typeinf.hpp:863

is_code_far
THREAD_SAFE bool is_code_far(cm_t cm)
Does the given model specify far code?.
Definition typeinf.hpp:870

is_data_far
THREAD_SAFE bool is_data_far(cm_t cm)
Does the given model specify far data?.
Definition typeinf.hpp:872

CM_M_NN
const cm_t CM_M_NN
small: code=near, data=near (or unknown if CM_UNKNOWN)
Definition typeinf.hpp:864

CM_M_FN
const cm_t CM_M_FN
medium: code=far, data=near
Definition typeinf.hpp:867

CM_M_FF
const cm_t CM_M_FF
large: code=far, data=far
Definition typeinf.hpp:865

CM_M_NF
const cm_t CM_M_NF
compact: code=near, data=far
Definition typeinf.hpp:866

CM_N32_F48
const cm_t CM_N32_F48
near 4 bytes, far 6 bytes
Definition typeinf.hpp:859

CM_N16_F32
const cm_t CM_N16_F32
near 2 bytes, far 4 bytes
Definition typeinf.hpp:858

CM_UNKNOWN
const cm_t CM_UNKNOWN
unknown
Definition typeinf.hpp:855

CM_N8_F16
const cm_t CM_N8_F16
if sizeof(int)<=2: near 1 byte, far 2 bytes
Definition typeinf.hpp:856

CM_MASK
const cm_t CM_MASK
Definition typeinf.hpp:854

CM_N64
const cm_t CM_N64
if sizeof(int)>2: near 8 bytes, far 8 bytes
Definition typeinf.hpp:857

COMP_BP
const comp_t COMP_BP
Delphi.
Definition typeinf.hpp:1879

COMP_WATCOM
const comp_t COMP_WATCOM
Watcom C++.
Definition typeinf.hpp:1874

COMP_MASK
const comp_t COMP_MASK
Definition typeinf.hpp:1870

COMP_UNK
const comp_t COMP_UNK
Unknown.
Definition typeinf.hpp:1871

COMP_BC
const comp_t COMP_BC
Borland C++.
Definition typeinf.hpp:1873

COMP_GNU
const comp_t COMP_GNU
GNU C++.
Definition typeinf.hpp:1877

COMP_MS
const comp_t COMP_MS
Visual C++.
Definition typeinf.hpp:1872

COMP_UNSURE
const comp_t COMP_UNSURE
uncertain compiler id
Definition typeinf.hpp:1881

COMP_VISAGE
const comp_t COMP_VISAGE
Visual Age C++.
Definition typeinf.hpp:1878

etf_flag_t
etf_flag_t
Definition typeinf.hpp:2913

ETF_NO_LAYOUT
@ ETF_NO_LAYOUT
don't calc type layout before editing
Definition typeinf.hpp:2918

ETF_FUNCARG
@ ETF_FUNCARG
udm - member is a function argument (cannot create arrays)
Definition typeinf.hpp:2921

ETF_AUTONAME
@ ETF_AUTONAME
udm - generate a member name if was not specified (add_udm, set_udm_type)
Definition typeinf.hpp:2923

ETF_NO_ARRAY
@ ETF_NO_ARRAY
add_udm, set_udm_type - do not convert type to an array on the size mismatch
Definition typeinf.hpp:2925

ETF_FORCENAME
@ ETF_FORCENAME
anyway use name, see below for more usage description
Definition typeinf.hpp:2922

ETF_NO_SAVE
@ ETF_NO_SAVE
don't save to til (normally typerefs are saved to til) A call with ETF_NO_SAVE must be followed by a ...
Definition typeinf.hpp:2914

ETF_COMPATIBLE
@ ETF_COMPATIBLE
new type must be compatible with the old
Definition typeinf.hpp:2920

ETF_MAY_DESTROY
@ ETF_MAY_DESTROY
may destroy other members
Definition typeinf.hpp:2919

ETF_BYTIL
@ ETF_BYTIL
udm - new type was created by the type subsystem
Definition typeinf.hpp:2924

decorate_name
idaman bool ida_export decorate_name(qstring *out, const char *name, bool should_decorate, callcnv_t cc=CM_CC_UNKNOWN, const tinfo_t *type=nullptr)
Decorate/undecorate a C symbol name.

calc_c_cpp_name
idaman ssize_t ida_export calc_c_cpp_name(qstring *out, const char *name, const tinfo_t *type, int ccn_flags)
Get C or C++ form of the name.

del_named_type
idaman bool ida_export del_named_type(til_t *ti, const char *name, int ntf_flags)
Delete information about a symbol.

next_named_type
idaman const char *ida_export next_named_type(const til_t *ti, const char *name, int ntf_flags)
Enumerate types.

gen_decorate_name
idaman bool ida_export gen_decorate_name(qstring *out, const char *name, bool should_decorate, callcnv_t cc, const tinfo_t *type)
Generic function for decorate_name() (may be used in IDP modules)

first_named_type
idaman const char *ida_export first_named_type(const til_t *ti, int ntf_flags)
Enumerate types.

tinfo_code_t
tinfo_code_t
Error codes various tinfo functions:
Definition typeinf.hpp:2318

custom_callcnv_t::decorate_name
virtual bool decorate_name(qstring *outbuf, const char *name, bool should_decorate, callcnv_t cc, const tinfo_t &type) const
Decorate a function name.
Definition typeinf.hpp:2429

tinfo_errstr
idaman const char *ida_export tinfo_errstr(tinfo_code_t code)
Helper function to convert an error code into a printable string.

get_named_type64
int idaapi get_named_type64(const til_t *ti, const char *name, int ntf_flags, const type_t **type=nullptr, const p_list **fields=nullptr, const char **cmt=nullptr, const p_list **fieldcmts=nullptr, sclass_t *sclass=nullptr, uint64 *value=nullptr)
See get_named_type() above.
Definition typeinf.hpp:2300

get_named_type
idaman int ida_export get_named_type(const til_t *ti, const char *name, int ntf_flags, const type_t **type=nullptr, const p_list **fields=nullptr, const char **cmt=nullptr, const p_list **fieldcmts=nullptr, sclass_t *sclass=nullptr, uint32 *value=nullptr)
Get named typeinfo.

copy_named_type
idaman uint32 ida_export copy_named_type(til_t *dsttil, const til_t *srctil, const char *name)
Copy a named type from one til to another.

TERR_ENUM_SIZE
@ TERR_ENUM_SIZE
bad enum size
Definition typeinf.hpp:2352

TERR_NOT_COMPAT
@ TERR_NOT_COMPAT
the new type is not compatible with the old type
Definition typeinf.hpp:2346

TERR_NOT_IMPL
@ TERR_NOT_IMPL
not implemented
Definition typeinf.hpp:2353

TERR_NOT_FOUND
@ TERR_NOT_FOUND
member not found
Definition typeinf.hpp:2357

TERR_BAD_OFFSET
@ TERR_BAD_OFFSET
bad member offset s
Definition typeinf.hpp:2329

TERR_BAD_ARG
@ TERR_BAD_ARG
bad argument
Definition typeinf.hpp:2323

TERR_BAD_GROUPS
@ TERR_BAD_GROUPS
bad group sizes for bitmask enum
Definition typeinf.hpp:2348

TERR_STRUCT_SIZE
@ TERR_STRUCT_SIZE
bad fixed structure size
Definition typeinf.hpp:2356

TERR_BAD_NAME
@ TERR_BAD_NAME
name s is not acceptable
Definition typeinf.hpp:2322

TERR_BAD_FX_SIZE
@ TERR_BAD_FX_SIZE
cannot extend struct beyond fixed size
Definition typeinf.hpp:2355

TERR_BAD_GAP
@ TERR_BAD_GAP
bad gap
Definition typeinf.hpp:2344

TERR_BAD_VARLAST
@ TERR_BAD_VARLAST
variable sized member must be the last member in the structure
Definition typeinf.hpp:2331

TERR_BAD_BF
@ TERR_BAD_BF
bitfields are forbidden as function arguments
Definition typeinf.hpp:2328

TERR_BAD_BMASK
@ TERR_BAD_BMASK
Bad enum member mask 0xI64X. The specified mask should not intersect with any existing mask in the en...
Definition typeinf.hpp:2336

TERR_BAD_BASE
@ TERR_BAD_BASE
bad base class
Definition typeinf.hpp:2343

TERR_STOCK
@ TERR_STOCK
stock type info cannot be modified
Definition typeinf.hpp:2351

TERR_BAD_TAH
@ TERR_BAD_TAH
bad bits in the type attributes (TAH bits)
Definition typeinf.hpp:2342

TERR_BAD_REPR
@ TERR_BAD_REPR
bad or incompatible field representation
Definition typeinf.hpp:2338

TERR_UNION_BF
@ TERR_UNION_BF
unions cannot have bitfields
Definition typeinf.hpp:2341

TERR_BAD_MSKVAL
@ TERR_BAD_MSKVAL
bad bmask and value combination (value=0xI64X; bitmask 0xI64X)
Definition typeinf.hpp:2337

TERR_GRP_NOEMPTY
@ TERR_GRP_NOEMPTY
could not delete group mask for not empty group 0xI64X
Definition typeinf.hpp:2339

TERR_SERIALIZE
@ TERR_SERIALIZE
failed to serialize
Definition typeinf.hpp:2321

TERR_BAD_TYPE
@ TERR_BAD_TYPE
bad type
Definition typeinf.hpp:2324

TERR_BAD_ARRAY
@ TERR_BAD_ARRAY
arrays are forbidden as function arguments
Definition typeinf.hpp:2327

TERR_TYPE_WORSE
@ TERR_TYPE_WORSE
the new type is worse than the old type
Definition typeinf.hpp:2354

TERR_NO_BMASK
@ TERR_NO_BMASK
bitmask 0xI64X is not found
Definition typeinf.hpp:2335

TERR_OVERLAP
@ TERR_OVERLAP
the member overlaps with other members that cannot be deleted
Definition typeinf.hpp:2332

TERR_ALIEN_NAME
@ TERR_ALIEN_NAME
enum member name is used in another enum
Definition typeinf.hpp:2350

TERR_COUNT
@ TERR_COUNT
Definition typeinf.hpp:2358

TERR_DUPNAME
@ TERR_DUPNAME
duplicate name s
Definition typeinf.hpp:2340

TERR_BAD_SERIAL
@ TERR_BAD_SERIAL
enum value has too many serials
Definition typeinf.hpp:2349

TERR_BAD_UNIVAR
@ TERR_BAD_UNIVAR
unions cannot have variable sized members
Definition typeinf.hpp:2330

TERR_BAD_LAYOUT
@ TERR_BAD_LAYOUT
failed to calculate the structure/union layout
Definition typeinf.hpp:2347

TERR_BAD_SUBTYPE
@ TERR_BAD_SUBTYPE
recursive structure nesting is forbidden
Definition typeinf.hpp:2333

TERR_BAD_SIZE
@ TERR_BAD_SIZE
bad size d
Definition typeinf.hpp:2325

TERR_OK
@ TERR_OK
ok
Definition typeinf.hpp:2319

TERR_BAD_VALUE
@ TERR_BAD_VALUE
value 0xI64X is not acceptable
Definition typeinf.hpp:2334

TERR_BAD_INDEX
@ TERR_BAD_INDEX
bad index d
Definition typeinf.hpp:2326

TERR_NESTED
@ TERR_NESTED
recursive structure nesting is forbidden
Definition typeinf.hpp:2345

TERR_SAVE_ERROR
@ TERR_SAVE_ERROR
failed to save
Definition typeinf.hpp:2320

is_ordinal_name
idaman bool ida_export is_ordinal_name(const char *name, uint32 *ord=nullptr)
Check if the name is an ordinal name.

is_type_choosable
idaman bool ida_export is_type_choosable(const til_t *ti, uint32 ordinal)
Check if a struct/union type is choosable.

alloc_type_ordinals
idaman uint32 ida_export alloc_type_ordinals(til_t *ti, int qty)
Allocate a range of ordinal numbers for new types.

get_ordinal_limit
idaman uint32 ida_export get_ordinal_limit(const til_t *ti=nullptr)
Get number of allocated ordinals + 1.

get_type_ordinal
idaman int32 ida_export get_type_ordinal(const til_t *ti, const char *name)
Get type ordinal by its name.

alloc_type_ordinal
uint32 alloc_type_ordinal(til_t *ti)
alloc_type_ordinals(ti, 1)
Definition typeinf.hpp:2496

get_numbered_type_name
idaman const char *ida_export get_numbered_type_name(const til_t *ti, uint32 ordinal)
Get type name (if exists) by its ordinal.

build_anon_type_name
idaman void ida_export build_anon_type_name(qstring *buf, const type_t *type, const p_list *fields)
Generate a name like $hex_numbers based on the field types and names.

set_type_choosable
idaman void ida_export set_type_choosable(til_t *ti, uint32 ordinal, bool value)
Enable/disable 'choosability' flag for a struct/union type.

del_numbered_type
idaman bool ida_export del_numbered_type(til_t *ti, uint32 ordinal)
Delete a numbered type.

get_numbered_type
idaman bool ida_export get_numbered_type(const til_t *ti, uint32 ordinal, const type_t **type=nullptr, const p_list **fields=nullptr, const char **cmt=nullptr, const p_list **fieldcmts=nullptr, sclass_t *sclass=nullptr)
Retrieve a type by its ordinal number.

get_alias_target
idaman uint32 ida_export get_alias_target(const til_t *ti, uint32 ordinal)
Find the final alias destination.

set_type_alias
idaman bool ida_export set_type_alias(til_t *ti, uint32 src_ordinal, uint32 dst_ordinal)
Create a type alias.

enable_numbered_types
idaman bool ida_export enable_numbered_types(til_t *ti, bool enable)
Enable the use of numbered types in til.

create_numbered_type_name
idaman ssize_t ida_export create_numbered_type_name(qstring *buf, int32 ord)
Create anonymous name for numbered type.

get_ordinal_count
uint32 get_ordinal_count(const til_t *ti=nullptr)
Get number of allocated ordinals.
Definition typeinf.hpp:2513

compact_numbered_types
idaman int ida_export compact_numbered_types(til_t *ti, uint32 min_ord=0, intvec_t *p_ordmap=nullptr, int flags=0)
Compact numbered types to get rid of empty slots.

h2ti_type_cb
int idaapi h2ti_type_cb(const char *name, const tinfo_t &tif, const char *cmt, const uint64 *value, void *cb_data)
This callback will be called for each type/variable declaration.
Definition typeinf.hpp:2096

print_type
idaman bool ida_export print_type(qstring *out, ea_t ea, int prtype_flags)
Get type declaration for the specified address.

h2ti
idaman int ida_export h2ti(til_t *ti, lexer_t *lx, const char *input, int flags=HTI_HIGH, h2ti_type_cb *type_cb=nullptr, h2ti_type_cb *var_cb=nullptr, printer_t *print_cb=nullptr, void *_cb_data=nullptr, abs_t _isabs=ABS_UNK)
Convert declarations to type_t*.
Definition typeinf.hpp:2122

parse_decl
idaman bool ida_export parse_decl(tinfo_t *out_tif, qstring *out_name, til_t *til, const char *decl, int pt_flags)
Parse ONE declaration.

AS_PRINTF
typedef AS_PRINTF(1, 2) int printer_t(const char *format
Specify a printing callback when parsing types.

parse_decls
idaman int ida_export parse_decls(til_t *til, const char *input, printer_t *printer, int hti_flags)
Parse many declarations and store them in a til.

convert_pt_flags_to_hti
THREAD_SAFE int convert_pt_flags_to_hti(int pt_flags)
Convert Type parsing flags to Type formatting flags.
Definition typeinf.hpp:2138

format
idaman THREAD_SAFE const char * format
Definition fpro.h:78

code
int code
Definition fpro.h:88

n
idaman size_t n
Definition pro.h:997

type_unsigned
const type_sign_t type_unsigned
unsigned type
Definition typeinf.hpp:675

type_attrs_t
qvector< type_attr_t > type_attrs_t
this vector must be sorted by keys
Definition typeinf.hpp:669

type_sign_t
int type_sign_t
type signedness
Definition typeinf.hpp:671

no_sign
const type_sign_t no_sign
no sign, or unknown
Definition typeinf.hpp:673

type_signed
const type_sign_t type_signed
signed type
Definition typeinf.hpp:674

DECLARE_TYPE_AS_MOVABLE
DECLARE_TYPE_AS_MOVABLE(type_attr_t)

BTMT_NONBASED
const type_t BTMT_NONBASED
Definition typeinf.hpp:233

BTMT_ARRESERV
const type_t BTMT_ARRESERV
reserved bit
Definition typeinf.hpp:241

BT_ARRAY
const type_t BT_ARRAY
array
Definition typeinf.hpp:232

BT_BOOL
const type_t BT_BOOL
bool
Definition typeinf.hpp:181

BTMT_BOOL8
const type_t BTMT_BOOL8
size 8bytes - inf_is_64bit()
Definition typeinf.hpp:185

BTMT_BOOL2
const type_t BTMT_BOOL2
size 2bytes - !inf_is_64bit()
Definition typeinf.hpp:184

BTMT_BOOL4
const type_t BTMT_BOOL4
size 4bytes
Definition typeinf.hpp:186

BTMT_DEFBOOL
const type_t BTMT_DEFBOOL
size is model specific or unknown(?)
Definition typeinf.hpp:182

BTMT_BOOL1
const type_t BTMT_BOOL1
size 1byte
Definition typeinf.hpp:183

BTMT_BFLDI16
const type_t BTMT_BFLDI16
__int16
Definition typeinf.hpp:327

BT_BITFIELD
const type_t BT_BITFIELD
bitfield (only in struct) ['bitmasked' enum see below] next byte is dt ((size in bits << 1) | (unsign...
Definition typeinf.hpp:322

BTMT_BFLDI32
const type_t BTMT_BFLDI32
__int32
Definition typeinf.hpp:328

BTMT_BFLDI64
const type_t BTMT_BFLDI64
__int64
Definition typeinf.hpp:329

BT_COMPLEX
const type_t BT_COMPLEX
struct/union/enum/typedef.
Definition typeinf.hpp:287

BTMT_ENUM
const type_t BTMT_ENUM
enum: next byte bte_t (see below) N records: de delta(s) OR blocks (see below)
Definition typeinf.hpp:314

BTMT_TYPEDEF
const type_t BTMT_TYPEDEF
named reference always p_string name
Definition typeinf.hpp:319

BTMT_BFLDI8
const type_t BTMT_BFLDI8
__int8
Definition typeinf.hpp:326

BTMT_STRUCT
const type_t BTMT_STRUCT
struct: MCNT records: type_t; [sdacl-typeattrs];
Definition typeinf.hpp:310

BTMT_UNION
const type_t BTMT_UNION
union: MCNT records: type_t...
Definition typeinf.hpp:312

BT_SEGREG
const type_t BT_SEGREG
segment register
Definition typeinf.hpp:373

BT_UNK_DWORD
const type_t BT_UNK_DWORD
4 bytes
Definition typeinf.hpp:380

BT_UNKNOWN
const type_t BT_UNKNOWN
unknown size - for parameters
Definition typeinf.hpp:383

BT_UNK_BYTE
const type_t BT_UNK_BYTE
1 byte
Definition typeinf.hpp:378

BT_UNK_QWORD
const type_t BT_UNK_QWORD
8 bytes
Definition typeinf.hpp:381

BT_UNK_OWORD
const type_t BT_UNK_OWORD
16 bytes
Definition typeinf.hpp:382

BT_UNK_WORD
const type_t BT_UNK_WORD
2 bytes
Definition typeinf.hpp:379

BTE_HEX
const bte_t BTE_HEX
hex
Definition typeinf.hpp:364

BTE_UDEC
const bte_t BTE_UDEC
unsigned decimal
Definition typeinf.hpp:367

BTE_RESERVED
const bte_t BTE_RESERVED
must be 0, in order to distinguish from a tah-byte
Definition typeinf.hpp:353

bte_t
uchar bte_t
Enum type flags.
Definition typeinf.hpp:347

BTE_BITMASK
const bte_t BTE_BITMASK
'subarrays'.
Definition typeinf.hpp:355

BTE_CHAR
const bte_t BTE_CHAR
char or hex
Definition typeinf.hpp:365

BTE_SDEC
const bte_t BTE_SDEC
signed decimal
Definition typeinf.hpp:366

BTE_ALWAYS
const bte_t BTE_ALWAYS
this bit MUST be present
Definition typeinf.hpp:368

BTE_SIZE_MASK
const bte_t BTE_SIZE_MASK
storage size.
Definition typeinf.hpp:349

BTE_OUT_MASK
const bte_t BTE_OUT_MASK
output style mask
Definition typeinf.hpp:363

BTMT_SPECFLT
const type_t BTMT_SPECFLT
float (variable size).
Definition typeinf.hpp:195

BTMT_LNGDBL
const type_t BTMT_LNGDBL
long double (compiler specific)
Definition typeinf.hpp:194

BT_FLOAT
const type_t BT_FLOAT
float
Definition typeinf.hpp:191

BTMT_FLOAT
const type_t BTMT_FLOAT
float (4 bytes)
Definition typeinf.hpp:192

BTMT_DOUBLE
const type_t BTMT_DOUBLE
double (8 bytes)
Definition typeinf.hpp:193

BTMT_FARCALL
const type_t BTMT_FARCALL
function returns by retf
Definition typeinf.hpp:280

BTMT_DEFCALL
const type_t BTMT_DEFCALL
call method - default for model or unknown
Definition typeinf.hpp:278

BT_FUNC
const type_t BT_FUNC
function.
Definition typeinf.hpp:249

BTMT_NEARCALL
const type_t BTMT_NEARCALL
function returns by retn
Definition typeinf.hpp:279

BTMT_INTCALL
const type_t BTMT_INTCALL
function returns by iret in this case cc MUST be 'unknown'
Definition typeinf.hpp:281

BT_INT
const type_t BT_INT
natural int. (size provided by idp module)
Definition typeinf.hpp:168

BT_INT16
const type_t BT_INT16
__int16
Definition typeinf.hpp:164

BTMT_UNKSIGN
const type_t BTMT_UNKSIGN
unknown signedness
Definition typeinf.hpp:169

BT_INT64
const type_t BT_INT64
__int64
Definition typeinf.hpp:166

BT_INT128
const type_t BT_INT128
__int128 (for alpha & future use)
Definition typeinf.hpp:167

BTMT_CHAR
const type_t BTMT_CHAR
specify char or segment register
Definition typeinf.hpp:173

BT_INT32
const type_t BT_INT32
__int32
Definition typeinf.hpp:165

BTMT_UNSIGNED
const type_t BTMT_UNSIGNED
Definition typeinf.hpp:172

BT_INT8
const type_t BT_INT8
__int8
Definition typeinf.hpp:163

BTMT_USIGNED
const type_t BTMT_USIGNED
unsigned
Definition typeinf.hpp:171

BTMT_SIGNED
const type_t BTMT_SIGNED
signed
Definition typeinf.hpp:170

_BT_LAST_BASIC
const type_t _BT_LAST_BASIC
the last basic type, all basic types may be followed by [tah-typeattrs]
Definition typeinf.hpp:202

TYPE_FULL_MASK
const type_t TYPE_FULL_MASK
basic type with type flags
Definition typeinf.hpp:136

TYPE_FLAGS_MASK
const type_t TYPE_FLAGS_MASK
type flags - they have different meaning depending on the basic type
Definition typeinf.hpp:130

TYPE_BASE_MASK
const type_t TYPE_BASE_MASK
the low 4 bits define the basic type
Definition typeinf.hpp:129

TYPE_MODIF_MASK
const type_t TYPE_MODIF_MASK
modifiers.
Definition typeinf.hpp:132

BTM_CONST
const type_t BTM_CONST
const
Definition typeinf.hpp:340

BTM_VOLATILE
const type_t BTM_VOLATILE
volatile
Definition typeinf.hpp:341

BTMT_CLOSURE
const type_t BTMT_CLOSURE
closure.
Definition typeinf.hpp:217

BT_PTR
const type_t BT_PTR
pointer.
Definition typeinf.hpp:211

BTMT_NEAR
const type_t BTMT_NEAR
near
Definition typeinf.hpp:215

BTMT_DEFPTR
const type_t BTMT_DEFPTR
default for model
Definition typeinf.hpp:214

BTMT_FAR
const type_t BTMT_FAR
far
Definition typeinf.hpp:216

BTF_INT64
const type_t BTF_INT64
signed long
Definition typeinf.hpp:404

BTF_UNION
const type_t BTF_UNION
union
Definition typeinf.hpp:422

BTF_UINT16
const type_t BTF_UINT16
unsigned short
Definition typeinf.hpp:399

BTF_DOUBLE
const type_t BTF_DOUBLE
double
Definition typeinf.hpp:417

BTF_UNK
const type_t BTF_UNK
unknown
Definition typeinf.hpp:390

BTF_UINT128
const type_t BTF_UINT128
unsigned 128-bit value
Definition typeinf.hpp:408

BTF_INT16
const type_t BTF_INT16
signed short
Definition typeinf.hpp:398

BTF_UINT64
const type_t BTF_UINT64
unsigned long
Definition typeinf.hpp:405

BTF_BYTE
const type_t BTF_BYTE
byte
Definition typeinf.hpp:389

BTF_UINT
const type_t BTF_UINT
unsigned int
Definition typeinf.hpp:411

BTF_UINT32
const type_t BTF_UINT32
unsigned int
Definition typeinf.hpp:402

BTF_ENUM
const type_t BTF_ENUM
enum
Definition typeinf.hpp:423

BTF_TYPEDEF
const type_t BTF_TYPEDEF
typedef
Definition typeinf.hpp:424

BTF_UCHAR
const type_t BTF_UCHAR
unsigned char
Definition typeinf.hpp:395

BTF_STRUCT
const type_t BTF_STRUCT
struct
Definition typeinf.hpp:421

BTF_VOID
const type_t BTF_VOID
void
Definition typeinf.hpp:391

BTF_CHAR
const type_t BTF_CHAR
signed char
Definition typeinf.hpp:394

BTF_LDOUBLE
const type_t BTF_LDOUBLE
long double
Definition typeinf.hpp:418

BTF_TBYTE
const type_t BTF_TBYTE
see BTMT_SPECFLT
Definition typeinf.hpp:419

BTF_INT8
const type_t BTF_INT8
signed byte
Definition typeinf.hpp:393

BTF_INT
const type_t BTF_INT
int, unknown signedness
Definition typeinf.hpp:410

BTF_INT128
const type_t BTF_INT128
signed 128-bit value
Definition typeinf.hpp:407

BTF_INT32
const type_t BTF_INT32
signed int
Definition typeinf.hpp:401

BTF_FLOAT
const type_t BTF_FLOAT
float
Definition typeinf.hpp:416

BTF_UINT8
const type_t BTF_UINT8
unsigned byte
Definition typeinf.hpp:396

BTF_SINT
const type_t BTF_SINT
singed int
Definition typeinf.hpp:412

BTF_BOOL
const type_t BTF_BOOL
boolean
Definition typeinf.hpp:414

BTMT_SIZE12
const type_t BTMT_SIZE12
size = 1 byte if BT_VOID; 2 if BT_UNK
Definition typeinf.hpp:155

BT_UNK
const type_t BT_UNK
unknown
Definition typeinf.hpp:152

BTMT_SIZE48
const type_t BTMT_SIZE48
size = 4 bytes if BT_VOID; 8 if BT_UNK
Definition typeinf.hpp:156

BTMT_SIZE128
const type_t BTMT_SIZE128
size = 16 bytes if BT_VOID; unknown if BT_UNK (IN struct alignment - see below)
Definition typeinf.hpp:157

BTMT_SIZE0
const type_t BTMT_SIZE0
BT_VOID - normal void; BT_UNK - don't use
Definition typeinf.hpp:154

BT_VOID
const type_t BT_VOID
void
Definition typeinf.hpp:153

BT_RESERVED
const type_t BT_RESERVED
RESERVED.
Definition typeinf.hpp:332

get_tid_ordinal
idaman uint32 ida_export get_tid_ordinal(tid_t tid)
Get type ordinal number for TID.

get_idainfo_by_udm
idaman bool ida_export get_idainfo_by_udm(flags64_t *flags, opinfo_t *ti, const udm_t &udm, ea_t refinfo_ea=BADADDR)
Calculate IDA info from udt member.

edm_t::get_tid
tid_t get_tid() const
Definition typeinf.hpp:6263

get_named_type_tid
idaman tid_t ida_export get_named_type_tid(const char *name)
Get named local type TID.

get_udm_by_fullname
idaman ssize_t ida_export get_udm_by_fullname(udm_t *udm, const char *fullname)
Get udt member by full name.

get_tid_name
idaman bool ida_export get_tid_name(qstring *out, tid_t tid)
Get a type name for the specified TID.

create_enum_type
tid_t create_enum_type(const char *enum_name, enum_type_data_t &ei, int enum_width, type_sign_t sign, bool convert_to_bitmask, const char *enum_cmt=nullptr)
Create type enum.
Definition typeinf.hpp:6310

del_vftable_ea
bool del_vftable_ea(uint32 ordinal)
Delete the address of a vftable instance for a vftable type.
Definition typeinf.hpp:2630

get_vftable_ordinal
idaman uint32 ida_export get_vftable_ordinal(ea_t vftable_ea)
Get ordinal number of the virtual function table.

set_vftable_ea
idaman bool ida_export set_vftable_ea(uint32 ordinal, ea_t vftable_ea)
Set the address of a vftable instance for a vftable type.

get_vftable_ea
idaman ea_t ida_export get_vftable_ea(uint32 ordinal)
Get address of a virtual function table.

e
cexpr_t * e
Definition hexrays.hpp:7308

type
const tinfo_t & type
Definition hexrays.hpp:7301

INF_H_PATH
@ INF_H_PATH
C header path.
Definition ida.hpp:513

INF_C_MACROS
@ INF_C_MACROS
C predefined macros.
Definition ida.hpp:514

inf_big_arg_align
bool inf_big_arg_align(void)
Definition ida.hpp:966

inf_get_cc_defalign
uchar inf_get_cc_defalign()
Definition ida.hpp:1010

inf_get_abibits
uint32 inf_get_abibits()
Definition ida.hpp:960

inf_get_cc_size_e
uchar inf_get_cc_size_e()
Definition ida.hpp:1007

callcnvs_t
qvector< callcnv_t > callcnvs_t
Definition ida.hpp:75

cm_t
uchar cm_t
calling convention and memory model
Definition ida.hpp:73

inf_get_callcnv
callcnv_t inf_get_callcnv()
Definition ida.hpp:998

callcnv_t
uint32 callcnv_t
Definition ida.hpp:74

inf_is_64bit
bool inf_is_64bit(void)
Definition ida.hpp:631

getinf_str
idaman ssize_t ida_export getinf_str(qstring *buf, inftag_t tag)
Get program specific information (a non-scalar value)

setinf_buf
idaman bool ida_export setinf_buf(inftag_t tag, const void *buf, size_t bufsize=0)
Set program specific information.

comp_t
uchar comp_t
target compiler id
Definition ida.hpp:72

inf_huge_arg_align
bool inf_huge_arg_align(void)
Definition ida.hpp:980

inf_set_callcnv
bool inf_set_callcnv(callcnv_t _v)
Definition ida.hpp:999

inf_pack_stkargs
bool inf_pack_stkargs(void)
Definition ida.hpp:964

inf_get_cc_id
comp_t inf_get_cc_id()
Definition ida.hpp:992

idp.hpp
Contains definition of the interface to IDP modules.

reginfovec_t
qvector< reg_info_t > reginfovec_t
vector of register info objects
Definition idp.hpp:2718

nbytes
int nbytes
Definition kernwin.hpp:2861

ok
bool ok
Definition kernwin.hpp:7006

uval_t
uval_t uval_t
Definition kernwin.hpp:1878

rc
ssize_t rc
Definition kernwin.hpp:7101

len
idaman size_t len
Definition kernwin.hpp:1356

size
asize_t size
Definition kernwin.hpp:6339

tif_cursor_t
uint64 tif_cursor_t
A location in a tinfo_t.
Definition kernwin.hpp:1882

void
void(idaapi *range_marker)(ea_t ea
Pointer to range marker function (for idaviews and hexviews) This pointer is initialized by setup_ran...

result
bool result
Definition kernwin.hpp:7890

ct
cast_t token_t * ct
Definition lex.hpp:172

uint64
unsigned __int64 uint64
Definition llong.hpp:13

get_tinfo
idaman bool ida_export get_tinfo(tinfo_t *tif, ea_t ea)

type_t
uchar type_t
In serialized form, a type is represented by a byte sequence.
Definition nalt.hpp:1317

aflags_t
flags_t aflags_t
Definition nalt.hpp:289

p_list
uchar p_list
several p_string's
Definition nalt.hpp:1318

name.hpp
Functions that deal with names.

t
idaman size_t const char time_t t
Definition pro.h:602

uint16
unsigned short uint16
unsigned 16 bit value
Definition pro.h:346

bool
int bool
Definition pro.h:329

uint32
unsigned int uint32
unsigned 32 bit value
Definition pro.h:348

intvec_t
qvector< int > intvec_t
vector of integers
Definition pro.h:2765

asize_t
uint64 asize_t
Definition pro.h:423

make_mask
constexpr T make_mask(int count)
Make a mask of 'count' bits.
Definition pro.h:1521

align_up
T align_up(T val, int elsize)
Align element up to nearest boundary.
Definition pro.h:4628

sval_t
adiff_t sval_t
signed value used by the processor.
Definition pro.h:446

int16
short int16
signed 16 bit value
Definition pro.h:345

adiff_t
int64 adiff_t
Definition pro.h:424

ea_t
uint64 ea_t
Definition pro.h:421

int32
int int32
signed 32 bit value
Definition pro.h:347

uchar
unsigned char uchar
unsigned 8 bit value
Definition pro.h:337

qswap
THREAD_SAFE void qswap(T &a, T &b)
Swap 2 objects of the same type using memory copies.
Definition pro.h:1715

bufsize
idaman size_t bufsize
Definition pro.h:600

qtype
_qstring< uchar > qtype
type string
Definition pro.h:3695

uint
unsigned int uint
unsigned 32 bit value
Definition pro.h:339

error_t
int error_t
Error code (errno)
Definition pro.h:458

eavec_t
qvector< ea_t > eavec_t
vector of addresses
Definition pro.h:2764

flags64_t
uint64 flags64_t
64-bit flags for each address
Definition pro.h:5009

ssize_t
ptrdiff_t ssize_t
Signed size_t - used to check for size overflows when the counter becomes negative.
Definition pro.h:381

ushort
unsigned short ushort
unsigned 16 bit value
Definition pro.h:338

align_down
T align_down(T val, int elsize)
Align element down to nearest boundary.
Definition pro.h:4638

setflag
void idaapi setflag(T &where, U bit, bool cnd)
Set a 'bit' in 'where' if 'value' if not zero.
Definition pro.h:1527

tid_t
ea_t tid_t
type id (for enums, structs, etc)
Definition pro.h:5010

is_pow2
constexpr bool is_pow2(T val)
is power of 2? (or zero)
Definition pro.h:1432

qstring
_qstring< char > qstring
regular string
Definition pro.h:3694

log2ceil
idaman int ida_export log2ceil(uint64 d64)
calculate ceil(log2(d64)) or floor(log2(d64)), it returns 0 if d64 == 0

compare
int compare(const T &a, const T &b)
Definition pro.h:4514

qstrvec_t
qvector< qstring > qstrvec_t
vector of strings
Definition pro.h:3697

aloc_visitor_t
Visit all argument locations.
Definition typeinf.hpp:1383

aloc_visitor_t::~aloc_visitor_t
virtual ~aloc_visitor_t()
Definition typeinf.hpp:1385

aloc_visitor_t::visit_location
virtual int idaapi visit_location(argloc_t &v, int off, int size)=0

argpart_t
Subsection of an argument location.
Definition typeinf.hpp:1313

argpart_t::operator<
bool operator<(const argpart_t &r) const
Compare two argparts, based on their offset.
Definition typeinf.hpp:1328

argpart_t::DEFINE_MEMORY_ALLOCATION_FUNCS
DEFINE_MEMORY_ALLOCATION_FUNCS() argpart_t(const argloc_t &a)
Constructor.
Definition typeinf.hpp:1316

argpart_t::argpart_t
argpart_t()
Constructor.
Definition typeinf.hpp:1318

argpart_t::size
ushort size
the number of bytes
Definition typeinf.hpp:1315

argpart_t::swap
void swap(argpart_t &r)
Assign this = r and r = this.
Definition typeinf.hpp:1331

argpart_t::off
ushort off
offset from the beginning of the argument
Definition typeinf.hpp:1314

argpart_t::bad_size
bool bad_size() const
Does this argpart have a valid size?
Definition typeinf.hpp:1325

argpart_t::bad_offset
bool bad_offset() const
Does this argpart have a valid offset?
Definition typeinf.hpp:1322

argpart_t::copy_from
argpart_t & copy_from(const argloc_t &a)
Definition typeinf.hpp:1319

argtinfo_helper_t
Definition typeinf.hpp:6106

argtinfo_helper_t::set_op_tinfo
virtual bool idaapi set_op_tinfo(const insn_t &insn, const op_t &x, const tinfo_t &tif, const char *name)=0
Set the operand type as specified.

argtinfo_helper_t::has_delay_slot
virtual bool idaapi has_delay_slot(ea_t)
The call instruction with a delay slot?.
Definition typeinf.hpp:6126

argtinfo_helper_t::reserved
size_t reserved
Definition typeinf.hpp:6107

argtinfo_helper_t::~argtinfo_helper_t
virtual ~argtinfo_helper_t()
Definition typeinf.hpp:6109

argtinfo_helper_t::use_arg_tinfos
void use_arg_tinfos(ea_t caller, func_type_data_t *fti, funcargvec_t *rargs)
This function is to be called by the processor module in response to ev_use_arg_types.
Definition typeinf.hpp:6140

argtinfo_helper_t::is_stkarg_load
virtual bool idaapi is_stkarg_load(const insn_t &insn, int *src, int *dst)=0
Is the current insn a stkarg load?

array_parameters_t
Definition nalt.hpp:682

array_parameters_t::flags
int32 flags
Definition nalt.hpp:683

array_type_data_t
Array type information (see tinfo_t::get_array_details())
Definition typeinf.hpp:4670

array_type_data_t::DEFINE_MEMORY_ALLOCATION_FUNCS
DEFINE_MEMORY_ALLOCATION_FUNCS() void swap(array_type_data_t &r)
set this = r and r = this
Definition typeinf.hpp:4675

array_type_data_t::nelems
uint32 nelems
number of elements
Definition typeinf.hpp:4673

array_type_data_t::elem_type
tinfo_t elem_type
element type
Definition typeinf.hpp:4671

array_type_data_t::array_type_data_t
array_type_data_t(size_t b=0, size_t n=0)
Constructor.
Definition typeinf.hpp:4674

array_type_data_t::base
uint32 base
array base
Definition typeinf.hpp:4672

bitfield_type_data_t
Bitfield type information (see tinfo_t::get_bitfield_details())
Definition typeinf.hpp:5581

bitfield_type_data_t::swap
void swap(bitfield_type_data_t &r)
Definition typeinf.hpp:5608

bitfield_type_data_t::nbytes
uchar nbytes
enclosing type size (1,2,4,8 bytes)
Definition typeinf.hpp:5582

bitfield_type_data_t::width
uchar width
number of bits
Definition typeinf.hpp:5583

bitfield_type_data_t::is_unsigned
bool is_unsigned
is bitfield unsigned?
Definition typeinf.hpp:5584

bitfield_type_data_t::DECLARE_COMPARISONS
DECLARE_COMPARISONS(bitfield_type_data_t)
Definition typeinf.hpp:5590

bitfield_type_data_t::serialize
bool serialize(qtype *type, type_t mods) const

bitfield_type_data_t::is_valid_bitfield
bool is_valid_bitfield() const
Definition typeinf.hpp:5609

bitfield_type_data_t::bitfield_type_data_t
bitfield_type_data_t(uchar _nbytes=0, uchar _width=0, bool _is_unsigned=false)
Definition typeinf.hpp:5585

compiler_info_t
Information about the target compiler.
Definition ida.hpp:79

compiler_info_t::id
comp_t id
compiler id (see Compiler IDs)
Definition ida.hpp:80

compiler_info_t::cm
cm_t cm
memory model and calling convention (see CM) see also get_cc/set_cc
Definition ida.hpp:81

compiler_info_t::_new_callcnv
callcnv_t _new_callcnv
Definition ida.hpp:91

const_aloc_visitor_t
Same as aloc_visitor_t, but may not modify the argloc.
Definition typeinf.hpp:1393

const_aloc_visitor_t::~const_aloc_visitor_t
virtual ~const_aloc_visitor_t()
Definition typeinf.hpp:1395

const_aloc_visitor_t::visit_location
virtual int idaapi visit_location(const argloc_t &v, int off, int size)=0

custloc_desc_t
Description of a custom argloc.
Definition typeinf.hpp:975

custloc_desc_t::elem_tif
tinfo_t * elem_tif
Definition typeinf.hpp:1057

custloc_desc_t::bool
bool(idaapi *get_tinfo)(tinfo_t *out
Retrieve type of the object at 'loc'.

custloc_desc_t::name
const char * name
name of the custom argloc type. must be unique
Definition typeinf.hpp:977

custloc_desc_t::bool
bool(idaapi *deref_array)(argloc_t *out
Dereference the array pointed by 'arrloc': take member number 'n' (element size is 'elsize'),...

custloc_desc_t::n
tinfo_t const argloc_t const tinfo_t asize_t n
Definition typeinf.hpp:1020

custloc_desc_t::loc
size_t const argloc_t & loc
Definition typeinf.hpp:999

custloc_desc_t::len
tinfo_t const argloc_t const tinfo_t size_t len
Definition typeinf.hpp:1060

custloc_desc_t::errbuf
const idc_value_t const value_union_t int qstring * errbuf
Definition typeinf.hpp:1046

custloc_desc_t::array_tif
tinfo_t const argloc_t const tinfo_t & array_tif
Definition typeinf.hpp:1019

custloc_desc_t::gaps
int const rangeset_t * gaps
Definition typeinf.hpp:989

custloc_desc_t::asize_t
asize_t(idaapi *guess_array_size)(const argloc_t &loc
Retrieve size of array at 'loc' (number of elements)

custloc_desc_t::strloc
tinfo_t const argloc_t & strloc
Definition typeinf.hpp:1008

custloc_desc_t::size_t
size_t(idaapi *print_ptr_value)(char *buf
Get string containing a printable representation of the pointer at 'loc'.

custloc_desc_t::idcv
const idc_value_t & idcv
Definition typeinf.hpp:1043

custloc_desc_t::src
const argloc_t & src
Definition typeinf.hpp:980

custloc_desc_t::bool
bool(idaapi *deref_field)(argloc_t *out
Dereference the struct/union pointed by 'strloc': take member at offset 'off' (or use the field name)...

custloc_desc_t::is_valid_ptr
size_t bool * is_valid_ptr
Definition typeinf.hpp:1082

custloc_desc_t::ptrloc
tinfo_t const argloc_t & ptrloc
Definition typeinf.hpp:1028

custloc_desc_t::void
void(idaapi *cleanup)(argloc_t *loc)
Clear contents of loc before it is modified (may be nullptr)

custloc_desc_t::void
void(idaapi *copy)(argloc_t *empty_dst
Copy src into empty_dst.

custloc_desc_t::tif
tinfo_t * tif
Definition typeinf.hpp:1007

custloc_desc_t::bool
bool(idaapi *verify)(const argloc_t &loc
May be nullptr.

custloc_desc_t::off
tinfo_t const argloc_t const tinfo_t asize_t off
Definition typeinf.hpp:1010

custloc_desc_t::string_tif
const tinfo_t & string_tif
Definition typeinf.hpp:1051

custloc_desc_t::size
int size
Definition typeinf.hpp:988

custloc_desc_t::bufsize
size_t bufsize
Definition typeinf.hpp:998

custloc_desc_t::asize_t
asize_t(idaapi *calc_string_length)(const argloc_t &loc
Calc max natural string length at 'loc' in the debugged process memory.

custloc_desc_t::bool
bool(idaapi *write_value)(const argloc_t &loc
Update value at 'loc'.

custloc_desc_t::cbsize
size_t cbsize
size of this structure
Definition typeinf.hpp:976

custloc_desc_t::praloc_flags
size_t const argloc_t asize_t int praloc_flags
Definition typeinf.hpp:1001

custloc_desc_t::int
int(idaapi *calc_number_of_children)(const argloc_t &loc
Calculate the number of children for the given location.

custloc_desc_t::bool
bool(idaapi *read_value)(value_union_t *value
Read the pointer at 'loc': retrieve value of a simple object.

custloc_desc_t::bool
bool(idaapi *get_string)(qstring *out
Retrieve string at 'loc' from the debugged process memory, returns quoted string value.

custloc_desc_t::part_of_scattered
int const rangeset_t bool part_of_scattered
Definition typeinf.hpp:990

custloc_desc_t::arrloc
tinfo_t const argloc_t & arrloc
Definition typeinf.hpp:1018

custloc_desc_t::struct_tif
tinfo_t const argloc_t const tinfo_t & struct_tif
Definition typeinf.hpp:1009

custloc_desc_t::scalar_value
const idc_value_t const value_union_t & scalar_value
Definition typeinf.hpp:1044

custloc_desc_t::b
const argloc_t & b
Definition typeinf.hpp:993

custloc_desc_t::size_t
size_t(idaapi *print)(char *buf
Get textual description of the location (not the value at the location!)

custloc_desc_t::elsize
tinfo_t const argloc_t const tinfo_t asize_t asize_t elsize
Definition typeinf.hpp:1021

custloc_desc_t::bool
bool(idaapi *deref_ptr)(argloc_t *out
Dereference the pointer at 'loc': retrieve location of the pointed object, improve 'tif' of the point...

custloc_desc_t::int
int(idaapi *compare)(const argloc_t &a
Lexical comparison of two arglocs.

custom_callcnv_t
Description of a custom calling convention.
Definition typeinf.hpp:1543

custom_callcnv_t::find_varargs
virtual ssize_t find_varargs(func_type_data_t *fti, ea_t call_ea, class mblock_t *blk) const
Discover variadic arguments.
Definition typeinf.hpp:1592

custom_callcnv_t::calc_retloc
virtual bool calc_retloc(func_type_data_t *fti) const =0
Calculate the location of the return value.

custom_callcnv_t::abibits
uint32 abibits
abibits to be used for the calling convention
Definition typeinf.hpp:1550

custom_callcnv_t::cbsize
int cbsize
Definition typeinf.hpp:1544

custom_callcnv_t::is_purging
bool is_purging() const
Definition typeinf.hpp:1553

custom_callcnv_t::calc_arglocs
virtual bool calc_arglocs(func_type_data_t *fti) const =0
Calculate the argument locations.

custom_callcnv_t::DECLARE_COMPARISONS
DECLARE_COMPARISONS(custom_callcnv_t)

custom_callcnv_t::custom_callcnv_t
custom_callcnv_t(const char *_name, uint64 f, uint32 _abibits)
Definition typeinf.hpp:1672

custom_callcnv_t::flags
uint64 flags
Definition typeinf.hpp:1545

custom_callcnv_t::is_vararg
bool is_vararg() const
Definition typeinf.hpp:1552

custom_callcnv_t::get_cc_regs
virtual bool get_cc_regs(callregs_t *out) const
Retrieve generic information about call registers.
Definition typeinf.hpp:1625

custom_callcnv_t::lower_func_type
virtual int lower_func_type(func_type_data_t *fti) const
Lower a function type.
Definition typeinf.hpp:1665

custom_callcnv_t::calc_purged_bytes
virtual int calc_purged_bytes(const func_type_data_t &fti, ea_t call_ea=BADADDR) const
Calculate the number of purged bytes.
Definition typeinf.hpp:1641

custom_callcnv_t::calc_varglocs
virtual bool calc_varglocs(func_type_data_t *fti, regobjs_t *regs, relobj_t *stkargs, int nfixed) const
Calculate the argument locations for a variadic function.
Definition typeinf.hpp:1611

custom_callcnv_t::name
qstring name
the name is used as a keyword in the function prototype
Definition typeinf.hpp:1549

custom_callcnv_t::custom_callcnv_t
custom_callcnv_t()=default

custom_callcnv_t::validate_func
virtual bool validate_func(const func_type_data_t &fti, qstring *reterr) const
Validate a function prototype.
Definition typeinf.hpp:1562

custom_callcnv_t::get_stkarg_area_info
virtual bool get_stkarg_area_info(stkarg_area_info_t *out) const
Retrieve generic information about stack arguments.
Definition typeinf.hpp:1632

custom_callcnv_t::~custom_callcnv_t
virtual ~custom_callcnv_t()
Definition typeinf.hpp:1675

custom_callcnv_t::is_usercall
bool is_usercall() const
Definition typeinf.hpp:1554

custom_data_type_info_t
Definition typeinf.hpp:5195

custom_data_type_info_t::fid
int16 fid
data format ids
Definition typeinf.hpp:5197

custom_data_type_info_t::dtid
int16 dtid
data type id
Definition typeinf.hpp:5196

edm_t
This structure describes an enum value.
Definition typeinf.hpp:4849

edm_t::name
qstring name
Definition typeinf.hpp:4850

edm_t::edm_t
edm_t(const char *_name, uint64 _value, const char *_cmt=nullptr)
Create an enumeration value with the specified name and value.
Definition typeinf.hpp:4861

edm_t::empty
bool empty() const
Definition typeinf.hpp:4865

edm_t::value
uint64 value
Definition typeinf.hpp:4852

edm_t::swap
void swap(edm_t &r)
Definition typeinf.hpp:4874

edm_t::cmt
qstring cmt
Definition typeinf.hpp:4851

edm_t::edm_t
edm_t()=default

edm_t::operator==
bool operator==(const edm_t &r) const
Definition typeinf.hpp:4867

edm_t::operator!=
bool operator!=(const edm_t &r) const
Definition typeinf.hpp:4873

enum_type_data_t
Enum type information (see tinfo_t::get_enum_details())
Definition typeinf.hpp:4889

enum_type_data_t::enum_type_data_t
enum_type_data_t(bte_t _bte=BTE_ALWAYS|BTE_HEX)
Definition typeinf.hpp:4895

enum_type_data_t::is_bin
bool is_bin() const
Definition typeinf.hpp:4944

enum_type_data_t::is_soct
bool is_soct() const
Definition typeinf.hpp:4947

enum_type_data_t::for_all_groups
int for_all_groups(std::function< int(size_t grp_start, int grp_size)> v, bool skip_trivial=false) const
visit all enum groups, for bitmask enum only
Definition typeinf.hpp:5135

enum_type_data_t::has_lzero
bool has_lzero() const
Definition typeinf.hpp:4950

enum_type_data_t::is_sbin
bool is_sbin() const
Definition typeinf.hpp:4948

enum_type_data_t::is_bf
bool is_bf() const
is bitmask or ordinary enum?
Definition typeinf.hpp:4957

enum_type_data_t::bte
bte_t bte
enum member sizes (shift amount) and style.
Definition typeinf.hpp:4893

enum_type_data_t::is_udec
bool is_udec() const
Definition typeinf.hpp:4945

enum_type_data_t::add_constant
void add_constant(const char *name, uint64 value, const char *cmt=nullptr)
add constant for regular enum
Definition typeinf.hpp:5067

enum_type_data_t::get_serial
uchar get_serial(size_t index) const
returns serial for the constant
Definition typeinf.hpp:5084

enum_type_data_t::is_char
bool is_char() const
Definition typeinf.hpp:4940

enum_type_data_t::is_oct
bool is_oct() const
Definition typeinf.hpp:4943

enum_type_data_t::get_constant_group
bool get_constant_group(size_t *group_start_index, size_t *group_size, size_t idx) const
get group parameters for the constant, valid for bitmask enum
Definition typeinf.hpp:4982

enum_type_data_t::set_lzero
void set_lzero(bool on)
Definition typeinf.hpp:4951

enum_type_data_t::set_nbytes
bool set_nbytes(int nbytes)
set enum width (nbytes)
Definition typeinf.hpp:4966

enum_type_data_t::group_sizes
intvec_t group_sizes
if present, specifies bitmask group sizes each non-trivial group starts with a mask member
Definition typeinf.hpp:4890

enum_type_data_t::is_group_mask_at
bool is_group_mask_at(size_t idx) const
is the enum member at IDX a non-trivial group mask?
Definition typeinf.hpp:5008

enum_type_data_t::DEFINE_MEMORY_ALLOCATION_FUNCS
DEFINE_MEMORY_ALLOCATION_FUNCS() int get_enum_radix() const
Get enum constant radix.
Definition typeinf.hpp:4896

enum_type_data_t::for_all_constants
int for_all_constants(std::function< int(size_t idx, size_t grp_start, int grp_size)> v) const
visit all enum constants not bmasks
Definition typeinf.hpp:5102

enum_type_data_t::is_shex
bool is_shex() const
Definition typeinf.hpp:4946

enum_type_data_t::set_value_repr
tinfo_code_t set_value_repr(const value_repr_t &repr)
set enum radix and other representation info
Definition typeinf.hpp:5081

enum_type_data_t::find_member
ssize_t find_member(uint64 value, uchar serial, size_t from=0, size_t to=size_t(-1), uint64 vmask=uint64(-1)) const
find member (constant or bmask) by value
Definition typeinf.hpp:5047

enum_type_data_t::is_valid_group_sizes
bool is_valid_group_sizes() const
is valid group sizes
Definition typeinf.hpp:5017

enum_type_data_t::is_dec
bool is_dec() const
Definition typeinf.hpp:4941

enum_type_data_t::store_64bit_values
bool store_64bit_values() const
Definition typeinf.hpp:4954

enum_type_data_t::set_enum_radix
void set_enum_radix(int radix, bool sign)
Set radix to display constants.
Definition typeinf.hpp:4927

enum_type_data_t::is_number_signed
bool is_number_signed() const
Definition typeinf.hpp:4919

enum_type_data_t::calc_nbytes
int calc_nbytes() const
get the width of enum in bytes
Definition typeinf.hpp:4960

enum_type_data_t::taenum_bits
uint32 taenum_bits
Type attributes for enums
Definition typeinf.hpp:4892

enum_type_data_t::is_hex
bool is_hex() const
Definition typeinf.hpp:4942

enum_type_data_t::get_value_repr
tinfo_code_t get_value_repr(value_repr_t *repr) const
get enum radix and other representation info
Definition typeinf.hpp:5077

enum_type_data_t::find_member
ssize_t find_member(const char *name, size_t from=0, size_t to=size_t(-1)) const
find member (constant or bmask) by name
Definition typeinf.hpp:5034

enum_type_data_t::calc_mask
uint64 calc_mask() const
Definition typeinf.hpp:4953

enum_type_data_t::swap
void swap(enum_type_data_t &r)
swap two instances
Definition typeinf.hpp:5064

enum_type_data_t::get_max_serial
uchar get_max_serial(uint64 value) const
return the maximum serial for the value
Definition typeinf.hpp:5098

format_data_info_t
See format_cdata()
Definition typeinf.hpp:6341

format_data_info_t::format_data_info_t
format_data_info_t()
Definition typeinf.hpp:6379

format_data_info_t::arrnelems
int arrnelems
for arrays: number of elements to print
Definition typeinf.hpp:6372

format_data_info_t::ptvf
int ptvf
Definition typeinf.hpp:6342

format_data_info_t::indent
int indent
how many spaces to use to indent nested structures/arrays
Definition typeinf.hpp:6377

format_data_info_t::max_length
int max_length
max length of the formatted text (0 means no limit) should be used to format huge arrays for the scre...
Definition typeinf.hpp:6366

format_data_info_t::arrbase
int arrbase
for arrays: the first element of array to print
Definition typeinf.hpp:6371

format_data_info_t::margin
int margin
length of one line (0 means to print everything on one line) if an item cannot be printed in a shorte...
Definition typeinf.hpp:6373

format_data_info_t::radix
int radix
number representation (8,10,16)
Definition typeinf.hpp:6365

func_type_data_t
Function type information (see tinfo_t::get_func_details())
Definition typeinf.hpp:4753

func_type_data_t::is_noret
bool is_noret() const
Definition typeinf.hpp:4790

func_type_data_t::is_pure
bool is_pure() const
Definition typeinf.hpp:4791

func_type_data_t::is_vararg_cc
bool is_vararg_cc() const
Definition typeinf.hpp:4798

func_type_data_t::_new_callcnv
callcnv_t _new_callcnv
Definition typeinf.hpp:4777

func_type_data_t::is_ctor
bool is_ctor() const
Definition typeinf.hpp:4795

func_type_data_t::stkargs
uval_t stkargs
size of stack arguments (not used in build_func_type)
Definition typeinf.hpp:4780

func_type_data_t::set_cc
void set_cc(callcnv_t cc)
Definition typeinf.hpp:4787

func_type_data_t::is_high
bool is_high() const
Definition typeinf.hpp:4789

func_type_data_t::get_cc
callcnv_t get_cc() const
Definition typeinf.hpp:4786

func_type_data_t::is_user_cc
bool is_user_cc() const
Definition typeinf.hpp:4801

func_type_data_t::flags
int flags
Function type data property bits
Definition typeinf.hpp:4754

func_type_data_t::is_static
bool is_static() const
Definition typeinf.hpp:4792

func_type_data_t::is_virtual
bool is_virtual() const
Definition typeinf.hpp:4793

func_type_data_t::guess_cc
callcnv_t guess_cc(int purged, int cc_flags) const
Guess function calling convention use the following info: argument locations and 'stkargs'.
Definition typeinf.hpp:4805

func_type_data_t::find_argument
ssize_t find_argument(const char *name, size_t from=0, size_t to=size_t(-1)) const
find argument by name
Definition typeinf.hpp:4822

func_type_data_t::get_call_method
int get_call_method() const
Definition typeinf.hpp:4797

func_type_data_t::is_swift_cc
bool is_swift_cc() const
Definition typeinf.hpp:4800

func_type_data_t::spoiled
reginfovec_t spoiled
spoiled register information.
Definition typeinf.hpp:4781

func_type_data_t::retloc
argloc_t retloc
return location
Definition typeinf.hpp:4779

func_type_data_t::is_const
bool is_const() const
Definition typeinf.hpp:4794

func_type_data_t::is_dtor
bool is_dtor() const
Definition typeinf.hpp:4796

func_type_data_t::_old_cc
cm_t _old_cc
Definition typeinf.hpp:4784

func_type_data_t::swap
void swap(func_type_data_t &r)
Definition typeinf.hpp:4788

func_type_data_t::dump
bool dump(qstring *out, int praloc_bits=PRALOC_STKOFF) const
Dump information that is not always visible in the function prototype.
Definition typeinf.hpp:4816

func_type_data_t::is_golang_cc
bool is_golang_cc() const
Definition typeinf.hpp:4799

func_type_data_t::rettype
tinfo_t rettype
return type
Definition typeinf.hpp:4778

func_type_data_t::get_explicit_cc
callcnv_t get_explicit_cc() const
Definition typeinf.hpp:4785

funcarg_t
Information about a single function argument.
Definition typeinf.hpp:4683

funcarg_t::type
tinfo_t type
argument type
Definition typeinf.hpp:4687

funcarg_t::argloc
argloc_t argloc
argument location
Definition typeinf.hpp:4684

funcarg_t::cmt
qstring cmt
argument comment (may be empty)
Definition typeinf.hpp:4686

funcarg_t::operator!=
bool operator!=(const funcarg_t &r) const
Definition typeinf.hpp:4745

funcarg_t::name
qstring name
argument name (may be empty)
Definition typeinf.hpp:4685

funcarg_t::funcarg_t
funcarg_t()=default

funcarg_t::funcarg_t
funcarg_t(const char *_name, const char *_type, const argloc_t &_argloc=argloc_t())
Create a function argument, with the specified name and type.
Definition typeinf.hpp:4732

funcarg_t::flags
uint32 flags
Function argument property bits
Definition typeinf.hpp:4688

funcarg_t::funcarg_t
funcarg_t(const char *_name, const tinfo_t &_type, const argloc_t &_argloc=argloc_t())
Create a function argument, with the specified name and arbitrary type.
Definition typeinf.hpp:4708

funcarg_t::operator==
bool operator==(const funcarg_t &r) const
Definition typeinf.hpp:4738

funcarg_t::funcarg_t
funcarg_t(const char *_name, const type_t _type, const argloc_t &_argloc=argloc_t())
Create a function argument, with the specified name and simple type.
Definition typeinf.hpp:4719

predicate_t
Helper class for choose_named_type().
Definition typeinf.hpp:6574

predicate_t::should_display
virtual bool idaapi should_display(const til_t *til, const char *name, const type_t *type, const p_list *fields)=0

predicate_t::~predicate_t
virtual ~predicate_t()
Definition typeinf.hpp:6580

processor_t::ev_decorate_name
@ ev_decorate_name
Decorate/undecorate a C symbol name.
Definition idp.hpp:1732

processor_t::ev_equal_reglocs
@ ev_equal_reglocs
Are 2 register arglocs the same?
Definition idp.hpp:1689

processor_t::equal_reglocs
static ssize_t equal_reglocs(const argloc_t &a1, const argloc_t &a2)
Definition typeinf.hpp:6673

processor_t::notify
static ssize_t notify(event_t event_code,...)
Definition idp.hpp:1766

processor_t::get_cc_regs
static ssize_t get_cc_regs(callregs_t *regs, callcnv_t cc)
Definition idp.hpp:2611

processor_t::_decorate_name
static ssize_t _decorate_name(qstring *outbuf, const char *name, bool mangle, callcnv_t cc, const tinfo_t &type)
Definition typeinf.hpp:6682

ptr_type_data_t
Pointer type information (see tinfo_t::get_ptr_details())
Definition typeinf.hpp:4640

ptr_type_data_t::operator!=
bool operator!=(const ptr_type_data_t &r) const
Definition typeinf.hpp:4661

ptr_type_data_t::based_ptr_size
uchar based_ptr_size
Definition typeinf.hpp:4645

ptr_type_data_t::delta
int32 delta
Offset from the beginning of the parent struct.
Definition typeinf.hpp:4644

ptr_type_data_t::operator==
bool operator==(const ptr_type_data_t &r) const
Definition typeinf.hpp:4655

ptr_type_data_t::is_shifted
bool is_shifted() const
Definition typeinf.hpp:4663

ptr_type_data_t::taptr_bits
uchar taptr_bits
TAH bits.
Definition typeinf.hpp:4646

ptr_type_data_t::obj_type
tinfo_t obj_type
pointed object type
Definition typeinf.hpp:4641

ptr_type_data_t::DEFINE_MEMORY_ALLOCATION_FUNCS
DEFINE_MEMORY_ALLOCATION_FUNCS() void swap(ptr_type_data_t &r)
Set this = r and r = this.
Definition typeinf.hpp:4653

ptr_type_data_t::closure
tinfo_t closure
cannot have both closure and based_ptr_size
Definition typeinf.hpp:4642

ptr_type_data_t::ptr_type_data_t
ptr_type_data_t(tinfo_t c=tinfo_t(), uchar bps=0, tinfo_t p=tinfo_t(), int32 d=0)
Definition typeinf.hpp:4647

ptr_type_data_t::parent
tinfo_t parent
Parent struct.
Definition typeinf.hpp:4643

ptr_type_data_t::is_code_ptr
bool is_code_ptr() const
Are we pointing to code?
Definition typeinf.hpp:4662

range64vec_t
Definition range.hpp:323

refinfo_t
Information about a reference.
Definition nalt.hpp:1010

regobj_t
Object that represents a register.
Definition typeinf.hpp:6035

regobj_t::value
bytevec_t value
Definition typeinf.hpp:6038

regobj_t::size
size_t size() const
Definition typeinf.hpp:6039

regobj_t::regidx
int regidx
index into dbg->registers
Definition typeinf.hpp:6036

regobj_t::relocate
int relocate
0-plain num, 1-must relocate
Definition typeinf.hpp:6037

regobjs_t
Definition typeinf.hpp:6044

relobj_t
Relocatable object.
Definition pro.h:4026

rrel_t
Register-relative argument location.
Definition typeinf.hpp:965

rrel_t::off
sval_t off
displacement from the address pointed by the register
Definition typeinf.hpp:966

rrel_t::reg
int reg
register index (into ph.reg_names)
Definition typeinf.hpp:967

simd_info_t
SIMD type info.
Definition typeinf.hpp:4584

simd_info_t::size
uint16 size
SIMD type size in bytes (0-undefined)
Definition typeinf.hpp:4587

simd_info_t::memtype
type_t memtype
member type BTF_INT8/16/32/64/128, BTF_UINT8/16/32/64/128 BTF_INT - integrals of any size/sign BTF_FL...
Definition typeinf.hpp:4588

simd_info_t::name
const char * name
name of SIMD type (nullptr-undefined)
Definition typeinf.hpp:4585

simd_info_t::tif
tinfo_t tif
SIMD type (empty-undefined)
Definition typeinf.hpp:4586

simd_info_t::match_pattern
bool match_pattern(const simd_info_t *pattern)
Definition typeinf.hpp:4599

simd_info_t::simd_info_t
simd_info_t(const char *nm=nullptr, uint16 sz=0, type_t memt=BTF_UNK)
Definition typeinf.hpp:4596

stkarg_area_info_t
Definition typeinf.hpp:1518

stkarg_area_info_t::cb
size_t cb
Definition typeinf.hpp:1519

stkarg_area_info_t::get_info
bool get_info(callcnv_t cc)
Definition typeinf.hpp:1537

stkarg_area_info_t::shadow_size
sval_t shadow_size
Size of the shadow area.
Definition typeinf.hpp:1528

stkarg_area_info_t::linkage_area
sval_t linkage_area
Size of the linkage area.
Definition typeinf.hpp:1533

stkarg_area_info_t::stkarg_offset
sval_t stkarg_offset
Offset from the SP to the first stack argument (can include linkage area) examples: pc: 0,...
Definition typeinf.hpp:1523

stkarg_area_info_t::stkarg_area_info_t
stkarg_area_info_t()=default

stkarg_area_info_t::stkarg_area_info_t
stkarg_area_info_t(callcnv_t cc)
Definition typeinf.hpp:1536

text_sink_t
Flush formatted text.
Definition typeinf.hpp:6475

text_sink_t::print
virtual int idaapi print(const char *str)=0

text_sink_t::~text_sink_t
virtual ~text_sink_t()
Definition typeinf.hpp:6476

til_symbol_t
A symbol in a type library.
Definition typeinf.hpp:6562

til_symbol_t::til
const til_t * til
pointer to til
Definition typeinf.hpp:6564

til_symbol_t::til_symbol_t
til_symbol_t(const char *n=nullptr, const til_t *t=nullptr)
Definition typeinf.hpp:6565

til_symbol_t::name
const char * name
symbol name
Definition typeinf.hpp:6563

til_t
Type Information Library.
Definition typeinf.hpp:725

til_t::flags
uint32 flags
Type info library property bits
Definition typeinf.hpp:730

til_t::desc
char * desc
human readable til description
Definition typeinf.hpp:727

til_t::cc
compiler_info_t cc
information about the target compiler
Definition typeinf.hpp:764

til_t::streams
til_stream_t ** streams
symbol stream storage
Definition typeinf.hpp:770

til_t::set_dirty
void set_dirty()
Mark the til as modified (TIL_MOD)
Definition typeinf.hpp:748

til_t::find_base
til_t * find_base(const char *n)
Find the base til with the provided name.
Definition typeinf.hpp:753

til_t::types
til_bucket_t * types
types
Definition typeinf.hpp:766

til_t::is_dirty
bool is_dirty() const
Has the til been modified? (TIL_MOD)
Definition typeinf.hpp:746

til_t::base
til_t ** base
tils that our til is based on
Definition typeinf.hpp:729

til_t::macros
til_bucket_t * macros
macros
Definition typeinf.hpp:767

til_t::nstreams
int nstreams
number of extra streams
Definition typeinf.hpp:769

til_t::name
char * name
short file name (without path and extension)
Definition typeinf.hpp:726

til_t::nbases
int nbases
number of base tils
Definition typeinf.hpp:728

til_t::syms
til_bucket_t * syms
symbols
Definition typeinf.hpp:765

til_t::nrefs
int nrefs
number of references to the til
Definition typeinf.hpp:768

til_type_ref_t
Definition typeinf.hpp:6710

til_type_ref_t::is_writable
bool is_writable
Definition typeinf.hpp:6715

til_type_ref_t::cursor
tif_cursor_t cursor
Definition typeinf.hpp:6713

til_type_ref_t::is_detached
bool is_detached
Definition typeinf.hpp:6716

til_type_ref_t::udm
udm_t udm
BTF_STRUCT or BTF_UNION: the current member.
Definition typeinf.hpp:6723

til_type_ref_t::ordinal
uint32 ordinal
Definition typeinf.hpp:6714

til_type_ref_t::is_func
bool is_func() const
Definition typeinf.hpp:6745

til_type_ref_t::unpadded_size
size_t unpadded_size
Definition typeinf.hpp:6725

til_type_ref_t::fa
const funcarg_t * fa
BT_FUNC: the current argument, nullptr - ellipsis.
Definition typeinf.hpp:6737

til_type_ref_t::is_enum
bool is_enum() const
Definition typeinf.hpp:6744

til_type_ref_t::kind
type_t kind
Definition typeinf.hpp:6718

til_type_ref_t::total_size
size_t total_size
Definition typeinf.hpp:6724

til_type_ref_t::last_udm_offset
uint64 last_udm_offset
Definition typeinf.hpp:6726

til_type_ref_t::is_forward
bool is_forward
Definition typeinf.hpp:6717

til_type_ref_t::is_union
bool is_union() const
Definition typeinf.hpp:6743

til_type_ref_t::bucket_start
uint64 bucket_start
Definition typeinf.hpp:6727

til_type_ref_t::offset
uint64 offset
Definition typeinf.hpp:6729

til_type_ref_t::clear
void clear()
Definition typeinf.hpp:6739

til_type_ref_t::bf_bitoff
int bf_bitoff
Definition typeinf.hpp:6728

til_type_ref_t::tif
tinfo_t tif
Definition typeinf.hpp:6712

til_type_ref_t::on_member
bool on_member() const
Definition typeinf.hpp:6740

til_type_ref_t::is_udt
bool is_udt() const
Definition typeinf.hpp:6746

til_type_ref_t::cb
size_t cb
Definition typeinf.hpp:6711

til_type_ref_t::is_struct
bool is_struct() const
Definition typeinf.hpp:6742

til_type_ref_t::nmembers
size_t nmembers
Definition typeinf.hpp:6720

til_type_ref_t::memidx
ssize_t memidx
Definition typeinf.hpp:6719

til_type_ref_t::edm
edm_t edm
BTF_ENUM: the current enum member.
Definition typeinf.hpp:6734

til_type_ref_t::is_typedef
bool is_typedef() const
Definition typeinf.hpp:6741

tinfo_visitor_t::~tinfo_visitor_t
virtual ~tinfo_visitor_t()
Definition typeinf.hpp:6005

tinfo_visitor_t::visit_type
virtual int idaapi visit_type(type_mods_t *out, const tinfo_t &tif, const char *name, const char *cmt)=0
Visit a subtype.

tinfo_visitor_t::tinfo_visitor_t
tinfo_visitor_t(int s=0)
Definition typeinf.hpp:6003

tinfo_visitor_t::apply_to
int apply_to(const tinfo_t &tif, type_mods_t *out=nullptr, const char *name=nullptr, const char *cmt=nullptr)
Call this function to initiate the traversal.
Definition typeinf.hpp:6023

tinfo_visitor_t::state
int state
tinfo visitor states
Definition typeinf.hpp:5994

tinfo_visitor_t::level
int level
Definition typeinf.hpp:6002

tinfo_visitor_t::prune_now
void prune_now()
To refuse to visit children of the current type, use this:
Definition typeinf.hpp:6020

type_attr_t
Definition typeinf.hpp:651

type_attr_t::key
qstring key
one symbol keys are reserved to be used by the kernel the ones starting with an underscore are reserv...
Definition typeinf.hpp:652

type_attr_t::value
bytevec_t value
attribute bytes
Definition typeinf.hpp:662

type_attr_t::operator>=
bool operator>=(const type_attr_t &r) const
Definition typeinf.hpp:664

type_attr_t::operator<
bool operator<(const type_attr_t &r) const
Definition typeinf.hpp:663

type_mods_t
Information about how to modify the current type, used by tinfo_visitor_t.
Definition typeinf.hpp:5957

type_mods_t::has_name
bool has_name() const
Definition typeinf.hpp:5985

type_mods_t::is_rptcmt
bool is_rptcmt() const
Definition typeinf.hpp:5987

type_mods_t::has_type
bool has_type() const
Definition typeinf.hpp:5984

type_mods_t::has_info
bool has_info() const
Definition typeinf.hpp:5988

type_mods_t::name
qstring name
current type name
Definition typeinf.hpp:5959

type_mods_t::type
tinfo_t type
current type
Definition typeinf.hpp:5958

type_mods_t::flags
int flags
Type modification bits
Definition typeinf.hpp:5961

type_mods_t::has_cmt
bool has_cmt() const
Definition typeinf.hpp:5986

type_mods_t::set_new_cmt
void set_new_cmt(const qstring &c, bool rptcmt)
Definition typeinf.hpp:5977

type_mods_t::cmt
qstring cmt
comment for current type
Definition typeinf.hpp:5960

type_mods_t::clear
void clear()
Definition typeinf.hpp:5970

type_mods_t::set_new_name
void set_new_name(const qstring &n)
Definition typeinf.hpp:5976

type_mods_t::set_new_type
void set_new_type(const tinfo_t &t)
The visit_type() function may optionally save the modified type info.
Definition typeinf.hpp:5975

typedef_type_data_t
Type information for typedefs.
Definition typeinf.hpp:5165

typedef_type_data_t::resolve
bool resolve
should resolve immediately?
Definition typeinf.hpp:5173

typedef_type_data_t::DEFINE_MEMORY_ALLOCATION_FUNCS
DEFINE_MEMORY_ALLOCATION_FUNCS() void swap(typedef_type_data_t &r)
Definition typeinf.hpp:5187

typedef_type_data_t::ordinal
uint32 ordinal
is_ordref=true: type ordinal number
Definition typeinf.hpp:5170

typedef_type_data_t::typedef_type_data_t
typedef_type_data_t(const til_t *_til, const char *_name, bool _resolve=false)
Definition typeinf.hpp:5174

typedef_type_data_t::name
const char * name
is_ordref=false: target type name. we do not own this pointer!
Definition typeinf.hpp:5169

typedef_type_data_t::typedef_type_data_t
typedef_type_data_t(const til_t *_til, uint32 ord, bool _resolve=false)
Definition typeinf.hpp:5180

typedef_type_data_t::is_ordref
bool is_ordref
is reference by ordinal?
Definition typeinf.hpp:5172

typedef_type_data_t::til
const til_t * til
type library to use when resolving
Definition typeinf.hpp:5166

udm_t
An object to represent struct or union members.
Definition typeinf.hpp:5300

udm_t::set_unaligned
void set_unaligned(bool on=true)
Definition typeinf.hpp:5381

udm_t::is_zero_bitfield
bool is_zero_bitfield() const
Definition typeinf.hpp:5368

udm_t::is_method
bool is_method() const
Definition typeinf.hpp:5373

udm_t::clr_virtbase
void clr_virtbase()
Definition typeinf.hpp:5392

udm_t::is_gap
bool is_gap() const
Definition typeinf.hpp:5374

udm_t::cmt
qstring cmt
member comment
Definition typeinf.hpp:5304

udm_t::operator==
bool operator==(const udm_t &r) const
Definition typeinf.hpp:5401

udm_t::is_retaddr
bool is_retaddr() const
Definition typeinf.hpp:5376

udm_t::is_unaligned
bool is_unaligned() const
Definition typeinf.hpp:5369

udm_t::clr_unaligned
void clr_unaligned()
Definition typeinf.hpp:5390

udm_t::set_savregs
void set_savregs(bool on=true)
Definition typeinf.hpp:5388

udm_t::clr_vftable
void clr_vftable()
Definition typeinf.hpp:5393

udm_t::compare_with
bool compare_with(const udm_t &r, int tcflags) const
Definition typeinf.hpp:5405

udm_t::udm_t
udm_t(const char *_name, const type_t _type, uint64 _offset=0)
Create a structure/union member, with the specified name and simple type.
Definition typeinf.hpp:5338

udm_t::tafld_bits
uint32 tafld_bits
TAH bits.
Definition typeinf.hpp:5308

udm_t::operator!=
bool operator!=(const udm_t &r) const
Definition typeinf.hpp:5416

udm_t::clr_baseclass
void clr_baseclass()
Definition typeinf.hpp:5391

udm_t::end
uint64 end() const
Definition typeinf.hpp:5396

udm_t::can_rename
bool can_rename() const
Definition typeinf.hpp:5431

udm_t::is_savregs
bool is_savregs() const
Definition typeinf.hpp:5377

udm_t::operator<
bool operator<(const udm_t &r) const
Definition typeinf.hpp:5397

udm_t::begin
uint64 begin() const
Definition typeinf.hpp:5395

udm_t::set_vftable
void set_vftable(bool on=true)
Definition typeinf.hpp:5384

udm_t::is_vftable
bool is_vftable() const
Definition typeinf.hpp:5372

udm_t::set_retaddr
void set_retaddr(bool on=true)
Definition typeinf.hpp:5387

udm_t::is_baseclass
bool is_baseclass() const
Definition typeinf.hpp:5370

udm_t::effalign
int effalign
effective field alignment (in bytes)
Definition typeinf.hpp:5307

udm_t::offset
uint64 offset
member offset in bits
Definition typeinf.hpp:5301

udm_t::set_baseclass
void set_baseclass(bool on=true)
Definition typeinf.hpp:5382

udm_t::can_be_dtor
bool can_be_dtor() const
Definition typeinf.hpp:5430

udm_t::udm_t
udm_t()=default

udm_t::is_by_til
bool is_by_til() const
Definition typeinf.hpp:5379

udm_t::size
uint64 size
size in bits
Definition typeinf.hpp:5302

udm_t::is_special_member
bool is_special_member() const
Definition typeinf.hpp:5378

udm_t::udm_t
udm_t(const char *_name, const tinfo_t &_type, uint64 _offset=0)
Create a structure/union member, with the specified name and arbitrary type.
Definition typeinf.hpp:5322

udm_t::is_anonymous_udm
bool is_anonymous_udm() const
Definition typeinf.hpp:5424

udm_t::fda
uchar fda
field alignment (shift amount)
Definition typeinf.hpp:5309

udm_t::set_method
void set_method(bool on=true)
Definition typeinf.hpp:5385

udm_t::clr_method
void clr_method()
Definition typeinf.hpp:5394

udm_t::DEFINE_MEMORY_ALLOCATION_FUNCS
DEFINE_MEMORY_ALLOCATION_FUNCS() void swap(udm_t &r)
Definition typeinf.hpp:5418

udm_t::repr
value_repr_t repr
radix, refinfo, strpath, custom_id, strtype
Definition typeinf.hpp:5306

udm_t::is_regcmt
bool is_regcmt() const
Definition typeinf.hpp:5375

udm_t::name
qstring name
member name
Definition typeinf.hpp:5303

udm_t::set_virtbase
void set_virtbase(bool on=true)
Definition typeinf.hpp:5383

udm_t::type
tinfo_t type
member type
Definition typeinf.hpp:5305

udm_t::set_value_repr
void set_value_repr(const value_repr_t &r)
Definition typeinf.hpp:5429

udm_t::set_by_til
void set_by_til(bool on=true)
Definition typeinf.hpp:5389

udm_t::udm_t
udm_t(const char *_name, const char *_type, uint64 _offset=0)
Create a structure/union member, with the specified name and type.
Definition typeinf.hpp:5357

udm_t::set_regcmt
void set_regcmt(bool on=true)
Definition typeinf.hpp:5386

udm_t::empty
bool empty() const
Definition typeinf.hpp:5365

udm_t::is_bitfield
bool is_bitfield() const
Definition typeinf.hpp:5367

udm_t::is_virtbase
bool is_virtbase() const
Definition typeinf.hpp:5371

udm_visitor_t
Definition typeinf.hpp:5549

udm_visitor_t::visit_udm
virtual int idaapi visit_udm(tid_t tid, const tinfo_t *tif, const udt_type_data_t *udt, ssize_t idx)=0

udm_visitor_t::~udm_visitor_t
virtual ~udm_visitor_t()
Definition typeinf.hpp:5559

udt_type_data_t
Definition typeinf.hpp:5441

udt_type_data_t::find_member
ssize_t find_member(const char *name) const
Definition typeinf.hpp:5494

udt_type_data_t::is_vftable
bool is_vftable() const
Definition typeinf.hpp:5457

udt_type_data_t::swap
void swap(udt_type_data_t &r)
Definition typeinf.hpp:5452

udt_type_data_t::pack
uchar pack
pragma pack() alignment (shift amount)
Definition typeinf.hpp:5449

udt_type_data_t::is_tuple
bool is_tuple() const
Definition typeinf.hpp:5459

udt_type_data_t::get_best_fit_member
ssize_t get_best_fit_member(asize_t disp) const
Get the member that is most likely referenced by the specified offset.
Definition typeinf.hpp:5510

udt_type_data_t::sda
uchar sda
declared structure alignment (shift amount+1). 0 - unspecified
Definition typeinf.hpp:5448

udt_type_data_t::find_member
ssize_t find_member(udm_t *pattern_udm, int strmem_flags) const
tinfo_t::find_udm
Definition typeinf.hpp:5492

udt_type_data_t::VERSION
static constexpr int VERSION
Definition typeinf.hpp:5442

udt_type_data_t::add_member
udm_t & add_member(const char *_name, const tinfo_t &_type, uint64 _offset=0)
Add a new member to a structure or union.
Definition typeinf.hpp:5479

udt_type_data_t::taudt_bits
uint32 taudt_bits
TA... and TAUDT... bits.
Definition typeinf.hpp:5446

udt_type_data_t::is_union
bool is_union
is union or struct?
Definition typeinf.hpp:5450

udt_type_data_t::is_last_baseclass
bool is_last_baseclass(size_t idx)
Definition typeinf.hpp:5465

udt_type_data_t::is_cppobj
bool is_cppobj() const
Definition typeinf.hpp:5456

udt_type_data_t::is_fixed
bool is_fixed() const
Definition typeinf.hpp:5458

udt_type_data_t::effalign
uint32 effalign
effective structure alignment (in bytes)
Definition typeinf.hpp:5445

udt_type_data_t::set_fixed
void set_fixed(bool on=true)
Definition typeinf.hpp:5462

udt_type_data_t::set_tuple
void set_tuple(bool on=true)
Definition typeinf.hpp:5463

udt_type_data_t::is_msstruct
bool is_msstruct() const
Definition typeinf.hpp:5455

udt_type_data_t::DEFINE_MEMORY_ALLOCATION_FUNCS
DEFINE_MEMORY_ALLOCATION_FUNCS() bool is_unaligned() const
Definition typeinf.hpp:5453

udt_type_data_t::set_vftable
void set_vftable(bool on=true)
Definition typeinf.hpp:5461

udt_type_data_t::version
uchar version
version of udt_type_data_t
Definition typeinf.hpp:5447

udt_type_data_t::unpadded_size
size_t unpadded_size
unpadded structure size in bytes
Definition typeinf.hpp:5444

udt_type_data_t::total_size
size_t total_size
total structure size in bytes
Definition typeinf.hpp:5443

udt_type_data_t::find_member
ssize_t find_member(uint64 bit_offset) const
Definition typeinf.hpp:5501

udtmembervec_t
vector of udt member objects
Definition typeinf.hpp:5438

valinfo_t
Additional information about the output lines.
Definition typeinf.hpp:6387

valinfo_t::swap
void swap(valinfo_t &r)
Definition typeinf.hpp:6393

valinfo_t::label
qstring label
Definition typeinf.hpp:6389

valinfo_t::loc
argloc_t loc
Definition typeinf.hpp:6388

valinfo_t::type
tinfo_t type
Definition typeinf.hpp:6390

valinfo_t::valinfo_t
valinfo_t(argloc_t l=argloc_t(), const char *name=nullptr, const tinfo_t &tif=tinfo_t())
Definition typeinf.hpp:6391

valstrs_t
Collection of value strings.
Definition typeinf.hpp:6448

value_repr_t
Visual representation of a member of a complex type (struct/union/enum)
Definition typeinf.hpp:5202

value_repr_t::is_offset
bool is_offset() const
Definition typeinf.hpp:5247

value_repr_t::set_lzeroes
void set_lzeroes(bool on)
Definition typeinf.hpp:5260

value_repr_t::is_custom
bool is_custom() const
Definition typeinf.hpp:5249

value_repr_t::bits
uint64 bits
Definition typeinf.hpp:5203

value_repr_t::ri
refinfo_t ri
FRB_OFFSET.
Definition typeinf.hpp:5227

value_repr_t::is_enum
bool is_enum() const
Definition typeinf.hpp:5246

value_repr_t::type_ordinal
uint32 type_ordinal
FRB_STROFF, FRB_ENUM.
Definition typeinf.hpp:5232

value_repr_t::empty
bool empty() const
Definition typeinf.hpp:5245

value_repr_t::DEFINE_MEMORY_ALLOCATION_FUNCS
DEFINE_MEMORY_ALLOCATION_FUNCS() void clear()
Definition typeinf.hpp:5241

value_repr_t::ap
array_parameters_t ap
FRB_TABFORM, AP_SIGNED is ignored, use FRB_SIGNED instead.
Definition typeinf.hpp:5236

value_repr_t::swap
void swap(value_repr_t &r)
Definition typeinf.hpp:5240

value_repr_t::is_typref
bool is_typref() const
Definition typeinf.hpp:5251

value_repr_t::get_vtype
uint64 get_vtype() const
Definition typeinf.hpp:5256

value_repr_t::parse_value_repr
bool parse_value_repr(const qstring &attr, type_t target_type=BTF_STRUCT)
Definition typeinf.hpp:5287

value_repr_t::DECLARE_COMPARISONS
DECLARE_COMPARISONS(value_repr_t)

value_repr_t::delta
adiff_t delta
FRB_STROFF.
Definition typeinf.hpp:5231

value_repr_t::has_tabform
bool has_tabform() const
Definition typeinf.hpp:5253

value_repr_t::from_opinfo
bool from_opinfo(flags64_t flags, aflags_t afl, const opinfo_t *opinfo, const array_parameters_t *_ap)
Definition typeinf.hpp:5279

value_repr_t::init_ap
void init_ap(array_parameters_t *_ap) const
Definition typeinf.hpp:5269

value_repr_t::set_vtype
void set_vtype(uint64 vt)
Definition typeinf.hpp:5257

value_repr_t::strtype
int32 strtype
FRB_STRLIT.
Definition typeinf.hpp:5228

value_repr_t::cd
custom_data_type_info_t cd
FRB_CUSTOM.
Definition typeinf.hpp:5234

value_repr_t::print
size_t print(qstring *result, bool colored=false) const
Definition typeinf.hpp:5283

value_repr_t::is_signed
bool is_signed() const
Definition typeinf.hpp:5252

value_repr_t::has_lzeroes
bool has_lzeroes() const
Definition typeinf.hpp:5254

value_repr_t::is_stroff
bool is_stroff() const
Definition typeinf.hpp:5250

value_repr_t::is_strlit
bool is_strlit() const
Definition typeinf.hpp:5248

value_repr_t::set_tabform
void set_tabform(bool on)
Definition typeinf.hpp:5259

value_repr_t::set_ap
void set_ap(const array_parameters_t &_ap)
Definition typeinf.hpp:5262

value_repr_t::set_signed
void set_signed(bool on)
Definition typeinf.hpp:5258

is_type_uint32
THREAD_SAFE bool is_type_uint32(type_t t)
See BTF_UINT32.
Definition typeinf.hpp:525

is_type_ext_arithmetic
THREAD_SAFE bool is_type_ext_arithmetic(type_t t)
Is the type an extended arithmetic type? (arithmetic or enum)
Definition typeinf.hpp:520

get_base_type
THREAD_SAFE type_t get_base_type(type_t t)
Get get basic type bits (TYPE_BASE_MASK)
Definition typeinf.hpp:435

calc_number_of_children
idaman int ida_export calc_number_of_children(const argloc_t &loc, const tinfo_t &tif, bool dont_deref_ptr=false)
Calculate max number of lines of a formatted c data, when expanded (PTV_EXPAND).

extract_argloc
idaman bool ida_export extract_argloc(argloc_t *vloc, const type_t **ptype, bool forbid_stkoff)
Deserialize an argument location.

get_full_type
THREAD_SAFE type_t get_full_type(type_t t)
Get basic type bits + type flags (TYPE_FULL_MASK)
Definition typeinf.hpp:437

apply_named_type
idaman bool ida_export apply_named_type(ea_t ea, const char *name)
Apply the specified named type to the address.

get_idainfo_by_type
idaman bool ida_export get_idainfo_by_type(size_t *out_size, flags64_t *out_flags, opinfo_t *out_mt, const tinfo_t &tif, size_t *out_alsize=nullptr)
Extract information from a tinfo_t.

is_type_int16
THREAD_SAFE bool is_type_int16(type_t t)
Does the type specify a 16-bit value? (signed or unsigned, see Basic type: integer)
Definition typeinf.hpp:489

is_type_func
THREAD_SAFE bool is_type_func(type_t t)
See BT_FUNC.
Definition typeinf.hpp:451

pack_idcobj_to_idb
idaman error_t ida_export pack_idcobj_to_idb(const idc_value_t *obj, const tinfo_t &tif, ea_t ea, int pio_flags=0)
Write a typed idc object to the database.

gts_code_t
gts_code_t
Constants to be used with get_size()
Definition typeinf.hpp:2950

GTS_NESTED
@ GTS_NESTED
nested type (embedded into a udt)
Definition typeinf.hpp:2951

GTS_BASECLASS
@ GTS_BASECLASS
is baseclass of a udt
Definition typeinf.hpp:2952

unpack_idcobj_from_bv
idaman error_t ida_export unpack_idcobj_from_bv(idc_value_t *obj, const tinfo_t &tif, const bytevec_t &bytes, int pio_flags=0)
Read a typed idc object from the byte vector.

guess_tinfo
idaman int ida_export guess_tinfo(tinfo_t *out, tid_t id)
Generate a type information about the id from the disassembly.

is_type_char
THREAD_SAFE bool is_type_char(type_t t)
Does the type specify a char value? (signed or unsigned, see Basic type: integer)
Definition typeinf.hpp:496

is_type_struct
THREAD_SAFE bool is_type_struct(type_t t)
See BTF_STRUCT.
Definition typeinf.hpp:456

del_til
idaman bool ida_export del_til(const char *name)
Unload a til file.

is_type_double
THREAD_SAFE bool is_type_double(type_t t)
See BTF_DOUBLE.
Definition typeinf.hpp:529

is_type_typedef
THREAD_SAFE bool is_type_typedef(type_t t)
See BTF_TYPEDEF.
Definition typeinf.hpp:454

TYPID_SHIFT
const int TYPID_SHIFT
First type detail bit.
Definition typeinf.hpp:3041

get_c_header_path
ssize_t get_c_header_path(qstring *buf)
Get the include directory path of the target compiler.
Definition typeinf.hpp:2822

set_c_header_path
void set_c_header_path(const char *incdir)
Set include directory path the target compiler.
Definition typeinf.hpp:2819

is_restype_void
bool is_restype_void(const til_t *til, const type_t *type)
Definition typeinf.hpp:689

is_type_ptr_or_array
THREAD_SAFE bool is_type_ptr_or_array(type_t t)
Is the type a pointer or array type?
Definition typeinf.hpp:510

get_scalar_bt
idaman type_t ida_export get_scalar_bt(int size)

regobjvec_t
qvector< regobj_t > regobjvec_t
Definition typeinf.hpp:6042

bmask64_t
uint64 bmask64_t
unsigned value that describes a bitmask
Definition typeinf.hpp:103

func_has_stkframe_hole
idaman bool ida_export func_has_stkframe_hole(ea_t ea, const func_type_data_t &fti)
Looks for a hole at the beginning of the stack arguments.

lower_type
idaman int ida_export lower_type(til_t *til, tinfo_t *tif, const char *name=nullptr, lowertype_helper_t *_helper=nullptr)
Lower type.

is_type_uint16
THREAD_SAFE bool is_type_uint16(type_t t)
See BTF_UINT16.
Definition typeinf.hpp:524

calc_arglocs
idaman bool ida_export calc_arglocs(func_type_data_t *fti)

is_type_integral
THREAD_SAFE bool is_type_integral(type_t t)
Is the type an integral type (char/short/int/long/bool)?
Definition typeinf.hpp:514

is_type_union
THREAD_SAFE bool is_type_union(type_t t)
See BTF_UNION.
Definition typeinf.hpp:457

is_tah_byte
THREAD_SAFE bool is_tah_byte(type_t t)
The TAH byte (type attribute header byte) denotes the start of type attributes.
Definition typeinf.hpp:605

is_type_bitfld
THREAD_SAFE bool is_type_bitfld(type_t t)
See BT_BITFIELD.
Definition typeinf.hpp:461

p_string
uchar p_string
Inside a type string, a pascal-like string: dt length, characters.
Definition typeinf.hpp:99

pack_idcobj_to_bv
idaman error_t ida_export pack_idcobj_to_bv(const idc_value_t *obj, const tinfo_t &tif, relobj_t *bytes, void *objoff, int pio_flags=0)
Write a typed idc object to the byte vector.

stock_type_id_t
stock_type_id_t
IDs for common types.
Definition typeinf.hpp:2874

STI_PINT
@ STI_PINT
int *
Definition typeinf.hpp:2880

STI_PCVOID
@ STI_PCVOID
const void *
Definition typeinf.hpp:2884

STI_AEABI_LCMP
@ STI_AEABI_LCMP
int __fastcall __pure(int64 x, int64 y)
Definition typeinf.hpp:2892

STI_RTC_CHECK_8
@ STI_RTC_CHECK_8
int64 __fastcall(int64 x)
Definition typeinf.hpp:2902

STI_SSIZE_T
@ STI_SSIZE_T
ssize_t
Definition typeinf.hpp:2896

STI_PUNKNOWN
@ STI_PUNKNOWN
_UNKNOWN *
Definition typeinf.hpp:2905

STI_AUCHAR
@ STI_AUCHAR
uint8[]
Definition typeinf.hpp:2886

STI_AEABI_MEMSET
@ STI_AEABI_MEMSET
void __fastcall(void *, size_t, int)
Definition typeinf.hpp:2898

STI_ACHAR
@ STI_ACHAR
char[]
Definition typeinf.hpp:2885

STI_DONT_USE
@ STI_DONT_USE
unused stock type id; should not be used
Definition typeinf.hpp:2894

STI_COMPLEX128
@ STI_COMPLEX128
struct complex128_t { double real, imag; }
Definition typeinf.hpp:2904

STI_PCCHAR
@ STI_PCCHAR
const char *
Definition typeinf.hpp:2877

STI_PUINT
@ STI_PUINT
unsigned int *
Definition typeinf.hpp:2881

STI_ACCHAR
@ STI_ACCHAR
const char[]
Definition typeinf.hpp:2887

STI_PCUCHAR
@ STI_PCUCHAR
const uint8 *
Definition typeinf.hpp:2878

STI_COMPLEX64
@ STI_COMPLEX64
struct complex64_t { float real, imag; }
Definition typeinf.hpp:2903

STI_RTC_CHECK_2
@ STI_RTC_CHECK_2
int16 __fastcall(int16 x)
Definition typeinf.hpp:2900

STI_RTC_CHECK_4
@ STI_RTC_CHECK_4
int32 __fastcall(int32 x)
Definition typeinf.hpp:2901

STI_AEABI_MEMCPY
@ STI_AEABI_MEMCPY
void __fastcall(void *, const void *, size_t)
Definition typeinf.hpp:2897

STI_MSGSEND
@ STI_MSGSEND
void *(void *, const char *, ...)
Definition typeinf.hpp:2891

STI_LAST
@ STI_LAST
Definition typeinf.hpp:2906

STI_FDELOP
@ STI_FDELOP
void __cdecl(void *)
Definition typeinf.hpp:2890

STI_PVOID
@ STI_PVOID
void *
Definition typeinf.hpp:2882

STI_PPVOID
@ STI_PPVOID
void **
Definition typeinf.hpp:2883

STI_AEABI_ULCMP
@ STI_AEABI_ULCMP
int __fastcall __pure(uint64 x, uint64 y)
Definition typeinf.hpp:2893

STI_AEABI_MEMCLR
@ STI_AEABI_MEMCLR
void __fastcall(void *, size_t)
Definition typeinf.hpp:2899

STI_FPURGING
@ STI_FPURGING
void __userpurge(int)
Definition typeinf.hpp:2889

STI_PCHAR
@ STI_PCHAR
char *
Definition typeinf.hpp:2875

STI_PUCHAR
@ STI_PUCHAR
uint8 *
Definition typeinf.hpp:2876

STI_ACUCHAR
@ STI_ACUCHAR
const uint8[]
Definition typeinf.hpp:2888

STI_PBYTE
@ STI_PBYTE
_BYTE *
Definition typeinf.hpp:2879

STI_SIZE_T
@ STI_SIZE_T
size_t
Definition typeinf.hpp:2895

is_type_int32
THREAD_SAFE bool is_type_int32(type_t t)
Does the type specify a 32-bit value? (signed or unsigned, see Basic type: integer)
Definition typeinf.hpp:482

is_type_uchar
THREAD_SAFE bool is_type_uchar(type_t t)
See BTF_UCHAR.
Definition typeinf.hpp:523

is_type_floating
THREAD_SAFE bool is_type_floating(type_t t)
Is the type a floating point type?
Definition typeinf.hpp:512

is_type_uint
THREAD_SAFE bool is_type_uint(type_t t)
See BTF_UINT.
Definition typeinf.hpp:522

is_type_partial
THREAD_SAFE bool is_type_partial(type_t t)
Identifies an unknown or void type with a known size (see Basic type: unknown & void)
Definition typeinf.hpp:444

visit_stroff_udms
idaman int ida_export visit_stroff_udms(udm_visitor_t &sfv, const tid_t *path, int plen, adiff_t *disp, bool appzero)
Visit structure fields in a stroff expression or in a reference to a struct data variable.

stroff_as_size
bool stroff_as_size(int plen, const tinfo_t &tif, asize_t value)
Should display a structure offset expression as the structure size?
Definition typeinf.hpp:5539

tinfovec_t
qvector< tinfo_t > tinfovec_t
vector of tinfo objects
Definition typeinf.hpp:4579

remove_pointer
tinfo_t remove_pointer(const tinfo_t &tif)
BT_PTR: If the current type is a pointer, return the pointed object.
Definition typeinf.hpp:5948

dump_func_type_data
idaman bool ida_export dump_func_type_data(qstring *out, const func_type_data_t &fti, int praloc_bits)
Use func_type_data_t::dump()

MAX_ENUM_SERIAL
const uchar MAX_ENUM_SERIAL
Max number of identical constants allowed for one enum type.
Definition typeinf.hpp:5160

choose_local_tinfo_and_delta
idaman uint32 ida_export choose_local_tinfo_and_delta(int32 *delta, const til_t *ti, const char *title, local_tinfo_predicate_t *func=nullptr, uint32 def_ord=0, void *ud=nullptr)
Choose a type from the local type library and specify the pointer shift value.

apply_tinfo_to_stkarg
idaman bool ida_export apply_tinfo_to_stkarg(const insn_t &insn, const op_t &x, uval_t v, const tinfo_t &tif, const char *name)
Helper function for the processor modules.

format_functype_t
format_functype_t
Function index for the 'format' attribute.
Definition typeinf.hpp:4839

FMTFUNC_SCANF
@ FMTFUNC_SCANF
Definition typeinf.hpp:4841

FMTFUNC_STRFTIME
@ FMTFUNC_STRFTIME
Definition typeinf.hpp:4842

FMTFUNC_STRFMON
@ FMTFUNC_STRFMON
Definition typeinf.hpp:4843

FMTFUNC_PRINTF
@ FMTFUNC_PRINTF
Definition typeinf.hpp:4840

is_type_int
THREAD_SAFE bool is_type_int(type_t bt)
Does the type_t specify one of the basic types in Basic type: integer?
Definition typeinf.hpp:465

is_type_arithmetic
THREAD_SAFE bool is_type_arithmetic(type_t t)
Is the type an arithmetic type? (floating or integral)
Definition typeinf.hpp:518

choose_named_type
idaman bool ida_export choose_named_type(til_symbol_t *out_sym, const til_t *root_til, const char *title, int ntf_flags, predicate_t *predicate=nullptr)
Choose a type from a type library.

apply_cdecl
idaman bool ida_export apply_cdecl(til_t *til, ea_t ea, const char *decl, int flags=0)
Apply the specified type to the address.

TYPID_ISREF
const int TYPID_ISREF
Identifies that a type that is a typeref.
Definition typeinf.hpp:3040

is_type_const
THREAD_SAFE bool is_type_const(type_t t)
See BTM_CONST.
Definition typeinf.hpp:432

is_restype_struni
bool is_restype_struni(const til_t *til, const type_t *type)
Definition typeinf.hpp:701

apply_tinfo
idaman bool ida_export apply_tinfo(ea_t ea, const tinfo_t &tif, uint32 flags)
Apply the specified type to the specified address.

add_base_tils
idaman int ida_export add_base_tils(qstring *errbuf, til_t *ti, const char *tildir, const char *bases, bool gen_events)
Add multiple base tils.

gtd_udt_t
gtd_udt_t
Constants to be used with get_udt_details()
Definition typeinf.hpp:2931

GTD_CALC_LAYOUT
@ GTD_CALC_LAYOUT
calculate udt layout
Definition typeinf.hpp:2932

GTD_NO_LAYOUT
@ GTD_NO_LAYOUT
don't calculate udt layout please note that udt layout may have been calculated earlier
Definition typeinf.hpp:2933

GTD_DEL_BITFLDS
@ GTD_DEL_BITFLDS
delete udt bitfields
Definition typeinf.hpp:2936

is_type_enum
THREAD_SAFE bool is_type_enum(type_t t)
See BTF_ENUM.
Definition typeinf.hpp:459

add_til
idaman int ida_export add_til(const char *name, int flags)
Load a til file and add it the database type libraries list.

funcargvec_t
qvector< funcarg_t > funcargvec_t
vector of function argument objects
Definition typeinf.hpp:4749

is_type_complex
THREAD_SAFE bool is_type_complex(type_t t)
See BT_COMPLEX.
Definition typeinf.hpp:450

is_type_array
THREAD_SAFE bool is_type_array(type_t t)
See BT_ARRAY.
Definition typeinf.hpp:452

load_til
idaman til_t *ida_export load_til(const char *name, qstring *errbuf, const char *tildir=nullptr)
Load til from a file without adding it to the database list (see also add_til).

ordvec_t
qvector< uint32 > ordvec_t
Definition typeinf.hpp:6505

align_size
THREAD_SAFE void align_size(size_t &cur_tot_size, size_t elem_size, size_t algn)
Get alignment delta for the a structure field.
Definition typeinf.hpp:2650

get_c_macros
ssize_t get_c_macros(qstring *buf)
Get predefined macros for the target compiler.
Definition typeinf.hpp:2828

gen_use_arg_tinfos
idaman void ida_export gen_use_arg_tinfos(struct argtinfo_helper_t *_this, ea_t caller, func_type_data_t *fti, funcargvec_t *rargs)
Do not call this function directly, use argtinfo_helper_t.

typid_t
uint64 typid_t
Definition typeinf.hpp:2975

load_til_header
idaman til_t *ida_export load_til_header(const char *tildir, const char *name, qstring *errbuf)
Get human-readable til description.

deref_ptr
idaman bool ida_export deref_ptr(ea_t *ptr_ea, const tinfo_t &tif, ea_t *closure_obj=nullptr)
Dereference a pointer.

get_enum_member_expr
idaman bool ida_export get_enum_member_expr(qstring *buf, const tinfo_t &tif, int serial, uint64 value)
Return a C expression that can be used to represent an enum member.

abs_t
abs_t
abstractness of declaration (see h2ti())
Definition typeinf.hpp:2027

ABS_YES
@ ABS_YES
Definition typeinf.hpp:2030

ABS_NO
@ ABS_NO
Definition typeinf.hpp:2029

ABS_UNK
@ ABS_UNK
Definition typeinf.hpp:2028

is_type_void
THREAD_SAFE bool is_type_void(type_t t)
See BTF_VOID.
Definition typeinf.hpp:446

update_type_t
update_type_t
See begin_type_updating()
Definition typeinf.hpp:6238

UTP_STRUCT
@ UTP_STRUCT
Definition typeinf.hpp:6240

UTP_ENUM
@ UTP_ENUM
Definition typeinf.hpp:6239

is_type_ldouble
THREAD_SAFE bool is_type_ldouble(type_t t)
See BTF_LDOUBLE.
Definition typeinf.hpp:528

get_arg_addrs
idaman bool ida_export get_arg_addrs(eavec_t *out, ea_t caller)
Retrieve argument initialization addresses.

free_til
idaman void ida_export free_til(til_t *ti)
Free memory allocated by til.

is_type_bool
THREAD_SAFE bool is_type_bool(type_t t)
See BTF_BOOL.
Definition typeinf.hpp:532

compact_til
idaman bool ida_export compact_til(til_t *ti)
Collect garbage in til.

store_til
idaman bool ida_export store_til(til_t *ti, const char *tildir, const char *name)
Store til to a file.

is_one_bit_mask
THREAD_SAFE bool is_one_bit_mask(uval_t mask)
Is bitmask one bit?
Definition typeinf.hpp:5637

BADSIZE
const size_t BADSIZE
bad type size
Definition typeinf.hpp:2021

align_stkarg_up
sval_t align_stkarg_up(sval_t spoff, int type_align, int slotsize, callcnv_t cc=CM_CC_UNKNOWN)
Definition typeinf.hpp:5684

is_type_struni
THREAD_SAFE bool is_type_struni(type_t t)
Is the type a struct or union?
Definition typeinf.hpp:458

get_default_align
size_t get_default_align()
Get default alignment for structure fields.
Definition typeinf.hpp:2641

is_type_ext_integral
THREAD_SAFE bool is_type_ext_integral(type_t t)
Is the type an extended integral type? (integral or enum)
Definition typeinf.hpp:516

is_restype_struct
bool is_restype_struct(const til_t *til, const type_t *type)
Definition typeinf.hpp:707

choose_local_tinfo
idaman uint32 ida_export choose_local_tinfo(const til_t *ti, const char *title, local_tinfo_predicate_t *func=nullptr, uint32 def_ord=0, void *ud=nullptr)
Choose a type from the local type library.

sclass_t
sclass_t
< storage class
Definition typeinf.hpp:2033

SC_EXT
@ SC_EXT
extern
Definition typeinf.hpp:2036

SC_FRIEND
@ SC_FRIEND
friend
Definition typeinf.hpp:2040

SC_VIRT
@ SC_VIRT
virtual
Definition typeinf.hpp:2041

SC_UNK
@ SC_UNK
unknown
Definition typeinf.hpp:2034

SC_AUTO
@ SC_AUTO
auto
Definition typeinf.hpp:2039

SC_TYPE
@ SC_TYPE
typedef
Definition typeinf.hpp:2035

SC_REG
@ SC_REG
register
Definition typeinf.hpp:2038

SC_STAT
@ SC_STAT
static
Definition typeinf.hpp:2037

is_sdacl_byte
THREAD_SAFE bool is_sdacl_byte(type_t t)
Identify an sdacl byte.
Definition typeinf.hpp:620

valstrvec_t
qvector< valstr_t > valstrvec_t
Definition typeinf.hpp:6446

is_type_uint64
THREAD_SAFE bool is_type_uint64(type_t t)
See BTF_UINT64.
Definition typeinf.hpp:526

get_type_flags
THREAD_SAFE type_t get_type_flags(type_t t)
Get type flags (TYPE_FLAGS_MASK)
Definition typeinf.hpp:436

begin_type_updating
idaman void ida_export begin_type_updating(update_type_t utp)
Mark the beginning of a large update operation on the types.

is_type_paf
THREAD_SAFE bool is_type_paf(type_t t)
Is the type a pointer, array, or function type?
Definition typeinf.hpp:503

is_type_tbyte
THREAD_SAFE bool is_type_tbyte(type_t t)
See BTF_FLOAT.
Definition typeinf.hpp:531

get_idati
idaman til_t *ida_export get_idati()
Pointer to the local type library - this til is private for each IDB file Functions that accept til_t...

operator<
THREAD_SAFE bool operator<(const bytevec_t &v1, const bytevec_t &v2)
Compare two bytevecs with '<'.
Definition typeinf.hpp:631

sort_til
idaman bool ida_export sort_til(til_t *ti)
Sort til (use after modifying it).

is_restype_enum
bool is_restype_enum(const til_t *til, const type_t *type)
Definition typeinf.hpp:695

enum_type_visitor_t
std::function< ssize_t(const struct enum_type_data_t &ei, size_t idx, uint64 value, uint64 bmask)> enum_type_visitor_t
Callback for visit_edms.
Definition typeinf.hpp:6647

is_type_uint128
THREAD_SAFE bool is_type_uint128(type_t t)
See BTF_UINT128.
Definition typeinf.hpp:527

remove_tinfo_pointer
idaman bool ida_export remove_tinfo_pointer(tinfo_t *tif, const char **pname, const til_t *til=nullptr)
Remove pointer of a type.

local_tinfo_predicate_t
int idaapi local_tinfo_predicate_t(uint32 ord, const tinfo_t &type, void *ud)
Controls which types are displayed/selected when choosing local types.
Definition typeinf.hpp:6604

gtd_func_t
gtd_func_t
Constants to be used with get_func_details()
Definition typeinf.hpp:2941

GTD_NO_ARGLOCS
@ GTD_NO_ARGLOCS
don't calculate func arg locations please note that the locations may have been calculated earlier
Definition typeinf.hpp:2943

GTD_CALC_ARGLOCS
@ GTD_CALC_ARGLOCS
calculate func arg locations
Definition typeinf.hpp:2942

set_c_macros
void set_c_macros(const char *macros)
Set predefined macros for the target compiler.
Definition typeinf.hpp:2825

is_type_unknown
THREAD_SAFE bool is_type_unknown(type_t t)
See BT_UNKNOWN.
Definition typeinf.hpp:447

end_type_updating
idaman void ida_export end_type_updating(update_type_t utp)
Mark the end of a large update operation on the types (see begin_type_updating())

simd_info_vec_t
qvector< simd_info_t > simd_info_vec_t
Definition typeinf.hpp:4616

apply_once_tinfo_and_name
idaman bool ida_export apply_once_tinfo_and_name(ea_t dea, const tinfo_t &tif, const char *name)
Apply the specified type and name to the address.

print_decls
idaman int ida_export print_decls(text_sink_t &printer, const til_t *til, const ordvec_t *ordinals, uint32 pdf_flags)
Print types (and possibly their dependencies) in a format suitable for using in a header file.

calc_retloc
idaman bool ida_export calc_retloc(func_type_data_t *fti)

is_type_float
THREAD_SAFE bool is_type_float(type_t t)
See BTF_FLOAT.
Definition typeinf.hpp:530

apply_callee_tinfo
idaman bool ida_export apply_callee_tinfo(ea_t caller, const tinfo_t &tif)
Apply the type of the called function to the calling instruction.

is_type_ptr
THREAD_SAFE bool is_type_ptr(type_t t)
See BT_PTR.
Definition typeinf.hpp:449

print_cdata
idaman int ida_export print_cdata(text_sink_t &printer, const idc_value_t &idc_value, const tinfo_t *tif, const format_data_info_t *fdi=nullptr)
The same as format_cdata(), but instead of returning the answer in a vector, print it.

replace_ordinal_typerefs
idaman int ida_export replace_ordinal_typerefs(til_t *til, tinfo_t *tif)
Replace references to ordinal types by name references.

get_arg_align
int get_arg_align(int type_align, int slotsize, callcnv_t cc=CM_CC_UNKNOWN)
Definition typeinf.hpp:5662

append_argloc
idaman bool ida_export append_argloc(qtype *out, const argloc_t &vloc)
Serialize argument location.

is_type_volatile
THREAD_SAFE bool is_type_volatile(type_t t)
See BTM_VOLATILE.
Definition typeinf.hpp:433

new_til
idaman til_t *ida_export new_til(const char *name, const char *desc)
Initialize a til.

is_typeid_last
THREAD_SAFE bool is_typeid_last(type_t t)
Is the type_t the last byte of type declaration?
Definition typeinf.hpp:441

format_cdata
idaman bool ida_export format_cdata(qstrvec_t *outvec, const idc_value_t &idc_value, const tinfo_t *tif, valstr_t *vtree=nullptr, const format_data_info_t *fdi=nullptr)
Format a data value as a C initializer.

is_type_sue
THREAD_SAFE bool is_type_sue(type_t t)
Is the type a struct/union/enum?
Definition typeinf.hpp:455

calc_varglocs
idaman bool ida_export calc_varglocs(func_type_data_t *fti, regobjs_t *regs, relobj_t *stkargs, int nfixed)

visit_edms
idaman ssize_t ida_export visit_edms(const tinfo_t &tif, uint64 value, int nbytes, uchar serial, const enum_type_visitor_t &visitor)
Visit enum members having the specified value.

edmvec_t
qvector< edm_t > edmvec_t
vector of enum values.
Definition typeinf.hpp:4885

is_type_int64
THREAD_SAFE bool is_type_int64(type_t t)
Does the type specify a 64-bit value? (signed or unsigned, see Basic type: integer)
Definition typeinf.hpp:475

is_type_int128
THREAD_SAFE bool is_type_int128(type_t t)
Does the type specify a 128-bit value? (signed or unsigned, see Basic type: integer)
Definition typeinf.hpp:468

unpack_idcobj_from_idb
idaman error_t ida_export unpack_idcobj_from_idb(idc_value_t *obj, const tinfo_t &tif, ea_t ea, const bytevec_t *off0, int pio_flags=0)
Collection of register objects.

resolve_typedef
idaman const type_t *ida_export resolve_typedef(const til_t *til, const type_t *type)

get_tinfo_by_flags
idaman bool ida_export get_tinfo_by_flags(tinfo_t *out, flags64_t flags)
Get tinfo object that corresponds to data flags.

guess_func_cc
idaman callcnv_t ida_export guess_func_cc(const func_type_data_t &fti, int npurged, int cc_flags)
Use func_type_data_t::guess_cc()

opinfo_t
Additional information about an operand type.
Definition nalt.hpp:1244

value_union_t
This union is used to pass byte values to various helper functions.
Definition ua.hpp:580