Module ida_typeinf
The recommended way of using type info is to use the tinfo_t class. The type information is internally kept as an array of bytes terminated by 0.
Items in brackets [] are optional and sometimes are omitted. type_t... means a sequence of type_t bytes which defines a type.
@note: to work with the types of instructions or data in the database, use get_tinfo()/set_tinfo() and similar functions.
Global Variables
ABS_NO
ABS_UNK
ABS_YES
ADDTIL_ABORTED
ADDTIL_COMP
ADDTIL_DEFAULT
ADDTIL_FAILED
ADDTIL_INCOMP
ADDTIL_OK
ADDTIL_SILENT
ALOC_CUSTOM
ALOC_DIST
ALOC_NONE
ALOC_REG1
ALOC_REG2
ALOC_RREL
ALOC_STACK
ALOC_STATIC
ARGREGS_BY_SLOTS
ARGREGS_FP_MASKS_GP
ARGREGS_GP_ONLY
ARGREGS_INDEPENDENT
ARGREGS_MIPS_O32
ARGREGS_POLICY_UNDEFINED
ARGREGS_RISCV
BADORD
BADSIZE
BFA_FUNC_EXT_FORMAT
BFA_FUNC_MARKER
BFA_HIGH
BFA_NORET
BFA_PURE
BFA_STATIC
BFA_VIRTUAL
BTE_ALWAYS
BTE_BITMASK
BTE_CHAR
BTE_HEX
BTE_OUT_MASK
BTE_RESERVED
BTE_SDEC
BTE_SIZE_MASK
BTE_UDEC
BTF_BOOL
BTF_BYTE
BTF_CHAR
BTF_DOUBLE
BTF_ENUM
BTF_FLOAT
BTF_INT
BTF_INT128
BTF_INT16
BTF_INT32
BTF_INT64
BTF_INT8
BTF_LDOUBLE
BTF_SINT
BTF_STRUCT
BTF_TBYTE
BTF_TYPEDEF
BTF_UCHAR
BTF_UINT
BTF_UINT128
BTF_UINT16
BTF_UINT32
BTF_UINT64
BTF_UINT8
BTF_UNION
BTF_UNK
BTF_VOID
BTMT_ARRESERV
BTMT_BFLDI16
BTMT_BFLDI32
BTMT_BFLDI64
BTMT_BFLDI8
BTMT_BOOL1
BTMT_BOOL2
BTMT_BOOL4
BTMT_BOOL8
BTMT_CHAR
BTMT_CLOSURE
BTMT_DEFBOOL
BTMT_DEFCALL
BTMT_DEFPTR
BTMT_DOUBLE
BTMT_ENUM
BTMT_FAR
BTMT_FARCALL
BTMT_FLOAT
BTMT_INTCALL
BTMT_LNGDBL
BTMT_NEAR
BTMT_NEARCALL
BTMT_NONBASED
BTMT_SIGNED
BTMT_SIZE0
BTMT_SIZE12
BTMT_SIZE128
BTMT_SIZE48
BTMT_SPECFLT
BTMT_STRUCT
BTMT_TYPEDEF
BTMT_UNION
BTMT_UNKSIGN
BTMT_UNSIGNED
BTMT_USIGNED
BTM_CONST
BTM_VOLATILE
BT_ARRAY
BT_BITFIELD
BT_BOOL
BT_COMPLEX
BT_FLOAT
BT_FUNC
BT_INT
BT_INT128
BT_INT16
BT_INT32
BT_INT64
BT_INT8
BT_PTR
BT_RESERVED
BT_SEGREG
BT_UNK
BT_UNKNOWN
BT_UNK_BYTE
BT_UNK_DWORD
BT_UNK_OWORD
BT_UNK_QWORD
BT_UNK_WORD
BT_VOID
CCN_C
CCN_CPP
CC_ALLOW_ARGPERM
CC_ALLOW_REGHOLES
CC_CDECL_OK
CC_GOLANG_OK
CC_HAS_ELLIPSIS
CM_CC_CDECL
CM_CC_ELLIPSIS
CM_CC_FASTCALL
CM_CC_GOLANG
CM_CC_INVALID
CM_CC_MASK
CM_CC_PASCAL
CM_CC_RESERVE3
CM_CC_SPECIAL
CM_CC_SPECIALE
CM_CC_SPECIALP
CM_CC_SPOILED
CM_CC_STDCALL
CM_CC_SWIFT
CM_CC_THISCALL
CM_CC_UNKNOWN
CM_CC_VOIDARG
CM_MASK
CM_M_FF
CM_M_FN
CM_M_MASK
CM_M_NF
CM_M_NN
CM_N16_F32
CM_N32_F48
CM_N64
CM_N8_F16
CM_UNKNOWN
COMP_BC
COMP_BP
COMP_GNU
COMP_MASK
COMP_MS
COMP_UNK
COMP_UNSURE
COMP_VISAGE
COMP_WATCOM
C_PC_COMPACT
C_PC_FLAT
C_PC_HUGE
C_PC_LARGE
C_PC_MEDIUM
C_PC_SMALL
C_PC_TINY
DEFMASK64
ETF_AUTONAME
ETF_BYTIL
ETF_COMPATIBLE
ETF_FORCENAME
ETF_FUNCARG
ETF_MAY_DESTROY
ETF_NO_ARRAY
ETF_NO_LAYOUT
ETF_NO_SAVE
FAH_BYTE
FAI_ARRAY
FAI_HIDDEN
FAI_RETPTR
FAI_STRUCT
FAI_UNUSED
FIRST_NONTRIVIAL_TYPID
FMTFUNC_PRINTF
FMTFUNC_SCANF
FMTFUNC_STRFMON
FMTFUNC_STRFTIME
FRB_CHAR
FRB_CUSTOM
FRB_ENUM
FRB_FLOAT
FRB_INVBITS
FRB_INVSIGN
FRB_LZERO
FRB_MASK
FRB_NUMB
FRB_NUMD
FRB_NUMH
FRB_NUMO
FRB_OFFSET
FRB_SEG
FRB_SIGNED
FRB_STRLIT
FRB_STROFF
FRB_TABFORM
FRB_UNK
FTI_ALL
FTI_ARGLOCS
FTI_CALLTYPE
FTI_CONST
FTI_CTOR
FTI_DEFCALL
FTI_DTOR
FTI_EXPLOCS
FTI_FARCALL
FTI_HIGH
FTI_INTCALL
FTI_NEARCALL
FTI_NORET
FTI_PURE
FTI_SPOILED
FTI_STATIC
FTI_VIRTUAL
GTD_CALC_ARGLOCS
GTD_CALC_LAYOUT
GTD_DEL_BITFLDS
GTD_NO_ARGLOCS
GTD_NO_LAYOUT
GTS_BASECLASS
GTS_NESTED
GUESS_FUNC_FAILED
GUESS_FUNC_OK
GUESS_FUNC_TRIVIAL
HTI_CPP
HTI_DCL
HTI_EXT
HTI_FIL
HTI_HIGH
HTI_INT
HTI_LEX
HTI_LOWER
HTI_MAC
HTI_NDC
HTI_NER
HTI_NOBASE
HTI_NWR
HTI_PAK
HTI_PAK1
HTI_PAK16
HTI_PAK2
HTI_PAK4
HTI_PAK8
HTI_PAKDEF
HTI_PAK_SHIFT
HTI_RAWARGS
HTI_RELAXED
HTI_TST
HTI_UNP
MAX_DECL_ALIGN
MAX_ENUM_SERIAL
MAX_FUNC_ARGS
NTF_64BIT
NTF_CHKSYNC
NTF_COPY
NTF_FIXNAME
NTF_IDBENC
NTF_NOBASE
NTF_NOCUR
NTF_NO_NAMECHK
NTF_REPLACE
NTF_SYMM
NTF_SYMU
NTF_TYPE
NTF_UMANGLED
PDF_DEF_BASE
PDF_DEF_FWD
PDF_HEADER_CMT
PDF_INCL_DEPS
PIO_IGNORE_PTRS
PIO_NOATTR_FAIL
PRALOC_STKOFF
PRALOC_VERIFY
PRTYPE_1LINCMT
PRTYPE_1LINE
PRTYPE_ARGLOCS
PRTYPE_COLORED
PRTYPE_CPP
PRTYPE_DEF
PRTYPE_HEADER
PRTYPE_MAXSTR
PRTYPE_METHODS
PRTYPE_MULTI
PRTYPE_NOARGS
PRTYPE_NOARRS
PRTYPE_NOREGEX
PRTYPE_NORES
PRTYPE_OFFSETS
PRTYPE_PRAGMA
PRTYPE_RESTORE
PRTYPE_SEMI
PRTYPE_TAIL
PRTYPE_TYPE
PT_EMPTY
PT_FILE
PT_HIGH
PT_LOWER
PT_NDC
PT_PACKMASK
PT_RAWARGS
PT_RELAXED
PT_REPLACE
PT_SIL
PT_TYP
PT_VAR
RESERVED_BYTE
SC_AUTO
SC_EXT
SC_FRIEND
SC_REG
SC_STAT
SC_TYPE
SC_UNK
SC_VIRT
SETCOMP_BY_USER
SETCOMP_ONLY_ABI
SETCOMP_ONLY_ID
SETCOMP_OVERRIDE
STI_ACCHAR
STI_ACHAR
STI_ACUCHAR
STI_AEABI_LCMP
STI_AEABI_MEMCLR
STI_AEABI_MEMCPY
STI_AEABI_MEMSET
STI_AEABI_ULCMP
STI_AUCHAR
STI_COMPLEX128
STI_COMPLEX64
STI_DONT_USE
STI_FDELOP
STI_FPURGING
STI_LAST
STI_MSGSEND
STI_PBYTE
STI_PCCHAR
STI_PCHAR
STI_PCUCHAR
STI_PCVOID
STI_PINT
STI_PPVOID
STI_PUCHAR
STI_PUINT
STI_PUNKNOWN
STI_PVOID
STI_RTC_CHECK_2
STI_RTC_CHECK_4
STI_RTC_CHECK_8
STI_SIZE_T
STI_SSIZE_T
STRMEM_ANON
STRMEM_AUTO
STRMEM_CASTABLE_TO
STRMEM_INDEX
STRMEM_LOWBND
STRMEM_MASK
STRMEM_MAXS
STRMEM_MINS
STRMEM_NAME
STRMEM_NEXT
STRMEM_OFFSET
STRMEM_SIZE
STRMEM_SKIP_EMPTY
STRMEM_SKIP_GAPS
STRMEM_TYPE
STRMEM_VFTABLE
STRUC_SEPARATOR
SUDT_ALIGN
SUDT_CONST
SUDT_FAST
SUDT_GAPS
SUDT_SERDEF
SUDT_SORT
SUDT_TRUNC
SUDT_UNEX
SUDT_VOLATILE
TAENUM_64BIT
TAENUM_BIN
TAENUM_LZERO
TAENUM_NUMSIGN
TAENUM_OCT
TAENUM_SIGNED
TAENUM_UNSIGNED
TAFLD_BASECLASS
TAFLD_BYTIL
TAFLD_FRAME_R
TAFLD_FRAME_S
TAFLD_GAP
TAFLD_METHOD
TAFLD_REGCMT
TAFLD_UNALIGNED
TAFLD_VFTABLE
TAFLD_VIRTBASE
TAH_ALL
TAH_BYTE
TAH_HASATTRS
TAPTR_PTR32
TAPTR_PTR64
TAPTR_RESTRICT
TAPTR_SHIFTED
TAUDT_CPPOBJ
TAUDT_FIXED
TAUDT_MSSTRUCT
TAUDT_UNALIGNED
TAUDT_VFTABLE
TA_FORMAT
TA_ORG_ARRDIM
TA_ORG_TYPEDEF
TA_VALUE_REPR
TCMP_ANYBASE
TCMP_AUTOCAST
TCMP_CALL
TCMP_DECL
TCMP_DELPTR
TCMP_EQUAL
TCMP_IGNMODS
TCMP_MANCAST
TCMP_SKIPTHIS
TERR_ALIEN_NAME
TERR_BAD_ARG
TERR_BAD_ARRAY
TERR_BAD_BASE
TERR_BAD_BF
TERR_BAD_BMASK
TERR_BAD_FX_SIZE
TERR_BAD_GAP
TERR_BAD_GROUPS
TERR_BAD_INDEX
TERR_BAD_LAYOUT
TERR_BAD_MSKVAL
TERR_BAD_NAME
TERR_BAD_OFFSET
TERR_BAD_REPR
TERR_BAD_SERIAL
TERR_BAD_SIZE
TERR_BAD_SUBTYPE
TERR_BAD_TAH
TERR_BAD_TYPE
TERR_BAD_UNIVAR
TERR_BAD_VALUE
TERR_BAD_VARLAST
TERR_COUNT
TERR_DUPNAME
TERR_ENUM_SIZE
TERR_GRP_NOEMPTY
TERR_NESTED
TERR_NOT_COMPAT
TERR_NOT_IMPL
TERR_NO_BMASK
TERR_OK
TERR_OVERLAP
TERR_SAVE
TERR_SAVE_ERROR
TERR_SERIALIZE
TERR_STOCK
TERR_TYPE_WORSE
TERR_UNION_BF
TERR_WRONGNAME
TIL_ADD_ALREADY
TIL_ADD_FAILED
TIL_ADD_OK
TIL_ALI
TIL_ESI
TIL_MAC
TIL_MOD
TIL_ORD
TIL_SLD
TIL_STM
TIL_UNI
TIL_ZIP
TINFO_DEFINITE
TINFO_DELAYFUNC
TINFO_GUESSED
TINFO_STRICT
TPOS_LNNUM
TPOS_REGCMT
TVIS_CMT
TVIS_NAME
TVIS_RPTCMT
TVIS_TYPE
TVST_DEF
TVST_LEVEL
TVST_PRUNE
TYPE_BASE_MASK
TYPE_FLAGS_MASK
TYPE_FULL_MASK
TYPE_MODIF_MASK
TYPID_ISREF
TYPID_SHIFT
UTP_ENUM
UTP_STRUCT
VALSTR_OPEN
VTBL_MEMNAME
VTBL_SUFFIX
no_sign
sc_auto
sc_ext
sc_friend
sc_reg
sc_stat
sc_type
sc_unk
sc_virt
type_signed
type_unsigned
Functions
add_til(name: char const *, flags: int) ‑> int
add_til(name, flags) -> int Load a til file and add it the database type libraries list. IDA will also apply function prototypes for matching function names.
alloc_type_ordinal(ti: til_t) ‑> uint32
alloc_type_ordinal(ti) -> uint32 alloc_type_ordinals(ti, 1)
alloc_type_ordinals(ti: til_t, qty: int) ‑> uint32
alloc_type_ordinals(ti, qty) -> uint32 Allocate a range of ordinal numbers for new types.
append_abi_opts(abi_opts: char const *, user_level: bool = False) ‑> bool
append_abi_opts(abi_opts, user_level=False) -> bool Add/remove/check ABI option General form of full abi name: abiname-opt1-opt2-... or -opt1-opt2-...
append_argloc(out: qtype *, vloc: argloc_t) ‑> bool
append_argloc(out, vloc) -> bool Serialize argument location
append_tinfo_covered(out: rangeset_t, typid: typid_t, offset: uint64) ‑> bool
append_tinfo_covered(out, typid, offset) -> bool
apply_callee_tinfo(caller: ea_t, tif: tinfo_t) ‑> bool
apply_callee_tinfo(caller, tif) -> bool 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.
apply_cdecl(til: til_t, ea: ea_t, decl: char const *, flags: int = 0) ‑> bool
apply_cdecl(til, ea, decl, flags=0) -> bool Apply the specified type to the address. This function parses the declaration and calls apply_tinfo()
apply_named_type(ea: ea_t, name: char const *) ‑> bool
apply_named_type(ea, name) -> bool Apply the specified named type to the address.
apply_once_tinfo_and_name(dea: ea_t, tif: tinfo_t, name: char const *) ‑> bool
apply_once_tinfo_and_name(dea, tif, name) -> bool Apply the specified type and name to the address. This function checks if the address already has a type. If the old type does not exist or the new type is 'better' than the old type, then the new type will be applied. A type is considered better if it has more information (e.g. BTMT_STRUCT is better than BT_INT). The same logic is with the name: if the address already have a meaningful name, it will be preserved. Only if the old name does not exist or it is a dummy name like byte_123, it will be replaced by the new name.
apply_tinfo(ea: ea_t, tif: tinfo_t, flags: uint32) ‑> bool
apply_tinfo(ea, tif, flags) -> bool 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.
apply_tinfo_to_stkarg(insn: insn_t const &, x: op_t const &, v: uval_t, tif: tinfo_t, name: char const *) ‑> bool
apply_tinfo_to_stkarg(insn, x, v, tif, name) -> bool Helper function for the processor modules. to be called from processor_t::use_stkarg_type
apply_type(ti: til_t, type: type_t const *, fields: p_list const *, ea: ea_t, flags: int) ‑> bool
apply_type(ti, type, fields, ea, flags) -> bool Apply the specified type to the address
begin_type_updating(utp: update_type_t) ‑> void
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()
calc_c_cpp_name(name: char const *, type: tinfo_t, ccn_flags: int) ‑> qstring *
calc_c_cpp_name(name, type, ccn_flags) -> str Get C or C++ form of the name.
calc_number_of_children(loc: argloc_t, tif: tinfo_t, dont_deref_ptr: bool = False) ‑> int
calc_number_of_children(loc, tif, dont_deref_ptr=False) -> int Calculate max number of lines of a formatted c data, when expanded (PTV_EXPAND).
calc_tinfo_gaps(out: rangeset_t, typid: typid_t) ‑> bool
calc_tinfo_gaps(out, typid) -> bool
calc_type_size(ti: til_t, tp: PyObject *) ‑> PyObject *
calc_type_size(ti, tp) -> PyObject * Returns the size of a type
choose_local_tinfo(ti: til_t, title: char const *, func: local_tinfo_predicate_t * = None, def_ord: uint32 = 0, ud: void * = None) ‑> uint32
choose_local_tinfo(ti, title, func=None, def_ord=0, ud=None) -> uint32 Choose a type from the local type library.
choose_local_tinfo_and_delta(delta: int32 *, ti: til_t, title: char const *, func: local_tinfo_predicate_t * = None, def_ord: uint32 = 0, ud: void * = None) ‑> uint32
choose_local_tinfo_and_delta(delta, ti, title, func=None, def_ord=0, ud=None) -> uint32 Choose a type from the local type library and specify the pointer shift value.
choose_named_type(out_sym: til_symbol_t, root_til: til_t, title: char const *, ntf_flags: int, predicate: predicate_t = None) ‑> bool
choose_named_type(out_sym, root_til, title, ntf_flags, predicate=None) -> bool Choose a type from a type library.
clear_tinfo_t(_this: tinfo_t) ‑> void
clear_tinfo_t(_this)
compact_til(ti: til_t) ‑> bool
compact_til(ti) -> bool Collect garbage in til. Must be called before storing the til.
compare_tinfo(t1: typid_t, t2: typid_t, tcflags: int) ‑> bool
compare_tinfo(t1, t2, tcflags) -> bool
convert_pt_flags_to_hti(pt_flags: int) ‑> int
convert_pt_flags_to_hti(pt_flags) -> int 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)
copy_named_type(dsttil: til_t, srctil: til_t, name: char const *) ‑> uint32
copy_named_type(dsttil, srctil, name) -> uint32 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.
copy_tinfo_t(_this: tinfo_t, r: tinfo_t) ‑> void
copy_tinfo_t(_this, r)
create_enum_type(enum_name: char const *, ei: enum_type_data_t, enum_width: int, sign: type_sign_t, convert_to_bitmask: bool, enum_cmt: char const * = None) ‑> tid_t
create_enum_type(enum_name, ei, enum_width, sign, convert_to_bitmask, enum_cmt=None) -> tid_t Create type enum
create_numbered_type_name(ord: int32) ‑> qstring *
create_numbered_type_name(ord) -> str 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
create_tinfo(_this: tinfo_t, bt: type_t, bt2: type_t, ptr: void *) ‑> bool
create_tinfo(_this, bt, bt2, ptr) -> bool
default_compiler() ‑> comp_t
default_compiler() -> comp_t Get compiler specified by inf.cc.
del_named_type(ti: til_t, name: char const *, ntf_flags: int) ‑> bool
del_named_type(ti, name, ntf_flags) -> bool Delete information about a symbol.
del_numbered_type(ti: til_t, ordinal: uint32) ‑> bool
del_numbered_type(ti, ordinal) -> bool Delete a numbered type.
del_til(name: char const *) ‑> bool
del_til(name) -> bool Unload a til file.
del_tinfo_attr(tif: tinfo_t, key: qstring const &, make_copy: bool) ‑> bool
del_tinfo_attr(tif, key, make_copy) -> bool
del_vftable_ea(ordinal: uint32) ‑> bool
del_vftable_ea(ordinal) -> bool Delete the address of a vftable instance for a vftable type.
deref_ptr(ptr_ea: ea_t *, tif: tinfo_t, closure_obj: ea_t * = None) ‑> bool
deref_ptr(ptr_ea, tif, closure_obj=None) -> bool Dereference a pointer.
in: address of the pointer
out: the pointed address tif: (C++: const tinfo_t &) type of the pointer closure_obj: (C++: ea_t *) closure object (not used yet) return: success
deserialize_tinfo(tif: tinfo_t, til: til_t, ptype: type_t const **, pfields: p_list const **, pfldcmts: p_list const **, cmt: char const * = None) ‑> bool
deserialize_tinfo(tif, til, ptype, pfields, pfldcmts, cmt=None) -> bool
detach_tinfo_t(_this: tinfo_t) ‑> bool
detach_tinfo_t(_this) -> bool
dstr_tinfo(tif: tinfo_t) ‑> char const *
dstr_tinfo(tif) -> char const *
dump_func_type_data(fti: func_type_data_t, praloc_bits: int) ‑> qstring *
dump_func_type_data(fti, praloc_bits) -> str Use func_type_data_t::dump()
enable_numbered_types(ti: til_t, enable: bool) ‑> bool
enable_numbered_types(ti, enable) -> bool Enable the use of numbered types in til. Currently it is impossible to disable numbered types once they are enabled
end_type_updating(utp: update_type_t) ‑> void
end_type_updating(utp) Mark the end of a large update operation on the types (see begin_type_updating())
extract_argloc(vloc: argloc_t, ptype: type_t const **, forbid_stkoff: bool) ‑> bool
extract_argloc(vloc, ptype, forbid_stkoff) -> bool Deserialize an argument location. Argument FORBID_STKOFF checks location type. It can be used, for example, to check the return location of a function that cannot return a value in the stack
find_tinfo_udt_member(udm: udm_t, typid: typid_t, strmem_flags: int) ‑> int
find_tinfo_udt_member(udm, typid, strmem_flags) -> int
first_named_type(ti: til_t, ntf_flags: int) ‑> char const *
first_named_type(ti, ntf_flags) -> char const * Enumerate types.
for_all_arglocs(vv: aloc_visitor_t, vloc: argloc_t, size: int, off: int = 0) ‑> int
for_all_arglocs(vv, vloc, size, off=0) -> int Compress larger argloc types and initiate the aloc visitor.
for_all_const_arglocs(vv: const_aloc_visitor_t, vloc: argloc_t, size: int, off: int = 0) ‑> int
for_all_const_arglocs(vv, vloc, size, off=0) -> int See for_all_arglocs()
free_til(ti: til_t) ‑> void
free_til(ti) Free memory allocated by til.
func_has_stkframe_hole(ea: ea_t, fti: func_type_data_t) ‑> bool
func_has_stkframe_hole(ea, fti) -> bool 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.
gcc_layout() ‑> bool
gcc_layout() -> bool Should use the struct/union layout as done by gcc?
gen_decorate_name(name: char const *, mangle: bool, cc: cm_t, type: tinfo_t) ‑> qstring *
gen_decorate_name(name, mangle, cc, type) -> str Generic function for decorate_name() (may be used in IDP modules)
gen_use_arg_tinfos(_this: argtinfo_helper_t, caller: ea_t, fti: func_type_data_t, rargs: funcargvec_t) ‑> void
gen_use_arg_tinfos(_this, caller, fti, rargs) Do not call this function directly, use argtinfo_helper_t.
get_abi_name() ‑> qstring *
get_abi_name() -> str Get ABI name.
get_alias_target(ti: til_t, ordinal: uint32) ‑> uint32
get_alias_target(ti, ordinal) -> uint32 Find the final alias destination. If the ordinal has not been aliased, return the specified ordinal itself If failed, returns 0.
get_arg_addrs(caller: ea_t) ‑> PyObject *
get_arg_addrs(caller) -> PyObject * Retrieve addresses of argument initialization instructions
get_base_type(t: type_t) ‑> type_t
get_base_type(t) -> type_t Get get basic type bits (TYPE_BASE_MASK)
get_c_header_path() ‑> qstring *
get_c_header_path() -> str Get the include directory path of the target compiler.
get_c_macros() ‑> qstring *
get_c_macros() -> str Get predefined macros for the target compiler.
get_comp(comp: comp_t) ‑> comp_t
get_comp(comp) -> comp_t Get compiler bits.
get_compiler_abbr(id: comp_t) ‑> char const *
get_compiler_abbr(id) -> char const * Get abbreviated compiler name.
get_compiler_name(id: comp_t) ‑> char const *
get_compiler_name(id) -> char const * Get full compiler name.
get_compilers(ids: compvec_t *, names: qstrvec_t *, abbrs: qstrvec_t *) ‑> void
get_compilers(ids, names, abbrs) Get names of all built-in compilers.
get_enum_member_expr(tif: tinfo_t, serial: int, value: uint64) ‑> qstring *
get_enum_member_expr(tif, serial, value) -> str 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.
get_full_type(t: type_t) ‑> type_t
get_full_type(t) -> type_t Get basic type bits + type flags (TYPE_FULL_MASK)
get_idainfo_by_type(out_flags: flags64_t *, tif: tinfo_t) ‑> size_t *, opinfo_t *
get_idainfo_by_type(out_flags, tif) -> bool Extract information from a tinfo_t.
get_idainfo_by_udm(flags: flags64_t *, ti: opinfo_t, udm: udm_t) ‑> bool
get_idainfo_by_udm(flags, ti, udm) -> bool Calculate IDA info from udt member
get_idati() ‑> til_t *
get_idati() -> til_t Pointer to the local type library - this til is private for each IDB file Functions that accept til_t* default to idati when is nullptr provided.
get_named_type(til: til_t, name: char const *, ntf_flags: int) ‑> PyObject *
get_named_type(til, name, ntf_flags) -> (int, bytes, bytes, NoneType, NoneType, int, int) Get a type data by its name.
get_named_type64(til: til_t, name: char const *, ntf_flags: int) ‑> PyObject *
get_named_type64(til, name, ntf_flags) -> (int, bytes, NoneType, NoneType, NoneType, int, int) See get_named_type() above. note: If the value in the 'ti' library is 32-bit, it will be sign-extended before being stored in the 'value' pointer.
get_named_type_tid(name: char const *) ‑> tid_t
get_named_type_tid(name) -> tid_t Get named local type TID
get_numbered_type(til: til_t, ordinal: uint32) ‑> PyObject *
get_numbered_type(til, ordinal) -> (bytes, NoneType, NoneType, NoneType, int), (bytes, bytes, NoneType, NoneType, int) Retrieve a type by its ordinal number.
get_numbered_type_name(ti: til_t, ordinal: uint32) ‑> char const *
get_numbered_type_name(ti, ordinal) -> char const * Get type name (if exists) by its ordinal. If the type is anonymous, returns "". If failed, returns nullptr
get_ordinal_count(ti: til_t = None) ‑> uint32
get_ordinal_count(ti=None) -> uint32 Get number of allocated ordinals.
get_ordinal_limit(ti: til_t = None) ‑> uint32
get_ordinal_limit(ti=None) -> uint32 Get number of allocated ordinals + 1. If there are no allocated ordinals, return 0. To enumerate all ordinals, use: for ( uint32 i = 1; i < limit; ++i )
get_scalar_bt(size: int) ‑> type_t
get_scalar_bt(size) -> type_t
get_stock_tinfo(tif: tinfo_t, id: stock_type_id_t) ‑> bool
get_stock_tinfo(tif, id) -> bool
get_tid_name(tid: tid_t) ‑> qstring *
get_tid_name(tid) -> str Get a type name for the specified TID
get_tid_ordinal(tid: tid_t) ‑> uint32
get_tid_ordinal(tid) -> uint32 Get type ordinal number for TID
get_tinfo_attr(typid: typid_t, key: qstring const &, bv: bytevec_t *, all_attrs: bool) ‑> bool
get_tinfo_attr(typid, key, bv, all_attrs) -> bool
get_tinfo_attrs(typid: typid_t, tav: type_attrs_t, include_ref_attrs: bool) ‑> bool
get_tinfo_attrs(typid, tav, include_ref_attrs) -> bool
get_tinfo_by_edm_name(tif: tinfo_t, til: til_t, mname: char const *) ‑> ssize_t
get_tinfo_by_edm_name(tif, til, mname) -> ssize_t
get_tinfo_by_flags(out: tinfo_t, flags: flags64_t) ‑> bool
get_tinfo_by_flags(out, flags) -> bool Get tinfo object that corresponds to data flags
get_tinfo_details(typid: typid_t, bt2: type_t, buf: void *) ‑> bool
get_tinfo_details(typid, bt2, buf) -> bool
get_tinfo_pdata(outptr: void *, typid: typid_t, what: int) ‑> size_t
get_tinfo_pdata(outptr, typid, what) -> size_t
get_tinfo_property(typid: typid_t, gta_prop: int) ‑> size_t
get_tinfo_property(typid, gta_prop) -> size_t
get_tinfo_property4(typid: typid_t, gta_prop: int, p1: size_t, p2: size_t, p3: size_t, p4: size_t) ‑> size_t
get_tinfo_property4(typid, gta_prop, p1, p2, p3, p4) -> size_t
get_tinfo_size(p_effalign: uint32 *, typid: typid_t, gts_code: int) ‑> size_t
get_tinfo_size(p_effalign, typid, gts_code) -> size_t
get_type_flags(t: type_t) ‑> type_t
get_type_flags(t) -> type_t Get type flags (TYPE_FLAGS_MASK)
get_type_ordinal(ti: til_t, name: char const *) ‑> int32
get_type_ordinal(ti, name) -> int32 Get type ordinal by its name.
get_udm_by_fullname(udm: udm_t, fullname: char const *) ‑> ssize_t
get_udm_by_fullname(udm, fullname) -> ssize_t Get udt member by full name
get_vftable_ea(ordinal: uint32) ‑> ea_t
get_vftable_ea(ordinal) -> ea_t Get address of a virtual function table.
get_vftable_ordinal(vftable_ea: ea_t) ‑> uint32
get_vftable_ordinal(vftable_ea) -> uint32 Get ordinal number of the virtual function table.
guess_func_cc(fti: func_type_data_t, npurged: int, cc_flags: int) ‑> cm_t
guess_func_cc(fti, npurged, cc_flags) -> cm_t Use func_type_data_t::guess_cc()
guess_tinfo(out: tinfo_t, id: tid_t) ‑> int
guess_tinfo(out, id) -> int Generate a type information about the id from the disassembly. id can be a structure/union/enum id or an address.
idc_get_local_type(ordinal: int, flags: int) ‑> size_t
idc_get_local_type(ordinal, flags) -> str
idc_get_local_type_name(ordinal: int) ‑> size_t
idc_get_local_type_name(ordinal) -> str
idc_get_local_type_raw(ordinal: int) ‑> PyObject *
idc_get_local_type_raw(ordinal) -> (bytes, bytes)
idc_get_type(ea: ea_t) ‑> size_t
idc_get_type(ea) -> str
idc_get_type_raw(ea: ea_t) ‑> PyObject *
idc_get_type_raw(ea) -> PyObject *
idc_guess_type(ea: ea_t) ‑> size_t
idc_guess_type(ea) -> str
idc_parse_decl(ti: til_t, decl: char const *, flags: int) ‑> PyObject *
idc_parse_decl(ti, decl, flags) -> (str, bytes, bytes) or None
idc_parse_types(input: char const *, flags: int) ‑> int
idc_parse_types(input, flags) -> int
idc_print_type(type: type_t const *, fields: p_list const *, name: char const *, flags: int) ‑> PyObject *
idc_print_type(type, fields, name, flags) -> str
idc_set_local_type(ordinal: int, dcl: char const *, flags: int) ‑> int
idc_set_local_type(ordinal, dcl, flags) -> int
inf_big_arg_align(*args) ‑> bool
inf_big_arg_align() -> bool inf_big_arg_align(cc) -> bool
inf_huge_arg_align(*args) ‑> bool
inf_huge_arg_align() -> bool inf_huge_arg_align(cc) -> bool
inf_pack_stkargs(*args) ‑> bool
inf_pack_stkargs() -> bool inf_pack_stkargs(cc) -> bool
is_code_far(cm: cm_t) ‑> bool
is_code_far(cm) -> bool Does the given model specify far code?.
is_comp_unsure(comp: comp_t) ‑> comp_t
is_comp_unsure(comp) -> comp_t See COMP_UNSURE.
is_data_far(cm: cm_t) ‑> bool
is_data_far(cm) -> bool Does the given model specify far data?.
is_gcc() ‑> bool
is_gcc() -> bool Is the target compiler COMP_GNU?
is_gcc32() ‑> bool
is_gcc32() -> bool Is the target compiler 32 bit gcc?
is_gcc64() ‑> bool
is_gcc64() -> bool Is the target compiler 64 bit gcc?
is_golang_cc(cc: cm_t) ‑> bool
is_golang_cc(cc) -> bool GO language calling convention (return value in stack)?
is_one_bit_mask(mask: uval_t) ‑> bool
is_one_bit_mask(mask) -> bool Is bitmask one bit?
is_ordinal_name(name: char const *, ord: uint32 * = None) ‑> bool
is_ordinal_name(name, ord=None) -> bool Check if the name is an ordinal name. Ordinal names have the following format: '#' + set_de(ord)
is_purging_cc(cm: cm_t) ‑> bool
is_purging_cc(cm) -> bool Does the calling convention clean the stack arguments upon return?. note: this function is valid only for x86 code
is_restype_enum(til: til_t, type: type_t const *) ‑> bool
is_restype_enum(til, type) -> bool
is_restype_struct(til: til_t, type: type_t const *) ‑> bool
is_restype_struct(til, type) -> bool
is_restype_struni(til: til_t, type: type_t const *) ‑> bool
is_restype_struni(til, type) -> bool
is_restype_void(til: til_t, type: type_t const *) ‑> bool
is_restype_void(til, type) -> bool
is_sdacl_byte(t: type_t) ‑> bool
is_sdacl_byte(t) -> bool 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)
is_swift_cc(cc: cm_t) ‑> bool
is_swift_cc(cc) -> bool Swift calling convention (arguments and return values in registers)?
is_tah_byte(t: type_t) ‑> bool
is_tah_byte(t) -> bool The TAH byte (type attribute header byte) denotes the start of type attributes. (see "tah-typeattrs" in the type bit definitions)
is_type_arithmetic(t: type_t) ‑> bool
is_type_arithmetic(t) -> bool Is the type an arithmetic type? (floating or integral)
is_type_array(t: type_t) ‑> bool
is_type_array(t) -> bool See BT_ARRAY.
is_type_bitfld(t: type_t) ‑> bool
is_type_bitfld(t) -> bool See BT_BITFIELD.
is_type_bool(t: type_t) ‑> bool
is_type_bool(t) -> bool See BTF_BOOL.
is_type_char(t: type_t) ‑> bool
is_type_char(t) -> bool Does the type specify a char value? (signed or unsigned, see Basic type: integer)
is_type_choosable(ti: til_t, ordinal: uint32) ‑> bool
is_type_choosable(ti, ordinal) -> bool Check if a struct/union type is choosable
is_type_complex(t: type_t) ‑> bool
is_type_complex(t) -> bool See BT_COMPLEX.
is_type_const(t: type_t) ‑> bool
is_type_const(t) -> bool See BTM_CONST.
is_type_double(t: type_t) ‑> bool
is_type_double(t) -> bool See BTF_DOUBLE.
is_type_enum(t: type_t) ‑> bool
is_type_enum(t) -> bool See BTF_ENUM.
is_type_ext_arithmetic(t: type_t) ‑> bool
is_type_ext_arithmetic(t) -> bool Is the type an extended arithmetic type? (arithmetic or enum)
is_type_ext_integral(t: type_t) ‑> bool
is_type_ext_integral(t) -> bool Is the type an extended integral type? (integral or enum)
is_type_float(t: type_t) ‑> bool
is_type_float(t) -> bool See BTF_FLOAT.
is_type_floating(t: type_t) ‑> bool
is_type_floating(t) -> bool Is the type a floating point type?
is_type_func(t: type_t) ‑> bool
is_type_func(t) -> bool See BT_FUNC.
is_type_int(bt: type_t) ‑> bool
is_type_int(bt) -> bool Does the type_t specify one of the basic types in Basic type: integer?
is_type_int128(t: type_t) ‑> bool
is_type_int128(t) -> bool Does the type specify a 128-bit value? (signed or unsigned, see Basic type: integer)
is_type_int16(t: type_t) ‑> bool
is_type_int16(t) -> bool Does the type specify a 16-bit value? (signed or unsigned, see Basic type: integer)
is_type_int32(t: type_t) ‑> bool
is_type_int32(t) -> bool Does the type specify a 32-bit value? (signed or unsigned, see Basic type: integer)
is_type_int64(t: type_t) ‑> bool
is_type_int64(t) -> bool Does the type specify a 64-bit value? (signed or unsigned, see Basic type: integer)
is_type_integral(t: type_t) ‑> bool
is_type_integral(t) -> bool Is the type an integral type (char/short/int/long/bool)?
is_type_ldouble(t: type_t) ‑> bool
is_type_ldouble(t) -> bool See BTF_LDOUBLE.
is_type_paf(t: type_t) ‑> bool
is_type_paf(t) -> bool Is the type a pointer, array, or function type?
is_type_partial(t: type_t) ‑> bool
is_type_partial(t) -> bool Identifies an unknown or void type with a known size (see Basic type: unknown & void)
is_type_ptr(t: type_t) ‑> bool
is_type_ptr(t) -> bool See BT_PTR.
is_type_ptr_or_array(t: type_t) ‑> bool
is_type_ptr_or_array(t) -> bool Is the type a pointer or array type?
is_type_struct(t: type_t) ‑> bool
is_type_struct(t) -> bool See BTF_STRUCT.
is_type_struni(t: type_t) ‑> bool
is_type_struni(t) -> bool Is the type a struct or union?
is_type_sue(t: type_t) ‑> bool
is_type_sue(t) -> bool Is the type a struct/union/enum?
is_type_tbyte(t: type_t) ‑> bool
is_type_tbyte(t) -> bool See BTF_FLOAT.
is_type_typedef(t: type_t) ‑> bool
is_type_typedef(t) -> bool See BTF_TYPEDEF.
is_type_uchar(t: type_t) ‑> bool
is_type_uchar(t) -> bool See BTF_UCHAR.
is_type_uint(t: type_t) ‑> bool
is_type_uint(t) -> bool See BTF_UINT.
is_type_uint128(t: type_t) ‑> bool
is_type_uint128(t) -> bool See BTF_UINT128.
is_type_uint16(t: type_t) ‑> bool
is_type_uint16(t) -> bool See BTF_UINT16.
is_type_uint32(t: type_t) ‑> bool
is_type_uint32(t) -> bool See BTF_UINT32.
is_type_uint64(t: type_t) ‑> bool
is_type_uint64(t) -> bool See BTF_UINT64.
is_type_union(t: type_t) ‑> bool
is_type_union(t) -> bool See BTF_UNION.
is_type_unknown(t: type_t) ‑> bool
is_type_unknown(t) -> bool See BT_UNKNOWN.
is_type_void(t: type_t) ‑> bool
is_type_void(t) -> bool See BTF_VOID.
is_type_volatile(t: type_t) ‑> bool
is_type_volatile(t) -> bool See BTM_VOLATILE.
is_typeid_last(t: type_t) ‑> bool
is_typeid_last(t) -> bool Is the type_t the last byte of type declaration? (there are no additional bytes after a basic type, see _BT_LAST_BASIC)
is_user_cc(cm: cm_t) ‑> bool
is_user_cc(cm) -> bool Does the calling convention specify argument locations explicitly?
is_vararg_cc(cm: cm_t) ‑> bool
is_vararg_cc(cm) -> bool Does the calling convention use ellipsis?
lexcompare_tinfo(t1: typid_t, t2: typid_t, arg3: int) ‑> int
lexcompare_tinfo(t1, t2, arg3) -> int
load_til(name: char const *, tildir: char const * = None) ‑> qstring *
load_til(name, tildir=None) -> til_t Load til from a file without adding it to the database list (see also add_til). Failure to load base tils are reported into 'errbuf'. They do not prevent loading of the main til.
NB: the file extension is forced to .til tildir: (C++: const char *) directory where to load the til from. nullptr means default til subdirectories. return: pointer to resulting til, nullptr if failed and error message is in errbuf
load_til_header(tildir: char const *, name: char const *) ‑> qstring *
load_til_header(tildir, name) -> til_t Get human-readable til description.
lower_type(til: til_t, tif: tinfo_t, name: char const * = None) ‑> int
lower_type(til, tif, name=None, _helper=None) -> int 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, etc We 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 children types walked through by recursion. retval 1: removed FTI_HIGH, retval 2: made substantial changes retval -1: failure
new_til(name: char const *, desc: char const *) ‑> til_t *
new_til(name, desc) -> til_t Initialize a til.
next_named_type(ti: til_t, name: char const *, ntf_flags: int) ‑> char const *
next_named_type(ti, name, ntf_flags) -> char const * Enumerate types.
optimize_argloc(vloc: argloc_t, size: int, gaps: rangeset_t) ‑> bool
optimize_argloc(vloc, size, gaps) -> bool Verify and optimize scattered argloc into simple form. All new arglocs must be processed by this function. retval true: success retval false: the input argloc was illegal
pack_idcobj_to_bv(obj: idc_value_t const *, tif: tinfo_t, bytes: relobj_t, objoff: void *, pio_flags: int = 0) ‑> error_t
pack_idcobj_to_bv(obj, tif, bytes, objoff, pio_flags=0) -> error_t Write a typed idc object to the byte vector. Byte vector may be non-empty, this function will append data to it
pack_idcobj_to_idb(obj: idc_value_t const *, tif: tinfo_t, ea: ea_t, pio_flags: int = 0) ‑> error_t
pack_idcobj_to_idb(obj, tif, ea, pio_flags=0) -> error_t Write a typed idc object to the database.
pack_object_to_bv(py_obj: PyObject *, ti: til_t, type: type_t const *, fields: p_list const *, base_ea: ea_t, pio_flags: int = 0) ‑> PyObject *
pack_object_to_bv(py_obj, ti, type, fields, base_ea, pio_flags=0) -> PyObject Packs a typed object to a string
pack_object_to_idb(py_obj: PyObject *, ti: til_t, type: type_t const *, fields: p_list const *, ea: ea_t, pio_flags: int = 0) ‑> PyObject *
pack_object_to_idb(py_obj, ti, type, fields, ea, pio_flags=0) -> PyObject 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
parse_decl(out_tif: tinfo_t, til: til_t, decl: char const *, pt_flags: int) ‑> qstring *
parse_decl(out_tif, til, decl, pt_flags) -> str 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. note: name & tif may be empty after the call!
parse_decls(til: til_t, input: char const *, printer: printer_t *, hti_flags: int) ‑> int
parse_decls(til, input, printer, hti_flags) -> int 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.
print_argloc(vloc: argloc_t, size: int = 0, vflags: int = 0) ‑> size_t
print_argloc(vloc, size=0, vflags=0) -> size_t Convert an argloc to human readable form.
print_decls(printer: text_sink_t, til: til_t, py_ordinals: PyObject *, flags: uint32) ‑> PyObject *
print_decls(printer, til, py_ordinals, flags) -> int Print types (and possibly their dependencies) in a format suitable for using in a header file. This is the reverse parse_decls().
print_tinfo(prefix: char const *, indent: int, cmtindent: int, flags: int, tif: tinfo_t, name: char const *, cmt: char const *) ‑> qstring *
print_tinfo(prefix, indent, cmtindent, flags, tif, name, cmt) -> str
print_type(ea: ea_t, prtype_flags: int) ‑> qstring *
print_type(ea, prtype_flags) -> str Get type declaration for the specified address.
read_tinfo_bitfield_value(typid: typid_t, v: uint64, bitoff: int) ‑> uint64
read_tinfo_bitfield_value(typid, v, bitoff) -> uint64
remove_abi_opts(abi_opts: char const *, user_level: bool = False) ‑> bool
remove_abi_opts(abi_opts, user_level=False) -> bool
remove_pointer(tif: tinfo_t) ‑> ida_typeinf.tinfo_t
remove_pointer(tif) -> tinfo_t
current type is not a pointer, return the current type. See also get_ptrarr_object() and get_pointed_object()
remove_tinfo_pointer(tif: tinfo_t, name: char const *, til: til_t) ‑> PyObject *
remove_tinfo_pointer(tif, name, til) -> (bool, NoneType), (bool, str) 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.
replace_ordinal_typerefs(til: til_t, tif: tinfo_t) ‑> int
replace_ordinal_typerefs(til, tif) -> int 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.
resolve_typedef(til: til_t, type: type_t const *) ‑> type_t const *
resolve_typedef(til, type) -> type_t const *
save_tinfo(tif: tinfo_t, til: til_t, ord: size_t, name: char const *, ntf_flags: int) ‑> tinfo_code_t
save_tinfo(tif, til, ord, name, ntf_flags) -> tinfo_code_t
score_tinfo(tif: tinfo_t) ‑> uint32
score_tinfo(tif) -> uint32
serialize_tinfo(type: qtype *, fields: qtype *, fldcmts: qtype *, tif: tinfo_t, sudt_flags: int) ‑> bool
serialize_tinfo(type, fields, fldcmts, tif, sudt_flags) -> bool
set_abi_name(abiname: char const *, user_level: bool = False) ‑> bool
set_abi_name(abiname, user_level=False) -> bool Set abi name (see Compiler IDs)
set_c_header_path(incdir: char const *) ‑> void
set_c_header_path(incdir) Set include directory path the target compiler.
set_c_macros(macros: char const *) ‑> void
set_c_macros(macros) Set predefined macros for the target compiler.
set_compiler(cc: compiler_info_t, flags: int, abiname: char const * = None) ‑> bool
set_compiler(cc, flags, abiname=None) -> bool Change current compiler.
set_compiler_id(id: comp_t, abiname: char const * = None) ‑> bool
set_compiler_id(id, abiname=None) -> bool Set the compiler id (see Compiler IDs)
set_compiler_string(compstr: char const *, user_level: bool) ‑> bool
set_compiler_string(compstr, user_level) -> bool
set_numbered_type(ti: til_t, ordinal: uint32, ntf_flags: int, name: char const *, type: type_t const *, fields: p_list const * = None, cmt: char const * = None, fldcmts: p_list const * = None, sclass: sclass_t const * = None) ‑> tinfo_code_t
set_numbered_type(ti, ordinal, ntf_flags, name, type, fields=None, cmt=None, fldcmts=None, sclass=None) -> tinfo_code_t
set_tinfo_attr(tif: tinfo_t, ta: type_attr_t, may_overwrite: bool) ‑> bool
set_tinfo_attr(tif, ta, may_overwrite) -> bool
set_tinfo_attrs(tif: tinfo_t, ta: type_attrs_t) ‑> bool
set_tinfo_attrs(tif, ta) -> bool
set_tinfo_property(tif: tinfo_t, sta_prop: int, x: size_t) ‑> size_t
set_tinfo_property(tif, sta_prop, x) -> size_t
set_tinfo_property4(tif: tinfo_t, sta_prop: int, p1: size_t, p2: size_t, p3: size_t, p4: size_t) ‑> size_t
set_tinfo_property4(tif, sta_prop, p1, p2, p3, p4) -> size_t
set_type_alias(ti: til_t, src_ordinal: uint32, dst_ordinal: uint32) ‑> bool
set_type_alias(ti, src_ordinal, dst_ordinal) -> bool Create a type alias. Redirects all references to source type to the destination type. This is equivalent to instantaneous replacement all references to srctype by dsttype.
set_type_choosable(ti: til_t, ordinal: uint32, value: bool) ‑> void
set_type_choosable(ti, ordinal, value) Enable/disable 'choosability' flag for a struct/union type
set_vftable_ea(ordinal: uint32, vftable_ea: ea_t) ‑> bool
set_vftable_ea(ordinal, vftable_ea) -> bool Set the address of a vftable instance for a vftable type.
store_til(ti: til_t, tildir: char const *, name: char const *) ‑> bool
store_til(ti, tildir, name) -> bool 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().
NB: the file extension is forced to .til return: success
stroff_as_size(plen: int, tif: tinfo_t, value: asize_t) ‑> bool
stroff_as_size(plen, tif, value) -> bool Should display a structure offset expression as the structure size?
switch_to_golang() ‑> void
switch_to_golang() switch to GOLANG calling convention (to be used as default CC)
tinfo_errstr(code: tinfo_code_t) ‑> char const *
tinfo_errstr(code) -> char const * Helper function to convert an error code into a printable string. Additional arguments are handled using the functions from err.h
udm_t__make_gap(_this: udm_t, byteoff: uval_t, nbytes: uval_t) ‑> bool
udm_t__make_gap(_this, byteoff, nbytes) -> bool
udt_type_data_t__find_member(_this: udt_type_data_t, udm: udm_t, strmem_flags: int) ‑> ssize_t
udt_type_data_t__find_member(_this, udm, strmem_flags) -> ssize_t
udt_type_data_t__get_best_fit_member(_this: udt_type_data_t, disp: asize_t) ‑> ssize_t
udt_type_data_t__get_best_fit_member(_this, disp) -> ssize_t
unpack_idcobj_from_bv(obj: idc_value_t *, tif: tinfo_t, bytes: bytevec_t const &, pio_flags: int = 0) ‑> error_t
unpack_idcobj_from_bv(obj, tif, bytes, pio_flags=0) -> error_t Read a typed idc object from the byte vector.
unpack_idcobj_from_idb(obj: idc_value_t *, tif: tinfo_t, ea: ea_t, off0: bytevec_t const *, pio_flags: int = 0) ‑> error_t
unpack_idcobj_from_idb(obj, tif, ea, off0, pio_flags=0) -> error_t Collection of register objects.
Read a typed idc object from the database
unpack_object_from_bv(ti: til_t, type: type_t const *, fields: p_list const *, bytes: bytevec_t const &, pio_flags: int = 0) ‑> PyObject *
unpack_object_from_bv(ti, type, fields, bytes, pio_flags=0) -> PyObject Unpacks a buffer into an object. Returns the error_t returned by idaapi.pack_object_to_idb
unpack_object_from_idb(ti: til_t, type: type_t const *, fields: p_list const *, ea: ea_t, pio_flags: int = 0) ‑> PyObject *
unpack_object_from_idb(ti, type, fields, ea, pio_flags=0) -> PyObject
use_golang_cc() ‑> bool
use_golang_cc() -> bool is GOLANG calling convention used by default?
value_repr_t__from_opinfo(_this: value_repr_t, flags: flags64_t, afl: aflags_t, opinfo: opinfo_t, ap: array_parameters_t) ‑> bool
value_repr_t__from_opinfo(_this, flags, afl, opinfo, ap) -> bool
value_repr_t__print_(_this: value_repr_t, colored: bool) ‑> qstring *
value_repr_t__print_(_this, colored) -> str
verify_argloc(vloc: argloc_t, size: int, gaps: rangeset_t) ‑> int
verify_argloc(vloc, size, gaps) -> int Verify argloc_t.
verify_tinfo(typid: typid_t) ‑> int
verify_tinfo(typid) -> int
visit_stroff_udms(sfv: udm_visitor_t, path: tid_t const *, disp: adiff_t *, appzero: bool) ‑> adiff_t *
visit_stroff_udms(sfv, path, disp, appzero) -> int Visit structure fields in a stroff expression or in a reference to a struct data variable. This function can be used to enumerate all components of an expression like 'a.b.c'.
visit_subtypes(visitor: tinfo_visitor_t, out: type_mods_t, tif: tinfo_t, name: char const *, cmt: char const *) ‑> int
visit_subtypes(visitor, out, tif, name, cmt) -> int
write_tinfo_bitfield_value(typid: typid_t, dst: uint64, v: uint64, bitoff: int) ‑> uint64
write_tinfo_bitfield_value(typid, dst, v, bitoff) -> uint64
Classes
aloc_visitor_t()
: Proxy of C++ aloc_visitor_t class.
Methods
visit_location(self, v: argloc_t, off: int, size: int) ‑> int visit_location(self, v, off, size) -> int
v: argloc_t & off: int size: int
argloc_t(*args)
: Proxy of C++ argloc_t class.
Descendants
Methods
advance(self, delta: int) ‑> bool advance(self, delta) -> bool Move the location to point 'delta' bytes further.
delta: (C++: int)
align_reg_high(self, size: size_t, _slotsize: size_t) ‑> void align_reg_high(self, size, _slotsize) Set register offset to align it to the upper part of _SLOTSIZE.
size: (C++: size_t) _slotsize: (C++: size_t)
align_stkoff_high(self, size: size_t, _slotsize: size_t) ‑> void align_stkoff_high(self, size, _slotsize) Set stack offset to align to the upper part of _SLOTSIZE.
size: (C++: size_t) _slotsize: (C++: size_t)
atype(self) ‑> argloc_type_t atype(self) -> argloc_type_t Get type (Argument location types)
calc_offset(self) ‑> sval_t calc_offset(self) -> sval_t Calculate offset that can be used to compare 2 similar arglocs.
compare(self, r: argloc_t) ‑> int compare(self, r) -> int
r: argloc_t const &
consume_rrel(self, p: rrel_t) ‑> void consume_rrel(self, p) Set register-relative location - can't be nullptr.
p: (C++: rrel_t *)
consume_scattered(self, p: scattered_aloc_t) ‑> void consume_scattered(self, p) Set distributed argument location.
p: (C++: scattered_aloc_t *) scattered_aloc_t const &
get_biggest(self) ‑> argloc_t::biggest_t get_biggest(self) -> argloc_t::biggest_t Get largest element in internal union.
get_custom(self) ‑> void * get_custom(self) -> void * Get custom argloc info. Use if atype() == ALOC_CUSTOM
get_ea(self) ‑> ea_t get_ea(self) -> ea_t Get the global address. Use when atype() == ALOC_STATIC
get_reginfo(self) ‑> uint32 get_reginfo(self) -> uint32 Get all register info. Use when atype() == ALOC_REG1 or ALOC_REG2
get_rrel(self, *args) ‑> rrel_t const & get_rrel(self) -> rrel_t Get register-relative info. Use when atype() == ALOC_RREL
has_reg(self) ‑> bool has_reg(self) -> bool TRUE if argloc has a register part.
has_stkoff(self) ‑> bool has_stkoff(self) -> bool TRUE if argloc has a stack part.
in_stack(self) ‑> bool in_stack(self) -> bool TRUE if argloc is in stack entirely.
is_badloc(self) ‑> bool is_badloc(self) -> bool See ALOC_NONE.
is_custom(self) ‑> bool is_custom(self) -> bool See ALOC_CUSTOM.
is_ea(self) ‑> bool is_ea(self) -> bool See ALOC_STATIC.
is_fragmented(self) ‑> bool is_fragmented(self) -> bool is_scattered() || is_reg2()
is_mixed_scattered(self) ‑> bool is_mixed_scattered(self) -> bool mixed scattered: consists of register and stack parts
is_reg(self) ‑> bool is_reg(self) -> bool is_reg1() || is_reg2()
is_reg1(self) ‑> bool is_reg1(self) -> bool See ALOC_REG1.
is_reg2(self) ‑> bool is_reg2(self) -> bool See ALOC_REG2.
is_rrel(self) ‑> bool is_rrel(self) -> bool See ALOC_RREL.
is_scattered(self) ‑> bool is_scattered(self) -> bool See ALOC_DIST.
is_stkoff(self) ‑> bool is_stkoff(self) -> bool See ALOC_STACK.
reg1(self) ‑> int reg1(self) -> int Get the register info. Use when atype() == ALOC_REG1 or ALOC_REG2
reg2(self) ‑> int reg2(self) -> int Get info for the second register. Use when atype() == ALOC_REG2
regoff(self) ‑> int regoff(self) -> int Get offset from the beginning of the register in bytes. Use when atype() == ALOC_REG1
scattered(self, *args) ‑> scattered_aloc_t const & scattered(self) -> scattered_aloc_t Get scattered argument info. Use when atype() == ALOC_DIST
set_badloc(self) ‑> void set_badloc(self) Set to invalid location.
set_ea(self, _ea: ea_t) ‑> void set_ea(self, _ea) Set static ea location.
_ea: (C++: ea_t)
set_reg1(self, reg: int, off: int = 0) ‑> void set_reg1(self, reg, off=0) Set register location.
reg: (C++: int) off: (C++: int)
set_reg2(self, _reg1: int, _reg2: int) ‑> void set_reg2(self, _reg1, _reg2) Set secondary register location.
_reg1: (C++: int) _reg2: (C++: int)
set_stkoff(self, off: sval_t) ‑> void set_stkoff(self, off) Set stack offset location.
off: (C++: sval_t)
stkoff(self) ‑> sval_t stkoff(self) -> sval_t Get the stack offset. Use if atype() == ALOC_STACK
swap(self, r: argloc_t) ‑> void swap(self, r) Assign this == r and r == this.
r: (C++: argloc_t &)
argpart_t(*args)
: Proxy of C++ argpart_t class.
Ancestors (in MRO)
Instance variables
off: ushort
off
size: ushort
size
Methods
bad_offset(self) ‑> bool bad_offset(self) -> bool Does this argpart have a valid offset?
bad_size(self) ‑> bool bad_size(self) -> bool Does this argpart have a valid size?
swap(self, r: argpart_t) ‑> void swap(self, r) Assign this = r and r = this.
r: (C++: argpart_t &)
argpartvec_t(*args)
: Proxy of C++ qvector< argpart_t > class.
Descendants
Methods
add_unique(self, x: argpart_t) ‑> bool add_unique(self, x) -> bool
x: argpart_t const &
at(self, _idx: size_t) ‑> argpart_t const & at(self, _idx) -> argpart_t
_idx: size_t
back(self)
begin(self, *args) ‑> qvector< argpart_t >::const_iterator begin(self) -> argpart_t
capacity(self) ‑> size_t capacity(self) -> size_t
clear(self) ‑> void clear(self)
empty(self) ‑> bool empty(self) -> bool
end(self, *args) ‑> qvector< argpart_t >::const_iterator end(self) -> argpart_t
erase(self, *args) ‑> qvector< argpart_t >::iterator erase(self, it) -> argpart_t
it: qvector< argpart_t >::iterator
erase(self, first, last) -> argpart_t
first: qvector< argpart_t >::iterator last: qvector< argpart_t >::iterator
extract(self) ‑> argpart_t * extract(self) -> argpart_t
find(self, *args) ‑> qvector< argpart_t >::const_iterator find(self, x) -> argpart_t
x: argpart_t const &
front(self)
grow(self, *args) ‑> void grow(self, x=argpart_t())
x: argpart_t const &
has(self, x: argpart_t) ‑> bool has(self, x) -> bool
x: argpart_t const &
inject(self, s: argpart_t, len: size_t) ‑> void inject(self, s, len)
s: argpart_t * len: size_t
insert(self, it: argpart_t, x: argpart_t) ‑> qvector< argpart_t >::iterator insert(self, it, x) -> argpart_t
it: qvector< argpart_t >::iterator x: argpart_t const &
pop_back(self) ‑> void pop_back(self)
push_back(self, *args) ‑> argpart_t & push_back(self, x)
x: argpart_t const &
push_back(self) -> argpart_t
qclear(self) ‑> void qclear(self)
reserve(self, cnt: size_t) ‑> void reserve(self, cnt)
cnt: size_t
resize(self, *args) ‑> void resize(self, _newsize, x)
_newsize: size_t x: argpart_t const &
resize(self, _newsize)
_newsize: size_t
size(self) ‑> size_t size(self) -> size_t
swap(self, r: argpartvec_t) ‑> void swap(self, r)
r: qvector< argpart_t > &
truncate(self) ‑> void truncate(self)
argtinfo_helper_t()
: Proxy of C++ argtinfo_helper_t class.
Instance variables
reserved: size_t
reserved
Methods
has_delay_slot(self, arg0: ea_t) ‑> bool has_delay_slot(self, arg0) -> bool The call instruction with a delay slot?.
arg0: ea_t
is_stkarg_load(self, insn: insn_t const &, src: int *, dst: int *) ‑> bool is_stkarg_load(self, insn, src, dst) -> bool Is the current insn a stkarg load?. if yes:
src: index of the source operand in insn_t::ops
dst: index of the destination operand in insn_t::ops insn_t::ops[dst].addr is expected to have the stack offset
insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) src: (C++: int *) dst: (C++: int *)
set_op_tinfo(self, insn: insn_t const &, x: op_t const &, tif: tinfo_t, name: char const *) ‑> bool set_op_tinfo(self, insn, x, tif, name) -> bool Set the operand type as specified.
insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) x: (C++: const op_t &) op_t const & tif: (C++: const tinfo_t &) tinfo_t const & name: (C++: const char *) char const *
use_arg_tinfos(self, caller: ea_t, fti: func_type_data_t, rargs: funcargvec_t) ‑> void use_arg_tinfos(self, caller, fti, rargs) This function is to be called by the processor module in response to ev_use_arg_types.
caller: (C++: ea_t) fti: (C++: func_type_data_t *) rargs: (C++: funcargvec_t *)
array_type_data_t(b: size_t = 0, n: size_t = 0)
: Proxy of C++ array_type_data_t class.
Instance variables
base: uint32
base
elem_type: tinfo_t
elem_type
nelems: uint32
nelems
Methods
swap(self, r: array_type_data_t) ‑> void swap(self, r) set this = r and r = this
r: (C++: array_type_data_t &)
bitfield_type_data_t()
: Proxy of C++ bitfield_type_data_t class.
Instance variables
is_unsigned: bool
is_unsigned
nbytes: uchar
nbytes
width: uchar
width
Methods
compare(self, r: bitfield_type_data_t) ‑> int compare(self, r) -> int
r: bitfield_type_data_t const &
is_valid_bitfield(self) ‑> bool is_valid_bitfield(self) -> bool
swap(self, r: bitfield_type_data_t) ‑> void swap(self, r)
r: bitfield_type_data_t &
callregs_t(*args)
: Proxy of C++ callregs_t class.
Class variables
FPREGS
GPREGS
Static methods
regcount(cc: cm_t) ‑> int regcount(cc) -> int Get max number of registers may be used in a function call.
cc: (C++: cm_t)
Instance variables
fpregs: intvec_t
fpregs
gpregs: intvec_t
gpregs
nregs: int
nregs
policy: argreg_policy_t
policy
Methods
by_slots(self) ‑> bool by_slots(self) -> bool
init_regs(self, cc: cm_t) ‑> void init_regs(self, cc) Init policy & registers for given CC.
cc: (C++: cm_t)
reginds(self, gp_ind: int *, fp_ind: int *, r: int) ‑> bool reginds(self, gp_ind, fp_ind, r) -> bool Get register indexes within GP/FP arrays. (-1 -> is not present in the corresponding array)
gp_ind: (C++: int *) fp_ind: (C++: int *) r: (C++: int)
reset(self) ‑> void reset(self) Set policy and registers to invalid values.
set(self, _policy: argreg_policy_t, gprs: int const *, fprs: int const *) ‑> void set(self, _policy, gprs, fprs) Init policy & registers (arrays are -1-terminated)
_policy: (C++: argreg_policy_t) enum argreg_policy_t gprs: (C++: const int *) int const * fprs: (C++: const int *) int const *
set_registers(self, kind: callregs_t::reg_kind_t, first_reg: int, last_reg: int) ‑> void set_registers(self, kind, first_reg, last_reg)
kind: enum callregs_t::reg_kind_t first_reg: int last_reg: int
swap(self, r: callregs_t) ‑> void swap(self, r) swap two instances
r: (C++: callregs_t &)
const_aloc_visitor_t()
: Proxy of C++ const_aloc_visitor_t class.
Methods
visit_location(self, v: argloc_t, off: int, size: int) ‑> int visit_location(self, v, off, size) -> int
v: argloc_t const & off: int size: int
custom_data_type_info_t()
: Proxy of C++ custom_data_type_info_t class.
Instance variables
dtid: int16
dtid
fid: int16
fid
edm_t()
: Proxy of C++ edm_t class.
Instance variables
cmt: qstring
cmt
name: qstring
name
value: uint64
value
Methods
get_tid(self) ‑> tid_t get_tid(self) -> tid_t
swap(self, r: edm_t) ‑> void swap(self, r)
r: edm_t &
enum_member_t()
: Proxy of C++ edm_t class.
Instance variables
cmt: qstring
cmt
name: qstring
name
value: uint64
value
Methods
get_tid(self) ‑> tid_t get_tid(self) -> tid_t
swap(self, r: edm_t) ‑> void swap(self, r)
r: edm_t &
edmvec_t(*args)
: Proxy of C++ qvector< edm_t > class.
Descendants
Methods
add_unique(self, x: edm_t) ‑> bool add_unique(self, x) -> bool
x: edm_t const &
at(self, _idx: size_t) ‑> edm_t const & at(self, _idx) -> edm_t
_idx: size_t
back(self)
begin(self, *args) ‑> qvector< edm_t >::const_iterator begin(self) -> edm_t
capacity(self) ‑> size_t capacity(self) -> size_t
clear(self) ‑> void clear(self)
empty(self) ‑> bool empty(self) -> bool
end(self, *args) ‑> qvector< edm_t >::const_iterator end(self) -> edm_t
erase(self, *args) ‑> qvector< edm_t >::iterator erase(self, it) -> edm_t
it: qvector< edm_t >::iterator
erase(self, first, last) -> edm_t
first: qvector< edm_t >::iterator last: qvector< edm_t >::iterator
extract(self) ‑> edm_t * extract(self) -> edm_t
find(self, *args) ‑> qvector< edm_t >::const_iterator find(self, x) -> edm_t
x: edm_t const &
front(self)
grow(self, *args) ‑> void grow(self, x=edm_t())
x: edm_t const &
has(self, x: edm_t) ‑> bool has(self, x) -> bool
x: edm_t const &
inject(self, s: edm_t, len: size_t) ‑> void inject(self, s, len)
s: edm_t * len: size_t
insert(self, it: edm_t, x: edm_t) ‑> qvector< edm_t >::iterator insert(self, it, x) -> edm_t
it: qvector< edm_t >::iterator x: edm_t const &
pop_back(self) ‑> void pop_back(self)
push_back(self, *args) ‑> edm_t & push_back(self, x)
x: edm_t const &
push_back(self) -> edm_t
qclear(self) ‑> void qclear(self)
reserve(self, cnt: size_t) ‑> void reserve(self, cnt)
cnt: size_t
resize(self, *args) ‑> void resize(self, _newsize, x)
_newsize: size_t x: edm_t const &
resize(self, _newsize)
_newsize: size_t
size(self) ‑> size_t size(self) -> size_t
swap(self, r: edmvec_t) ‑> void swap(self, r)
r: qvector< edm_t > &
truncate(self) ‑> void truncate(self)
enum_member_vec_t(*args)
: Proxy of C++ qvector< edm_t > class.
Descendants
Methods
add_unique(self, x: edm_t) ‑> bool add_unique(self, x) -> bool
x: edm_t const &
at(self, _idx: size_t) ‑> edm_t const & at(self, _idx) -> edm_t
_idx: size_t
back(self)
begin(self, *args) ‑> qvector< edm_t >::const_iterator begin(self) -> edm_t
capacity(self) ‑> size_t capacity(self) -> size_t
clear(self) ‑> void clear(self)
empty(self) ‑> bool empty(self) -> bool
end(self, *args) ‑> qvector< edm_t >::const_iterator end(self) -> edm_t
erase(self, *args) ‑> qvector< edm_t >::iterator erase(self, it) -> edm_t
it: qvector< edm_t >::iterator
erase(self, first, last) -> edm_t
first: qvector< edm_t >::iterator last: qvector< edm_t >::iterator
extract(self) ‑> edm_t * extract(self) -> edm_t
find(self, *args) ‑> qvector< edm_t >::const_iterator find(self, x) -> edm_t
x: edm_t const &
front(self)
grow(self, *args) ‑> void grow(self, x=edm_t())
x: edm_t const &
has(self, x: edm_t) ‑> bool has(self, x) -> bool
x: edm_t const &
inject(self, s: edm_t, len: size_t) ‑> void inject(self, s, len)
s: edm_t * len: size_t
insert(self, it: edm_t, x: edm_t) ‑> qvector< edm_t >::iterator insert(self, it, x) -> edm_t
it: qvector< edm_t >::iterator x: edm_t const &
pop_back(self) ‑> void pop_back(self)
push_back(self, *args) ‑> edm_t & push_back(self, x)
x: edm_t const &
push_back(self) -> edm_t
qclear(self) ‑> void qclear(self)
reserve(self, cnt: size_t) ‑> void reserve(self, cnt)
cnt: size_t
resize(self, *args) ‑> void resize(self, _newsize, x)
_newsize: size_t x: edm_t const &
resize(self, _newsize)
_newsize: size_t
size(self) ‑> size_t size(self) -> size_t
swap(self, r: edmvec_t) ‑> void swap(self, r)
r: qvector< edm_t > &
truncate(self) ‑> void truncate(self)
enum_type_data_t(*args)
: Proxy of C++ enum_type_data_t class.
Ancestors (in MRO)
Instance variables
bte: bte_t
bte
group_sizes: intvec_t
group_sizes
taenum_bits: uint32
taenum_bits
Methods
add_constant(self, name: char const *, value: uint64, cmt: char const * = None) ‑> void add_constant(self, name, value, cmt=None) add constant for regular enum
name: (C++: const char *) char const * value: (C++: uint64) cmt: (C++: const char *) char const *
all_constants(self) Generate tupples of all constants except of bitmasks. Each tupple is: [0] constant index [1] enum member index of group start [2] group size In case of regular enum the second element of tupple is 0 and the third element of tupple is the number of enum members.
all_groups(self, skip_trivial=False) Generate tuples for bitmask enum groups. Each tupple is: [0] enum member index of group start [1] group size Tupples may include or not the group with 1 element.
calc_mask(self) ‑> uint64 calc_mask(self) -> uint64
calc_nbytes(self) ‑> int calc_nbytes(self) -> int get the width of enum in bytes
find_member(self, *args) ‑> ssize_t find_member(self, name, _from=0, to=size_t(-1)) -> ssize_t find member (constant or bmask) by value
name: char const * from: (C++: size_t) to: (C++: size_t)
find_member(self, value, serial, _from=0, to=size_t(-1), vmask=uint64(-1)) -> ssize_t
value: uint64 serial: uchar from: size_t to: size_t vmask: uint64
get_constant_group(self, *args) ‑> PyObject * get_constant_group(self, group_start_index, group_size, idx) -> bool get group parameters for the constant, valid for bitmask enum
group_start_index: (C++: size_t *) index of the group mask group_size: (C++: size_t *) group size (>=1) idx: (C++: size_t) constant index return: success get_constant_group(self, idx) -> PyObject *
idx: size_t
get_enum_radix(self) ‑> int get_enum_radix(self) -> int Get enum constant radix
return: radix or 1 for BTE_CHAR
get_max_serial(self, value: uint64) ‑> uchar get_max_serial(self, value) -> uchar return the maximum serial for the value
value: (C++: uint64)
get_serial(self, index: size_t) ‑> uchar get_serial(self, index) -> uchar returns serial for the constant
index: (C++: size_t)
get_value_repr(self, repr: value_repr_t) ‑> tinfo_code_t get_value_repr(self, repr) -> tinfo_code_t get enum radix and other representation info
repr: (C++: value_repr_t *) value display info
has_lzero(self) ‑> bool has_lzero(self) -> bool
is_bf(self) ‑> bool is_bf(self) -> bool is bitmask or ordinary enum?
is_bin(self) ‑> bool is_bin(self) -> bool
is_char(self) ‑> bool is_char(self) -> bool
is_dec(self) ‑> bool is_dec(self) -> bool
is_group_mask_at(self, idx: size_t) ‑> bool is_group_mask_at(self, idx) -> bool is the enum member at IDX a non-trivial group mask? a trivial group consist of one bit and has just one member, which can be considered as a mask or a bitfield constant
idx: (C++: size_t) index return: success
is_hex(self) ‑> bool is_hex(self) -> bool
is_number_signed(self) ‑> bool is_number_signed(self) -> bool
is_oct(self) ‑> bool is_oct(self) -> bool
is_sbin(self) ‑> bool is_sbin(self) -> bool
is_shex(self) ‑> bool is_shex(self) -> bool
is_soct(self) ‑> bool is_soct(self) -> bool
is_udec(self) ‑> bool is_udec(self) -> bool
is_valid_group_sizes(self) ‑> bool is_valid_group_sizes(self) -> bool is valid group sizes
set_enum_radix(self, radix: int, sign: bool) ‑> void set_enum_radix(self, radix, sign) Set radix to display constants
radix: (C++: int) radix with the special case 1 to display as character sign: (C++: bool)
set_lzero(self, on: bool) ‑> void set_lzero(self, on)
on: bool
set_nbytes(self, nbytes: int) ‑> bool set_nbytes(self, nbytes) -> bool set enum width (nbytes)
nbytes: (C++: int)
set_value_repr(self, repr: value_repr_t) ‑> tinfo_code_t set_value_repr(self, repr) -> tinfo_code_t set enum radix and other representation info
repr: (C++: const value_repr_t &) value display info
store_64bit_values(self) ‑> bool store_64bit_values(self) -> bool
swap(self, r: enum_type_data_t) ‑> void swap(self, r) swap two instances
r: (C++: enum_type_data_t &)
func_type_data_t()
: Proxy of C++ func_type_data_t class.
Ancestors (in MRO)
Instance variables
cc: cm_t
cc
flags: int
flags
retloc: argloc_t
retloc
rettype: tinfo_t
rettype
spoiled: reginfovec_t
spoiled
stkargs: uval_t
stkargs
Methods
dump(self, praloc_bits: int = 2) ‑> bool dump(self, praloc_bits=0x02) -> bool Dump information that is not always visible in the function prototype. (argument locations, return location, total stkarg size)
praloc_bits: (C++: int)
find_argument(self, *args) ‑> ssize_t find_argument(self, name, _from=0, to=size_t(-1)) -> ssize_t find argument by name
name: (C++: const char *) char const * from: (C++: size_t) to: (C++: size_t)
get_call_method(self) ‑> int get_call_method(self) -> int
guess_cc(self, purged: int, cc_flags: int) ‑> cm_t guess_cc(self, purged, cc_flags) -> cm_t Guess function calling convention use the following info: argument locations and 'stkargs'
purged: (C++: int) cc_flags: (C++: int)
is_const(self) ‑> bool is_const(self) -> bool
is_ctor(self) ‑> bool is_ctor(self) -> bool
is_dtor(self) ‑> bool is_dtor(self) -> bool
is_golang_cc(self) ‑> bool is_golang_cc(self) -> bool
is_high(self) ‑> bool is_high(self) -> bool
is_noret(self) ‑> bool is_noret(self) -> bool
is_pure(self) ‑> bool is_pure(self) -> bool
is_static(self) ‑> bool is_static(self) -> bool
is_swift_cc(self) ‑> bool is_swift_cc(self) -> bool
is_vararg_cc(self) ‑> bool is_vararg_cc(self) -> bool
is_virtual(self) ‑> bool is_virtual(self) -> bool
swap(self, r: func_type_data_t) ‑> void swap(self, r)
r: func_type_data_t &
funcarg_t()
: Proxy of C++ funcarg_t class.
Instance variables
argloc: argloc_t
argloc
cmt: qstring
cmt
flags: uint32
flags
name: qstring
name
type: tinfo_t
type
funcargvec_t(*args)
: Proxy of C++ qvector< funcarg_t > class.
Descendants
Methods
add_unique(self, x: funcarg_t) ‑> bool add_unique(self, x) -> bool
x: funcarg_t const &
at(self, _idx: size_t) ‑> funcarg_t const & at(self, _idx) -> funcarg_t
_idx: size_t
back(self)
begin(self, *args) ‑> qvector< funcarg_t >::const_iterator begin(self) -> funcarg_t
capacity(self) ‑> size_t capacity(self) -> size_t
clear(self) ‑> void clear(self)
empty(self) ‑> bool empty(self) -> bool
end(self, *args) ‑> qvector< funcarg_t >::const_iterator end(self) -> funcarg_t
erase(self, *args) ‑> qvector< funcarg_t >::iterator erase(self, it) -> funcarg_t
it: qvector< funcarg_t >::iterator
erase(self, first, last) -> funcarg_t
first: qvector< funcarg_t >::iterator last: qvector< funcarg_t >::iterator
extract(self) ‑> funcarg_t * extract(self) -> funcarg_t
find(self, *args) ‑> qvector< funcarg_t >::const_iterator find(self, x) -> funcarg_t
x: funcarg_t const &
front(self)
grow(self, *args) ‑> void grow(self, x=funcarg_t())
x: funcarg_t const &
has(self, x: funcarg_t) ‑> bool has(self, x) -> bool
x: funcarg_t const &
inject(self, s: funcarg_t, len: size_t) ‑> void inject(self, s, len)
s: funcarg_t * len: size_t
insert(self, it: funcarg_t, x: funcarg_t) ‑> qvector< funcarg_t >::iterator insert(self, it, x) -> funcarg_t
it: qvector< funcarg_t >::iterator x: funcarg_t const &
pop_back(self) ‑> void pop_back(self)
push_back(self, *args) ‑> funcarg_t & push_back(self, x)
x: funcarg_t const &
push_back(self) -> funcarg_t
qclear(self) ‑> void qclear(self)
reserve(self, cnt: size_t) ‑> void reserve(self, cnt)
cnt: size_t
resize(self, *args) ‑> void resize(self, _newsize, x)
_newsize: size_t x: funcarg_t const &
resize(self, _newsize)
_newsize: size_t
size(self) ‑> size_t size(self) -> size_t
swap(self, r: funcargvec_t) ‑> void swap(self, r)
r: qvector< funcarg_t > &
truncate(self) ‑> void truncate(self)
ida_lowertype_helper_t(_tif: tinfo_t, _ea: ea_t, _pb: int)
: Proxy of C++ ida_lowertype_helper_t class.
Ancestors (in MRO)
Methods
get_func_purged_bytes(self, candidate: tinfo_t, arg3: func_type_data_t) ‑> int get_func_purged_bytes(self, candidate, arg3) -> int
candidate: tinfo_t const & arg3: func_type_data_t const &
lowertype_helper_t(*args, **kwargs)
: Proxy of C++ lowertype_helper_t class.
Descendants
Methods
func_has_stkframe_hole(self, candidate: tinfo_t, candidate_data: func_type_data_t) ‑> bool func_has_stkframe_hole(self, candidate, candidate_data) -> bool
candidate: tinfo_t const & candidate_data: func_type_data_t const &
get_func_purged_bytes(self, candidate: tinfo_t, candidate_data: func_type_data_t) ‑> int get_func_purged_bytes(self, candidate, candidate_data) -> int
candidate: tinfo_t const & candidate_data: func_type_data_t const &
predicate_t()
: Proxy of C++ predicate_t class.
Methods
should_display(self, til: til_t, name: char const *, type: type_t const *, fields: p_list const *) ‑> bool should_display(self, til, name, type, fields) -> bool
til: til_t const * name: char const * type: type_t const * fields: p_list const *
ptr_type_data_t(*args)
: Proxy of C++ ptr_type_data_t class.
Instance variables
based_ptr_size: uchar
based_ptr_size
closure: tinfo_t
closure
delta: int32
delta
obj_type: tinfo_t
obj_type
parent: tinfo_t
parent
taptr_bits: uchar
taptr_bits
Methods
is_code_ptr(self) ‑> bool is_code_ptr(self) -> bool Are we pointing to code?
is_shifted(self) ‑> bool is_shifted(self) -> bool
swap(self, r: ptr_type_data_t) ‑> void swap(self, r) Set this = r and r = this.
r: (C++: ptr_type_data_t &)
reginfovec_t(*args)
: Proxy of C++ qvector< reg_info_t > class.
Methods
add_unique(self, x: reg_info_t) ‑> bool add_unique(self, x) -> bool
x: reg_info_t const &
append(self, *args) ‑> reg_info_t & push_back(self, x)
x: reg_info_t const &
push_back(self) -> reg_info_t
at(self, i: size_t) ‑> reg_info_t const & getitem(self, i) -> reg_info_t
i: size_t
back(self)
begin(self, *args) ‑> qvector< reg_info_t >::const_iterator begin(self) -> reg_info_t
capacity(self) ‑> size_t capacity(self) -> size_t
clear(self) ‑> void clear(self)
empty(self) ‑> bool empty(self) -> bool
end(self, *args) ‑> qvector< reg_info_t >::const_iterator end(self) -> reg_info_t
erase(self, *args) ‑> qvector< reg_info_t >::iterator erase(self, it) -> reg_info_t
it: qvector< reg_info_t >::iterator
erase(self, first, last) -> reg_info_t
first: qvector< reg_info_t >::iterator last: qvector< reg_info_t >::iterator
extract(self) ‑> reg_info_t * extract(self) -> reg_info_t
find(self, *args) ‑> qvector< reg_info_t >::const_iterator find(self, x) -> reg_info_t
x: reg_info_t const &
front(self)
grow(self, *args) ‑> void grow(self, x=reg_info_t())
x: reg_info_t const &
has(self, x: reg_info_t) ‑> bool has(self, x) -> bool
x: reg_info_t const &
inject(self, s: reg_info_t, len: size_t) ‑> void inject(self, s, len)
s: reg_info_t * len: size_t
insert(self, it: reg_info_t, x: reg_info_t) ‑> qvector< reg_info_t >::iterator insert(self, it, x) -> reg_info_t
it: qvector< reg_info_t >::iterator x: reg_info_t const &
pop_back(self) ‑> void pop_back(self)
push_back(self, *args) ‑> reg_info_t & push_back(self, x)
x: reg_info_t const &
push_back(self) -> reg_info_t
qclear(self) ‑> void qclear(self)
reserve(self, cnt: size_t) ‑> void reserve(self, cnt)
cnt: size_t
resize(self, *args) ‑> void resize(self, _newsize, x)
_newsize: size_t x: reg_info_t const &
resize(self, _newsize)
_newsize: size_t
size(self) ‑> size_t size(self) -> size_t
swap(self, r: reginfovec_t) ‑> void swap(self, r)
r: qvector< reg_info_t > &
truncate(self) ‑> void truncate(self)
regobj_t()
: Proxy of C++ regobj_t class.
Instance variables
regidx: int
regidx
relocate: int
relocate
value: bytevec_t
value
Methods
size(self) ‑> size_t size(self) -> size_t
regobjs_t()
: Proxy of C++ regobjs_t class.
Ancestors (in MRO)
regobjvec_t(*args)
: Proxy of C++ qvector< regobj_t > class.
Descendants
Methods
at(self, _idx: size_t) ‑> regobj_t const & at(self, _idx) -> regobj_t
_idx: size_t
back(self)
begin(self, *args) ‑> qvector< regobj_t >::const_iterator begin(self) -> regobj_t
capacity(self) ‑> size_t capacity(self) -> size_t
clear(self) ‑> void clear(self)
empty(self) ‑> bool empty(self) -> bool
end(self, *args) ‑> qvector< regobj_t >::const_iterator end(self) -> regobj_t
erase(self, *args) ‑> qvector< regobj_t >::iterator erase(self, it) -> regobj_t
it: qvector< regobj_t >::iterator
erase(self, first, last) -> regobj_t
first: qvector< regobj_t >::iterator last: qvector< regobj_t >::iterator
extract(self) ‑> regobj_t * extract(self) -> regobj_t
front(self)
grow(self, *args) ‑> void grow(self, x=regobj_t())
x: regobj_t const &
inject(self, s: regobj_t, len: size_t) ‑> void inject(self, s, len)
s: regobj_t * len: size_t
insert(self, it: regobj_t, x: regobj_t) ‑> qvector< regobj_t >::iterator insert(self, it, x) -> regobj_t
it: qvector< regobj_t >::iterator x: regobj_t const &
pop_back(self) ‑> void pop_back(self)
push_back(self, *args) ‑> regobj_t & push_back(self, x)
x: regobj_t const &
push_back(self) -> regobj_t
qclear(self) ‑> void qclear(self)
reserve(self, cnt: size_t) ‑> void reserve(self, cnt)
cnt: size_t
resize(self, *args) ‑> void resize(self, _newsize, x)
_newsize: size_t x: regobj_t const &
resize(self, _newsize)
_newsize: size_t
size(self) ‑> size_t size(self) -> size_t
swap(self, r: regobjvec_t) ‑> void swap(self, r)
r: qvector< regobj_t > &
truncate(self) ‑> void truncate(self)
rrel_t()
: Proxy of C++ rrel_t class.
Instance variables
off: sval_t
off
reg: int
reg
scattered_aloc_t()
: Proxy of C++ scattered_aloc_t class.
Ancestors (in MRO)
simd_info_t(*args)
: Proxy of C++ simd_info_t class.
Instance variables
memtype: type_t
memtype
name: char const *
name
size: uint16
size
tif: tinfo_t
tif
Methods
match_pattern(self, pattern: simd_info_t) ‑> bool match_pattern(self, pattern) -> bool
pattern: simd_info_t const *
stkarg_area_info_t()
: Proxy of C++ stkarg_area_info_t class.
Instance variables
cb: size_t
cb
linkage_area: sval_t
linkage_area
shadow_size: sval_t
shadow_size
stkarg_offset: sval_t
stkarg_offset
text_sink_t()
: Proxy of C++ text_sink_t class.
til_symbol_t(n: char const * = None, t: til_t = None)
: Proxy of C++ til_symbol_t class.
Instance variables
name: char const *
name
til: til_t const *
til
til_t()
: Proxy of C++ til_t class.
Instance variables
cc: compiler_info_t
cc
desc: char *
desc
flags: uint32
flags
name: char *
name
nbases: int
nbases
nrefs: int
nrefs
nstreams: int
nstreams
streams: til_stream_t **
streams
type_names
Methods
base(self, n: int) ‑> til_t * base(self, n) -> til_t tils that our til is based on
n: int
find_base(self, n: char const *) ‑> til_t * find_base(self, n) -> til_t Find the base til with the provided name
n: (C++: const char *) the base til name return: the found til_t, or nullptr
get_type_names(self)
is_dirty(self) ‑> bool is_dirty(self) -> bool Has the til been modified? (TIL_MOD)
set_dirty(self) ‑> void set_dirty(self) Mark the til as modified (TIL_MOD)
tinfo_t(*args)
: Proxy of C++ tinfo_t class.
Class variables
ENUMBM_AUTO
ENUMBM_OFF
ENUMBM_ON
Static methods
get_stock(id: stock_type_id_t) ‑> tinfo_t get_stock(id) -> tinfo_t Get stock type information. This function can be used to get tinfo_t for some common types. The same tinfo_t will be returned for the same id, thus saving memory and increasing the speed Please note that retrieving the STI_SIZE_T or STI_SSIZE_T stock type, will also have the side-effect of adding that type to the 'idati' TIL, under the well-known name 'size_t' or 'ssize_t' (respectively). The same is valid for STI_COMPLEX64 and STI_COMPLEX64 stock types with names 'complex64_t' and 'complex128_t' (respectively).
id: (C++: stock_type_id_t) enum stock_type_id_t
Methods
add_edm(self, *args) ‑> tinfo_code_t add_edm(self, edm, bmask=bmask64_t(-1), etf_flags=0, idx=-1) -> tinfo_code_t Add a new enum member (a new symbolic constant)
edm: (C++: const edm_t &) the constant name, value, and comment bmask: (C++: bmask64_t) bmask of the group to add the constant to note: 1. For non-bitmask enum push back constant, BMASK is not used (set it ot -1), never failed 2. For bitmask enum:
if VAL and BMASK are not agreed, return TERR_BAD_MSKVAL
if group with BMASK exists, push back constant to group
otherwise use constant as bitmask for a new group note: ETF_NO_SAVE is ignored
add_funcarg(self, farg: funcarg_t, etf_flags: uint = 0, idx: ssize_t = -1) ‑> tinfo_code_t add_funcarg(self, farg, etf_flags=0, idx=-1) -> tinfo_code_t Add a function argument.
farg: (C++: const funcarg_t &) argument to add etf_flags: (C++: uint) type changing flags flags idx: (C++: ssize_t) the index in the funcarg array where the new funcarg should be placed. if the specified index cannot be honored because it would spoil the funcarg sorting order, it is silently ignored. note: ETF_NO_SAVE is ignored
add_udm(self, udm: udm_t, etf_flags: uint = 0, times: size_t = 1, idx: ssize_t = -1) ‑> tinfo_code_t add_udm(self, udm, etf_flags=0, times=1, idx=-1) -> tinfo_code_t Add a structure/union member.
udm: (C++: const udm_t &) member to add etf_flags: (C++: uint) type changing flags flags times: (C++: size_t) how many times to add. if times > 1, the member name will be appended a suffix like "_2" and so on idx: (C++: ssize_t) the index in the udm array where the new udm should be placed. if the specified index cannot be honored because it would spoil the udm sorting order, it is silently ignored. note: ETF_NO_SAVE is ignored
append_covered(self, out: rangeset_t, offset: uint64 = 0) ‑> bool append_covered(self, out, offset=0) -> bool Calculate set of covered bytes for the type
out: (C++: rangeset_t *) pointer to the output buffer. covered bytes will be appended to it. offset: (C++: uint64) delta in bytes to add to all calculations. used internally during recurion.
calc_enum_mask(self) ‑> uint64 calc_enum_mask(self) -> uint64
calc_gaps(self, out: rangeset_t) ‑> bool calc_gaps(self, out) -> bool Calculate set of padding bytes for the type
out: (C++: rangeset_t *) pointer to the output buffer; old buffer contents will be lost.
calc_purged_bytes(self) ‑> int calc_purged_bytes(self) -> int
calc_score(self) ‑> uint32 calc_score(self) -> uint32 Calculate the type score (the higher - the nicer is the type)
calc_udt_aligns(self, sudt_flags: int = 4) ‑> bool calc_udt_aligns(self, sudt_flags=0x0004) -> bool Calculate the udt alignments using the field offsets/sizes and the total udt size This function does not work on typerefs
sudt_flags: (C++: int)
change_sign(self, sign: type_sign_t) ‑> bool change_sign(self, sign) -> bool Change the type sign. Works only for the types that may have sign.
sign: (C++: type_sign_t)
clear(self) ‑> void clear(self) Clear contents of this tinfo, and remove from the type system.
clr_const(self) ‑> bool clr_const(self) -> bool
clr_const_volatile(self) ‑> bool clr_const_volatile(self) -> bool
clr_decl_const_volatile(self) ‑> void clr_decl_const_volatile(self)
clr_volatile(self) ‑> bool clr_volatile(self) -> bool
compare(self, r: tinfo_t) ‑> int compare(self, r) -> int
r: tinfo_t const &
compare_with(self, r: tinfo_t, tcflags: int = 0) ‑> bool compare_with(self, r, tcflags=0) -> bool Compare two types, based on given flags (see tinfo_t comparison flags)
r: (C++: const tinfo_t &) tinfo_t const & tcflags: (C++: int)
convert_array_to_ptr(self) ‑> bool convert_array_to_ptr(self) -> bool Convert an array into a pointer. type[] => type *
copy(self) ‑> ida_typeinf.tinfo_t copy(self) -> tinfo_t
copy_type(self, *args) ‑> tinfo_code_t copy_type(self, til, name, ntf_flags=0x0001|0x1000) -> tinfo_code_t
til: til_t * name: char const * ntf_flags: int
create_array(self, *args) ‑> bool create_array(self, p, decl_type=BT_ARRAY) -> bool
p: array_type_data_t const & decl_type: type_t
create_array(self, tif, nelems=0, base=0, decl_type=BT_ARRAY) -> bool
tif: tinfo_t const & nelems: uint32 base: uint32 decl_type: type_t
create_bitfield(self, *args) ‑> bool create_bitfield(self, p, decl_type=BT_BITFIELD) -> bool
p: bitfield_type_data_t const & decl_type: type_t
create_bitfield(self, nbytes, width, is_unsigned=False, decl_type=BT_BITFIELD) -> bool
nbytes: uchar width: uchar is_unsigned: bool decl_type: type_t
create_enum(self, *args) ‑> bool create_enum(self, p, decl_type=BTF_ENUM) -> bool
p: enum_type_data_t & decl_type: type_t
create_forward_decl(self, til: til_t, decl_type: type_t, name: char const *, ntf_flags: int = 0) ‑> tinfo_code_t create_forward_decl(self, til, decl_type, name, ntf_flags=0) -> tinfo_code_t Create a forward declaration. decl_type: BTF_STRUCT, BTF_UNION, or BTF_ENUM
til: (C++: til_t *) decl_type: (C++: type_t) name: (C++: const char *) char const * ntf_flags: (C++: int)
create_func(self, *args) ‑> bool create_func(self, p, decl_type=BT_FUNC) -> bool
p: func_type_data_t & decl_type: type_t
create_ptr(self, *args) ‑> bool create_ptr(self, p, decl_type=BT_PTR) -> bool
p: ptr_type_data_t const & decl_type: type_t
create_ptr(self, tif, bps=0, decl_type=BT_PTR) -> bool
tif: tinfo_t const & bps: uchar decl_type: type_t
create_simple_type(self, decl_type: type_t) ‑> bool create_simple_type(self, decl_type) -> bool
decl_type: type_t
create_typedef(self, *args) ‑> void create_typedef(self, p, decl_type=BTF_TYPEDEF, try_ordinal=True) -> bool
p: typedef_type_data_t const & decl_type: type_t try_ordinal: bool
create_typedef(self, til, name, decl_type=BTF_TYPEDEF, try_ordinal=True)
til: til_t const * name: char const * decl_type: type_t try_ordinal: bool
create_typedef(self, til, ord, decl_type=BTF_TYPEDEF)
til: til_t const * ord: uint decl_type: type_t
create_udt(self, *args) ‑> bool create_udt(self, p) -> bool
p: udt_type_data_t &
create_udt(self, p, decl_type) -> bool
p: udt_type_data_t & decl_type: type_t
del_attr(self, key: qstring const &, make_copy: bool = True) ‑> bool del_attr(self, key, make_copy=True) -> bool Del a type attribute. typerefs cannot be modified by this function.
key: (C++: const qstring &) qstring const & make_copy: (C++: bool)
del_attrs(self) ‑> void del_attrs(self) Del all type attributes. typerefs cannot be modified by this function.
del_edm(self, idx: size_t, etf_flags: uint = 0) ‑> tinfo_code_t del_edm(self, idx, etf_flags=0) -> tinfo_code_t
idx: size_t etf_flags: uint
del_edms(self, idx1: size_t, idx2: size_t, etf_flags: uint = 0) ‑> tinfo_code_t del_edms(self, idx1, idx2, etf_flags=0) -> tinfo_code_t Delete enum members
idx1: (C++: size_t) index in edmvec_t idx2: (C++: size_t) index in edmvec_t or size_t(-1) etf_flags: (C++: uint) etf_flag_t Delete enum members in [idx1, idx2) note: For bitmask enum, the first member of a non-trivial group (having 2 or more members) is considered as a group mask. It is impossible to delete the group mask of a non-trivial group, other members of the group must be deleted first. Empty groups are automatically deleted.
del_funcarg(self, idx: size_t, etf_flags: uint = 0) ‑> tinfo_code_t del_funcarg(self, idx, etf_flags=0) -> tinfo_code_t
idx: size_t etf_flags: uint
del_funcargs(self, idx1: size_t, idx2: size_t, etf_flags: uint = 0) ‑> tinfo_code_t del_funcargs(self, idx1, idx2, etf_flags=0) -> tinfo_code_t Delete function arguments
idx1: (C++: size_t) index in funcargvec_t idx2: (C++: size_t) index in funcargvec_t or size_t(-1) etf_flags: (C++: uint) etf_flag_t Delete function arguments in [idx1, idx2)
del_udm(self, index: size_t, etf_flags: uint = 0) ‑> tinfo_code_t del_udm(self, index, etf_flags=0) -> tinfo_code_t Delete a structure/union member.
index: (C++: size_t) etf_flags: (C++: uint)
del_udms(self, idx1: size_t, idx2: size_t, etf_flags: uint = 0) ‑> tinfo_code_t del_udms(self, idx1, idx2, etf_flags=0) -> tinfo_code_t Delete structure/union members in the range [idx1, idx2)
idx1: (C++: size_t) idx2: (C++: size_t) etf_flags: (C++: uint)
deserialize(self, *args) ‑> bool deserialize(self, til, ptype, pfields=None, pfldcmts=None, cmt=None) -> bool Deserialize a type string into a tinfo_t object.
til: (C++: const til_t *) til_t const * ptype: (C++: const qtype *) type_t const ** pfields: (C++: const qtype *) p_list const ** pfldcmts: (C++: const qtype *) p_list const ** cmt: (C++: const char *) char const *
deserialize(self, til, type, fields, cmts=None) -> bool
til: til_t const * type: type_t const * fields: p_list const * cmts: p_list const *
detach(self) ‑> bool detach(self) -> bool Detach tinfo_t from the underlying type. After calling this finction, tinfo_t will lose its link to the underlying named or numbered type (if any) and will become a reference to a unique type. After that, any modifications to tinfo_t will affect only its type.
dstr(self) ‑> char const * dstr(self) -> char const * Function to facilitate debugging.
edit_edm(self, *args) ‑> tinfo_code_t edit_edm(self, idx, value, bmask=bmask64_t(-1), etf_flags=0) -> tinfo_code_t Change constant value and/or bitmask
idx: (C++: size_t) index in edmvec_t value: (C++: uint64) old or new value bmask: (C++: bmask64_t) old or new bitmask note: if new bitmask is specified the index of constant may be changed
empty(self) ‑> bool empty(self) -> bool Was tinfo_t initialized with some type info or not?
equals_to(self, r: tinfo_t) ‑> bool equals_to(self, r) -> bool
r: tinfo_t const &
expand_udt(self, idx: size_t, delta: adiff_t, etf_flags: uint = 0) ‑> tinfo_code_t expand_udt(self, idx, delta, etf_flags=0) -> tinfo_code_t Expand/shrink a structure by adding/removing a gap before the specified member.
idx: (C++: size_t) index of the member delta: (C++: adiff_t) number of bytes to add or remove etf_flags: (C++: uint) etf_flag_t Please note that it is impossible to add a gap at the very end of a structure. However, adding before a regular member is possible. This function can be used to remove gaps in the middle of a structure by specifying a negative delta value.
find_edm(self, *args) ‑> ssize_t find_edm(self, edm, value, bmask=bmask64_t(-1), serial=0) -> ssize_t Find enum member
edm: (C++: edm_t *) enum type member, may be nullptr value: uint64 bmask: bmask64_t return: member index, otherwise returns -1. find_edm(self, edm, name) -> ssize_t
edm: edm_t * name: char const *
find_udm(self, *args) ‑> int find_udm(self, udm, strmem_flags) -> int BTF_STRUCT,BTF_UNION: Find an udt member by name
udm: udm_t * strmem_flags: (C++: int)
return: the index of the found member or -1 find_udm(self, offset, strmem_flags=0) -> int
offset: uint64 strmem_flags: int
find_udm(self, name, strmem_flags=0) -> int
name: char const * strmem_flags: int
find_udt_member(self, *args) ‑> int find_udm(self, udm, strmem_flags) -> int BTF_STRUCT,BTF_UNION: Find an udt member by name
udm: udm_t * strmem_flags: (C++: int)
return: the index of the found member or -1 find_udm(self, offset, strmem_flags=0) -> int
offset: uint64 strmem_flags: int
find_udm(self, name, strmem_flags=0) -> int
name: char const * strmem_flags: int
force_tid(self) ‑> tid_t force_tid(self) -> tid_t Get the type tid. Create if it does not exist yet. If the type comes from a base til, the type will be copied to the local til and a new tid will be created for it. (if the type comes from a base til, it does not have a tid yet). If the type comes from the local til, this function is equivalent to get_tid()
return: tid or BADADDR
get_alias_target(self) ‑> uint32 get_alias_target(self) -> uint32 Get type alias If the type has no alias, return 0.
get_array_details(self, ai: array_type_data_t) ‑> bool get_array_details(self, ai) -> bool Get the array specific info.
ai: (C++: array_type_data_t *)
get_array_element(self) ‑> ida_typeinf.tinfo_t get_array_element(self) -> tinfo_t
get_array_nelems(self) ‑> int get_array_nelems(self) -> int
get_attr(self, key: qstring const &, all_attrs: bool = True) ‑> PyObject * get_attr(self, key, all_attrs=True) -> PyObject Get a type attribute.
key: (C++: const qstring &) qstring const & all_attrs: (C++: bool)
get_attrs(self, tav: type_attrs_t, all_attrs: bool = False) ‑> bool get_attrs(self, tav, all_attrs=False) -> bool Get type attributes (all_attrs: include attributes of referenced types, if any)
tav: (C++: type_attrs_t *) all_attrs: (C++: bool)
get_bit_buckets(self, buckets: range64vec_t) ‑> bool get_bit_buckets(self, buckets) -> bool ::BT_STRUCT: get bit buckets Bit buckets are used to layout bitfields
buckets: (C++: range64vec_t *) return: false if wrong type was passed
get_bitfield_details(self, bi: bitfield_type_data_t) ‑> bool get_bitfield_details(self, bi) -> bool Get the bitfield specific info.
bi: (C++: bitfield_type_data_t *)
get_declalign(self) ‑> uchar get_declalign(self) -> uchar Get declared alignment of the type.
get_decltype(self) ‑> type_t get_decltype(self) -> type_t Get declared type (without resolving type references; they are returned as is). Obviously this is a very fast function and should be used instead of get_realtype() if possible. Please note that for typerefs this function will return BTF_TYPEDEF. To determine if a typeref is a typedef, use is_typedef()
get_edm(self, edm: edm_t, idx: size_t) ‑> tinfo_code_t get_edm(self, edm, idx) -> tinfo_code_t Get enum member
edm: (C++: edm_t *) enum type member idx: (C++: size_t) enum member index
get_edm_by_name(self, mname: char const *, til: til_t = None) ‑> ssize_t get_edm_by_name(self, mname, til=None) -> ssize_t Retrieve enum tinfo using enum member name
mname: (C++: const char *) enum type member name til: (C++: const til_t *) type library return: member index, otherwise returns -1. If the function fails, THIS object becomes empty.
get_edm_by_tid(self, edm: edm_t, tid: tid_t) ‑> ssize_t get_edm_by_tid(self, edm, tid) -> ssize_t
edm: edm_t * tid: tid_t
get_edm_tid(self, idx: size_t) ‑> tid_t get_edm_tid(self, idx) -> tid_t Get enum member TID
idx: (C++: size_t) enum member index return: tid or BADADDR The tid is used to collect xrefs to the member, it can be passed to xref-related functions instead of the address.
get_enum_base_type(self) ‑> type_t get_enum_base_type(self) -> type_t Get enum base type (convert enum to integer type) Returns BT_UNK if failed to convert
get_enum_details(self, ei: enum_type_data_t) ‑> bool get_enum_details(self, ei) -> bool Get the enum specific info.
ei: (C++: enum_type_data_t *)
get_enum_nmembers(self) ‑> size_t get_enum_nmembers(self) -> size_t Get number of enum members.
return: BADSIZE if error
get_enum_radix(self) ‑> int get_enum_radix(self) -> int Get enum constant radix
return: radix or 1 for BTE_CHAR enum_type_data_t::get_enum_radix()
get_enum_repr(self, repr: value_repr_t) ‑> tinfo_code_t get_enum_repr(self, repr) -> tinfo_code_t Set the representation of enum members.
repr: (C++: value_repr_t *) value_repr_t
get_enum_width(self) ‑> int get_enum_width(self) -> int Get enum width
return: width of enum base type in bytes, 0 - unspecified, or -1 enum_type_data_t::calc_nbytes()
get_final_element(self) ‑> ida_typeinf.tinfo_t get_final_element(self) -> tinfo_t repeat recursively: if an array, return the type of its element; else return the type itself.
get_final_ordinal(self) ‑> uint32 get_final_ordinal(self) -> uint32 Get final type ordinal (0 if none)
get_final_type_name(self) ‑> bool get_final_type_name(self) -> bool Use in the case of typedef chain (TYPE1 -> TYPE2 -> TYPE3...TYPEn).
return: the name of the last type in the chain (TYPEn). if there is no chain, returns TYPE1
get_forward_type(self) ‑> type_t get_forward_type(self) -> type_t Get type of a forward declaration. For a forward declaration this function returns its base type. In other cases it returns BT_UNK
get_frame_func(self) ‑> ea_t get_frame_func(self) -> ea_t Get function address for the frame.
get_func_details(self, fi: func_type_data_t, gtd: gtd_func_t = 0) ‑> bool get_func_details(self, fi, gtd=GTD_CALC_ARGLOCS) -> bool Get only the function specific info for this tinfo_t.
fi: (C++: func_type_data_t *) gtd: (C++: gtd_func_t) enum gtd_func_t
get_func_frame(self, pfn: func_t const *) ‑> bool get_func_frame(self, pfn) -> bool Create a tinfo_t object for the function frame
pfn: (C++: const func_t *) function
get_innermost_member_type(self, bitoffset: uint64) ‑> tinfo_t get_innermost_member_type(self, bitoffset) -> tinfo_t Get the innermost member type at the given offset
bitoffset: (C++: uint64) bit offset into the structure retval the: innermost member type
get_innermost_udm(self, bitoffset: uint64) ‑> tinfo_t get_innermost_udm(self, bitoffset) -> tinfo_t Get the innermost member at the given offset
bitoffset: (C++: uint64) bit offset into the structure retval udt: with the innermost member retval empty: type if it is not a struct type or OFFSET could not be found
get_methods(self, methods: udtmembervec_t) ‑> bool get_methods(self, methods) -> bool
BT_COMPLEX: get a list of member functions declared in this udt. return: false if no member functions exist
get_modifiers(self) ‑> type_t get_modifiers(self) -> type_t
get_named_type(self, *args) ‑> bool get_named_type(self, til, name, decl_type=BTF_TYPEDEF, resolve=True, try_ordinal=True) -> bool
til: til_t const * name: char const * decl_type: type_t resolve: bool try_ordinal: bool
get_named_type(self, name, decl_type=BTF_TYPEDEF, resolve=True, try_ordinal=True) -> bool
name: char const * decl_type: type_t resolve: bool try_ordinal: bool
get_nargs(self) ‑> int get_nargs(self) -> int BT_FUNC or BT_PTR BT_FUNC: Calculate number of arguments (-1 - error)
get_next_type_name(self) ‑> bool get_next_type_name(self) -> bool Use In the case of typedef chain (TYPE1 -> TYPE2 -> TYPE3...TYPEn).
return: the name of the next type in the chain (TYPE2). if there is no chain, returns failure
get_nice_type_name(self) ‑> bool get_nice_type_name(self) -> bool Get the beautified type name. Get the referenced name and apply regular expressions from goodname.cfg to beautify the name
get_nth_arg(self, n: int) ‑> ida_typeinf.tinfo_t get_nth_arg(self, n) -> tinfo_t BT_FUNC or BT_PTR BT_FUNC: Get type of n-th arg (-1 means return type, see get_rettype())
n: (C++: int)
get_numbered_type(self, *args) ‑> bool get_numbered_type(self, til, ordinal, decl_type=BTF_TYPEDEF, resolve=True) -> bool
til: til_t const * ordinal: uint32 decl_type: type_t resolve: bool
get_numbered_type(self, ordinal, decl_type=BTF_TYPEDEF, resolve=True) -> bool
ordinal: uint32 decl_type: type_t resolve: bool
get_onemember_type(self) ‑> ida_typeinf.tinfo_t get_onemember_type(self) -> tinfo_t For objects consisting of one member entirely: return type of the member.
get_ordinal(self) ‑> uint32 get_ordinal(self) -> uint32 Get type ordinal (only if the type was created as a numbered type, 0 if none)
get_pointed_object(self) ‑> ida_typeinf.tinfo_t get_pointed_object(self) -> tinfo_t
get_ptr_details(self, pi: ptr_type_data_t) ‑> bool get_ptr_details(self, pi) -> bool Get the pointer info.
pi: (C++: ptr_type_data_t *)
get_ptrarr_object(self) ‑> ida_typeinf.tinfo_t get_ptrarr_object(self) -> tinfo_t BT_PTR & BT_ARRAY: get the pointed object or array element. If the current type is not a pointer or array, return empty type info.
get_ptrarr_objsize(self) ‑> int get_ptrarr_objsize(self) -> int BT_PTR & BT_ARRAY: get size of pointed object or array element. On error returns -1
get_realtype(self, full: bool = False) ‑> type_t get_realtype(self, full=False) -> type_t Get the resolved base type. Deserialization options:
if full=true, the referenced type will be deserialized fully, this may not always be desirable (slows down things)
if full=false, we just return the base type, the referenced type will be resolved again later if necessary (this may lead to multiple resolvings of the same type) imho full=false is a better approach because it does not perform unnecessary actions just in case. however, in some cases the caller knows that it is very likely that full type info will be required. in those cases full=true makes sense
full: (C++: bool)
get_rettype(self) ‑> ida_typeinf.tinfo_t get_rettype(self) -> tinfo_t BT_FUNC or BT_PTR BT_FUNC: Get the function's return type
get_sign(self) ‑> type_sign_t get_sign(self) -> type_sign_t Get type sign.
get_size(self, p_effalign: uint32 * = None, gts_code: int = 0) ‑> size_t get_size(self, p_effalign=None, gts_code=0) -> size_t Get the type size in bytes.
p_effalign: (C++: uint32 *) buffer for the alignment value gts_code: (C++: int) combination of GTS_... constants return: BADSIZE in case of problems
get_stkvar(self, insn: insn_t const &, x: op_t const, v: sval_t) ‑> ssize_t get_stkvar(self, insn, x, v) -> ssize_t Retrieve frame tinfo for a stack variable
insn: (C++: const insn_t &) the instruction x: (C++: const op_t *) reference to instruction operand, may be nullptr v: (C++: sval_t) immediate value in the operand (usually x.addr) return: returns the member index, otherwise returns -1. if the function fails, THIS object becomes empty.
get_tid(self) ‑> tid_t get_tid(self) -> tid_t Get the type tid Each type in the local type library has a so-called
tidassociated with it. The tid is used to collect xrefs to the type. The tid is created when the type is created in the local type library and does not change afterwards. It can be passed to xref-related functions instead of the address.return: tid or BADADDR note: types that do not come from a type library (that exist only in the memory) can not have a tid.
get_til(self) ‑> til_t * get_til(self) -> til_t Get the type library for tinfo_t.
get_type_by_tid(self, tid: tid_t) ‑> bool get_type_by_tid(self, tid) -> bool
tid: tid_t
get_type_cmt(self) ‑> int get_type_cmt(self) -> int Get type comment
return: 0-failed, 1-returned regular comment, 2-returned repeatable comment
get_type_name(self) ‑> bool get_type_name(self) -> bool Does a type refer to a name?. If yes, fill the provided buffer with the type name and return true. Names are returned for numbered types too: either a user- defined nice name or, if a user-provided name does not exist, an ordinal name (like #xx, see create_numbered_type_name()).
get_type_rptcmt(self) ‑> bool get_type_rptcmt(self) -> bool Get type comment only if it is repeatable.
get_udm_by_tid(self, udm: udm_t, tid: tid_t) ‑> ssize_t get_udm_by_tid(self, udm, tid) -> ssize_t Retrive tinfo using type TID or struct/enum member MID
udm: (C++: udm_t *) [out]: place to save the found member to, may be nullptr tid: (C++: tid_t) tid can denote a type tid or a member tid. return: if a member tid was specified, returns the member index, otherwise returns -1. if the function fails, THIS object becomes empty.
get_udm_tid(self, idx: size_t) ‑> tid_t get_udm_tid(self, idx) -> tid_t Get udt member TID
idx: (C++: size_t) the index of udt the member return: tid or BADADDR The tid is used to collect xrefs to the member, it can be passed to xref-related functions instead of the address.
get_udt_details(self, udt: udt_type_data_t, gtd: gtd_udt_t = 0) ‑> bool get_udt_details(self, udt, gtd=GTD_CALC_LAYOUT) -> bool Get the udt specific info.
udt: (C++: udt_type_data_t *) gtd: (C++: gtd_udt_t) enum gtd_udt_t
get_udt_nmembers(self) ‑> int get_udt_nmembers(self) -> int Get number of udt members. -1-error.
get_unpadded_size(self) ‑> size_t get_unpadded_size(self) -> size_t Get the type size in bytes without the final padding, in bytes. For some UDTs get_unpadded_size() != get_size()
has_details(self) ‑> bool has_details(self) -> bool Does this type refer to a nontrivial type?
has_union(self) ‑> bool has_union(self) -> bool Has a member of type "union"?
has_vftable(self) ‑> bool has_vftable(self) -> bool Has a vftable?
is_aliased(self) ‑> bool is_aliased(self) -> bool
is_anonymous_udt(self) ‑> bool is_anonymous_udt(self) -> bool Is an anonymous struct/union? We assume that types with names are anonymous if the name starts with $
is_arithmetic(self) ‑> bool is_arithmetic(self) -> bool is_type_arithmetic(get_realtype())
is_array(self) ‑> bool is_array(self) -> bool is_type_array(get_realtype())
is_bitfield(self) ‑> bool is_bitfield(self) -> bool is_type_bitfld(get_realtype())
is_bitmask_enum(self) ‑> bool is_bitmask_enum(self) -> bool Is bitmask enum?
return: true for bitmask enum and false in other cases enum_type_data_t::is_bf()
is_bool(self) ‑> bool is_bool(self) -> bool is_type_bool(get_realtype())
is_castable_to(self, target: tinfo_t) ‑> bool is_castable_to(self, target) -> bool
target: tinfo_t const &
is_char(self) ‑> bool is_char(self) -> bool is_type_char(get_realtype())
is_complex(self) ‑> bool is_complex(self) -> bool is_type_complex(get_realtype())
is_const(self) ‑> bool is_const(self) -> bool is_type_const(get_realtype())
is_correct(self) ‑> bool is_correct(self) -> bool Is the type object correct?. It is possible to create incorrect types. For example, we can define a function that returns an enum and then delete the enum type. If this function returns false, the type should not be used in disassembly. Please note that this function does not verify all involved types: for example, pointers to undefined types are permitted.
is_decl_array(self) ‑> bool is_decl_array(self) -> bool is_type_array(get_decltype())
is_decl_bitfield(self) ‑> bool is_decl_bitfield(self) -> bool is_type_bitfld(get_decltype())
is_decl_bool(self) ‑> bool is_decl_bool(self) -> bool is_type_bool(get_decltype())
is_decl_char(self) ‑> bool is_decl_char(self) -> bool is_type_char(get_decltype())
is_decl_complex(self) ‑> bool is_decl_complex(self) -> bool is_type_complex(get_decltype())
is_decl_const(self) ‑> bool is_decl_const(self) -> bool is_type_const(get_decltype())
is_decl_double(self) ‑> bool is_decl_double(self) -> bool is_type_double(get_decltype())
is_decl_enum(self) ‑> bool is_decl_enum(self) -> bool is_type_enum(get_decltype())
is_decl_float(self) ‑> bool is_decl_float(self) -> bool is_type_float(get_decltype())
is_decl_floating(self) ‑> bool is_decl_floating(self) -> bool is_type_floating(get_decltype())
is_decl_func(self) ‑> bool is_decl_func(self) -> bool is_type_func(get_decltype())
is_decl_int(self) ‑> bool is_decl_int(self) -> bool is_type_int(get_decltype())
is_decl_int128(self) ‑> bool is_decl_int128(self) -> bool is_type_int128(get_decltype())
is_decl_int16(self) ‑> bool is_decl_int16(self) -> bool is_type_int16(get_decltype())
is_decl_int32(self) ‑> bool is_decl_int32(self) -> bool is_type_int32(get_decltype())
is_decl_int64(self) ‑> bool is_decl_int64(self) -> bool is_type_int64(get_decltype())
is_decl_last(self) ‑> bool is_decl_last(self) -> bool is_typeid_last(get_decltype())
is_decl_ldouble(self) ‑> bool is_decl_ldouble(self) -> bool is_type_ldouble(get_decltype())
is_decl_paf(self) ‑> bool is_decl_paf(self) -> bool is_type_paf(get_decltype())
is_decl_partial(self) ‑> bool is_decl_partial(self) -> bool is_type_partial(get_decltype())
is_decl_ptr(self) ‑> bool is_decl_ptr(self) -> bool is_type_ptr(get_decltype())
is_decl_struct(self) ‑> bool is_decl_struct(self) -> bool is_type_struct(get_decltype())
is_decl_sue(self) ‑> bool is_decl_sue(self) -> bool is_type_sue(get_decltype())
is_decl_tbyte(self) ‑> bool is_decl_tbyte(self) -> bool is_type_tbyte(get_decltype())
is_decl_typedef(self) ‑> bool is_decl_typedef(self) -> bool is_type_typedef(get_decltype())
is_decl_uchar(self) ‑> bool is_decl_uchar(self) -> bool is_type_uchar(get_decltype())
is_decl_udt(self) ‑> bool is_decl_udt(self) -> bool is_type_struni(get_decltype())
is_decl_uint(self) ‑> bool is_decl_uint(self) -> bool is_type_uint(get_decltype())
is_decl_uint128(self) ‑> bool is_decl_uint128(self) -> bool is_type_uint128(get_decltype())
is_decl_uint16(self) ‑> bool is_decl_uint16(self) -> bool is_type_uint16(get_decltype())
is_decl_uint32(self) ‑> bool is_decl_uint32(self) -> bool is_type_uint32(get_decltype())
is_decl_uint64(self) ‑> bool is_decl_uint64(self) -> bool is_type_uint64(get_decltype())
is_decl_union(self) ‑> bool is_decl_union(self) -> bool is_type_union(get_decltype())
is_decl_unknown(self) ‑> bool is_decl_unknown(self) -> bool is_type_unknown(get_decltype())
is_decl_void(self) ‑> bool is_decl_void(self) -> bool is_type_void(get_decltype())
is_decl_volatile(self) ‑> bool is_decl_volatile(self) -> bool is_type_volatile(get_decltype())
is_double(self) ‑> bool is_double(self) -> bool is_type_double(get_realtype())
is_empty_enum(self) ‑> bool is_empty_enum(self) -> bool Is an empty enum? (has no constants)
is_empty_udt(self) ‑> bool is_empty_udt(self) -> bool Is an empty struct/union? (has no fields)
is_enum(self) ‑> bool is_enum(self) -> bool is_type_enum(get_realtype())
is_ext_arithmetic(self) ‑> bool is_ext_arithmetic(self) -> bool is_type_ext_arithmetic(get_realtype())
is_ext_integral(self) ‑> bool is_ext_integral(self) -> bool is_type_ext_integral(get_realtype())
is_fixed_struct(self) ‑> bool is_fixed_struct(self) -> bool Is a structure with fixed offsets?
is_float(self) ‑> bool is_float(self) -> bool is_type_float(get_realtype())
is_floating(self) ‑> bool is_floating(self) -> bool is_type_floating(get_realtype())
is_forward_decl(self) ‑> bool is_forward_decl(self) -> bool Is this a forward declaration?. Forward declarations are placeholders: the type definition does not exist
is_forward_enum(self) ‑> bool is_forward_enum(self) -> bool
is_forward_struct(self) ‑> bool is_forward_struct(self) -> bool
is_forward_union(self) ‑> bool is_forward_union(self) -> bool
is_frame(self) ‑> bool is_frame(self) -> bool Is a function frame?
is_from_subtil(self) ‑> bool is_from_subtil(self) -> bool Was the named type found in some base type library (not the top level type library)?. If yes, it usually means that the type comes from some loaded type library, not the local type library for the database
is_func(self) ‑> bool is_func(self) -> bool is_type_func(get_realtype())
is_funcptr(self) ‑> bool is_funcptr(self) -> bool Is this pointer to a function?
is_high_func(self) ‑> bool is_high_func(self) -> bool
is_int(self) ‑> bool is_int(self) -> bool is_type_int(get_realtype())
is_int128(self) ‑> bool is_int128(self) -> bool is_type_int128(get_realtype())
is_int16(self) ‑> bool is_int16(self) -> bool is_type_int16(get_realtype())
is_int32(self) ‑> bool is_int32(self) -> bool is_type_int32(get_realtype())
is_int64(self) ‑> bool is_int64(self) -> bool is_type_int64(get_realtype())
is_integral(self) ‑> bool is_integral(self) -> bool is_type_integral(get_realtype())
is_ldouble(self) ‑> bool is_ldouble(self) -> bool is_type_ldouble(get_realtype())
is_manually_castable_to(self, target: tinfo_t) ‑> bool is_manually_castable_to(self, target) -> bool
target: tinfo_t const &
is_one_fpval(self) ‑> bool is_one_fpval(self) -> bool Floating value or an object consisting of one floating member entirely.
is_paf(self) ‑> bool is_paf(self) -> bool is_type_paf(get_realtype())
is_partial(self) ‑> bool is_partial(self) -> bool is_type_partial(get_realtype())
is_ptr(self) ‑> bool is_ptr(self) -> bool is_type_ptr(get_realtype())
is_ptr_or_array(self) ‑> bool is_ptr_or_array(self) -> bool is_type_ptr_or_array(get_realtype())
is_punknown(self) ‑> bool is_punknown(self) -> bool Is "_UNKNOWN *"?. This function does not check the pointer attributes and type modifiers.
is_purging_cc(self) ‑> bool is_purging_cc(self) -> bool is_purging_cc(get_cc())
is_pvoid(self) ‑> bool is_pvoid(self) -> bool Is "void *"?. This function does not check the pointer attributes and type modifiers.
is_scalar(self) ‑> bool is_scalar(self) -> bool Does the type represent a single number?
is_shifted_ptr(self) ‑> bool is_shifted_ptr(self) -> bool Is a shifted pointer?
is_signed(self) ‑> bool is_signed(self) -> bool Is this a signed type?
is_small_udt(self) ‑> bool is_small_udt(self) -> bool Is a small udt? (can fit a register or a pair of registers)
is_sse_type(self) ‑> bool is_sse_type(self) -> bool Is a SSE vector type?
is_struct(self) ‑> bool is_struct(self) -> bool is_type_struct(get_realtype())
is_sue(self) ‑> bool is_sue(self) -> bool is_type_sue(get_realtype())
is_tbyte(self) ‑> bool is_tbyte(self) -> bool is_type_tbyte(get_realtype())
is_typedef(self) ‑> bool is_typedef(self) -> bool Is this a typedef?. This function will return true for a reference to a local type that is declared as a typedef.
is_typeref(self) ‑> bool is_typeref(self) -> bool Is this type a type reference?.
is_uchar(self) ‑> bool is_uchar(self) -> bool is_type_uchar(get_realtype())
is_udm_by_til(self, idx: size_t) ‑> bool is_udm_by_til(self, idx) -> bool Was the member created due to the type system
idx: (C++: size_t) index of the member
is_udt(self) ‑> bool is_udt(self) -> bool is_type_struni(get_realtype())
is_uint(self) ‑> bool is_uint(self) -> bool is_type_uint(get_realtype())
is_uint128(self) ‑> bool is_uint128(self) -> bool is_type_uint128(get_realtype())
is_uint16(self) ‑> bool is_uint16(self) -> bool is_type_uint16(get_realtype())
is_uint32(self) ‑> bool is_uint32(self) -> bool is_type_uint32(get_realtype())
is_uint64(self) ‑> bool is_uint64(self) -> bool is_type_uint64(get_realtype())
is_union(self) ‑> bool is_union(self) -> bool is_type_union(get_realtype())
is_unknown(self) ‑> bool is_unknown(self) -> bool is_type_unknown(get_realtype())
is_unsigned(self) ‑> bool is_unsigned(self) -> bool Is this an unsigned type?
is_user_cc(self) ‑> bool is_user_cc(self) -> bool is_user_cc(get_cc())
is_vararg_cc(self) ‑> bool is_vararg_cc(self) -> bool is_vararg_cc(get_cc())
is_varmember(self) ‑> bool is_varmember(self) -> bool Can the type be of a variable struct member? This function checks for: is_array() && array.nelems==0 Such a member can be only the very last member of a structure
is_varstruct(self) ‑> bool is_varstruct(self) -> bool Is a variable-size structure?
is_vftable(self) ‑> bool is_vftable(self) -> bool Is a vftable type?
is_void(self) ‑> bool is_void(self) -> bool is_type_void(get_realtype())
is_volatile(self) ‑> bool is_volatile(self) -> bool is_type_volatile(get_realtype())
is_well_defined(self) ‑> bool is_well_defined(self) -> bool !(empty()) && !(is_decl_partial()) && !(is_punknown())
parse(self, decl: char const *, til: til_t = None, pt_flags: int = 0) ‑> bool parse(self, decl, til=None, pt_flags=0) -> bool Convenience function to parse a string with a type declaration
decl: (C++: const char *) a type declaration til: (C++: til_t *) type library to use pt_flags: (C++: int) combination of Type parsing flags bits
present(self) ‑> bool present(self) -> bool Is the type really present? (not a reference to a missing type, for example)
read_bitfield_value(self, v: uint64, bitoff: int) ‑> uint64 read_bitfield_value(self, v, bitoff) -> uint64
v: uint64 bitoff: int
remove_ptr_or_array(self) ‑> bool remove_ptr_or_array(self) -> bool Replace the current type with the ptr obj or array element. This function performs one of the following conversions:
type[] => type
type* => type If the conversion is performed successfully, return true
rename_edm(self, idx: size_t, name: char const *, etf_flags: uint = 0) ‑> tinfo_code_t rename_edm(self, idx, name, etf_flags=0) -> tinfo_code_t Rename a enum member
idx: (C++: size_t) index in edmvec_t name: (C++: const char *) new name etf_flags: (C++: uint) etf_flag_t ETF_FORCENAME may be used in case of TERR_ALIEN_NAME note: ETF_NO_SAVE is ignored
rename_funcarg(self, index: size_t, name: char const *, etf_flags: uint = 0) ‑> tinfo_code_t rename_funcarg(self, index, name, etf_flags=0) -> tinfo_code_t Rename a function argument. The new name must be unique.
index: (C++: size_t) argument index in the function array name: (C++: const char *) new name etf_flags: (C++: uint) etf_flag_t note: ETF_NO_SAVE is ignored
rename_type(self, name: char const *, ntf_flags: int = 0) ‑> tinfo_code_t rename_type(self, name, ntf_flags=0) -> tinfo_code_t Rename a type
name: (C++: const char *) new type name ntf_flags: (C++: int) Flags for named types note: The change is saved immediately
rename_udm(self, index: size_t, name: char const *, etf_flags: uint = 0) ‑> tinfo_code_t rename_udm(self, index, name, etf_flags=0) -> tinfo_code_t Rename a structure/union member. The new name must be unique. note: ETF_NO_SAVE is ignored
index: (C++: size_t) name: (C++: const char *) char const * etf_flags: (C++: uint)
requires_qualifier(self, name: char const *, offset: uint64) ‑> bool requires_qualifier(self, name, offset) -> bool Requires full qualifier? (name is not unique)
name: (C++: const char *) field name offset: (C++: uint64) field offset in bits return: if the name is not unique, returns true
save_type(self, *args) ‑> tinfo_code_t save_type(self, ntf_flags=0x0001|0x0004) -> tinfo_code_t
ntf_flags: int
serialize(self, *args) ‑> PyObject * serialize(self, sudt_flags=SUDT_FAST|SUDT_TRUNC) -> PyObject Serialize tinfo_t object into a type string.
sudt_flags: (C++: int)
set_attr(self, ta: type_attr_t, may_overwrite: bool = True) ‑> bool set_attr(self, ta, may_overwrite=True) -> bool Set a type attribute. If necessary, a new typid will be created.
ta: (C++: const type_attr_t &) type_attr_t const & may_overwrite: (C++: bool)
set_attrs(self, tav: type_attrs_t) ‑> bool set_attrs(self, tav) -> bool Set type attributes. If necessary, a new typid will be created. this function modifies tav! (returns old attributes, if any)
tav: (C++: type_attrs_t *) return: false: bad attributes
set_const(self) ‑> void set_const(self)
set_declalign(self, declalign: uchar) ‑> bool set_declalign(self, declalign) -> bool
declalign: uchar
set_edm_cmt(self, idx: size_t, cmt: char const *, etf_flags: uint = 0) ‑> tinfo_code_t set_edm_cmt(self, idx, cmt, etf_flags=0) -> tinfo_code_t Set a comment for an enum member. Such comments are always considered as repeatable.
idx: (C++: size_t) index in edmvec_t cmt: (C++: const char *) comment etf_flags: (C++: uint) etf_flag_t
set_enum_is_bitmask(self, *args) ‑> tinfo_code_t set_enum_is_bitmask(self, stance=ENUMBM_ON, etf_flags=0) -> tinfo_code_t
stance: enum tinfo_t::bitmask_cvt_stance_t etf_flags: uint
set_enum_radix(self, radix: int, sign: bool, etf_flags: uint = 0) ‑> tinfo_code_t set_enum_radix(self, radix, sign, etf_flags=0) -> tinfo_code_t Set enum radix to display constants
radix: (C++: int) radix 2, 4, 8, 16, with the special case 1 to display as character sign: (C++: bool) display as signed or unsigned etf_flags: (C++: uint) etf_flag_t
set_enum_repr(self, repr: value_repr_t, etf_flags: uint = 0) ‑> tinfo_code_t set_enum_repr(self, repr, etf_flags=0) -> tinfo_code_t Set the representation of enum members.
repr: (C++: const value_repr_t &) value_repr_t etf_flags: (C++: uint) etf_flag_t
set_enum_sign(self, sign: type_sign_t, etf_flags: uint = 0) ‑> tinfo_code_t set_enum_sign(self, sign, etf_flags=0) -> tinfo_code_t Set enum sign
sign: (C++: type_sign_t) etf_flags: (C++: uint) etf_flag_t
set_enum_width(self, nbytes: int, etf_flags: uint = 0) ‑> tinfo_code_t set_enum_width(self, nbytes, etf_flags=0) -> tinfo_code_t Set the width of enum base type
nbytes: (C++: int) width of enum base type, allowed values: 0 (unspecified),1,2,4,8,16,32,64 etf_flags: (C++: uint) etf_flag_t
set_fixed_struct(self, on: bool = True) ‑> tinfo_code_t set_fixed_struct(self, on=True) -> tinfo_code_t Declare struct member offsets as fixed. For such structures, IDA will not recalculate the member offsets. If a member does not fit into its place anymore, it will be deleted. This function works only with structures (not unions).
on: (C++: bool)
set_func_cc(self, cc: cm_t, etf_flags: uint = 0) ‑> tinfo_code_t set_func_cc(self, cc, etf_flags=0) -> tinfo_code_t Set function calling convention.
cc: (C++: cm_t) etf_flags: (C++: uint)
set_func_retloc(self, argloc: argloc_t, etf_flags: uint = 0) ‑> tinfo_code_t set_func_retloc(self, argloc, etf_flags=0) -> tinfo_code_t Set location of function return value.
argloc: (C++: const argloc_t &) new location for the return value etf_flags: (C++: uint) etf_flag_t return: tinfo_code_t
set_func_rettype(self, tif: tinfo_t, etf_flags: uint = 0) ‑> tinfo_code_t set_func_rettype(self, tif, etf_flags=0) -> tinfo_code_t Set function return type .
tif: (C++: const tinfo_t &) new type for the return type etf_flags: (C++: uint) etf_flag_t return: tinfo_code_t
set_funcarg_loc(self, index: size_t, argloc: argloc_t, etf_flags: uint = 0) ‑> tinfo_code_t set_funcarg_loc(self, index, argloc, etf_flags=0) -> tinfo_code_t Set location of a function argument.
index: (C++: size_t) argument index in the function array argloc: (C++: const argloc_t &) new location for the argument etf_flags: (C++: uint) etf_flag_t return: tinfo_code_t
set_funcarg_type(self, index: size_t, tif: tinfo_t, etf_flags: uint = 0) ‑> tinfo_code_t set_funcarg_type(self, index, tif, etf_flags=0) -> tinfo_code_t Set type of a function argument.
index: (C++: size_t) argument index in the function array tif: (C++: const tinfo_t &) new type for the argument etf_flags: (C++: uint) etf_flag_t return: tinfo_code_t
set_methods(self, methods: udtmembervec_t) ‑> bool set_methods(self, methods) -> bool
BT_COMPLEX: set the list of member functions. This function consumes 'methods' (makes it empty). return: false if this type is not a udt, or if the given list is empty
set_modifiers(self, mod: type_t) ‑> void set_modifiers(self, mod)
mod: type_t
set_named_type(self, til: til_t, name: char const *, ntf_flags: int = 0) ‑> tinfo_code_t set_named_type(self, til, name, ntf_flags=0) -> tinfo_code_t
til: til_t * name: char const * ntf_flags: int
set_numbered_type(self, til: til_t, ord: uint32, ntf_flags: int = 0, name: char const * = None) ‑> tinfo_code_t set_numbered_type(self, til, ord, ntf_flags=0, name=None) -> tinfo_code_t
til: til_t * ord: uint32 ntf_flags: int name: char const *
set_struct_size(self, new_size: size_t) ‑> tinfo_code_t set_struct_size(self, new_size) -> tinfo_code_t Explicitly specify the struct size. This function works only with fixed structures. The new struct size can be equal or higher the unpadded struct size (IOW, all existing members should fit into the specified size).
new_size: (C++: size_t) new structure size in bytes
set_symbol_type(self, til: til_t, name: char const *, ntf_flags: int = 0) ‑> tinfo_code_t set_symbol_type(self, til, name, ntf_flags=0) -> tinfo_code_t
til: til_t * name: char const * ntf_flags: int
set_type_alias(self, dest_ord: uint32) ‑> bool set_type_alias(self, dest_ord) -> bool Set type alias Redirects all references to source type to the destination type. This is equivalent to instantaneous replacement all references to srctype by dsttype.
dest_ord: (C++: uint32)
set_type_alignment(self, declalign: uchar, etf_flags: uint = 0) ‑> tinfo_code_t set_type_alignment(self, declalign, etf_flags=0) -> tinfo_code_t Set type alignment.
declalign: (C++: uchar) etf_flags: (C++: uint)
set_type_cmt(self, cmt: char const *, is_regcmt: bool = False, etf_flags: uint = 0) ‑> tinfo_code_t set_type_cmt(self, cmt, is_regcmt=False, etf_flags=0) -> tinfo_code_t Set type comment This function works only for non-trivial types
cmt: (C++: const char *) char const * is_regcmt: (C++: bool) etf_flags: (C++: uint)
set_udm_by_til(self, idx: size_t, on: bool = True, etf_flags: uint = 0) ‑> tinfo_code_t set_udm_by_til(self, idx, on=True, etf_flags=0) -> tinfo_code_t The member is created due to the type system
idx: (C++: size_t) index of the member on: (C++: bool) etf_flags: (C++: uint) etf_flag_t
set_udm_cmt(self, index: size_t, cmt: char const *, is_regcmt: bool = False, etf_flags: uint = 0) ‑> tinfo_code_t set_udm_cmt(self, index, cmt, is_regcmt=False, etf_flags=0) -> tinfo_code_t Set a comment for a structure/union member. A member may have just one comment, and it is either repeatable or regular.
index: (C++: size_t) cmt: (C++: const char *) char const * is_regcmt: (C++: bool) etf_flags: (C++: uint)
set_udm_repr(self, index: size_t, repr: value_repr_t, etf_flags: uint = 0) ‑> tinfo_code_t set_udm_repr(self, index, repr, etf_flags=0) -> tinfo_code_t Set the representation of a structure/union member.
index: (C++: size_t) repr: (C++: const value_repr_t &) value_repr_t const & etf_flags: (C++: uint)
set_udm_type(self, index: size_t, tif: tinfo_t, etf_flags: uint = 0, repr: value_repr_t = None) ‑> tinfo_code_t set_udm_type(self, index, tif, etf_flags=0, repr=None) -> tinfo_code_t Set type of a structure/union member.
index: (C++: size_t) member index in the udm array tif: (C++: const tinfo_t &) new type for the member etf_flags: (C++: uint) etf_flag_t repr: (C++: const value_repr_t *) new representation for the member (optional) return: tinfo_code_t
set_udt_alignment(self, sda: int, etf_flags: uint = 0) ‑> tinfo_code_t set_udt_alignment(self, sda, etf_flags=0) -> tinfo_code_t Set declared structure alignment (sda) This alignment supersedes the alignment returned by get_declalign() and is really used when calculating the struct layout. However, the effective structure alignment may differ from
sdabecause of packing. The type editing functions (they accept etf_flags) may overwrite this attribute.sda: (C++: int) etf_flags: (C++: uint)
set_udt_pack(self, pack: int, etf_flags: uint = 0) ‑> tinfo_code_t set_udt_pack(self, pack, etf_flags=0) -> tinfo_code_t Set structure packing. The value controls how little a structure member alignment can be. Example: if pack=1, then it is possible to align a double to a byte. attribute((aligned(1))) double x; However, if pack=3, a double will be aligned to 8 (2**3) even if requested to be aligned to a byte. pack==0 will have the same effect. The type editing functions (they accept etf_flags) may overwrite this attribute.
pack: (C++: int) etf_flags: (C++: uint)
set_volatile(self) ‑> void set_volatile(self)
swap(self, r: tinfo_t) ‑> void swap(self, r) Assign this = r and r = this.
r: (C++: tinfo_t &)
write_bitfield_value(self, dst: uint64, v: uint64, bitoff: int) ‑> uint64 write_bitfield_value(self, dst, v, bitoff) -> uint64
dst: uint64 v: uint64 bitoff: int
tinfo_visitor_t(s: int = 0)
: Proxy of C++ tinfo_visitor_t class.
Instance variables
state: int
state
Methods
apply_to(self, tif: tinfo_t, out: type_mods_t = None, name: char const * = None, cmt: char const * = None) ‑> int apply_to(self, tif, out=None, name=None, cmt=None) -> int Call this function to initiate the traversal.
tif: (C++: const tinfo_t &) tinfo_t const & out: (C++: type_mods_t *) name: (C++: const char *) char const * cmt: (C++: const char *) char const *
prune_now(self) ‑> void prune_now(self) To refuse to visit children of the current type, use this:
visit_type(self, out: type_mods_t, tif: tinfo_t, name: char const *, cmt: char const *) ‑> int visit_type(self, out, tif, name, cmt) -> int Visit a subtype. this function must be implemented in the derived class. it may optionally fill out with the new type info. this can be used to modify types (in this case the 'out' argument of apply_to() may not be nullptr) return 0 to continue the traversal. return !=0 to stop the traversal.
out: (C++: type_mods_t *) tif: (C++: const tinfo_t &) tinfo_t const & name: (C++: const char *) char const * cmt: (C++: const char *) char const *
type_attr_t()
: Proxy of C++ type_attr_t class.
Instance variables
key: qstring
key
value: bytevec_t
value
type_attrs_t(*args)
: Proxy of C++ qvector< type_attr_t > class.
Methods
at(self, _idx: size_t) ‑> type_attr_t const & at(self, _idx) -> type_attr_t
_idx: size_t
back(self)
begin(self, *args) ‑> qvector< type_attr_t >::const_iterator begin(self) -> type_attr_t
capacity(self) ‑> size_t capacity(self) -> size_t
clear(self) ‑> void clear(self)
empty(self) ‑> bool empty(self) -> bool
end(self, *args) ‑> qvector< type_attr_t >::const_iterator end(self) -> type_attr_t
erase(self, *args) ‑> qvector< type_attr_t >::iterator erase(self, it) -> type_attr_t
it: qvector< type_attr_t >::iterator
erase(self, first, last) -> type_attr_t
first: qvector< type_attr_t >::iterator last: qvector< type_attr_t >::iterator
extract(self) ‑> type_attr_t * extract(self) -> type_attr_t
front(self)
grow(self, *args) ‑> void grow(self, x=type_attr_t())
x: type_attr_t const &
inject(self, s: type_attr_t, len: size_t) ‑> void inject(self, s, len)
s: type_attr_t * len: size_t
insert(self, it: type_attr_t, x: type_attr_t) ‑> qvector< type_attr_t >::iterator insert(self, it, x) -> type_attr_t
it: qvector< type_attr_t >::iterator x: type_attr_t const &
pop_back(self) ‑> void pop_back(self)
push_back(self, *args) ‑> type_attr_t & push_back(self, x)
x: type_attr_t const &
push_back(self) -> type_attr_t
qclear(self) ‑> void qclear(self)
reserve(self, cnt: size_t) ‑> void reserve(self, cnt)
cnt: size_t
resize(self, *args) ‑> void resize(self, _newsize, x)
_newsize: size_t x: type_attr_t const &
resize(self, _newsize)
_newsize: size_t
size(self) ‑> size_t size(self) -> size_t
swap(self, r: type_attrs_t) ‑> void swap(self, r)
r: qvector< type_attr_t > &
truncate(self) ‑> void truncate(self)
type_mods_t()
: Proxy of C++ type_mods_t class.
Instance variables
cmt: qstring
cmt
flags: int
flags
name: qstring
name
type: tinfo_t
type
Methods
clear(self) ‑> void clear(self)
has_cmt(self) ‑> bool has_cmt(self) -> bool
has_info(self) ‑> bool has_info(self) -> bool
has_name(self) ‑> bool has_name(self) -> bool
has_type(self) ‑> bool has_type(self) -> bool
is_rptcmt(self) ‑> bool is_rptcmt(self) -> bool
set_new_cmt(self, c: qstring const &, rptcmt: bool) ‑> void set_new_cmt(self, c, rptcmt)
c: qstring const & rptcmt: bool
set_new_name(self, n: qstring const &) ‑> void set_new_name(self, n)
n: qstring const &
set_new_type(self, t: tinfo_t) ‑> void set_new_type(self, t) The visit_type() function may optionally save the modified type info. Use the following functions for that. The new name and comment will be applied only if the current tinfo element has storage for them.
t: (C++: const tinfo_t &) tinfo_t const &
typedef_type_data_t(*args)
: Proxy of C++ typedef_type_data_t class.
Instance variables
is_ordref: bool
is_ordref
name: char const *
name
ordinal: uint32
ordinal
resolve: bool
resolve
til: til_t const *
til
Methods
swap(self, r: typedef_type_data_t) ‑> void swap(self, r)
r: typedef_type_data_t &
udm_t()
: Proxy of C++ udm_t class.
Instance variables
cmt: qstring
cmt
effalign: int
effalign
fda: uchar
fda
name: qstring
name
offset: uint64
offset
repr: value_repr_t
repr
size: uint64
size
tafld_bits: uint32
tafld_bits
type: tinfo_t
type
Methods
begin(self) ‑> uint64 begin(self) -> uint64
can_be_dtor(self) ‑> bool can_be_dtor(self) -> bool
can_rename(self) ‑> bool can_rename(self) -> bool
clr_baseclass(self) ‑> void clr_baseclass(self)
clr_method(self) ‑> void clr_method(self)
clr_unaligned(self) ‑> void clr_unaligned(self)
clr_vftable(self) ‑> void clr_vftable(self)
clr_virtbase(self) ‑> void clr_virtbase(self)
end(self) ‑> uint64 end(self) -> uint64
is_anonymous_udm(self) ‑> bool is_anonymous_udm(self) -> bool
is_baseclass(self) ‑> bool is_baseclass(self) -> bool
is_bitfield(self) ‑> bool is_bitfield(self) -> bool
is_by_til(self) ‑> bool is_by_til(self) -> bool
is_gap(self) ‑> bool is_gap(self) -> bool
is_method(self) ‑> bool is_method(self) -> bool
is_regcmt(self) ‑> bool is_regcmt(self) -> bool
is_retaddr(self) ‑> bool is_retaddr(self) -> bool
is_savregs(self) ‑> bool is_savregs(self) -> bool
is_special_member(self) ‑> bool is_special_member(self) -> bool
is_unaligned(self) ‑> bool is_unaligned(self) -> bool
is_vftable(self) ‑> bool is_vftable(self) -> bool
is_virtbase(self) ‑> bool is_virtbase(self) -> bool
is_zero_bitfield(self) ‑> bool is_zero_bitfield(self) -> bool
make_gap(self, byteoff: uval_t, nbytes: uval_t) ‑> bool make_gap(self, byteoff, nbytes) -> bool
byteoff: uval_t nbytes: uval_t
set_baseclass(self, on: bool = True) ‑> void set_baseclass(self, on=True)
on: bool
set_by_til(self, on: bool = True) ‑> void set_by_til(self, on=True)
on: bool
set_method(self, on: bool = True) ‑> void set_method(self, on=True)
on: bool
set_regcmt(self, on: bool = True) ‑> void set_regcmt(self, on=True)
on: bool
set_retaddr(self, on: bool = True) ‑> void set_retaddr(self, on=True)
on: bool
set_savregs(self, on: bool = True) ‑> void set_savregs(self, on=True)
on: bool
set_unaligned(self, on: bool = True) ‑> void set_unaligned(self, on=True)
on: bool
set_value_repr(self, r: value_repr_t) ‑> void set_value_repr(self, r)
r: value_repr_t const &
set_vftable(self, on: bool = True) ‑> void set_vftable(self, on=True)
on: bool
set_virtbase(self, on: bool = True) ‑> void set_virtbase(self, on=True)
on: bool
swap(self, r: udm_t) ‑> void swap(self, r)
r: udm_t &
udt_member_t()
: Proxy of C++ udm_t class.
Instance variables
cmt: qstring
cmt
effalign: int
effalign
fda: uchar
fda
name: qstring
name
offset: uint64
offset
repr: value_repr_t
repr
size: uint64
size
tafld_bits: uint32
tafld_bits
type: tinfo_t
type
Methods
begin(self) ‑> uint64 begin(self) -> uint64
can_be_dtor(self) ‑> bool can_be_dtor(self) -> bool
can_rename(self) ‑> bool can_rename(self) -> bool
clr_baseclass(self) ‑> void clr_baseclass(self)
clr_method(self) ‑> void clr_method(self)
clr_unaligned(self) ‑> void clr_unaligned(self)
clr_vftable(self) ‑> void clr_vftable(self)
clr_virtbase(self) ‑> void clr_virtbase(self)
end(self) ‑> uint64 end(self) -> uint64
is_anonymous_udm(self) ‑> bool is_anonymous_udm(self) -> bool
is_baseclass(self) ‑> bool is_baseclass(self) -> bool
is_bitfield(self) ‑> bool is_bitfield(self) -> bool
is_by_til(self) ‑> bool is_by_til(self) -> bool
is_gap(self) ‑> bool is_gap(self) -> bool
is_method(self) ‑> bool is_method(self) -> bool
is_regcmt(self) ‑> bool is_regcmt(self) -> bool
is_retaddr(self) ‑> bool is_retaddr(self) -> bool
is_savregs(self) ‑> bool is_savregs(self) -> bool
is_special_member(self) ‑> bool is_special_member(self) -> bool
is_unaligned(self) ‑> bool is_unaligned(self) -> bool
is_vftable(self) ‑> bool is_vftable(self) -> bool
is_virtbase(self) ‑> bool is_virtbase(self) -> bool
is_zero_bitfield(self) ‑> bool is_zero_bitfield(self) -> bool
make_gap(self, byteoff: uval_t, nbytes: uval_t) ‑> bool make_gap(self, byteoff, nbytes) -> bool
byteoff: uval_t nbytes: uval_t
set_baseclass(self, on: bool = True) ‑> void set_baseclass(self, on=True)
on: bool
set_by_til(self, on: bool = True) ‑> void set_by_til(self, on=True)
on: bool
set_method(self, on: bool = True) ‑> void set_method(self, on=True)
on: bool
set_regcmt(self, on: bool = True) ‑> void set_regcmt(self, on=True)
on: bool
set_retaddr(self, on: bool = True) ‑> void set_retaddr(self, on=True)
on: bool
set_savregs(self, on: bool = True) ‑> void set_savregs(self, on=True)
on: bool
set_unaligned(self, on: bool = True) ‑> void set_unaligned(self, on=True)
on: bool
set_value_repr(self, r: value_repr_t) ‑> void set_value_repr(self, r)
r: value_repr_t const &
set_vftable(self, on: bool = True) ‑> void set_vftable(self, on=True)
on: bool
set_virtbase(self, on: bool = True) ‑> void set_virtbase(self, on=True)
on: bool
swap(self, r: udm_t) ‑> void swap(self, r)
r: udm_t &
udm_visitor_t()
: Proxy of C++ udm_visitor_t class.
Methods
visit_udm(self, tid: tid_t, tif: tinfo_t, udt: udt_type_data_t, idx: ssize_t) ‑> int visit_udm(self, tid, tif, udt, idx) -> int
tid: (C++: tid_t) udt tid tif: (C++: const tinfo_t *) udt type info (may be nullptr for corrupted idbs) udt: (C++: const udt_type_data_t *) udt type data (may be nullptr for corrupted idbs) idx: (C++: ssize_t) the index of udt the member (may be -1 if udm was not found)
udt_type_data_t()
: Proxy of C++ udt_type_data_t class.
Ancestors (in MRO)
Instance variables
effalign: uint32
effalign
is_union: bool
is_union
pack: uchar
pack
sda: uchar
sda
taudt_bits: uint32
taudt_bits
total_size: size_t
total_size
unpadded_size: size_t
unpadded_size
version: uchar
version
Methods
find_member(self, *args) ‑> ssize_t find_member(self, pattern_udm, strmem_flags) -> ssize_t
pattern_udm: udm_t * strmem_flags: int
find_member(self, name) -> ssize_t
name: char const *
find_member(self, bit_offset) -> ssize_t
bit_offset: uint64
get_best_fit_member(self, disp: asize_t) ‑> ssize_t get_best_fit_member(self, disp) -> ssize_t Get member that is most likely referenced by the specified offset. Useful for offsets > sizeof(struct).
disp: (C++: asize_t)
is_cppobj(self) ‑> bool is_cppobj(self) -> bool
is_fixed(self) ‑> bool is_fixed(self) -> bool
is_last_baseclass(self, idx: size_t) ‑> bool is_last_baseclass(self, idx) -> bool
idx: size_t
is_msstruct(self) ‑> bool is_msstruct(self) -> bool
is_unaligned(self) ‑> bool is_unaligned(self) -> bool
is_vftable(self) ‑> bool is_vftable(self) -> bool
set_fixed(self, on: bool = True) ‑> void set_fixed(self, on=True)
on: bool
set_vftable(self, on: bool = True) ‑> void set_vftable(self, on=True)
on: bool
swap(self, r: udt_type_data_t) ‑> void swap(self, r)
r: udt_type_data_t &
udtmembervec_t()
: Proxy of C++ udtmembervec_t class.
Ancestors (in MRO)
Descendants
udtmembervec_template_t(*args)
: Proxy of C++ qvector< udm_t > class.
Descendants
Methods
add_unique(self, x: udm_t) ‑> bool add_unique(self, x) -> bool
x: udm_t const &
at(self, _idx: size_t) ‑> udm_t const & at(self, _idx) -> udm_t
_idx: size_t
back(self)
begin(self, *args) ‑> qvector< udm_t >::const_iterator begin(self) -> udm_t
capacity(self) ‑> size_t capacity(self) -> size_t
clear(self) ‑> void clear(self)
empty(self) ‑> bool empty(self) -> bool
end(self, *args) ‑> qvector< udm_t >::const_iterator end(self) -> udm_t
erase(self, *args) ‑> qvector< udm_t >::iterator erase(self, it) -> udm_t
it: qvector< udm_t >::iterator
erase(self, first, last) -> udm_t
first: qvector< udm_t >::iterator last: qvector< udm_t >::iterator
extract(self) ‑> udm_t * extract(self) -> udm_t
find(self, *args) ‑> qvector< udm_t >::const_iterator find(self, x) -> udm_t
x: udm_t const &
front(self)
grow(self, *args) ‑> void grow(self, x=udm_t())
x: udm_t const &
has(self, x: udm_t) ‑> bool has(self, x) -> bool
x: udm_t const &
inject(self, s: udm_t, len: size_t) ‑> void inject(self, s, len)
s: udm_t * len: size_t
insert(self, it: udm_t, x: udm_t) ‑> qvector< udm_t >::iterator insert(self, it, x) -> udm_t
it: qvector< udm_t >::iterator x: udm_t const &
pop_back(self) ‑> void pop_back(self)
push_back(self, *args) ‑> udm_t & push_back(self, x)
x: udm_t const &
push_back(self) -> udm_t
qclear(self) ‑> void qclear(self)
reserve(self, cnt: size_t) ‑> void reserve(self, cnt)
cnt: size_t
resize(self, *args) ‑> void resize(self, _newsize, x)
_newsize: size_t x: udm_t const &
resize(self, _newsize)
_newsize: size_t
size(self) ‑> size_t size(self) -> size_t
swap(self, r: udtmembervec_template_t) ‑> void swap(self, r)
r: qvector< udm_t > &
truncate(self) ‑> void truncate(self)
valstr_t()
: Proxy of C++ valstr_t class.
Instance variables
info: valinfo_t *
info
length: size_t
length
members: valstrs_t *
members
oneline: qstring
oneline
props: int
props
valstrs_t()
: Proxy of C++ valstrs_t class.
Ancestors (in MRO)
valstrvec_t(*args)
: Proxy of C++ qvector< valstr_t > class.
Descendants
Methods
at(self, _idx: size_t) ‑> valstr_t const & at(self, _idx) -> valstr_t
_idx: size_t
back(self)
begin(self, *args) ‑> qvector< valstr_t >::const_iterator begin(self) -> valstr_t
capacity(self) ‑> size_t capacity(self) -> size_t
clear(self) ‑> void clear(self)
empty(self) ‑> bool empty(self) -> bool
end(self, *args) ‑> qvector< valstr_t >::const_iterator end(self) -> valstr_t
erase(self, *args) ‑> qvector< valstr_t >::iterator erase(self, it) -> valstr_t
it: qvector< valstr_t >::iterator
erase(self, first, last) -> valstr_t
first: qvector< valstr_t >::iterator last: qvector< valstr_t >::iterator
extract(self) ‑> valstr_t * extract(self) -> valstr_t
front(self)
grow(self, *args) ‑> void grow(self, x=valstr_t())
x: valstr_t const &
inject(self, s: valstr_t, len: size_t) ‑> void inject(self, s, len)
s: valstr_t * len: size_t
insert(self, it: valstr_t, x: valstr_t) ‑> qvector< valstr_t >::iterator insert(self, it, x) -> valstr_t
it: qvector< valstr_t >::iterator x: valstr_t const &
pop_back(self) ‑> void pop_back(self)
push_back(self, *args) ‑> valstr_t & push_back(self, x)
x: valstr_t const &
push_back(self) -> valstr_t
qclear(self) ‑> void qclear(self)
reserve(self, cnt: size_t) ‑> void reserve(self, cnt)
cnt: size_t
resize(self, *args) ‑> void resize(self, _newsize, x)
_newsize: size_t x: valstr_t const &
resize(self, _newsize)
_newsize: size_t
size(self) ‑> size_t size(self) -> size_t
swap(self, r: valstrvec_t) ‑> void swap(self, r)
r: qvector< valstr_t > &
truncate(self) ‑> void truncate(self)
value_repr_t()
: Proxy of C++ value_repr_t class.
Instance variables
ap: array_parameters_t
ap
bits: uint64
bits
cd: custom_data_type_info_t
cd
delta: adiff_t
delta
ri: refinfo_t
ri
strtype: int32
strtype
type_ordinal: uint32
type_ordinal
Methods
clear(self) ‑> void clear(self)
empty(self) ‑> bool empty(self) -> bool
from_opinfo(self, flags: flags64_t, afl: aflags_t, opinfo: opinfo_t, _ap: array_parameters_t) ‑> bool from_opinfo(self, flags, afl, opinfo, _ap) -> bool
flags: flags64_t afl: aflags_t opinfo: opinfo_t const * _ap: array_parameters_t const *
get_vtype(self) ‑> uint64 get_vtype(self) -> uint64
has_lzeroes(self) ‑> bool has_lzeroes(self) -> bool
has_tabform(self) ‑> bool has_tabform(self) -> bool
init_ap(self, _ap: array_parameters_t) ‑> void init_ap(self, _ap)
_ap: array_parameters_t *
is_custom(self) ‑> bool is_custom(self) -> bool
is_enum(self) ‑> bool is_enum(self) -> bool
is_offset(self) ‑> bool is_offset(self) -> bool
is_signed(self) ‑> bool is_signed(self) -> bool
is_strlit(self) ‑> bool is_strlit(self) -> bool
is_stroff(self) ‑> bool is_stroff(self) -> bool
is_typref(self) ‑> bool is_typref(self) -> bool
parse_value_repr(self, *args) ‑> bool parse_value_repr(self, attr, target_type=BTF_STRUCT) -> bool
attr: qstring const & target_type: type_t
set_ap(self, _ap: array_parameters_t) ‑> void set_ap(self, _ap)
_ap: array_parameters_t const &
set_lzeroes(self, on: bool) ‑> void set_lzeroes(self, on)
on: bool
set_signed(self, on: bool) ‑> void set_signed(self, on)
on: bool
set_tabform(self, on: bool) ‑> void set_tabform(self, on)
on: bool
set_vtype(self, vt: uint64) ‑> void set_vtype(self, vt)
vt: uint64
swap(self, r: value_repr_t) ‑> void swap(self, r)
r: value_repr_t &
Last updated