Module ida_typeinf
[frames] | no frames]

Module ida_typeinf

IDA Plugin SDK API wrapper: typeinf

Classes
  funcargvec_t
Proxy of C++ qvector<(funcarg_t)> class
  udtmembervec_t
Proxy of C++ qvector<(udt_member_t)> class
  reginfovec_t
Proxy of C++ qvector<(reg_info_t)> class
  enum_member_vec_t
Proxy of C++ qvector<(enum_member_t)> class
  argpartvec_t
Proxy of C++ qvector<(argpart_t)> class
  valstrvec_t
Proxy of C++ qvector<(valstr_t)> class
  regobjvec_t
Proxy of C++ qvector<(regobj_t)> class
  type_attrs_t
Proxy of C++ qvector<(type_attr_t)> class
  type_attr_t
Proxy of C++ type_attr_t class
  til_t
Proxy of C++ til_t class
  rrel_t
Proxy of C++ rrel_t class
  argloc_t
Proxy of C++ argloc_t class
  argpart_t
Proxy of C++ argpart_t class
  scattered_aloc_t
Proxy of C++ scattered_aloc_t class
  aloc_visitor_t
Proxy of C++ aloc_visitor_t class
  const_aloc_visitor_t
Proxy of C++ const_aloc_visitor_t class
  callregs_t
Proxy of C++ callregs_t class
  tinfo_t
Proxy of C++ tinfo_t class
  simd_info_t
Proxy of C++ simd_info_t class
  ptr_type_data_t
Proxy of C++ ptr_type_data_t class
  array_type_data_t
Proxy of C++ array_type_data_t class
  funcarg_t
Proxy of C++ funcarg_t class
  func_type_data_t
Proxy of C++ func_type_data_t class
  enum_member_t
Proxy of C++ enum_member_t class
  enum_type_data_t
Proxy of C++ enum_type_data_t class
  typedef_type_data_t
Proxy of C++ typedef_type_data_t class
  udt_member_t
Proxy of C++ udt_member_t class
  udt_type_data_t
Proxy of C++ udt_type_data_t class
  bitfield_type_data_t
Proxy of C++ bitfield_type_data_t class
  type_mods_t
Proxy of C++ type_mods_t class
  tinfo_visitor_t
Proxy of C++ tinfo_visitor_t class
  regobj_t
Proxy of C++ regobj_t class
  regobjs_t
Proxy of C++ regobjs_t class
  lowertype_helper_t
Proxy of C++ lowertype_helper_t class
  ida_lowertype_helper_t
Proxy of C++ ida_lowertype_helper_t class
  valstr_t
Proxy of C++ valstr_t class
  valstrs_t
Proxy of C++ valstrs_t class
  text_sink_t
Proxy of C++ text_sink_t class
  til_symbol_t
Proxy of C++ til_symbol_t class
  predicate_t
Proxy of C++ predicate_t class
Functions
bool
is_type_const(t)
See 'BTM_CONST' .
bool
is_type_volatile(t)
See 'BTM_VOLATILE' .
type_t
get_base_type(t)
Get get basic type bits ( 'TYPE_BASE_MASK' )
type_t
get_type_flags(t)
Get type flags ( 'TYPE_FLAGS_MASK' )
type_t
get_full_type(t)
Get basic type bits + type flags ( 'TYPE_FULL_MASK' )
bool
is_typeid_last(t)
Is the type_t the last byte of type declaration? (there are no additional bytes after a basic type, see '_BT_LAST_BASIC' )
bool
is_type_partial(t)
Identifies an unknown or void type with a known size (see 'Basic type: unknown & void' )
bool
is_type_void(t)
See 'BTF_VOID' .
bool
is_type_unknown(t)
See 'BT_UNKNOWN' .
bool
is_type_ptr(t)
See 'BT_PTR' .
bool
is_type_complex(t)
See 'BT_COMPLEX' .
bool
is_type_func(t)
See 'BT_FUNC' .
bool
is_type_array(t)
See 'BT_ARRAY' .
bool
is_type_typedef(t)
See 'BTF_TYPEDEF' .
bool
is_type_sue(t)
Is the type a struct/union/enum?
bool
is_type_struct(t)
See 'BTF_STRUCT' .
bool
is_type_union(t)
See 'BTF_UNION' .
bool
is_type_struni(t)
Is the type a struct or union?
bool
is_type_enum(t)
See 'BTF_ENUM' .
bool
is_type_bitfld(t)
See 'BT_BITFIELD' .
bool
is_type_int(bt)
Does the type_t specify one of the basic types in 'Basic type: integer' ?
bool
is_type_int128(t)
Does the type specify a 128-bit value? (signed or unsigned, see 'Basic type: integer' )
bool
is_type_int64(t)
Does the type specify a 64-bit value? (signed or unsigned, see 'Basic type: integer' )
bool
is_type_int32(t)
Does the type specify a 32-bit value? (signed or unsigned, see 'Basic type: integer' )
bool
is_type_int16(t)
Does the type specify a 16-bit value? (signed or unsigned, see 'Basic type: integer' )
bool
is_type_char(t)
Does the type specify a char value? (signed or unsigned, see 'Basic type: integer' )
bool
is_type_paf(t)
Is the type a pointer, array, or function type?
bool
is_type_ptr_or_array(t)
Is the type a pointer or array type?
bool
is_type_floating(t)
Is the type a floating point type?
bool
is_type_integral(t)
Is the type an integral type (char/short/int/long/bool)?
bool
is_type_ext_integral(t)
Is the type an extended integral type? (integral or enum)
bool
is_type_arithmetic(t)
Is the type an arithmetic type? (floating or integral)
bool
is_type_ext_arithmetic(t)
Is the type an extended arithmetic type? (arithmetic or enum)
bool
is_type_uint(t)
See 'BTF_UINT' .
bool
is_type_uchar(t)
See 'BTF_UCHAR' .
bool
is_type_uint16(t)
See 'BTF_UINT16' .
bool
is_type_uint32(t)
See 'BTF_UINT32' .
bool
is_type_uint64(t)
See 'BTF_UINT64' .
bool
is_type_uint128(t)
See 'BTF_UINT128' .
bool
is_type_ldouble(t)
See 'BTF_LDOUBLE' .
bool
is_type_double(t)
See 'BTF_DOUBLE' .
bool
is_type_float(t)
See 'BTF_FLOAT' .
bool
is_type_tbyte(t)
See 'BTF_FLOAT' .
bool
is_type_bool(t)
See 'BTF_BOOL' .
bool
is_tah_byte(t)
The TAH byte (type attribute header byte) denotes the start of type attributes.
bool
is_sdacl_byte(t)
Identify an sdacl byte.
bool
append_argloc(out, vloc)
Serialize argument location.
bool
extract_argloc(vloc, ptype, is_retval)
Deserialize argument location.
type_t const *
resolve_typedef(til, type)
bool
is_restype_void(til, type)
bool
is_restype_enum(til, type)
bool
is_restype_struni(til, type)
bool
is_restype_struct(til, type)
type_t
get_scalar_bt(size)
til_t
new_til(name, desc)
Initialize a til.
bool
compact_til(ti)
Collect garbage in til.
bool
store_til(ti, tildir, name)
Store til to a file.
 
free_til(ti)
Free memory allocated by til.
bool
is_code_far(cm)
Does the given model specify far code?.
bool
is_data_far(cm)
Does the given model specify far data?.
int
verify_argloc(vloc, size, gaps)
Verify 'argloc_t' .
bool
optimize_argloc(vloc, size, gaps)
Verify and optimize scattered argloc into simple form.
size_t
print_argloc(vloc, size=0, vflags=0)
Convert an argloc to human readable form.
int
for_all_arglocs(vv, vloc, size, off=0)
Compress larger argloc types and initiate the aloc visitor.
int
for_all_const_arglocs(vv, vloc, size, off=0)
See 'for_all_arglocs()'
bool
is_user_cc(cm)
Does the calling convention specify argument locations explicitly?
bool
is_vararg_cc(cm)
Does the calling convention use ellipsis?
bool
is_purging_cc(cm)
Does the calling convention clean the stack arguments upon return?.this function is valid only for x86 code
int
callregs_t_regcount(cc)
comp_t
get_comp(comp)
Get compiler bits.
char const *
get_compiler_name(id)
Get full compiler name.
char const *
get_compiler_abbr(id)
Get abbreviated compiler name.
 
get_compilers(ids, names, abbrs)
Get names of all built-in compilers.
comp_t
is_comp_unsure(comp)
See 'COMP_UNSURE' .
comp_t
default_compiler()
Get compiler specified by armem{inf,idainfo,cc}.
bool
is_gcc()
Is the target compiler 'COMP_GNU' ?
bool
is_gcc32()
Is the target compiler 32 bit gcc?
bool
is_gcc64()
Is the target compiler 64 bit gcc?
bool
gcc_layout()
Should use the struct/union layout as done by gcc?
bool
set_compiler(cc, flags, abiname=None)
Change current compiler.
bool
set_compiler_id(id, abiname=None)
Set the compiler id (see 'Compiler IDs' )
bool
set_abi_name(abiname, user_level=False)
Set abi name (see 'Compiler IDs' )
ssize_t
get_abi_name()
Get ABI name.
bool
append_abi_opts(abi_opts, user_level=False)
Add/remove/check ABI option General form of full abi name: abiname- opt1-opt2-...
bool
remove_abi_opts(abi_opts, user_level=False)
bool
set_compiler_string(compstr, user_level)
bool
parse_decl(tif, til, decl, flags)
Parse ONE declaration.
int
convert_pt_flags_to_hti(pt_flags)
Convert 'Type parsing flags' to 'Type formatting flags' .
int
parse_decls(til, input, printer, hti_flags)
Parse many declarations and store them in a til.
bool
print_type(ea, prtype_flags)
Get type declaration for the specified address.
bool
del_named_type(ti, name, ntf_flags)
Delete information about a symbol.
char const *
first_named_type(ti, ntf_flags)
Enumerate types.
char const *
next_named_type(ti, name, ntf_flags)
Enumerate types.
uint32
copy_named_type(dsttil, srctil, name)
Copy a named type from one til to another.
bool
gen_decorate_name(name, mangle, cc, type)
Generic function for 'decorate_name()' (may be used in IDP modules)
ssize_t
calc_c_cpp_name(name, type, ccn_flags)
Get C or C++ form of the name.
uint32
alloc_type_ordinals(ti, qty)
Allocate a range of ordinal numbers for new types.
uint32
alloc_type_ordinal(ti)
\call2{alloc_type_ordinals,ti,1}
uint32
get_ordinal_qty(ti)
Get number of allocated ordinals.
tinfo_code_t
set_numbered_type(ti, ordinal, ntf_flags, name, type, fields=None, cmt=None, fldcmts=None, sclass=None)
Store a type in the til.
bool
del_numbered_type(ti, ordinal)
Delete a numbered type.
bool
set_type_alias(ti, src_ordinal, dst_ordinal)
Create a type alias.
uint32
get_alias_target(ti, ordinal)
Find the final alias destination.
int32
get_type_ordinal(ti, name)
Get type ordinal by its name.
char const *
get_numbered_type_name(ti, ordinal)
Get type name (if exists) by its ordinal.
ssize_t
create_numbered_type_name(ord)
Create anonymous name for numbered type.
bool
is_ordinal_name(name, ord=None)
Check if the name is an ordinal name.
int
get_ordinal_from_idb_type(name, type)
Get ordinal number of an idb type (struct/enum).
bool
is_autosync(name, type)
is_autosync(name, tif) -> bool
bool
deref_ptr(ptr_ea, tif, closure_obj=None)
Dereference a pointer.
tid_t
import_type(til, idx, name, flags=0)
Copy a named type from til to idb.
int
add_til(name, flags)
Load a til file.
bool
del_til(name)
Unload a til file.
bool
apply_named_type(ea, name)
Apply the specified named type to the address.
bool
apply_tinfo(ea, tif, flags)
Apply the specified type to the specified address.
bool
apply_cdecl(til, ea, decl, flags=0)
Apply the specified type to the address.
bool
apply_callee_tinfo(caller, tif)
Apply the type of the called function to the calling instruction.
bool
apply_once_tinfo_and_name(dea, tif, name)
Apply the specified type and name to the address.
int
guess_tinfo(tif, id)
Generate a type information about the id from the disassembly.
 
set_c_header_path(incdir)
Set include directory path the target compiler.
ssize_t
get_c_header_path()
Get the include directory path of the target compiler.
 
set_c_macros(macros)
Set predefined macros for the target compiler.
ssize_t
get_c_macros()
Get predefined macros for the target compiler.
til_t
get_idati()
Pointer to the local type library - this til is private for each IDB file Function that accepts til_t* uses local type library instead of NULL.
bool
get_idainfo_by_type(tif)
Extract information from a 'tinfo_t' .
 
copy_tinfo_t(_this, r)
 
clear_tinfo_t(_this)
bool
create_tinfo(_this, bt, bt2, ptr)
int
verify_tinfo(typid)
bool
get_tinfo_details(typid, bt2, buf)
size_t
get_tinfo_size(p_effalign, typid, gts_code)
size_t
get_tinfo_pdata(outptr, typid, what)
size_t
get_tinfo_property(typid, gta_prop)
size_t
set_tinfo_property(tif, sta_prop, x)
bool
serialize_tinfo(type, fields, fldcmts, tif, sudt_flags)
bool
deserialize_tinfo(tif, til, ptype, pfields, pfldcmts)
int
find_tinfo_udt_member(udm, typid, strmem_flags)
bool
print_tinfo(prefix, indent, cmtindent, flags, tif, name, cmt)
char const *
dstr_tinfo(tif)
int
visit_subtypes(visitor, out, tif, name, cmt)
bool
compare_tinfo(t1, t2, tcflags)
int
lexcompare_tinfo(t1, t2, arg3)
bool
get_stock_tinfo(tif, id)
uint64
read_tinfo_bitfield_value(typid, v, bitoff)
uint64
write_tinfo_bitfield_value(typid, dst, v, bitoff)
bool
get_tinfo_attr(typid, key, bv, all_attrs)
bool
set_tinfo_attr(tif, ta, may_overwrite)
bool
del_tinfo_attr(tif, key, make_copy)
bool
get_tinfo_attrs(typid, tav, include_ref_attrs)
bool
set_tinfo_attrs(tif, ta)
uint32
score_tinfo(tif)
tinfo_code_t
save_tinfo(tif, til, ord, name, ntf_flags)
bool
append_tinfo_covered(out, typid, offset)
bool
calc_tinfo_gaps(out, typid)
tinfo_t
remove_pointer(tif)
'BT_PTR' : If the current type is a pointer, return the pointed object.
tinfo_t
tinfo_t_get_stock(id)
cm_t
guess_func_cc(fti, npurged, cc_flags)
Use 'func_type_data_t::guess_cc()'
bool
dump_func_type_data(fti, praloc_bits)
Use 'func_type_data_t::dump()'
error_t
unpack_idcobj_from_idb(obj, tif, ea, off0, pio_flags=0)
Collection of register objects.
error_t
unpack_idcobj_from_bv(obj, tif, bytes, pio_flags=0)
Read a typed idc object from the byte vector.
error_t
pack_idcobj_to_idb(obj, tif, ea, pio_flags=0)
Write a typed idc object to the database.
error_t
pack_idcobj_to_bv(obj, tif, bytes, objoff, pio_flags=0)
Write a typed idc object to the byte vector.
bool
apply_tinfo_to_stkarg(insn, x, v, tif, name)
Helper function for the processor modules.
 
gen_use_arg_tinfos(caller, fti, rargs, set_optype, is_stkarg_load, has_delay_slot)
The main function using these callbacks:
bool
func_has_stkframe_hole(ea, fti)
Looks for a hole at the beginning of the stack arguments.
int
lower_type(til, tif, name=None, _helper=None)
Lower type.
int
replace_ordinal_typerefs(til, tif)
Replace references to ordinal types by name references.
 
begin_type_updating(utp)
Mark the beginning of a large update operation on the types.
 
end_type_updating(utp)
Mark the end of a large update operation on the types (see 'begin_type_updating()' )
int
calc_number_of_children(loc, tif, dont_deref_ptr=False)
Calculate max number of lines of a formatted c data, when expanded ( 'PTV_EXPAND' ).
bool
get_enum_member_expr(tif, serial, value)
Return a C expression that can be used to represent an enum member.
bool
choose_named_type(out_sym, root_til, title, ntf_flags, predicate=None)
Choose a type from a type library.
uint32
choose_local_tinfo(ti, title, func=None, def_ord=0, ud=None)
Choose a type from the local type library.
PyObject *
idc_parse_decl(ti, decl, flags)
PyObject *
calc_type_size(ti, tp)
Returns the size of a type
bool
apply_type(ti, py_type, py_fields, ea, flags)
Apply the specified type to the address
PyObject *
get_arg_addrs(caller)
Retrieve addresses of argument initialization instructions
PyObject *
unpack_object_from_idb(ti, py_type, py_fields, ea, pio_flags=0)
PyObject *
unpack_object_from_bv(ti, py_type, py_fields, py_bytes, pio_flags=0)
Unpacks a buffer into an object.
PyObject *
pack_object_to_idb(py_obj, ti, py_type, py_fields, ea, pio_flags=0)
Write a typed object to the database.
PyObject *
pack_object_to_bv(py_obj, ti, py_type, py_fields, base_ea, pio_flags=0)
Packs a typed object to a string
int
idc_parse_types(input, flags)
PyObject *
idc_get_type_raw(ea)
PyObject *
idc_get_local_type_raw(ordinal)
char *
idc_guess_type(ea)
char *
idc_get_type(ea)
int
idc_set_local_type(ordinal, dcl, flags)
int
idc_get_local_type(ordinal, flags, buf, maxsize)
PyObject *
idc_print_type(py_type, py_fields, name, flags)
char
idc_get_local_type_name(ordinal)
PyObject *
get_named_type(til, name, ntf_flags)
Get a type data by its name.
PyObject *
get_named_type64(til, name, ntf_flags)
See 'get_named_type()' above.If the value in the 'ti' library is 32-bit, it will be sign-extended before being stored in the 'value' pointer.
int
print_decls(printer, til, py_ordinals, flags)
Print types (and possibly their dependencies) in a format suitable for use in a header file.
til_t
load_til(name, tildir)
Load til from a file.
til_t
load_til_header(tildir, name)
Get human-readable til description.
PyObject *
remove_tinfo_pointer(tif, name, til)
Remove pointer of a type.
PyObject *
get_numbered_type(til, ordinal)
Retrieve a type by its ordinal number.
Variables
  RESERVED_BYTE = 255
multifunctional purpose
  TAH_BYTE = 254
type attribute header byte
  FAH_BYTE = 255
function argument attribute header byte
  MAX_DECL_ALIGN = 15
  TAH_HASATTRS = 16
has extended attributes
  TAUDT_UNALIGNED = 64
struct: unaligned struct
  TAUDT_MSSTRUCT = 32
struct: gcc msstruct attribute
  TAUDT_CPPOBJ = 128
struct: a c++ object, not simple pod type
  TAUDT_VFTABLE = 256
struct: is virtual function table
  TAFLD_BASECLASS = 32
field: do not include but inherit from the current field
  TAFLD_UNALIGNED = 64
field: unaligned field
  TAFLD_VIRTBASE = 128
field: virtual base (not supported yet)
  TAFLD_VFTABLE = 256
field: ptr to virtual function table
  TAPTR_PTR32 = 32
ptr: __ptr32
  TAPTR_PTR64 = 64
ptr: __ptr64
  TAPTR_RESTRICT = 96
ptr: __restrict
  TAPTR_SHIFTED = 128
ptr: __shifted(parent_struct, delta)
  TAENUM_64BIT = 32
enum: store 64-bit values
  TAENUM_UNSIGNED = 64
enum: unsigned
  TAENUM_SIGNED = 128
enum: signed
  TAH_ALL = 496
all defined bits
  cvar = _ida_typeinf.cvar
  TYPE_BASE_MASK = 15
  TYPE_FLAGS_MASK = 48
  TYPE_MODIF_MASK = 192
  TYPE_FULL_MASK = 63
  BT_UNK = 0
  BT_VOID = 1
  BTMT_SIZE0 = 0
  BTMT_SIZE12 = 16
  BTMT_SIZE48 = 32
  BTMT_SIZE128 = 48
  BT_INT8 = 2
  BT_INT16 = 3
  BT_INT32 = 4
  BT_INT64 = 5
  BT_INT128 = 6
  BT_INT = 7
  BTMT_UNKSIGN = 0
  BTMT_SIGNED = 16
  BTMT_USIGNED = 32
  BTMT_UNSIGNED = 32
  BTMT_CHAR = 48
  BT_BOOL = 8
  BTMT_DEFBOOL = 0
  BTMT_BOOL1 = 16
  BTMT_BOOL2 = 32
  BTMT_BOOL8 = 32
  BTMT_BOOL4 = 48
  BT_FLOAT = 9
  BTMT_FLOAT = 0
  BTMT_DOUBLE = 16
  BTMT_LNGDBL = 32
  BTMT_SPECFLT = 48
  BT_PTR = 10
  BTMT_DEFPTR = 0
  BTMT_NEAR = 16
  BTMT_FAR = 32
  BTMT_CLOSURE = 48
  BT_ARRAY = 11
  BTMT_NONBASED = 16
  BTMT_ARRESERV = 32
  BT_FUNC = 12
  BTMT_DEFCALL = 0
  BTMT_NEARCALL = 16
  BTMT_FARCALL = 32
  BTMT_INTCALL = 48
  BT_COMPLEX = 13
  BTMT_STRUCT = 0
  BTMT_UNION = 16
  BTMT_ENUM = 32
  BTMT_TYPEDEF = 48
  BT_BITFIELD = 14
  BTMT_BFLDI8 = 0
  BTMT_BFLDI16 = 16
  BTMT_BFLDI32 = 32
  BTMT_BFLDI64 = 48
  BT_RESERVED = 15
  BTM_CONST = 64
  BTM_VOLATILE = 128
  BTE_SIZE_MASK = 7
  BTE_RESERVED = 8
  BTE_BITFIELD = 16
  BTE_OUT_MASK = 96
  BTE_HEX = 0
  BTE_CHAR = 32
  BTE_SDEC = 64
  BTE_UDEC = 96
  BTE_ALWAYS = 128
  BT_SEGREG = 55
  BT_UNK_BYTE = 17
  BT_UNK_WORD = 16
  BT_UNK_DWORD = 33
  BT_UNK_QWORD = 32
  BT_UNK_OWORD = 49
  BT_UNKNOWN = 48
  BTF_BYTE = 17
  BTF_UNK = 48
  BTF_VOID = 1
  BTF_INT8 = 18
  BTF_CHAR = 50
  BTF_UCHAR = 34
  BTF_UINT8 = 34
  BTF_INT16 = 19
  BTF_UINT16 = 35
  BTF_INT32 = 20
  BTF_UINT32 = 36
  BTF_INT64 = 21
  BTF_UINT64 = 37
  BTF_INT128 = 22
  BTF_UINT128 = 38
  BTF_INT = 7
  BTF_UINT = 39
  BTF_SINT = 23
  BTF_BOOL = 8
  BTF_FLOAT = 9
  BTF_DOUBLE = 25
  BTF_LDOUBLE = 41
  BTF_TBYTE = 57
  BTF_STRUCT = 13
  BTF_UNION = 29
  BTF_ENUM = 45
  BTF_TYPEDEF = 61
  no_sign = 0
  type_signed = 1
  type_unsigned = 2
  TIL_ZIP = 1
pack buckets using zip
  TIL_MAC = 2
til has macro table
  TIL_ESI = 4
extended sizeof info (short, long, longlong)
  TIL_UNI = 8
universal til for any compiler
  TIL_ORD = 16
type ordinal numbers are present
  TIL_ALI = 32
type aliases are present (this bit is used only on the disk)
  TIL_MOD = 64
til has been modified, should be saved
  TIL_STM = 128
til has extra streams
  TIL_SLD = 256
sizeof(long double)
  TIL_ADD_FAILED = 0
see errbuf
  TIL_ADD_OK = 1
some tils were added
  TIL_ADD_ALREADY = 2
the base til was already added
  CM_MASK = 3
  CM_UNKNOWN = 0
  CM_N8_F16 = 1
  CM_N64 = 1
  CM_N16_F32 = 2
  CM_N32_F48 = 3
  CM_M_MASK = 12
  CM_M_NN = 0
  CM_M_FF = 4
  CM_M_NF = 8
  CM_M_FN = 12
  CM_CC_MASK = 240
  CM_CC_INVALID = 0
  CM_CC_UNKNOWN = 16
  CM_CC_VOIDARG = 32
  CM_CC_CDECL = 48
  CM_CC_ELLIPSIS = 64
  CM_CC_STDCALL = 80
  CM_CC_PASCAL = 96
  CM_CC_FASTCALL = 112
  CM_CC_THISCALL = 128
  CM_CC_MANUAL = 144
  CM_CC_SPOILED = 160
  CM_CC_RESERVE4 = 176
  CM_CC_RESERVE3 = 192
  CM_CC_SPECIALE = 208
  CM_CC_SPECIALP = 224
  CM_CC_SPECIAL = 240
  BFA_NORET = 1
  BFA_PURE = 2
  BFA_HIGH = 4
  BFA_STATIC = 8
  BFA_VIRTUAL = 16
  BFA_FUNC_EXT_FORMAT = 128
  ALOC_NONE = 0
  ALOC_STACK = 1
  ALOC_DIST = 2
  ALOC_REG1 = 3
  ALOC_REG2 = 4
  ALOC_RREL = 5
  ALOC_STATIC = 6
  ALOC_CUSTOM = 7
  PRALOC_VERIFY = 1
interr if illegal argloc
  PRALOC_STKOFF = 2
print stack offsets
  ARGREGS_POLICY_UNDEFINED = 0
  ARGREGS_GP_ONLY = 1
  ARGREGS_INDEPENDENT = 2
  ARGREGS_BY_SLOTS = 3
  ARGREGS_FP_CONSUME_GP = 4
  C_PC_TINY = 2
  C_PC_SMALL = 2
  C_PC_COMPACT = 10
  C_PC_MEDIUM = 14
  C_PC_LARGE = 6
  C_PC_HUGE = 6
  C_PC_FLAT = 3
  SETCOMP_OVERRIDE = 1
may override old compiler info
  SETCOMP_ONLY_ID = 2
cc has only 'id' field the rest will be set to defaults corresponding to the program bitness
  SETCOMP_ONLY_ABI = 4
ignore cc field complete, use only abiname
  SETCOMP_BY_USER = 8
invoked by user, cannot be replaced by module/loader
  MAX_FUNC_ARGS = 256
max number of function arguments
  abs_unk = 0
  abs_no = 1
  abs_yes = 2
  sc_unk = 0
  sc_type = 1
  sc_ext = 2
  sc_stat = 3
  sc_reg = 4
  sc_auto = 5
  sc_friend = 6
  sc_virt = 7
  HTI_CPP = 1
C++ mode (not implemented)
  HTI_INT = 2
debug: print internal representation of types
  HTI_EXT = 4
debug: print external representation of types
  HTI_LEX = 8
debug: print tokens
  HTI_UNP = 16
debug: check the result by unpacking it
  HTI_TST = 32
test mode: discard the result
  HTI_FIL = 64
otherwise "input" contains a C declaration
  HTI_MAC = 128
define macros from the base tils
  HTI_NWR = 256
no warning messages
  HTI_NER = 512
ignore all errors but display them
  HTI_DCL = 1024
don't complain about redeclarations
  HTI_NDC = 2048
don't decorate names
  HTI_PAK = 28672
explicit structure pack value (#pragma pack)
  HTI_PAK_SHIFT = 12
shift for 'HTI_PAK' .
  HTI_PAKDEF = 0
default pack value
  HTI_PAK1 = 4096
#pragma pack(1)
  HTI_PAK2 = 8192
#pragma pack(2)
  HTI_PAK4 = 12288
#pragma pack(4)
  HTI_PAK8 = 16384
#pragma pack(8)
  HTI_PAK16 = 20480
#pragma pack(16)
  HTI_HIGH = 32768
(with hidden args, etc)
  HTI_LOWER = 65536
lower the function prototypes
  HTI_RAWARGS = 131072
leave argument names unchanged (do not remove underscores)
  PT_SIL = 1
silent, no messages
  PT_NDC = 2
don't decorate names
  PT_TYP = 4
return declared type information
  PT_VAR = 8
return declared object information
  PT_PACKMASK = 112
mask for pack alignment values
  PT_HIGH = 128
(with hidden args, etc)
  PT_LOWER = 256
lower the function prototypes
  PT_REPLACE = 512
replace the old type (used in idc)
  PT_RAWARGS = 1024
leave argument names unchanged (do not remove underscores)
  PRTYPE_1LINE = 0
print to one line
  PRTYPE_MULTI = 1
print to many lines
  PRTYPE_TYPE = 2
print type declaration (not variable declaration)
  PRTYPE_PRAGMA = 4
print pragmas for alignment
  PRTYPE_SEMI = 8
append ; to the end
  PRTYPE_CPP = 16
use c++ name (only for 'print_type()' )
  PRTYPE_DEF = 32
'tinfo_t' : print definition, if available
  PRTYPE_NOARGS = 64
'tinfo_t' : do not print function argument names
  PRTYPE_NOARRS = 128
'tinfo_t' : print arguments with 'FAI_ARRAY' as pointers
  PRTYPE_NORES = 256
'tinfo_t' : never resolve types (meaningful with PRTYPE_DEF)
  PRTYPE_RESTORE = 512
'tinfo_t' : print restored types for 'FAI_ARRAY' and 'FAI_STRUCT'
  NTF_TYPE = 1
type name
  NTF_SYMU = 8
symbol, name is unmangled ('func')
  NTF_SYMM = 0
only one of 'NTF_TYPE' and 'NTF_SYMU' , 'NTF_SYMM' can be used
  NTF_NOBASE = 2
don't inspect base tils (for get_named_type)
  NTF_REPLACE = 4
replace original type (for set_named_type)
  NTF_UMANGLED = 8
name is unmangled (don't use this flag)
  NTF_NOCUR = 32
don't inspect current til file (for get_named_type)
  NTF_64BIT = 64
value is 64bit
  NTF_FIXNAME = 128
(set_named_type, set_numbered_type only)
  NTF_IDBENC = 256
the name is given in the IDB encoding; non-ASCII bytes will be decoded accordingly (set_named_type, set_numbered_type only)
  NTF_CHKSYNC = 512
(set_numbered_type, set_named_type)
  TERR_OK = 0
  TERR_SAVE = -1
  TERR_SERIALIZE = -2
  TERR_WRONGNAME = -3
  TERR_BADSYNC = -4
  CCN_C = 0
  CCN_CPP = 1
  IMPTYPE_VERBOSE = 1
more verbose output (dialog boxes may appear)
  IMPTYPE_OVERRIDE = 2
override existing type
  IMPTYPE_LOCAL = 4
the type is local, the struct/enum won't be marked as til type.
  ADDTIL_DEFAULT = 0
default behavior
  ADDTIL_INCOMP = 1
load incompatible tils
  ADDTIL_SILENT = 2
do not ask any questions
  ADDTIL_FAILED = 0
something bad, the warning is displayed
  ADDTIL_OK = 1
ok, til is loaded
  ADDTIL_COMP = 2
ok, but til is not compatible with the current compiler
  ADDTIL_ABORTED = 3
til was not loaded (incompatible til rejected by user)
  TINFO_GUESSED = 0
this is a guessed type
  TINFO_DEFINITE = 1
this is a definite type
  TINFO_DELAYFUNC = 2
if type is a function and no function exists at ea, schedule its creation and argument renaming to auto-analysis otherwise try to create it immediately
  TINFO_STRICT = 4
never convert given type to another one before applying
  GUESS_FUNC_FAILED = 0
couldn't guess the function type
  GUESS_FUNC_TRIVIAL = 1
the function type doesn't have interesting info
  GUESS_FUNC_OK = 2
ok, some non-trivial information is gathered
  STI_PCHAR = 0
  STI_PUCHAR = 1
  STI_PCCHAR = 2
  STI_PCUCHAR = 3
  STI_PBYTE = 4
  STI_PINT = 5
  STI_PUINT = 6
  STI_PVOID = 7
  STI_PPVOID = 8
  STI_PCVOID = 9
  STI_ACHAR = 10
  STI_AUCHAR = 11
  STI_ACCHAR = 12
  STI_ACUCHAR = 13
  STI_FPURGING = 14
  STI_FDELOP = 15
  STI_MSGSEND = 16
  STI_AEABI_LCMP = 17
  STI_AEABI_ULCMP = 18
  STI_DONT_USE = 19
  STI_SIZE_T = 20
  STI_SSIZE_T = 21
  STI_AEABI_MEMCPY = 22
  STI_AEABI_MEMSET = 23
  STI_AEABI_MEMCLR = 24
  STI_RTC_CHECK_2 = 25
  STI_RTC_CHECK_4 = 26
  STI_RTC_CHECK_8 = 27
  STI_LAST = 28
  GTD_CALC_LAYOUT = 0
  GTD_NO_LAYOUT = 128
  GTD_DEL_BITFLDS = 64
  GTD_CALC_ARGLOCS = 0
  GTD_NO_ARGLOCS = 128
  GTS_NESTED = 1
  GTS_BASECLASS = 2
  SUDT_SORT = 1
fields are not sorted by offset, sort them first
  SUDT_ALIGN = 2
to match the offsets and size info
  SUDT_GAPS = 4
allow to fill gaps with additional members (_BYTE[])
  SUDT_UNEX = 8
references to nonexistent member types are acceptable in this case it is better to set the corresponding 'udt_member_t::fda' field to the type alignment.
  SUDT_FAST = 16
serialize without verifying offsets and alignments
  SUDT_CONST = 64
only for serialize_udt: make type const
  SUDT_VOLATILE = 128
only for serialize_udt: make type volatile
  SUDT_TRUNC = 256
serialize: truncate useless strings from fields, fldcmts
  COMP_MASK = 15
  COMP_UNK = 0
  COMP_MS = 1
  COMP_BC = 2
  COMP_WATCOM = 3
  COMP_GNU = 6
  COMP_VISAGE = 7
  COMP_BP = 8
  COMP_UNSURE = 128
  BADSIZE = 18446744073709551615
  BADORD = 4294967295
  FIRST_NONTRIVIAL_TYPID = 256
  TYPID_ISREF = 256
  TYPID_SHIFT = 9
  STRMEM_MASK = 7
  STRMEM_OFFSET = 0
get member by offset- in: udm->offset - is a member offset in bits
  STRMEM_INDEX = 1
get member by number- in: udm->offset - is a member number
  STRMEM_AUTO = 2
get member by offset if struct, or get member by index if union - nb: union: index is stored in the udm->offset field!nb: struct: offset is in bytes (not in bits)!
  STRMEM_NAME = 3
get member by name- in: udm->name - the desired member name.
  STRMEM_TYPE = 4
get member by type.
  STRMEM_SIZE = 5
get member by size.- in: udm->size - the desired member size.
  STRMEM_MINS = 6
get smallest member by size.
  STRMEM_MAXS = 7
get biggest member by size.
  STRMEM_VFTABLE = 268435456
can be combined with 'STRMEM_OFFSET' , 'STRMEM_AUTO' get vftable instead of the base class
  STRMEM_SKIP_EMPTY = 536870912
can be combined with 'STRMEM_OFFSET' , 'STRMEM_AUTO' skip empty members (i.e.
  STRMEM_CASTABLE_TO = 1073741824
can be combined with 'STRMEM_TYPE' : member type must be castable to the specified type
  STRMEM_ANON = -2147483648
can be combined with 'STRMEM_NAME' : look inside anonymous members too.
  TCMP_EQUAL = 0
are types equal?
  TCMP_IGNMODS = 1
ignore const/volatile modifiers
  TCMP_AUTOCAST = 2
can t1 be cast into t2 automatically?
  TCMP_MANCAST = 4
can t1 be cast into t2 manually?
  TCMP_CALL = 8
can t1 be called with t2 type?
  TCMP_DELPTR = 16
remove pointer from types before comparing
  TCMP_DECL = 32
compare declarations without resolving them
  TCMP_ANYBASE = 64
accept any base class when casting
  TCMP_SKIPTHIS = 128
skip the first function argument in comparison
  FAI_HIDDEN = 1
hidden argument
  FAI_RETPTR = 2
pointer to return value.
  FAI_STRUCT = 4
was initially a structure
  FAI_ARRAY = 8
was initially an array see "__org_typedef" or "__org_arrdim" type attributes to determine the original type
  TA_ORG_TYPEDEF = '__org_typedef'
the original typedef name (simple string)
  TA_ORG_ARRDIM = '__org_arrdim'
the original array dimension (pack_dd)
  TA_FORMAT = 'format'
info about the 'format' argument 3 times pack_dd: 'format_functype_t' , argument number of 'format', argument number of '...'
  FTI_SPOILED = 1
information about spoiled registers is present
  FTI_NORET = 2
noreturn
  FTI_PURE = 4
__pure
  FTI_HIGH = 8
high level prototype (with possibly hidden args)
  FTI_STATIC = 16
static
  FTI_VIRTUAL = 32
virtual
  FTI_CALLTYPE = 192
mask for FTI_*CALL
  FTI_DEFCALL = 0
default call
  FTI_NEARCALL = 64
near call
  FTI_FARCALL = 128
far call
  FTI_INTCALL = 192
interrupt call
  FTI_ARGLOCS = 256
(stkargs and retloc too)
  FTI_ALL = 511
all defined bits
  CC_CDECL_OK = 1
can use __cdecl calling convention?
  CC_ALLOW_ARGPERM = 2
disregard argument order?
  CC_ALLOW_REGHOLES = 4
allow holes in register argument list?
  CC_HAS_ELLIPSIS = 8
function has a variable list of arguments?
  FMTFUNC_PRINTF = 0
  FMTFUNC_SCANF = 1
  FMTFUNC_STRFTIME = 2
  FMTFUNC_STRFMON = 3
  VTBL_SUFFIX = '_vtbl'
  VTBL_MEMNAME = '__vftable'
  TVIS_TYPE = 1
new type info is present
  TVIS_NAME = 2
new name is present
  TVIS_CMT = 4
new comment is present
  TVST_PRUNE = 1
don't visit children of current type
  TVST_DEF = 2
visit type definition (meaningful for typerefs)
  TVST_LEVEL = 4
  PIO_NOATTR_FAIL = 4
missing attributes are not ok
  PIO_IGNORE_PTRS = 8
do not follow pointers
  UTP_ENUM = 0
  UTP_STRUCT = 1
  VALSTR_OPEN = 1
printed opening curly brace '{'
  PDF_INCL_DEPS = 1
Include all type dependencies.
  PDF_DEF_FWD = 2
Allow forward declarations.
  PDF_DEF_BASE = 4
Include base types: __int8, __int16, etc..
  PDF_HEADER_CMT = 8
Prepend output with a descriptive comment.
  PCN_RADIX = 7
number base to use
  PCN_DEC = 0
decimal
  PCN_HEX = 1
hexadecimal
  PCN_OCT = 2
octal
  PCN_CHR = 3
character
  PCN_UNSIGNED = 8
add 'u' suffix
  PCN_LZHEX = 16
print leading zeroes for hexdecimal number
  PCN_NEGSIGN = 32
print negated value (-N) for negative numbers
  PCN_DECSEXT = 64
automatically extend sign of signed decimal numbers
  __package__ = None
Function Details

is_type_const(t)

 

See 'BTM_CONST' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_volatile(t)

 

See 'BTM_VOLATILE' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

get_base_type(t)

 

Get get basic type bits ( 'TYPE_BASE_MASK' )

Parameters:
  • t, (C++ - type_t)
Returns: type_t

get_type_flags(t)

 

Get type flags ( 'TYPE_FLAGS_MASK' )

Parameters:
  • t, (C++ - type_t)
Returns: type_t

get_full_type(t)

 

Get basic type bits + type flags ( 'TYPE_FULL_MASK' )

Parameters:
  • t, (C++ - type_t)
Returns: type_t

is_typeid_last(t)

 

Is the type_t the last byte of type declaration? (there are no additional bytes after a basic type, see '_BT_LAST_BASIC' )

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_partial(t)

 

Identifies an unknown or void type with a known size (see 'Basic type: unknown & void' )

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_void(t)

 

See 'BTF_VOID' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_unknown(t)

 

See 'BT_UNKNOWN' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_ptr(t)

 

See 'BT_PTR' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_complex(t)

 

See 'BT_COMPLEX' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_func(t)

 

See 'BT_FUNC' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_array(t)

 

See 'BT_ARRAY' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_typedef(t)

 

See 'BTF_TYPEDEF' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_sue(t)

 

Is the type a struct/union/enum?

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_struct(t)

 

See 'BTF_STRUCT' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_union(t)

 

See 'BTF_UNION' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_struni(t)

 

Is the type a struct or union?

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_enum(t)

 

See 'BTF_ENUM' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_bitfld(t)

 

See 'BT_BITFIELD' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_int(bt)

 

Does the type_t specify one of the basic types in 'Basic type: integer' ?

Parameters:
  • bt, (C++ - type_t)
Returns: bool

is_type_int128(t)

 

Does the type specify a 128-bit value? (signed or unsigned, see 'Basic type: integer' )

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_int64(t)

 

Does the type specify a 64-bit value? (signed or unsigned, see 'Basic type: integer' )

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_int32(t)

 

Does the type specify a 32-bit value? (signed or unsigned, see 'Basic type: integer' )

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_int16(t)

 

Does the type specify a 16-bit value? (signed or unsigned, see 'Basic type: integer' )

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_char(t)

 

Does the type specify a char value? (signed or unsigned, see 'Basic type: integer' )

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_paf(t)

 

Is the type a pointer, array, or function type?

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_ptr_or_array(t)

 

Is the type a pointer or array type?

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_floating(t)

 

Is the type a floating point type?

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_integral(t)

 

Is the type an integral type (char/short/int/long/bool)?

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_ext_integral(t)

 

Is the type an extended integral type? (integral or enum)

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_arithmetic(t)

 

Is the type an arithmetic type? (floating or integral)

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_ext_arithmetic(t)

 

Is the type an extended arithmetic type? (arithmetic or enum)

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_uint(t)

 

See 'BTF_UINT' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_uchar(t)

 

See 'BTF_UCHAR' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_uint16(t)

 

See 'BTF_UINT16' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_uint32(t)

 

See 'BTF_UINT32' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_uint64(t)

 

See 'BTF_UINT64' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_uint128(t)

 

See 'BTF_UINT128' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_ldouble(t)

 

See 'BTF_LDOUBLE' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_double(t)

 

See 'BTF_DOUBLE' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_float(t)

 

See 'BTF_FLOAT' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_tbyte(t)

 

See 'BTF_FLOAT' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_type_bool(t)

 

See 'BTF_BOOL' .

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_tah_byte(t)

 

The TAH byte (type attribute header byte) denotes the start of type attributes. (see "tah-typeattrs" in the type bit definitions)

Parameters:
  • t, (C++ - type_t)
Returns: bool

is_sdacl_byte(t)

 

Identify an sdacl byte. The first sdacl byte has the following format: 11xx000x. The sdacl bytes are appended to udt fields. They indicate the start of type attributes (as the tah-bytes do). The sdacl bytes are used in the udt headers instead of the tah-byte. This is done for compatibility with old databases, they were already using sdacl bytes in udt headers and as udt field postfixes. (see "sdacl-typeattrs" in the type bit definitions)

Parameters:
  • t, (C++ - type_t)
Returns: bool

append_argloc(out, vloc)

 

Serialize argument location.

Parameters:
  • out, (C++ - qtype *)
  • vloc, (C++ - const argloc_t &)
Returns: bool

extract_argloc(vloc, ptype, is_retval)

 

Deserialize argument location.

Parameters:
  • vloc, (C++ - argloc_t *)
  • ptype, (C++ - const type_t **)
  • is_retval, (C++ - bool)
Returns: bool

new_til(name, desc)

 

Initialize a til.

Parameters:
  • name, (C++ - const char *)
  • desc, (C++ - const char *)
Returns: til_t

compact_til(ti)

 

Collect garbage in til. Must be called before storing the til.

Parameters:
  • ti, (C++ - til_t *)
Returns: bool
true if any memory was freed

store_til(ti, tildir, name)

 

Store til to a file. If the til contains garbage, it will be collected before storing the til. Your plugin should call 'compact_til()' before calling 'store_til()' .

Parameters:
  • ti - type library to store (C++: til_t *)
  • tildir - directory where to store the til. NULL means current directory. (C++: const char *)
  • name - filename of the til. If it's an absolute path, tildir is ignored. NB: the file extension is forced to .til (C++: const char *)
Returns: bool
success

free_til(ti)

 

Free memory allocated by til.

Parameters:
  • ti, (C++ - til_t *)

is_code_far(cm)

 

Does the given model specify far code?.

Parameters:
  • cm, (C++ - cm_t)
Returns: bool

is_data_far(cm)

 

Does the given model specify far data?.

Parameters:
  • cm, (C++ - cm_t)
Returns: bool

verify_argloc(vloc, size, gaps)

 

Verify 'argloc_t' .

Parameters:
  • vloc, (C++ - const argloc_t &)
  • size - total size of the variable (C++: int)
  • gaps - if not NULL, specifies gaps in structure definition. these gaps should not map to any argloc, but everything else must be covered (C++: const rangeset_t *)
Returns: int
0 if ok, otherwise an interr code.

optimize_argloc(vloc, size, gaps)

 

Verify and optimize scattered argloc into simple form. All new arglocs must be processed by this function.

Parameters:
  • vloc, (C++ - argloc_t *)
  • size, (C++ - int)
  • gaps, (C++ - const rangeset_t *)
Returns: bool

print_argloc(vloc, size=0, vflags=0)

 

Convert an argloc to human readable form.

Parameters:
  • vloc, (C++ - const argloc_t &)
  • size, (C++ - int)
  • vflags, (C++ - int)
Returns: size_t

for_all_arglocs(vv, vloc, size, off=0)

 

Compress larger argloc types and initiate the aloc visitor.

Parameters:
  • vv, (C++ - aloc_visitor_t &)
  • vloc, (C++ - argloc_t &)
  • size, (C++ - int)
  • off, (C++ - int)
Returns: int

for_all_const_arglocs(vv, vloc, size, off=0)

 

See 'for_all_arglocs()'

Parameters:
  • vv, (C++ - const_aloc_visitor_t &)
  • vloc, (C++ - const argloc_t &)
  • size, (C++ - int)
  • off, (C++ - int)
Returns: int

is_user_cc(cm)

 

Does the calling convention specify argument locations explicitly?

Parameters:
  • cm, (C++ - cm_t)
Returns: bool

is_vararg_cc(cm)

 

Does the calling convention use ellipsis?

Parameters:
  • cm, (C++ - cm_t)
Returns: bool

is_purging_cc(cm)

 

Does the calling convention clean the stack arguments upon return?.this function is valid only for x86 code

Parameters:
  • cm, (C++ - cm_t)
Returns: bool

get_comp(comp)

 

Get compiler bits.

Parameters:
  • comp, (C++ - comp_t)
Returns: comp_t

get_compiler_name(id)

 

Get full compiler name.

Parameters:
  • id, (C++ - comp_t)
Returns: char const *

get_compiler_abbr(id)

 

Get abbreviated compiler name.

Parameters:
  • id, (C++ - comp_t)
Returns: char const *

get_compilers(ids, names, abbrs)

 

Get names of all built-in compilers.

Parameters:
  • ids, (C++ - compvec_t *)
  • names, (C++ - qstrvec_t *)
  • abbrs, (C++ - qstrvec_t *)

is_comp_unsure(comp)

 

See 'COMP_UNSURE' .

Parameters:
  • comp, (C++ - comp_t)
Returns: comp_t

set_compiler(cc, flags, abiname=None)

 

Change current compiler.

Parameters:
  • cc - compiler to switch to (C++: const compiler_info_t &)
  • flags - Set compiler flags (C++: int)
  • abiname - ABI name (C++: const char *)
Returns: bool
success

set_compiler_id(id, abiname=None)

 

Set the compiler id (see 'Compiler IDs' )

Parameters:
  • id, (C++ - comp_t)
  • abiname, (C++ - const char *)
Returns: bool

set_abi_name(abiname, user_level=False)

 

Set abi name (see 'Compiler IDs' )

Parameters:
  • abiname, (C++ - const char *)
  • user_level, (C++ - bool)
Returns: bool

get_abi_name()

 

Get ABI name.

Returns: ssize_t
length of the name (>=0)

append_abi_opts(abi_opts, user_level=False)

 

Add/remove/check ABI option General form of full abi name: abiname- opt1-opt2-... or -opt1-opt2-...

Parameters:
  • abi_opts - - ABI options to add/remove in form opt1-opt2-... (C++: const char *)
  • user_level - - initiated by user if TRUE (==SETCOMP_BY_USER) (C++: bool)
Returns: bool
success

parse_decl(tif, til, decl, flags)

 

Parse ONE declaration. If the input string contains more than one declaration, the first complete type declaration ( 'PT_TYP' ) or the last variable declaration ( 'PT_VAR' ) will be used.name & tif may be empty after the call!

Parameters:
  • tif - type info (C++: tinfo_t *)
  • til - type library to use. may be NULL (C++: til_t *)
  • decl - C declaration to parse (C++: const char *)
  • flags - combination of Type parsing flags bits (C++: int)
Returns: bool

convert_pt_flags_to_hti(pt_flags)

 

Convert 'Type parsing flags' to 'Type formatting flags' . Type parsing flags lesser than 0x10 don't have stable meaning and will be ignored (more on these flags can be seen in idc.idc)

Parameters:
  • pt_flags, (C++ - int)
Returns: int

parse_decls(til, input, printer, hti_flags)

 

Parse many declarations and store them in a til. If there are any errors, they will be printed using 'printer'. This function uses default include path and predefined macros from the database settings. It always uses the 'HTI_DCL' bit.

Parameters:
  • til - type library to store the result (C++: til_t *)
  • input - input string or file name (see hti_flags) (C++: const char *)
  • printer - function to output error messages (use msg or NULL or your own callback) (C++: printer_t *)
  • hti_flags - combination of Type formatting flags (C++: int)
Returns: int
number of errors, 0 means ok.

print_type(ea, prtype_flags)

 

Get type declaration for the specified address.

Parameters:
  • ea - address (C++: ea_t)
  • prtype_flags - combination of Type printing flags (C++: int)
Returns: bool
success

del_named_type(ti, name, ntf_flags)

 

Delete information about a symbol.

Parameters:
  • ti - type library (C++: til_t *)
  • name - name of symbol (C++: const char *)
  • ntf_flags - combination of Flags for named types (C++: int)
Returns: bool
success

first_named_type(ti, ntf_flags)

 

Enumerate types. Returns mangled names. Never returns anonymous types. To include it, enumerate types by ordinals.

Parameters:
  • ti, (C++ - const til_t *)
  • ntf_flags, (C++ - int)
Returns: char const *

next_named_type(ti, name, ntf_flags)

 

Enumerate types. Returns mangled names. Never returns anonymous types. To include it, enumerate types by ordinals.

Parameters:
  • ti, (C++ - const til_t *)
  • name, (C++ - const char *)
  • ntf_flags, (C++ - int)
Returns: char const *

copy_named_type(dsttil, srctil, name)

 

Copy a named type from one til to another. This function will copy the specified type and all dependent types from the source type library to the destination library.

Parameters:
  • dsttil - Destination til. It must have orginal types enabled (C++: til_t *)
  • srctil - Source til. (C++: const til_t *)
  • name - name of the type to copy (C++: const char *)
Returns: uint32
ordinal number of the copied type. 0 means error

gen_decorate_name(name, mangle, cc, type)

 

Generic function for 'decorate_name()' (may be used in IDP modules)

Parameters:
  • name, (C++ - const char *)
  • mangle, (C++ - bool)
  • cc, (C++ - cm_t)
  • type, (C++ - const tinfo_t *)
Returns: bool

calc_c_cpp_name(name, type, ccn_flags)

 

Get C or C++ form of the name.

Parameters:
  • name - original (mangled or decorated) name (C++: const char *)
  • type - name type if known, otherwise NULL (C++: const tinfo_t *)
  • ccn_flags - one of C/C++ naming flags (C++: int)
Returns: ssize_t

alloc_type_ordinals(ti, qty)

 

Allocate a range of ordinal numbers for new types.

Parameters:
  • ti - type library (C++: til_t *)
  • qty - number of ordinals to allocate (C++: int)
Returns: uint32
the first ordinal. 0 means failure.

alloc_type_ordinal(ti)

 

\call2{alloc_type_ordinals,ti,1}

Parameters:
  • ti, (C++ - til_t *)
Returns: uint32

get_ordinal_qty(ti)

 

Get number of allocated ordinals.

Parameters:
  • ti, (C++ - const til_t *)
Returns: uint32
uint32(-1) if failed

set_numbered_type(ti, ordinal, ntf_flags, name, type, fields=None, cmt=None, fldcmts=None, sclass=None)

 

Store a type in the til. 'name' may be NULL for anonymous types. The specified ordinal must be free (no other type is using it). For ntf_flags, only 'NTF_REPLACE' is consulted.

Parameters:
  • ti, (C++ - til_t *)
  • ordinal, (C++ - uint32)
  • ntf_flags, (C++ - int)
  • name, (C++ - const char *)
  • type, (C++ - const type_t *)
  • fields, (C++ - const p_list *)
  • cmt, (C++ - const char *)
  • fldcmts, (C++ - const p_list *)
  • sclass, (C++ - const sclass_t *)
Returns: tinfo_code_t

del_numbered_type(ti, ordinal)

 

Delete a numbered type.

Parameters:
  • ti, (C++ - til_t *)
  • ordinal, (C++ - uint32)
Returns: bool

set_type_alias(ti, src_ordinal, dst_ordinal)

 

Create a type alias. Redirects all references to source type to the destination type. This is equivalent to instantaneous replacement all reference to srctype by dsttype.

Parameters:
  • ti, (C++ - til_t *)
  • src_ordinal, (C++ - uint32)
  • dst_ordinal, (C++ - uint32)
Returns: bool

get_alias_target(ti, ordinal)

 

Find the final alias destination. If the ordinal has not been aliased, return the specified ordinal itself If failed, returns 0.

Parameters:
  • ti, (C++ - const til_t *)
  • ordinal, (C++ - uint32)
Returns: uint32

get_type_ordinal(ti, name)

 

Get type ordinal by its name.

Parameters:
  • ti, (C++ - const til_t *)
  • name, (C++ - const char *)
Returns: int32

get_numbered_type_name(ti, ordinal)

 

Get type name (if exists) by its ordinal. If the type is anonymous, returns "". If failed, returns NULL

Parameters:
  • ti, (C++ - const til_t *)
  • ordinal, (C++ - uint32)
Returns: char const *

create_numbered_type_name(ord)

 

Create anonymous name for numbered type. This name can be used to reference a numbered type by its ordinal Ordinal names have the following format: '#' + set_de(ord) Returns: -1 if error, otherwise the name length

Parameters:
  • ord, (C++ - int32)
Returns: ssize_t

is_ordinal_name(name, ord=None)

 

Check if the name is an ordinal name. Ordinal names have the following format: '#' + set_de(ord)

Parameters:
  • name, (C++ - const char *)
  • ord, (C++ - uint32 *)
Returns: bool

get_ordinal_from_idb_type(name, type)

 

Get ordinal number of an idb type (struct/enum). The 'type' parameter is used only to determine the kind of the type (struct or enum) Use this function to find out the correspondence between idb types and til types

Parameters:
  • name, (C++ - const char *)
  • type, (C++ - const type_t *)
Returns: int

is_autosync(name, type)

 
  is_autosync(name, tif) -> bool


Is the specified idb type automatically synchronized?


@param name (C++: const char *)
@param type (C++: const  type_t  *)
  

Returns: bool

deref_ptr(ptr_ea, tif, closure_obj=None)

 

Dereference a pointer.

Parameters:
  • ptr_ea - in/out parameter in: address of the pointer out: the pointed address (C++: ea_t *)
  • tif - type of the pointer (C++: const tinfo_t &)
  • closure_obj - closure object (not used yet) (C++: ea_t *)
Returns: bool
success

import_type(til, idx, name, flags=0)

 

Copy a named type from til to idb.

Parameters:
  • til - type library (C++: const til_t *)
  • idx - the position of the new type in the list of types (structures or enums). -1 means at the end of the list (C++: int)
  • name - the type name (C++: const char *)
  • flags - combination of Import type flags (C++: int)
Returns: tid_t
BADNODE on error

add_til(name, flags)

 

Load a til file.

Parameters:
  • name - til name (C++: const char *)
  • flags - combination of Load TIL flags (C++: int)
Returns: int
one of Load TIL result codes

del_til(name)

 

Unload a til file.

Parameters:
  • name, (C++ - const char *)
Returns: bool

apply_named_type(ea, name)

 

Apply the specified named type to the address.

Parameters:
  • ea - linear address (C++: ea_t)
  • name - the type name, e.g. "FILE" (C++: const char *)
Returns: bool
success

apply_tinfo(ea, tif, flags)

 

Apply the specified type to the specified address. This function sets the type and tries to convert the item at the specified address to conform the type.

Parameters:
  • ea - linear address (C++: ea_t)
  • tif - type string in internal format (C++: const tinfo_t &)
  • flags - combination of Apply tinfo flags (C++: uint32)
Returns: bool
success

apply_cdecl(til, ea, decl, flags=0)

 

Apply the specified type to the address. This function parses the declaration and calls 'apply_tinfo()'

Parameters:
  • til - type library (C++: til_t *)
  • ea - linear address (C++: ea_t)
  • decl - type declaration in C form (C++: const char *)
  • flags - flags to pass to apply_tinfo ( TINFO_DEFINITE is always passed) (C++: int)
Returns: bool
success

apply_callee_tinfo(caller, tif)

 

Apply the type of the called function to the calling instruction. This function will append parameter comments and rename the local variables of the calling function. It also stores information about the instructions that initialize call arguments in the database. Use 'get_arg_addrs()' to retrieve it if necessary. Alternatively it is possible to hook to processor_t::arg_addrs_ready event.

Parameters:
  • caller - linear address of the calling instruction. must belong to a function. (C++: ea_t)
  • tif - type info (C++: const tinfo_t &)
Returns: bool
success

apply_once_tinfo_and_name(dea, tif, name)

 

Apply the specified type and name to the address. This function checks if the address already has a type. If the old typedoes not exist or the new type is 'better' than the old type, then thenew type will be applied. A type is considered better if it has moreinformation (e.g. 'BTMT_STRUCT' is better than 'BT_INT' ).The same logic is with the name: if the address already have a meaningfulname, it will be preserved. Only if the old name does not exist or itis a dummy name like byte_123, it will be replaced by the new name.

Parameters:
  • dea - linear address (C++: ea_t)
  • tif - type string in the internal format (C++: const tinfo_t &)
  • name - new name for the address (C++: const char *)
Returns: bool
success

guess_tinfo(tif, id)

 

Generate a type information about the id from the disassembly. id can be a structure/union/enum id or an address.

Parameters:
  • tif, (C++ - tinfo_t *)
  • id, (C++ - tid_t)
Returns: int
one of Guess tinfo codes

set_c_header_path(incdir)

 

Set include directory path the target compiler.

Parameters:
  • incdir, (C++ - const char *)

set_c_macros(macros)

 

Set predefined macros for the target compiler.

Parameters:
  • macros, (C++ - const char *)

get_idainfo_by_type(tif)

 

Extract information from a 'tinfo_t' .

Parameters:
  • tif - the type to inspect (C++: const tinfo_t &)
Returns: bool

remove_pointer(tif)

 
 'BT_PTR' : If the current type is a pointer, return the pointed
object. If the current type is not a pointer, return the current type.
See also get_ptrarr_object() and get_pointed_object()

@param tif (C++: const  tinfo_t  &)

Returns: tinfo_t

guess_func_cc(fti, npurged, cc_flags)

 

Use 'func_type_data_t::guess_cc()'

Parameters:
  • fti, (C++ - const func_type_data_t &)
  • npurged, (C++ - int)
  • cc_flags, (C++ - int)
Returns: cm_t

dump_func_type_data(fti, praloc_bits)

 

Use 'func_type_data_t::dump()'

Parameters:
  • fti, (C++ - const func_type_data_t &)
  • praloc_bits, (C++ - int)
Returns: bool

unpack_idcobj_from_idb(obj, tif, ea, off0, pio_flags=0)

 

Collection of register objects.

Read a typed idc object from the database

Parameters:
  • obj, (C++ - idc_value_t *)
  • tif, (C++ - const tinfo_t &)
  • ea, (C++ - ea_t)
  • off0, (C++ - const bytevec_t *)
  • pio_flags, (C++ - int)
Returns: error_t

unpack_idcobj_from_bv(obj, tif, bytes, pio_flags=0)

 

Read a typed idc object from the byte vector.

Parameters:
  • obj, (C++ - idc_value_t *)
  • tif, (C++ - const tinfo_t &)
  • bytes, (C++ - const bytevec_t &)
  • pio_flags, (C++ - int)
Returns: error_t

pack_idcobj_to_idb(obj, tif, ea, pio_flags=0)

 

Write a typed idc object to the database.

Parameters:
  • obj, (C++ - const idc_value_t *)
  • tif, (C++ - const tinfo_t &)
  • ea, (C++ - ea_t)
  • pio_flags, (C++ - int)
Returns: error_t

pack_idcobj_to_bv(obj, tif, bytes, objoff, pio_flags=0)

 

Write a typed idc object to the byte vector. Byte vector may be non- empty, this function will append data to it

Parameters:
  • obj, (C++ - const idc_value_t *)
  • tif, (C++ - const tinfo_t &)
  • bytes, (C++ - relobj_t *)
  • objoff, (C++ - void *)
  • pio_flags, (C++ - int)
Returns: error_t

apply_tinfo_to_stkarg(insn, x, v, tif, name)

 

Helper function for the processor modules. to be called from \ph{use_stkarg_type}

Parameters:
  • insn, (C++ - const insn_t &)
  • x, (C++ - const op_t &)
  • v, (C++ - uval_t)
  • tif, (C++ - const tinfo_t &)
  • name, (C++ - const char *)
Returns: bool

gen_use_arg_tinfos(caller, fti, rargs, set_optype, is_stkarg_load, has_delay_slot)

 

The main function using these callbacks:

Parameters:
  • caller, (C++ - ea_t)
  • fti, (C++ - func_type_data_t *)
  • rargs, (C++ - funcargvec_t *)
  • set_optype, (C++ - set_op_tinfo_t *)
  • is_stkarg_load, (C++ - is_stkarg_load_t *)
  • has_delay_slot, (C++ - has_delay_slot_t *)

func_has_stkframe_hole(ea, fti)

 

Looks for a hole at the beginning of the stack arguments. Will make use of the IDB's 'func_t' function at that place (if present) to help determine the presence of such a hole.

Parameters:
  • ea, (C++ - ea_t)
  • fti, (C++ - const func_type_data_t &)
Returns: bool

lower_type(til, tif, name=None, _helper=None)

 

Lower type. Inspect the type and lower all function subtypes using lower_func_type().We call the prototypes usually encountered in source files "high level"They may have implicit arguments, array arguments, big structure retvals, etcWe introduce explicit arguments (i.e. 'this' pointer) and call the result"low level prototype". See 'FTI_HIGH' .In order to improve heuristics for recognition of big structure retvals,it is recommended to pass a helper that will be used to make decisions.That helper will be used only for lowering 'tif', and not for the childrentypes walked through by recursion.

Parameters:
  • til, (C++ - til_t *)
  • tif, (C++ - tinfo_t *)
  • name, (C++ - const char *)
  • _helper, (C++ - lowertype_helper_t *)
Returns: int

replace_ordinal_typerefs(til, tif)

 

Replace references to ordinal types by name references. This function 'unties' the type from the current local type library and makes it easier to export it.

Parameters:
  • til - type library to use. may be NULL. (C++: til_t *)
  • tif - type to modify (in/out) (C++: tinfo_t *)
Returns: int

begin_type_updating(utp)

 

Mark the beginning of a large update operation on the types. Can be used with 'add_enum_member()' , add_struc_member, etc... Also see 'end_type_updating()'

Parameters:
  • utp, (C++ - update_type_t)

end_type_updating(utp)

 

Mark the end of a large update operation on the types (see 'begin_type_updating()' )

Parameters:
  • utp, (C++ - update_type_t)

calc_number_of_children(loc, tif, dont_deref_ptr=False)

 

Calculate max number of lines of a formatted c data, when expanded ( 'PTV_EXPAND' ).

Parameters:
  • loc - location of the data ( ALOC_STATIC or ALOC_CUSTOM ) (C++: const argloc_t &)
  • tif - type info (C++: const tinfo_t &)
  • dont_deref_ptr - consider 'ea' as the ptr value (C++: bool)
Returns: int

get_enum_member_expr(tif, serial, value)

 

Return a C expression that can be used to represent an enum member. If the value does not correspond to any single enum member, this function tries to find a bitwise combination of enum members that correspond to it. If more than half of value bits do not match any enum members, it fails.

Parameters:
  • tif - enumeration type (C++: const tinfo_t &)
  • serial - which enumeration member to use (0 means the first with the given value) (C++: int)
  • value - value to search in the enumeration type. only 32-bit number can be handled yet (C++: uint64)
Returns: bool
success

choose_named_type(out_sym, root_til, title, ntf_flags, predicate=None)

 

Choose a type from a type library.

Parameters:
  • out_sym - pointer to be filled with the chosen type (C++: til_symbol_t *)
  • root_til - pointer to starting til (the function will inspect the base tils if allowed by flags) (C++: const til_t *)
  • title - title of listbox to display (C++: const char *)
  • ntf_flags - combination of Flags for named types (C++: int)
  • predicate - predicate to select types to display (maybe NULL) (C++: predicate_t *)
Returns: bool
false if nothing is chosen, otherwise true

choose_local_tinfo(ti, title, func=None, def_ord=0, ud=None)

 

Choose a type from the local type library.

Parameters:
  • ti - pointer to til (C++: const til_t *)
  • title - title of listbox to display (C++: const char *)
  • func - predicate to select types to display (maybe NULL) (C++: local_tinfo_predicate_t *)
  • def_ord - ordinal to position cursor before choose (C++: uint32)
  • ud - user data (C++: void *)
Returns: uint32
== 0 means nothing is chosen, otherwise an ordinal number

calc_type_size(ti, tp)

 

Returns the size of a type

Parameters:
  • ti - Type info. 'None' can be passed.
  • tp - type string
Returns: PyObject *
  • None on failure
  • The size of the type

apply_type(ti, py_type, py_fields, ea, flags)

 

Apply the specified type to the address

Parameters:
  • ti - Type info library. 'None' can be used.
  • py_type - type string
  • py_fields - fields string (may be empty or None)
  • ea - the address of the object
  • flags - combination of TINFO_... constants or 0
Returns: bool
Boolean

get_arg_addrs(caller)

 

Retrieve addresses of argument initialization instructions

Parameters:
  • caller - the address of the call instruction
Returns: PyObject *
list of instruction addresses

unpack_object_from_bv(ti, py_type, py_fields, py_bytes, pio_flags=0)

 

Unpacks a buffer into an object. Returns the error_t returned by idaapi.pack_object_to_idb

Parameters:
  • ti - Type info. 'None' can be passed.
  • tp - type string
  • fields - fields string (may be empty or None)
  • bytes - the bytes to unpack
  • pio_flags - flags used while unpacking
Returns: PyObject *
  • tuple(0, err) on failure
  • tuple(1, obj) on success

pack_object_to_idb(py_obj, ti, py_type, py_fields, ea, pio_flags=0)

 

Write a typed object to the database. Raises an exception if wrong parameters were passed or conversion fails Returns the error_t returned by idaapi.pack_object_to_idb

Parameters:
  • ti - Type info. 'None' can be passed.
  • tp - type string
  • fields - fields string (may be empty or None)
  • ea - ea to be used while packing
  • pio_flags - flags used while unpacking
Returns: PyObject *

pack_object_to_bv(py_obj, ti, py_type, py_fields, base_ea, pio_flags=0)

 

Packs a typed object to a string

Parameters:
  • ti - Type info. 'None' can be passed.
  • tp - type string
  • fields - fields string (may be empty or None)
  • base_ea - base ea used to relocate the pointers in the packed object
  • pio_flags - flags used while unpacking
Returns: PyObject *
tuple(0, err_code) on failure tuple(1, packed_buf) on success

get_named_type(til, name, ntf_flags)

 

Get a type data by its name.

Parameters:
  • til - the type library
  • name - the type name
  • ntf_flags - a combination of NTF_* constants
Returns: PyObject *
None on failure tuple(code, type_str, fields_str, cmt, field_cmts, sclass, value) on success

get_named_type64(til, name, ntf_flags)

 

See 'get_named_type()' above.If the value in the 'ti' library is 32-bit, it will be sign-extended before being stored in the 'value' pointer.

Parameters:
  • name, (C++ - const char *)
  • ntf_flags, (C++ - int)
Returns: PyObject *

print_decls(printer, til, py_ordinals, flags)

 

Print types (and possibly their dependencies) in a format suitable for use in a header file. This is the reverse 'parse_decls()' .

Parameters:
  • printer - a handler for printing text (C++: text_sink_t &)
  • til - the type library holding the ordinals (C++: til_t *)
  • flags - flags for the algorithm. A combination of PDF_* constants (C++: uint32)
Returns: int

load_til(name, tildir)

 

Load til from a file. Failure to load base tils are reported into 'errbuf'. They do not prevent loading of the main til.

Parameters:
  • name - filename of the til. If it's an absolute path, tildir is ignored. NB: the file extension is forced to .til (C++: const char *)
  • tildir - directory where to load the til from. NULL means default til subdirectories. (C++: const char *)
Returns: til_t
pointer to resulting til, NULL if failed and error message is in errbuf

load_til_header(tildir, name)

 

Get human-readable til description.

Parameters:
  • tildir, (C++ - const char *)
  • name, (C++ - const char *)
Returns: til_t

remove_tinfo_pointer(tif, name, til)

 

Remove pointer of a type. (i.e. convert "char *" into "char"). Optionally remove the "lp" (or similar) prefix of the input name. If the input type is not a pointer, then fail.

Parameters:
  • tif, (C++ - tinfo_t *)
  • til, (C++ - const til_t *)
Returns: PyObject *

get_numbered_type(til, ordinal)

 

Retrieve a type by its ordinal number.

Parameters:
  • ordinal, (C++ - uint32)
Returns: PyObject *

Variables Details

HTI_FIL

otherwise "input" contains a C declaration

"input" is file name,

Value:
64

HTI_PAK_SHIFT

shift for 'HTI_PAK' . This field should be used if you want to remember an explicit pack value for each structure/union type. See 'HTI_PAK' ... definitions

Value:
12

HTI_HIGH

(with hidden args, etc)

assume high level prototypes

Value:
32768

PT_HIGH

(with hidden args, etc)

assume high level prototypes

Value:
128

NTF_SYMM

only one of 'NTF_TYPE' and 'NTF_SYMU' , 'NTF_SYMM' can be used

symbol, name is mangled ('_func')

Value:
0

NTF_FIXNAME

(set_named_type, set_numbered_type only)

force-validate the name of the type when setting

Value:
128

NTF_CHKSYNC

(set_numbered_type, set_named_type)

check that synchronization to IDB passed OK

Value:
512

IMPTYPE_LOCAL

the type is local, the struct/enum won't be marked as til type. there is no need to specify this bit if til==idati, the kernel will set it automatically

Value:
4

SUDT_ALIGN

to match the offsets and size info

recalculate field alignments, struct packing, etc

Value:
2

SUDT_UNEX

references to nonexistent member types are acceptable in this case it is better to set the corresponding 'udt_member_t::fda' field to the type alignment. if this field is not set, ida will try to guess the alignment.

Value:
8

STRMEM_TYPE

get member by type. - in: udm->type - the desired member type. member types are compared with tinfo_t::equals_to()

Value:
4

STRMEM_SKIP_EMPTY

can be combined with 'STRMEM_OFFSET' , 'STRMEM_AUTO' skip empty members (i.e. having zero size) only last empty member can be returned

Value:
536870912

FAI_RETPTR

pointer to return value. implies hidden

Value:
2

FTI_ARGLOCS

(stkargs and retloc too)

info about argument locations has been calculated

Value:
256