Module index

Module ida_typeinf

IDA Plugin SDK API wrapper: typeinf

Global variables

var ADDTIL_ABORTED
til was not loaded (incompatible til rejected by user)
var ADDTIL_COMP
ok, but til is not compatible with the current compiler
var ADDTIL_DEFAULT
default behavior
var ADDTIL_FAILED
something bad, the warning is displayed
var ADDTIL_INCOMP
load incompatible tils
var ADDTIL_OK
ok, til is loaded
var ADDTIL_SILENT
do not ask any questions
var ALOC_CUSTOM
ALOC_CUSTOM = 7
var ALOC_DIST
ALOC_DIST = 2
var ALOC_NONE
ALOC_NONE = 0
var ALOC_REG1
ALOC_REG1 = 3
var ALOC_REG2
ALOC_REG2 = 4
var ALOC_RREL
ALOC_RREL = 5
var ALOC_STACK
ALOC_STACK = 1
var ALOC_STATIC
ALOC_STATIC = 6
var ARGREGS_BY_SLOTS
ARGREGS_BY_SLOTS = 3
var ARGREGS_FP_CONSUME_GP
ARGREGS_FP_CONSUME_GP = 4
var ARGREGS_GP_ONLY
ARGREGS_GP_ONLY = 1
var ARGREGS_INDEPENDENT
ARGREGS_INDEPENDENT = 2
var ARGREGS_MIPS_O32
ARGREGS_MIPS_O32 = 5
var ARGREGS_POLICY_UNDEFINED
ARGREGS_POLICY_UNDEFINED = 0
var BADORD
BADORD = 4294967295
var BADSIZE
BADSIZE = 18446744073709551615
var BFA_FUNC_EXT_FORMAT
BFA_FUNC_EXT_FORMAT = 128
var BFA_FUNC_MARKER
BFA_FUNC_MARKER = 15
var BFA_HIGH
BFA_HIGH = 4
var BFA_NORET
BFA_NORET = 1
var BFA_PURE
BFA_PURE = 2
var BFA_STATIC
BFA_STATIC = 8
var BFA_VIRTUAL
BFA_VIRTUAL = 16
var BTE_ALWAYS
BTE_ALWAYS = 128
var BTE_BITFIELD
BTE_BITFIELD = 16
var BTE_CHAR
BTE_CHAR = 32
var BTE_HEX
BTE_HEX = 0
var BTE_OUT_MASK
BTE_OUT_MASK = 96
var BTE_RESERVED
BTE_RESERVED = 8
var BTE_SDEC
BTE_SDEC = 64
var BTE_SIZE_MASK
BTE_SIZE_MASK = 7
var BTE_UDEC
BTE_UDEC = 96
var BTF_BOOL
BTF_BOOL = 8
var BTF_BYTE
BTF_BYTE = 17
var BTF_CHAR
BTF_CHAR = 50
var BTF_DOUBLE
BTF_DOUBLE = 25
var BTF_ENUM
BTF_ENUM = 45
var BTF_FLOAT
BTF_FLOAT = 9
var BTF_INT
BTF_INT = 7
var BTF_INT128
BTF_INT128 = 22
var BTF_INT16
BTF_INT16 = 19
var BTF_INT32
BTF_INT32 = 20
var BTF_INT64
BTF_INT64 = 21
var BTF_INT8
BTF_INT8 = 18
var BTF_LDOUBLE
BTF_LDOUBLE = 41
var BTF_SINT
BTF_SINT = 23
var BTF_STRUCT
BTF_STRUCT = 13
var BTF_TBYTE
BTF_TBYTE = 57
var BTF_TYPEDEF
BTF_TYPEDEF = 61
var BTF_UCHAR
BTF_UCHAR = 34
var BTF_UINT
BTF_UINT = 39
var BTF_UINT128
BTF_UINT128 = 38
var BTF_UINT16
BTF_UINT16 = 35
var BTF_UINT32
BTF_UINT32 = 36
var BTF_UINT64
BTF_UINT64 = 37
var BTF_UINT8
BTF_UINT8 = 34
var BTF_UNION
BTF_UNION = 29
var BTF_UNK
BTF_UNK = 48
var BTF_VOID
BTF_VOID = 1
var BTMT_ARRESERV
BTMT_ARRESERV = 32
var BTMT_BFLDI16
BTMT_BFLDI16 = 16
var BTMT_BFLDI32
BTMT_BFLDI32 = 32
var BTMT_BFLDI64
BTMT_BFLDI64 = 48
var BTMT_BFLDI8
BTMT_BFLDI8 = 0
var BTMT_BOOL1
BTMT_BOOL1 = 16
var BTMT_BOOL2
BTMT_BOOL2 = 32
var BTMT_BOOL4
BTMT_BOOL4 = 48
var BTMT_BOOL8
BTMT_BOOL8 = 32
var BTMT_CHAR
BTMT_CHAR = 48
var BTMT_CLOSURE
BTMT_CLOSURE = 48
var BTMT_DEFBOOL
BTMT_DEFBOOL = 0
var BTMT_DEFCALL
BTMT_DEFCALL = 0
var BTMT_DEFPTR
BTMT_DEFPTR = 0
var BTMT_DOUBLE
BTMT_DOUBLE = 16
var BTMT_ENUM
BTMT_ENUM = 32
var BTMT_FAR
BTMT_FAR = 32
var BTMT_FARCALL
BTMT_FARCALL = 32
var BTMT_FLOAT
BTMT_FLOAT = 0
var BTMT_INTCALL
BTMT_INTCALL = 48
var BTMT_LNGDBL
BTMT_LNGDBL = 32
var BTMT_NEAR
BTMT_NEAR = 16
var BTMT_NEARCALL
BTMT_NEARCALL = 16
var BTMT_NONBASED
BTMT_NONBASED = 16
var BTMT_SIGNED
BTMT_SIGNED = 16
var BTMT_SIZE0
BTMT_SIZE0 = 0
var BTMT_SIZE12
BTMT_SIZE12 = 16
var BTMT_SIZE128
BTMT_SIZE128 = 48
var BTMT_SIZE48
BTMT_SIZE48 = 32
var BTMT_SPECFLT
BTMT_SPECFLT = 48
var BTMT_STRUCT
BTMT_STRUCT = 0
var BTMT_TYPEDEF
BTMT_TYPEDEF = 48
var BTMT_UNION
BTMT_UNION = 16
var BTMT_UNKSIGN
BTMT_UNKSIGN = 0
var BTMT_UNSIGNED
BTMT_UNSIGNED = 32
var BTMT_USIGNED
BTMT_USIGNED = 32
var BTM_CONST
BTM_CONST = 64
var BTM_VOLATILE
BTM_VOLATILE = 128
var BT_ARRAY
BT_ARRAY = 11
var BT_BITFIELD
BT_BITFIELD = 14
var BT_BOOL
BT_BOOL = 8
var BT_COMPLEX
BT_COMPLEX = 13
var BT_FLOAT
BT_FLOAT = 9
var BT_FUNC
BT_FUNC = 12
var BT_INT
BT_INT = 7
var BT_INT128
BT_INT128 = 6
var BT_INT16
BT_INT16 = 3
var BT_INT32
BT_INT32 = 4
var BT_INT64
BT_INT64 = 5
var BT_INT8
BT_INT8 = 2
var BT_PTR
BT_PTR = 10
var BT_RESERVED
BT_RESERVED = 15
var BT_SEGREG
BT_SEGREG = 55
var BT_UNK
BT_UNK = 0
var BT_UNKNOWN
BT_UNKNOWN = 48
var BT_UNK_BYTE
BT_UNK_BYTE = 17
var BT_UNK_DWORD
BT_UNK_DWORD = 33
var BT_UNK_OWORD
BT_UNK_OWORD = 49
var BT_UNK_QWORD
BT_UNK_QWORD = 32
var BT_UNK_WORD
BT_UNK_WORD = 16
var BT_VOID
BT_VOID = 1
var CCN_C
CCN_C = 0
var CCN_CPP
CCN_CPP = 1
var CC_ALLOW_ARGPERM
disregard argument order?
var CC_ALLOW_REGHOLES
allow holes in register argument list?
var CC_CDECL_OK
can use __cdecl calling convention?
var CC_GOLANG_OK
can use __golang calling convention
var CC_HAS_ELLIPSIS
function has a variable list of arguments?
var CM_CC_CDECL
CM_CC_CDECL = 48
var CM_CC_ELLIPSIS
CM_CC_ELLIPSIS = 64
var CM_CC_FASTCALL
CM_CC_FASTCALL = 112
var CM_CC_GOLANG
CM_CC_GOLANG = 176
var CM_CC_INVALID
CM_CC_INVALID = 0
var CM_CC_MANUAL
CM_CC_MANUAL = 144
var CM_CC_MASK
CM_CC_MASK = 240
var CM_CC_PASCAL
CM_CC_PASCAL = 96
var CM_CC_RESERVE3
CM_CC_RESERVE3 = 192
var CM_CC_SPECIAL
CM_CC_SPECIAL = 240
var CM_CC_SPECIALE
CM_CC_SPECIALE = 208
var CM_CC_SPECIALP
CM_CC_SPECIALP = 224
var CM_CC_SPOILED
CM_CC_SPOILED = 160
var CM_CC_STDCALL
CM_CC_STDCALL = 80
var CM_CC_THISCALL
CM_CC_THISCALL = 128
var CM_CC_UNKNOWN
CM_CC_UNKNOWN = 16
var CM_CC_VOIDARG
CM_CC_VOIDARG = 32
var CM_MASK
CM_MASK = 3
var CM_M_FF
CM_M_FF = 4
var CM_M_FN
CM_M_FN = 12
var CM_M_MASK
CM_M_MASK = 12
var CM_M_NF
CM_M_NF = 8
var CM_M_NN
CM_M_NN = 0
var CM_N16_F32
CM_N16_F32 = 2
var CM_N32_F48
CM_N32_F48 = 3
var CM_N64
CM_N64 = 1
var CM_N8_F16
CM_N8_F16 = 1
var CM_UNKNOWN
CM_UNKNOWN = 0
var COMP_BC
COMP_BC = 2
var COMP_BP
COMP_BP = 8
var COMP_GNU
COMP_GNU = 6
var COMP_MASK
COMP_MASK = 15
var COMP_MS
COMP_MS = 1
var COMP_UNK
COMP_UNK = 0
var COMP_UNSURE
COMP_UNSURE = 128
var COMP_VISAGE
COMP_VISAGE = 7
var COMP_WATCOM
COMP_WATCOM = 3
var C_PC_COMPACT
C_PC_COMPACT = 10
var C_PC_FLAT
C_PC_FLAT = 3
var C_PC_HUGE
C_PC_HUGE = 6
var C_PC_LARGE
C_PC_LARGE = 6
var C_PC_MEDIUM
C_PC_MEDIUM = 14
var C_PC_SMALL
C_PC_SMALL = 2
var C_PC_TINY
C_PC_TINY = 2
var FAH_BYTE
function argument attribute header byte
var FAI_ARRAY
was initially an array see "__org_typedef" or "__org_arrdim" type attributes to determine the original type
var FAI_HIDDEN
hidden argument
var FAI_RETPTR
pointer to return value. implies hidden
var FAI_STRUCT
was initially a structure
var FAI_UNUSED
argument is not used by the function
var FIRST_NONTRIVIAL_TYPID
FIRST_NONTRIVIAL_TYPID = 256
var FMTFUNC_PRINTF
FMTFUNC_PRINTF = 0
var FMTFUNC_SCANF
FMTFUNC_SCANF = 1
var FMTFUNC_STRFMON
FMTFUNC_STRFMON = 3
var FMTFUNC_STRFTIME
FMTFUNC_STRFTIME = 2
var FTI_ALL
all defined bits
var FTI_ARGLOCS
info about argument locations has been calculated (stkargs and retloc too)
var FTI_CALLTYPE
mask for FTI_*CALL
var FTI_DEFCALL
default call
var FTI_EXPLOCS
all arglocs are specified explicitly
var FTI_FARCALL
far call
var FTI_HIGH
high level prototype (with possibly hidden args)
var FTI_INTCALL
interrupt call
var FTI_NEARCALL
near call
var FTI_NORET
noreturn
var FTI_PURE
__pure
var FTI_SPOILED
information about spoiled registers is present
var FTI_STATIC
static
var FTI_VIRTUAL
virtual
var GTD_CALC_ARGLOCS
GTD_CALC_ARGLOCS = 0
var GTD_CALC_LAYOUT
GTD_CALC_LAYOUT = 0
var GTD_DEL_BITFLDS
GTD_DEL_BITFLDS = 64
var GTD_NO_ARGLOCS
GTD_NO_ARGLOCS = 128
var GTD_NO_LAYOUT
GTD_NO_LAYOUT = 128
var GTS_BASECLASS
GTS_BASECLASS = 2
var GTS_NESTED
GTS_NESTED = 1
var GUESS_FUNC_FAILED
couldn't guess the function type
var GUESS_FUNC_OK
ok, some non-trivial information is gathered
var GUESS_FUNC_TRIVIAL
the function type doesn't have interesting info
var HTI_CPP
C++ mode (not implemented)
var HTI_DCL
don't complain about redeclarations
var HTI_EXT
debug: print external representation of types
var HTI_FIL
"input" is file name, otherwise "input" contains a C declaration
var HTI_HIGH
assume high level prototypes (with hidden args, etc)
var HTI_INT
debug: print internal representation of types
var HTI_LEX
debug: print tokens
var HTI_LOWER
lower the function prototypes
var HTI_MAC
define macros from the base tils
var HTI_NDC
don't decorate names
var HTI_NER
ignore all errors but display them
var HTI_NWR
no warning messages
var HTI_PAK
explicit structure pack value (#pragma pack)
var HTI_PAK1
#pragma pack(1)
var HTI_PAK16
#pragma pack(16)
var HTI_PAK2
#pragma pack(2)
var HTI_PAK4
#pragma pack(4)
var HTI_PAK8
#pragma pack(8)
var HTI_PAKDEF
default pack value
var HTI_PAK_SHIFT
shift for 'HTI_PAK' . This field should be used if you want to remember an explicit pack value for each structure/union type. See 'HTI_PAK' ... definitions
var HTI_RAWARGS
leave argument names unchanged (do not remove underscores)
var HTI_TST
test mode: discard the result
var HTI_UNP
debug: check the result by unpacking it
var IMPTYPE_LOCAL
the type is local, the struct/enum won't be marked as til type. there is no need to specify this bit if til==idati, the kernel will set it automatically
var IMPTYPE_OVERRIDE
override existing type
var IMPTYPE_VERBOSE
more verbose output (dialog boxes may appear)
var MAX_DECL_ALIGN
MAX_DECL_ALIGN = 15
var MAX_FUNC_ARGS
max number of function arguments
var NTF_64BIT
value is 64bit
var NTF_CHKSYNC
check that synchronization to IDB passed OK (set_numbered_type, set_named_type)
var NTF_FIXNAME
force-validate the name of the type when setting (set_named_type, set_numbered_type only)
var NTF_IDBENC
the name is given in the IDB encoding; non-ASCII bytes will be decoded accordingly (set_named_type, set_numbered_type only)
var NTF_NOBASE
don't inspect base tils (for get_named_type)
var NTF_NOCUR
don't inspect current til file (for get_named_type)
var NTF_REPLACE
replace original type (for set_named_type)
var NTF_SYMM
symbol, name is mangled ('_func') only one of 'NTF_TYPE' and 'NTF_SYMU' , 'NTF_SYMM' can be used
var NTF_SYMU
symbol, name is unmangled ('func')
var NTF_TYPE
type name
var NTF_UMANGLED
name is unmangled (don't use this flag)
var PCN_CHR
character
var PCN_DEC
decimal
var PCN_DECSEXT
automatically extend sign of signed decimal numbers
var PCN_HEX
hexadecimal
var PCN_LZHEX
print leading zeroes for hexdecimal number
var PCN_NEGSIGN
print negated value (-N) for negative numbers
var PCN_OCT
octal
var PCN_RADIX
number base to use
var PCN_UNSIGNED
add 'u' suffix
var PDF_DEF_BASE
Include base types: __int8, __int16, etc..
var PDF_DEF_FWD
Allow forward declarations.
var PDF_HEADER_CMT
Prepend output with a descriptive comment.
var PDF_INCL_DEPS
Include all type dependencies.
var PIO_IGNORE_PTRS
do not follow pointers
var PIO_NOATTR_FAIL
missing attributes are not ok
var PRALOC_STKOFF
print stack offsets
var PRALOC_VERIFY
interr if illegal argloc
var PRTYPE_1LINE
print to one line
var PRTYPE_COLORED
add color tag COLOR_SYMBOL for any parentheses, commas and colons
var PRTYPE_CPP
use c++ name (only for 'print_type()' )
var PRTYPE_DEF
'tinfo_t' : print definition, if available
var PRTYPE_MULTI
print to many lines
var PRTYPE_NOARGS
'tinfo_t' : do not print function argument names
var PRTYPE_NOARRS
'tinfo_t' : print arguments with 'FAI_ARRAY' as pointers
var PRTYPE_NOREGEX
do not apply regular expressions to beautify name
var PRTYPE_NORES
'tinfo_t' : never resolve types (meaningful with PRTYPE_DEF)
var PRTYPE_PRAGMA
print pragmas for alignment
var PRTYPE_RESTORE
'tinfo_t' : print restored types for 'FAI_ARRAY' and 'FAI_STRUCT'
var PRTYPE_SEMI
append ; to the end
var PRTYPE_TYPE
print type declaration (not variable declaration)
var PT_FILE
PT_FILE = 65536
var PT_HIGH
assume high level prototypes (with hidden args, etc)
var PT_LOWER
lower the function prototypes
var PT_NDC
don't decorate names
var PT_PACKMASK
mask for pack alignment values
var PT_RAWARGS
leave argument names unchanged (do not remove underscores)
var PT_REPLACE
replace the old type (used in idc)
var PT_SIL
silent, no messages
var PT_TYP
return declared type information
var PT_VAR
return declared object information
var RESERVED_BYTE
multifunctional purpose
var SETCOMP_BY_USER
invoked by user, cannot be replaced by module/loader
var SETCOMP_ONLY_ABI
ignore cc field complete, use only abiname
var SETCOMP_ONLY_ID
cc has only 'id' field the rest will be set to defaults corresponding to the program bitness
var SETCOMP_OVERRIDE
may override old compiler info
var STI_ACCHAR
STI_ACCHAR = 12
var STI_ACHAR
STI_ACHAR = 10
var STI_ACUCHAR
STI_ACUCHAR = 13
var STI_AEABI_LCMP
STI_AEABI_LCMP = 17
var STI_AEABI_MEMCLR
STI_AEABI_MEMCLR = 24
var STI_AEABI_MEMCPY
STI_AEABI_MEMCPY = 22
var STI_AEABI_MEMSET
STI_AEABI_MEMSET = 23
var STI_AEABI_ULCMP
STI_AEABI_ULCMP = 18
var STI_AUCHAR
STI_AUCHAR = 11
var STI_DONT_USE
STI_DONT_USE = 19
var STI_FDELOP
STI_FDELOP = 15
var STI_FPURGING
STI_FPURGING = 14
var STI_LAST
STI_LAST = 28
var STI_MSGSEND
STI_MSGSEND = 16
var STI_PBYTE
STI_PBYTE = 4
var STI_PCCHAR
STI_PCCHAR = 2
var STI_PCHAR
STI_PCHAR = 0
var STI_PCUCHAR
STI_PCUCHAR = 3
var STI_PCVOID
STI_PCVOID = 9
var STI_PINT
STI_PINT = 5
var STI_PPVOID
STI_PPVOID = 8
var STI_PUCHAR
STI_PUCHAR = 1
var STI_PUINT
STI_PUINT = 6
var STI_PVOID
STI_PVOID = 7
var STI_RTC_CHECK_2
STI_RTC_CHECK_2 = 25
var STI_RTC_CHECK_4
STI_RTC_CHECK_4 = 26
var STI_RTC_CHECK_8
STI_RTC_CHECK_8 = 27
var STI_SIZE_T
STI_SIZE_T = 20
var STI_SSIZE_T
STI_SSIZE_T = 21
var STRMEM_ANON
can be combined with 'STRMEM_NAME' : look inside anonymous members too.
var STRMEM_AUTO
get member by offset if struct, or get member by index if unionnb: union: index is stored in the udm->offset field!nb: struct: offset is in bytes (not in bits)!
var STRMEM_CASTABLE_TO
can be combined with 'STRMEM_TYPE' : member type must be castable to the specified type
var STRMEM_INDEX
get member by numberin: udm->offset - is a member number
var STRMEM_MASK
STRMEM_MASK = 7
var STRMEM_MAXS
get biggest member by size.
var STRMEM_MINS
get smallest member by size.
var STRMEM_NAME
get member by namein: udm->name - the desired member name.
var STRMEM_OFFSET
get member by offsetin: udm->offset - is a member offset in bits
var STRMEM_SIZE
get member by size.in: udm->size - the desired member size.
var STRMEM_SKIP_EMPTY
can be combined with 'STRMEM_OFFSET' , 'STRMEM_AUTO' skip empty members (i.e. having zero size) only last empty member can be returned
var STRMEM_TYPE
get member by type.in: udm->type - the desired member type. member types are compared with tinfo_t::equals_to()
var STRMEM_VFTABLE
can be combined with 'STRMEM_OFFSET' , 'STRMEM_AUTO' get vftable instead of the base class
var SUDT_ALIGN
recalculate field alignments, struct packing, etc to match the offsets and size info
var SUDT_CONST
only for serialize_udt: make type const
var SUDT_FAST
serialize without verifying offsets and alignments
var SUDT_GAPS
allow to fill gaps with additional members (_BYTE[])
var SUDT_SORT
fields are not sorted by offset, sort them first
var SUDT_TRUNC
serialize: truncate useless strings from fields, fldcmts
var SUDT_UNEX
references to nonexistent member types are acceptable in this case it is better to set the corresponding 'udt_member_t::fda' field to the type alignment. if this field is not set, ida will try to guess the alignment.
var SUDT_VOLATILE
only for serialize_udt: make type volatile
var TAENUM_64BIT
enum: store 64-bit values
var TAENUM_SIGNED
enum: signed
var TAENUM_UNSIGNED
enum: unsigned
var TAFLD_BASECLASS
field: do not include but inherit from the current field
var TAFLD_UNALIGNED
field: unaligned field
var TAFLD_VFTABLE
field: ptr to virtual function table
var TAFLD_VIRTBASE
field: virtual base (not supported yet)
var TAH_ALL
all defined bits
var TAH_BYTE
type attribute header byte
var TAH_HASATTRS
has extended attributes
var TAPTR_PTR32
ptr: __ptr32
var TAPTR_PTR64
ptr: __ptr64
var TAPTR_RESTRICT
ptr: __restrict
var TAPTR_SHIFTED
ptr: __shifted(parent_struct, delta)
var TAUDT_CPPOBJ
struct: a c++ object, not simple pod type
var TAUDT_MSSTRUCT
struct: gcc msstruct attribute
var TAUDT_UNALIGNED
struct: unaligned struct
var TAUDT_VFTABLE
struct: is virtual function table
var TA_FORMAT
info about the 'format' argument 3 times pack_dd: 'format_functype_t' , argument number of 'format', argument number of '...'
var TA_ORG_ARRDIM
the original array dimension (pack_dd)
var TA_ORG_TYPEDEF
the original typedef name (simple string)
var TCMP_ANYBASE
accept any base class when casting
var TCMP_AUTOCAST
can t1 be cast into t2 automatically?
var TCMP_CALL
can t1 be called with t2 type?
var TCMP_DECL
compare declarations without resolving them
var TCMP_DELPTR
remove pointer from types before comparing
var TCMP_EQUAL
are types equal?
var TCMP_IGNMODS
ignore const/volatile modifiers
var TCMP_MANCAST
can t1 be cast into t2 manually?
var TCMP_SKIPTHIS
skip the first function argument in comparison
var TERR_BADSYNC
TERR_BADSYNC = -4
var TERR_OK
TERR_OK = 0
var TERR_SAVE
TERR_SAVE = -1
var TERR_SERIALIZE
TERR_SERIALIZE = -2
var TERR_WRONGNAME
TERR_WRONGNAME = -3
var TIL_ADD_ALREADY
the base til was already added
var TIL_ADD_FAILED
see errbuf
var TIL_ADD_OK
some tils were added
var TIL_ALI
type aliases are present (this bit is used only on the disk)
var TIL_ESI
extended sizeof info (short, long, longlong)
var TIL_MAC
til has macro table
var TIL_MOD
til has been modified, should be saved
var TIL_ORD
type ordinal numbers are present
var TIL_SLD
sizeof(long double)
var TIL_STM
til has extra streams
var TIL_UNI
universal til for any compiler
var TIL_ZIP
pack buckets using zip
var TINFO_DEFINITE
this is a definite type
var TINFO_DELAYFUNC
if type is a function and no function exists at ea, schedule its creation and argument renaming to auto-analysis otherwise try to create it immediately
var TINFO_GUESSED
this is a guessed type
var TINFO_STRICT
never convert given type to another one before applying
var TPOS_LNNUM
TPOS_LNNUM = '\x05'
var TVIS_CMT
new comment is present
var TVIS_NAME
new name is present
var TVIS_TYPE
new type info is present
var TVST_DEF
visit type definition (meaningful for typerefs)
var TVST_LEVEL
TVST_LEVEL = 4
var TVST_PRUNE
don't visit children of current type
var TYPE_BASE_MASK
TYPE_BASE_MASK = 15
var TYPE_FLAGS_MASK
TYPE_FLAGS_MASK = 48
var TYPE_FULL_MASK
TYPE_FULL_MASK = 63
var TYPE_MODIF_MASK
TYPE_MODIF_MASK = 192
var TYPID_ISREF
TYPID_ISREF = 256
var TYPID_SHIFT
TYPID_SHIFT = 9
var UTP_ENUM
UTP_ENUM = 0
var UTP_STRUCT
UTP_STRUCT = 1
var VALSTR_OPEN
printed opening curly brace '{'
var VTBL_MEMNAME
VTBL_MEMNAME = '__vftable'
var VTBL_SUFFIX
VTBL_SUFFIX = '_vtbl'
var abs_no
abs_no = 1
var abs_unk
abs_unk = 0
var abs_yes
abs_yes = 2
var no_sign
no_sign = 0
var sc_auto
sc_auto = 5
var sc_ext
sc_ext = 2
var sc_friend
sc_friend = 6
var sc_reg
sc_reg = 4
var sc_stat
sc_stat = 3
var sc_type
sc_type = 1
var sc_unk
sc_unk = 0
var sc_virt
sc_virt = 7
var type_signed
type_signed = 1
var type_unsigned
type_unsigned = 2

Functions

def add_til(*args) ‑> int
Load a til file.
add_til(name, flags) -> int
name: til name (C++: const char *)
flags: combination of Load TIL flags (C++: int)
return: one of Load TIL result codes
def alloc_type_ordinal(*args) ‑> uint32
\call2{alloc_type_ordinals,ti,1}
alloc_type_ordinal(ti) -> uint32
ti (C++: til_t *)
def alloc_type_ordinals(*args) ‑> uint32
Allocate a range of ordinal numbers for new types.
alloc_type_ordinals(ti, qty) -> uint32
ti: type library (C++: til_t *)
qty: number of ordinals to allocate (C++: int)
return: the first ordinal. 0 means failure.
def append_abi_opts(*args) ‑> bool
Add/remove/check ABI option General form of full abi name: abiname- opt1-opt2-... or -opt1-opt2-...
append_abi_opts(abi_opts, user_level=False) -> bool
abi_opts: - ABI options to add/remove in form opt1-opt2-...
(C++: const char *)
user_level: - initiated by user if TRUE (==SETCOMP_BY_USER)
(C++: bool)
return: success
def append_argloc(*args) ‑> bool
Serialize argument location Deserialize an argument location. Argument FORBID_STKOFF check location type. It can be used, for example, to check the return location of a function that cannot return a value in the stack
append_argloc(out, vloc) -> bool
out (C++: qtype *)
vloc (C++: const argloc_t &)
def append_tinfo_covered(*args) ‑> bool
append_tinfo_covered(out, typid, offset) -> bool
out: rangeset_t * typid: uint32 offset: uint64
def apply_callee_tinfo(*args) ‑> 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_callee_tinfo(caller, tif) -> bool
caller: linear address of the calling instruction. must belong
to a function. (C++: ea_t)
tif: type info (C++: const tinfo_t &)
return: success
def apply_cdecl(*args) ‑> bool
Apply the specified type to the address. This function parses the declaration and calls 'apply_tinfo()'
apply_cdecl(til, ea, decl, flags=0) -> bool
til: type library (C++: til_t *)
ea: linear address (C++: ea_t)
decl: type declaration in C form (C++: const char *)
flags: flags to pass to apply_tinfo ( TINFO_DEFINITE is always
passed) (C++: int)
return: success
def apply_named_type(*args) ‑> bool
Apply the specified named type to the address.
apply_named_type(ea, name) -> bool
ea: linear address (C++: ea_t)
name: the type name, e.g. "FILE" (C++: const char *)
return: success
def apply_once_tinfo_and_name(*args) ‑> bool
Apply the specified type and name to the address. This function checks if the address already has a type. If the old typedoes not exist or the new type is 'better' than the old type, then thenew type will be applied. A type is considered better if it has moreinformation (e.g. 'BTMT_STRUCT' is better than 'BT_INT' ).The same logic is with the name: if the address already have a meaningfulname, it will be preserved. Only if the old name does not exist or itis a dummy name like byte_123, it will be replaced by the new name.
apply_once_tinfo_and_name(dea, tif, name) -> bool
dea: linear address (C++: ea_t)
tif: type string in the internal format (C++: const tinfo_t
&)
name: new name for the address (C++: const char *)
return: success
def apply_tinfo(*args) ‑> 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(ea, tif, flags) -> bool
ea: linear address (C++: ea_t)
tif: type string in internal format (C++: const tinfo_t &)
flags: combination of Apply tinfo flags (C++: uint32)
return: success
def apply_tinfo_to_stkarg(*args) ‑> bool
Helper function for the processor modules. to be called from
\ph{use_stkarg_type}
apply_tinfo_to_stkarg(insn, x, v, tif, name) -> bool
insn - an ida_ua.insn_t, or an address (C++: const insn_t &)
x (C++: const op_t &)
v (C++: uval_t)
tif (C++: const tinfo_t &)
name (C++: const char *)
def apply_type(*args) ‑> bool
apply_type(ti, type, fields, ea, flags) -> bool
Apply the specified type to the address
ti: Type info library. 'None' can be used.
py_type: type string
py_fields: fields string (may be empty or None)
ea: the address of the object
flags: combination of TINFO_... constants or 0
return: Boolean
def begin_type_updating(*args) ‑> void
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()'
begin_type_updating(utp)
utp (C++: update_type_t)
def calc_c_cpp_name(*args) ‑> qstring *
Get C or C++ form of the name.
calc_c_cpp_name(name, type, ccn_flags) -> str
name: original (mangled or decorated) name (C++: const char *)
type: name type if known, otherwise NULL (C++: const tinfo_t
*)
ccn_flags: one of C/C++ naming flags (C++: int)
def calc_number_of_children(*args) ‑> int
Calculate max number of lines of a formatted c data, when expanded ( 'PTV_EXPAND' ).
calc_number_of_children(loc, tif, dont_deref_ptr=False) -> int
loc: location of the data ( ALOC_STATIC or ALOC_CUSTOM )
(C++: const argloc_t &)
tif: type info (C++: const tinfo_t &)
dont_deref_ptr: consider 'ea' as the ptr value (C++: bool)
retval: 0 - data is not expandable
retval: -1 - error, see qerrno
retval: else - the max number of lines
def calc_tinfo_gaps(*args) ‑> bool
calc_tinfo_gaps(out, typid) -> bool
out: rangeset_t * typid: uint32
def calc_type_size(*args) ‑> PyObject *
calc_type_size(ti, tp) -> PyObject *
Returns the size of a type
ti: Type info. 'None' can be passed.
tp: type string
return:
  • None on failure
  • The size of the type
def callregs_t_regcount(*args) ‑> int
callregs_t_regcount(cc) -> int
cc: cm_t
def choose_local_tinfo(*args) ‑> uint32
Choose a type from the local type library.
choose_local_tinfo(ti, title, func=None, def_ord=0, ud=None) -> uint32
ti: pointer to til (C++: const til_t *)
title: title of listbox to display (C++: const char *)
func: predicate to select types to display (maybe NULL) (C++:
local_tinfo_predicate_t *)
def_ord: ordinal to position cursor before choose (C++: uint32)
ud: user data (C++: void *)
return: == 0 means nothing is chosen, otherwise an ordinal number
def choose_local_tinfo_and_delta(*args) ‑> uint32
Choose a type from the local type library and specify the pointer shift value.
choose_local_tinfo_and_delta(delta, ti, title, func=None, def_ord=0, ud=None) -> uint32
delta: pointer shift value (C++: int32 *)
ti: pointer to til (C++: const til_t *)
title: title of listbox to display (C++: const char *)
func: predicate to select types to display (maybe NULL) (C++:
local_tinfo_predicate_t *)
def_ord: ordinal to position cursor before choose (C++: uint32)
ud: user data (C++: void *)
return: == 0 means nothing is chosen, otherwise an ordinal number
def choose_named_type(*args) ‑> bool
Choose a type from a type library.
choose_named_type(out_sym, root_til, title, ntf_flags, predicate=None) -> bool
out_sym: pointer to be filled with the chosen type (C++:
til_symbol_t *)
root_til: pointer to starting til (the function will inspect
the base tils if allowed by flags) (C++: const til_t *)
title: title of listbox to display (C++: const char *)
ntf_flags: combination of Flags for named types (C++: int)
predicate: predicate to select types to display (maybe NULL)
(C++: predicate_t *)
return: false if nothing is chosen, otherwise true
def clear_tinfo_t(*args) ‑> void
clear_tinfo_t(_this)
_this: tinfo_t *
def compact_til(*args) ‑> bool
Collect garbage in til. Must be called before storing the til.
compact_til(ti) -> bool
ti (C++: til_t *)
return: true if any memory was freed
def compare_tinfo(*args) ‑> bool
compare_tinfo(t1, t2, tcflags) -> bool
t1: uint32 t2: uint32 tcflags: int
def convert_pt_flags_to_hti(*args) ‑> 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)
convert_pt_flags_to_hti(pt_flags) -> int
pt_flags (C++: int)
def copy_named_type(*args) ‑> 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_named_type(dsttil, srctil, name) -> uint32
dsttil: Destination til. It must have orginal types enabled
(C++: til_t *)
srctil: Source til. (C++: const til_t *)
name: name of the type to copy (C++: const char *)
return: ordinal number of the copied type. 0 means error
def copy_tinfo_t(*args) ‑> void
copy_tinfo_t(_this, r)
_this: tinfo_t * r: tinfo_t const &
def create_numbered_type_name(*args) ‑> qstring *
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_numbered_type_name(ord) -> str
ord (C++: int32)
def create_tinfo(*args) ‑> bool
create_tinfo(_this, bt, bt2, ptr) -> bool
_this: tinfo_t * bt: type_t bt2: type_t ptr: void *
def default_compiler(*args) ‑> comp_t
Get compiler specified by \varmem{inf,idainfo,cc} .
def del_named_type(*args) ‑> bool
Delete information about a symbol.
del_named_type(ti, name, ntf_flags) -> bool
ti: type library (C++: til_t *)
name: name of symbol (C++: const char *)
ntf_flags: combination of Flags for named types (C++: int)
return: success
def del_numbered_type(*args) ‑> bool
Delete a numbered type.
del_numbered_type(ti, ordinal) -> bool
ti (C++: til_t *)
ordinal (C++: uint32)
def del_til(*args) ‑> bool
Unload a til file.
del_til(name) -> bool
name (C++: const char *)
def del_tinfo_attr(*args) ‑> bool
del_tinfo_attr(tif, key, make_copy) -> bool
tif: tinfo_t * key: qstring const & make_copy: bool
def del_vftable_ea(*args) ‑> bool
Delete the address of a vftable instance for a vftable type.
del_vftable_ea(ordinal) -> bool
ordinal: ordinal number of a vftable type. (C++: uint32)
return: success
def deref_ptr(*args) ‑> bool
Dereference a pointer.
deref_ptr(ptr_ea, tif, closure_obj=None) -> bool
ptr_ea: in/out parameter in: address of the pointer out:
the pointed address (C++: ea_t *)
tif: type of the pointer (C++: const tinfo_t &)
closure_obj: closure object (not used yet) (C++: ea_t *)
return: success
def deserialize_tinfo(*args) ‑> bool
deserialize_tinfo(tif, til, ptype, pfields, pfldcmts) -> bool
tif: tinfo_t * til: til_t const * ptype: type_t const ** pfields: p_list const ** pfldcmts: p_list const **
def dstr_tinfo(*args) ‑> char const *
dstr_tinfo(tif) -> char const *
tif: tinfo_t const *
def dump_func_type_data(*args) ‑> qstring *
Use 'func_type_data_t::dump()'
dump_func_type_data(fti, praloc_bits) -> str
fti (C++: const func_type_data_t &)
praloc_bits (C++: int)
def end_type_updating(*args) ‑> void
Mark the end of a large update operation on the types (see 'begin_type_updating()' )
end_type_updating(utp)
utp (C++: update_type_t)
def extract_argloc(*args) ‑> bool
extract_argloc(vloc, ptype, forbid_stkoff) -> bool
vloc (C++: argloc_t *)
ptype (C++: const type_t **)
forbid_stkoff (C++: bool)
def find_tinfo_udt_member(*args) ‑> int
find_tinfo_udt_member(udm, typid, strmem_flags) -> int
udm: udt_member_t * typid: uint32 strmem_flags: int
def first_named_type(*args) ‑> char const *
Enumerate types. Returns mangled names. Never returns anonymous types. To include it, enumerate types by ordinals.
first_named_type(ti, ntf_flags) -> char const *
ti (C++: const til_t *)
ntf_flags (C++: int)
def for_all_arglocs(*args) ‑> int
Compress larger argloc types and initiate the aloc visitor.
for_all_arglocs(vv, vloc, size, off=0) -> int
vv (C++: aloc_visitor_t &)
vloc (C++: argloc_t &)
size (C++: int)
off (C++: int)
def for_all_const_arglocs(*args) ‑> int
See 'for_all_arglocs()'
for_all_const_arglocs(vv, vloc, size, off=0) -> int
vv (C++: const_aloc_visitor_t &)
vloc (C++: const argloc_t &)
size (C++: int)
off (C++: int)
def free_til(*args) ‑> void
Free memory allocated by til.
free_til(ti)
ti (C++: til_t *)
def func_has_stkframe_hole(*args) ‑> 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.
func_has_stkframe_hole(ea, fti) -> bool
ea (C++: ea_t)
fti (C++: const func_type_data_t &)
def gcc_layout(*args) ‑> bool
Should use the struct/union layout as done by gcc?
def gen_decorate_name(*args) ‑> qstring *
Generic function for 'decorate_name()' (may be used in IDP modules)
gen_decorate_name(name, mangle, cc, type) -> str
name (C++: const char *)
mangle (C++: bool)
cc (C++: cm_t)
type (C++: const tinfo_t *)
def gen_use_arg_tinfos(*args) ‑> void
gen_use_arg_tinfos(caller, fti, rargs, set_optype, is_stkarg_load, has_delay_slot)
caller (C++: ea_t)
fti (C++: func_type_data_t *)
rargs (C++: funcargvec_t *)
set_optype (C++: set_op_tinfo_t *)
is_stkarg_load (C++: is_stkarg_load_t *)
has_delay_slot (C++: has_delay_slot_t *)
def gen_use_arg_tinfos2(*args) ‑> void
Do not call this function directly, use 'argtinfo_helper_t' .
gen_use_arg_tinfos2(_this, caller, fti, rargs)
_this (C++: struct argtinfo_helper_t *)
caller (C++: ea_t)
fti (C++: func_type_data_t *)
rargs (C++: funcargvec_t *)
def get_abi_name(*args) ‑> qstring *
Get ABI name.
def get_alias_target(*args) ‑> uint32
Find the final alias destination. If the ordinal has not been aliased, return the specified ordinal itself If failed, returns 0.
get_alias_target(ti, ordinal) -> uint32
ti (C++: const til_t *)
ordinal (C++: uint32)
def get_arg_addrs(*args) ‑> PyObject *
get_arg_addrs(caller) -> PyObject *
Retrieve addresses of argument initialization instructions
caller: the address of the call instruction
return: list of instruction addresses
def get_base_type(*args) ‑> type_t
Get get basic type bits ( 'TYPE_BASE_MASK' )
get_base_type(t) -> type_t
t (C++: type_t)
def get_c_header_path(*args) ‑> qstring *
Get the include directory path of the target compiler.
def get_c_macros(*args) ‑> qstring *
Get predefined macros for the target compiler.
def get_comp(*args) ‑> comp_t
Get compiler bits.
get_comp(comp) -> comp_t
comp (C++: comp_t)
def get_compiler_abbr(*args) ‑> char const *
Get abbreviated compiler name.
get_compiler_abbr(id) -> char const *
id (C++: comp_t)
def get_compiler_name(*args) ‑> char const *
Get full compiler name.
get_compiler_name(id) -> char const *
id (C++: comp_t)
def get_compilers(*args) ‑> void
Get names of all built-in compilers.
get_compilers(ids, names, abbrs)
ids (C++: compvec_t *)
names (C++: qstrvec_t *)
abbrs (C++: qstrvec_t *)
def get_enum_member_expr(*args) ‑> qstring *
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_enum_member_expr(tif, serial, value) -> str
tif: enumeration type (C++: const tinfo_t &)
serial: which enumeration member to use (0 means the first with
the given value) (C++: int)
value: value to search in the enumeration type. only 32-bit
number can be handled yet (C++: uint64)
return: success
def get_full_type(*args) ‑> type_t
Get basic type bits + type flags ( 'TYPE_FULL_MASK' )
get_full_type(t) -> type_t
t (C++: type_t)
def get_idainfo_by_type(*args) ‑> size_t *, flags_t *, opinfo_t *, size_t *
Extract information from a 'tinfo_t' .
get_idainfo_by_type(tif) -> bool
tif: the type to inspect (C++: const tinfo_t &)
def get_idati(*args) ‑> til_t const *
Pointer to the local type library - this til is private for each IDB file Function that accepts til_t* uses local type library instead of NULL.
def get_named_type(*args) ‑> PyObject *
get_named_type(til, name, ntf_flags) -> PyObject *
Get a type data by its name.
til: the type library
name: the type name
ntf_flags: a combination of NTF_* constants
return:
None on failure tuple(code, type_str, fields_str, cmt, field_cmts, sclass, value) on success
def get_named_type64(*args) ‑> PyObject *
See 'get_named_type()' above.If the value in the 'ti' library is 32-bit, it will be sign-extended before being stored in the 'value' pointer.
get_named_type64(til, name, ntf_flags) -> PyObject *
til: til_t const *
name (C++: const char *)
ntf_flags (C++: int)
def get_numbered_type(*args) ‑> PyObject *
Retrieve a type by its ordinal number.
get_numbered_type(til, ordinal) -> PyObject *
til: til_t const *
ordinal (C++: uint32)
def get_numbered_type_name(*args) ‑> char const *
Get type name (if exists) by its ordinal. If the type is anonymous, returns "". If failed, returns NULL
get_numbered_type_name(ti, ordinal) -> char const *
ti (C++: const til_t *)
ordinal (C++: uint32)
def get_ordinal_from_idb_type(*args) ‑> int
Get ordinal number of an idb type (struct/enum). The 'type' parameter is used only to determine the kind of the type (struct or enum) Use this function to find out the correspondence between idb types and til types
get_ordinal_from_idb_type(name, type) -> int
name (C++: const char *)
type (C++: const type_t *)
def get_ordinal_qty(*args) ‑> uint32
Get number of allocated ordinals.
get_ordinal_qty(ti) -> uint32
ti (C++: const til_t *)
return: uint32(-1) if failed
def get_scalar_bt(*args) ‑> type_t
get_scalar_bt(size) -> type_t
size (C++: int)
def get_stock_tinfo(*args) ‑> bool
get_stock_tinfo(tif, id) -> bool
tif: tinfo_t * id: enum stock_type_id_t
def get_tinfo_attr(*args) ‑> bool
get_tinfo_attr(typid, key, bv, all_attrs) -> bool
typid: uint32 key: qstring const & bv: bytevec_t * all_attrs: bool
def get_tinfo_attrs(*args) ‑> bool
get_tinfo_attrs(typid, tav, include_ref_attrs) -> bool
typid: uint32 tav: type_attrs_t * include_ref_attrs: bool
def get_tinfo_details(*args) ‑> bool
get_tinfo_details(typid, bt2, buf) -> bool
typid: uint32 bt2: type_t buf: void *
def get_tinfo_pdata(*args) ‑> size_t
get_tinfo_pdata(outptr, typid, what) -> size_t
outptr: void * typid: uint32 what: int
def get_tinfo_property(*args) ‑> size_t
get_tinfo_property(typid, gta_prop) -> size_t
typid: uint32 gta_prop: int
def get_tinfo_size(*args) ‑> size_t
get_tinfo_size(p_effalign, typid, gts_code) -> size_t
p_effalign: uint32 * typid: uint32 gts_code: int
def get_type_flags(*args) ‑> type_t
Get type flags ( 'TYPE_FLAGS_MASK' )
get_type_flags(t) -> type_t
t (C++: type_t)
def get_type_ordinal(*args) ‑> int32
Get type ordinal by its name.
get_type_ordinal(ti, name) -> int32
ti (C++: const til_t *)
name (C++: const char *)
def get_vftable_ea(*args) ‑> ea_t
Get address of a virtual function table.
get_vftable_ea(ordinal) -> ea_t
ordinal: ordinal number of a vftable type. (C++: uint32)
return: address of the corresponding virtual function table in the
current database.
def get_vftable_ordinal(*args) ‑> uint32
Get ordinal number of the virtual function table.
get_vftable_ordinal(vftable_ea) -> uint32
vftable_ea: address of a virtual function table. (C++: ea_t)
return: ordinal number of the corresponding vftable type. 0 -
failure.
def guess_func_cc(*args) ‑> cm_t
Use 'func_type_data_t::guess_cc()'
guess_func_cc(fti, npurged, cc_flags) -> cm_t
fti (C++: const func_type_data_t &)
npurged (C++: int)
cc_flags (C++: int)
def guess_tinfo(*args) ‑> int
Generate a type information about the id from the disassembly. id can be a structure/union/enum id or an address.
guess_tinfo(tif, id) -> int
tif (C++: tinfo_t *)
id (C++: tid_t)
return: one of Guess tinfo codes
def idc_get_local_type(*args) ‑> int
idc_get_local_type(ordinal, flags, buf, maxsize) -> int
ordinal: int flags: int buf: char * maxsize: size_t
def idc_get_local_type_name(*args) ‑> size_t
idc_get_local_type_name(ordinal) -> str
ordinal: int
def idc_get_local_type_raw(*args) ‑> PyObject *
idc_get_local_type_raw(ordinal) -> PyObject *
ordinal: int
def idc_get_type(*args) ‑> size_t
idc_get_type(ea) -> str
ea: ea_t
def idc_get_type_raw(*args) ‑> PyObject *
idc_get_type_raw(ea) -> PyObject *
ea: ea_t
def idc_guess_type(*args) ‑> size_t
idc_guess_type(ea) -> str
ea: ea_t
def idc_parse_decl(*args) ‑> PyObject *
idc_parse_decl(ti, decl, flags) -> PyObject *
ti: til_t * decl: char const * flags: int
def idc_parse_types(*args) ‑> int
idc_parse_types(input, flags) -> int
input: char const * flags: int
def idc_print_type(*args) ‑> PyObject *
idc_print_type(type, fields, name, flags) -> PyObject *
type: type_t const * fields: p_list const * name: char const * flags: int
def idc_set_local_type(*args) ‑> int
idc_set_local_type(ordinal, dcl, flags) -> int
ordinal: int dcl: char const * flags: int
def import_type(*args) ‑> tid_t
Copy a named type from til to idb.
import_type(til, idx, name, flags=0) -> tid_t
til: type library (C++: const til_t *)
idx: the position of the new type in the list of types
(structures or enums). -1 means at the end of the list (C++: int)
name: the type name (C++: const char *)
flags: combination of Import type flags (C++: int)
return: BADNODE on error
def is_autosync(*args) ‑> bool
Is the specified idb type automatically synchronized?
is_autosync(name, type) -> bool
name (C++: const char *)
type (C++: const type_t *)
is_autosync(name, tif) -> bool
name (C++: const char *) tif: tinfo_t const &
def is_code_far(*args) ‑> bool
Does the given model specify far code?.
is_code_far(cm) -> bool
cm (C++: cm_t)
def is_comp_unsure(*args) ‑> comp_t
See 'COMP_UNSURE' .
is_comp_unsure(comp) -> comp_t
comp (C++: comp_t)
def is_data_far(*args) ‑> bool
Does the given model specify far data?.
is_data_far(cm) -> bool
cm (C++: cm_t)
def is_gcc(*args) ‑> bool
Is the target compiler 'COMP_GNU' ?
def is_gcc32(*args) ‑> bool
Is the target compiler 32 bit gcc?
def is_gcc64(*args) ‑> bool
Is the target compiler 64 bit gcc?
def is_golang_cc(*args) ‑> bool
GO language calling convention (return value in stack)?
is_golang_cc(cc) -> bool
cc (C++: cm_t)
def is_ordinal_name(*args) ‑> bool
Check if the name is an ordinal name. Ordinal names have the following format: '#' + set_de(ord)
is_ordinal_name(name, ord=None) -> bool
name (C++: const char *)
ord (C++: uint32 *)
def is_purging_cc(*args) ‑> bool
Does the calling convention clean the stack arguments upon return?.this function is valid only for x86 code
is_purging_cc(cm) -> bool
cm (C++: cm_t)
def is_restype_enum(*args) ‑> bool
is_restype_enum(til, type) -> bool
til (C++: const til_t *)
type (C++: const type_t *)
def is_restype_struct(*args) ‑> bool
is_restype_struct(til, type) -> bool
til (C++: const til_t *)
type (C++: const type_t *)
def is_restype_struni(*args) ‑> bool
is_restype_struni(til, type) -> bool
til (C++: const til_t *)
type (C++: const type_t *)
def is_restype_void(*args) ‑> bool
is_restype_void(til, type) -> bool
til (C++: const til_t *)
type (C++: const type_t *)
def is_sdacl_byte(*args) ‑> 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_sdacl_byte(t) -> bool
t (C++: type_t)
def is_tah_byte(*args) ‑> bool
The TAH byte (type attribute header byte) denotes the start of type attributes. (see "tah-typeattrs" in the type bit definitions)
is_tah_byte(t) -> bool
t (C++: type_t)
def is_type_arithmetic(*args) ‑> bool
Is the type an arithmetic type? (floating or integral)
is_type_arithmetic(t) -> bool
t (C++: type_t)
def is_type_array(*args) ‑> bool
See 'BT_ARRAY' .
is_type_array(t) -> bool
t (C++: type_t)
def is_type_bitfld(*args) ‑> bool
See 'BT_BITFIELD' .
is_type_bitfld(t) -> bool
t (C++: type_t)
def is_type_bool(*args) ‑> bool
See 'BTF_BOOL' .
is_type_bool(t) -> bool
t (C++: type_t)
def is_type_char(*args) ‑> bool
Does the type specify a char value? (signed or unsigned, see 'Basic type: integer' )
is_type_char(t) -> bool
t (C++: type_t)
def is_type_complex(*args) ‑> bool
See 'BT_COMPLEX' .
is_type_complex(t) -> bool
t (C++: type_t)
def is_type_const(*args) ‑> bool
See 'BTM_CONST' .
is_type_const(t) -> bool
t (C++: type_t)
def is_type_double(*args) ‑> bool
See 'BTF_DOUBLE' .
is_type_double(t) -> bool
t (C++: type_t)
def is_type_enum(*args) ‑> bool
See 'BTF_ENUM' .
is_type_enum(t) -> bool
t (C++: type_t)
def is_type_ext_arithmetic(*args) ‑> bool
Is the type an extended arithmetic type? (arithmetic or enum)
is_type_ext_arithmetic(t) -> bool
t (C++: type_t)
def is_type_ext_integral(*args) ‑> bool
Is the type an extended integral type? (integral or enum)
is_type_ext_integral(t) -> bool
t (C++: type_t)
def is_type_float(*args) ‑> bool
See 'BTF_FLOAT' .
is_type_float(t) -> bool
t (C++: type_t)
def is_type_floating(*args) ‑> bool
Is the type a floating point type?
is_type_floating(t) -> bool
t (C++: type_t)
def is_type_func(*args) ‑> bool
See 'BT_FUNC' .
is_type_func(t) -> bool
t (C++: type_t)
def is_type_int(*args) ‑> bool
Does the type_t specify one of the basic types in 'Basic type: integer' ?
is_type_int(bt) -> bool
bt (C++: type_t)
def is_type_int128(*args) ‑> bool
Does the type specify a 128-bit value? (signed or unsigned, see 'Basic type: integer' )
is_type_int128(t) -> bool
t (C++: type_t)
def is_type_int16(*args) ‑> bool
Does the type specify a 16-bit value? (signed or unsigned, see 'Basic type: integer' )
is_type_int16(t) -> bool
t (C++: type_t)
def is_type_int32(*args) ‑> bool
Does the type specify a 32-bit value? (signed or unsigned, see 'Basic type: integer' )
is_type_int32(t) -> bool
t (C++: type_t)
def is_type_int64(*args) ‑> bool
Does the type specify a 64-bit value? (signed or unsigned, see 'Basic type: integer' )
is_type_int64(t) -> bool
t (C++: type_t)
def is_type_integral(*args) ‑> bool
Is the type an integral type (char/short/int/long/bool)?
is_type_integral(t) -> bool
t (C++: type_t)
def is_type_ldouble(*args) ‑> bool
See 'BTF_LDOUBLE' .
is_type_ldouble(t) -> bool
t (C++: type_t)
def is_type_paf(*args) ‑> bool
Is the type a pointer, array, or function type?
is_type_paf(t) -> bool
t (C++: type_t)
def is_type_partial(*args) ‑> bool
Identifies an unknown or void type with a known size (see 'Basic type: unknown & void' )
is_type_partial(t) -> bool
t (C++: type_t)
def is_type_ptr(*args) ‑> bool
See 'BT_PTR' .
is_type_ptr(t) -> bool
t (C++: type_t)
def is_type_ptr_or_array(*args) ‑> bool
Is the type a pointer or array type?
is_type_ptr_or_array(t) -> bool
t (C++: type_t)
def is_type_struct(*args) ‑> bool
See 'BTF_STRUCT' .
is_type_struct(t) -> bool
t (C++: type_t)
def is_type_struni(*args) ‑> bool
Is the type a struct or union?
is_type_struni(t) -> bool
t (C++: type_t)
def is_type_sue(*args) ‑> bool
Is the type a struct/union/enum?
is_type_sue(t) -> bool
t (C++: type_t)
def is_type_tbyte(*args) ‑> bool
See 'BTF_FLOAT' .
is_type_tbyte(t) -> bool
t (C++: type_t)
def is_type_typedef(*args) ‑> bool
See 'BTF_TYPEDEF' .
is_type_typedef(t) -> bool
t (C++: type_t)
def is_type_uchar(*args) ‑> bool
See 'BTF_UCHAR' .
is_type_uchar(t) -> bool
t (C++: type_t)
def is_type_uint(*args) ‑> bool
See 'BTF_UINT' .
is_type_uint(t) -> bool
t (C++: type_t)
def is_type_uint128(*args) ‑> bool
See 'BTF_UINT128' .
is_type_uint128(t) -> bool
t (C++: type_t)
def is_type_uint16(*args) ‑> bool
See 'BTF_UINT16' .
is_type_uint16(t) -> bool
t (C++: type_t)
def is_type_uint32(*args) ‑> bool
See 'BTF_UINT32' .
is_type_uint32(t) -> bool
t (C++: type_t)
def is_type_uint64(*args) ‑> bool
See 'BTF_UINT64' .
is_type_uint64(t) -> bool
t (C++: type_t)
def is_type_union(*args) ‑> bool
See 'BTF_UNION' .
is_type_union(t) -> bool
t (C++: type_t)
def is_type_unknown(*args) ‑> bool
See 'BT_UNKNOWN' .
is_type_unknown(t) -> bool
t (C++: type_t)
def is_type_void(*args) ‑> bool
See 'BTF_VOID' .
is_type_void(t) -> bool
t (C++: type_t)
def is_type_volatile(*args) ‑> bool
See 'BTM_VOLATILE' .
is_type_volatile(t) -> bool
t (C++: type_t)
def is_typeid_last(*args) ‑> 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_typeid_last(t) -> bool
t (C++: type_t)
def is_user_cc(*args) ‑> bool
Does the calling convention specify argument locations explicitly?
is_user_cc(cm) -> bool
cm (C++: cm_t)
def is_vararg_cc(*args) ‑> bool
Does the calling convention use ellipsis?
is_vararg_cc(cm) -> bool
cm (C++: cm_t)
def lexcompare_tinfo(*args) ‑> int
lexcompare_tinfo(t1, t2, arg3) -> int
t1: uint32 t2: uint32 arg3: int
def load_til(*args) ‑> qstring *
Load til from a file. Failure to load base tils are reported into 'errbuf'. They do not prevent loading of the main til.
load_til(name, tildir=None) -> til_t
name: filename of the til. If it's an absolute path, tildir is
ignored. NB: the file extension is forced to .til (C++: const char *)
tildir: directory where to load the til from. NULL means
default til subdirectories. (C++: const char *)
return: pointer to resulting til, NULL if failed and error message is
in errbuf
def load_til_header(*args) ‑> qstring *
Get human-readable til description.
load_til_header(tildir, name) -> til_t
tildir (C++: const char *)
name (C++: const char *)
def lower_type(*args) ‑> 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, etcWe introduce explicit arguments (i.e. 'this' pointer) and call the result"low level prototype". See 'FTI_HIGH' .In order to improve heuristics for recognition of big structure retvals,it is recommended to pass a helper that will be used to make decisions.That helper will be used only for lowering 'tif', and not for the childrentypes walked through by recursion.
lower_type(til, tif, name=None, _helper=None) -> int
til (C++: til_t *)
tif (C++: tinfo_t *)
name (C++: const char *)
_helper (C++: lowertype_helper_t *)
retval: 1 - removed FTI_HIGH ,
retval: 2 - made substantial changes
retval: -1 - failure
def new_til(*args) ‑> til_t *
Initialize a til.
new_til(name, desc) -> til_t
name (C++: const char *)
desc (C++: const char *)
def next_named_type(*args) ‑> char const *
Enumerate types. Returns mangled names. Never returns anonymous types. To include it, enumerate types by ordinals.
next_named_type(ti, name, ntf_flags) -> char const *
ti (C++: const til_t *)
name (C++: const char *)
ntf_flags (C++: int)
def optimize_argloc(*args) ‑> bool
Verify and optimize scattered argloc into simple form. All new arglocs must be processed by this function.
optimize_argloc(vloc, size, gaps) -> bool
vloc (C++: argloc_t *)
size (C++: int)
gaps (C++: const rangeset_t *)
retval: true - success
retval: false - the input argloc was illegal
def pack_idcobj_to_bv(*args) ‑> 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_bv(obj, tif, bytes, objoff, pio_flags=0) -> error_t
obj (C++: const idc_value_t *)
tif (C++: const tinfo_t &)
bytes (C++: relobj_t *)
objoff (C++: void *)
pio_flags (C++: int)
def pack_idcobj_to_idb(*args) ‑> error_t
Write a typed idc object to the database.
pack_idcobj_to_idb(obj, tif, ea, pio_flags=0) -> error_t
obj (C++: const idc_value_t *)
tif (C++: const tinfo_t &)
ea (C++: ea_t)
pio_flags (C++: int)
def pack_object_to_bv(*args) ‑> PyObject *
pack_object_to_bv(py_obj, ti, type, fields, base_ea, pio_flags=0) -> PyObject *
Packs a typed object to a string
ti: Type info. 'None' can be passed.
tp: type string
fields: fields string (may be empty or None)
base_ea: base ea used to relocate the pointers in the packed object
pio_flags: flags used while unpacking
return:
tuple(0, err_code) on failure tuple(1, packed_buf) on success
def pack_object_to_idb(*args) ‑> 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
ti: Type info. 'None' can be passed.
tp: type string
fields: fields string (may be empty or None)
ea: ea to be used while packing
pio_flags: flags used while unpacking
def parse_decl(*args) ‑> qstring *
Parse ONE declaration. If the input string contains more than one declaration, the first complete type declaration ( 'PT_TYP' ) or the last variable declaration ( 'PT_VAR' ) will be used.name & tif may be empty after the call!
parse_decl(tif, til, decl, flags) -> str
tif: type info (C++: tinfo_t *)
til: type library to use. may be NULL (C++: til_t *)
decl: C declaration to parse (C++: const char *)
flags: combination of Type parsing flags bits (C++: int)
retval: true - ok
retval: false - declaration is bad, the error message is displayed if
!PT_SIL
def parse_decls(*args) ‑> 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.
parse_decls(til, input, printer, hti_flags) -> int
til: type library to store the result (C++: til_t *)
input: input string or file name (see hti_flags) (C++: const
char *)
printer: function to output error messages (use msg or NULL or
your own callback) (C++: printer_t *)
hti_flags: combination of Type formatting flags (C++: int)
return: number of errors, 0 means ok.
def print_argloc(*args) ‑> size_t
Convert an argloc to human readable form.
print_argloc(vloc, size=0, vflags=0) -> str
vloc (C++: const argloc_t &)
size (C++: int)
vflags (C++: int)
def print_decls(*args) ‑> PyObject *
Print types (and possibly their dependencies) in a format suitable for use in a header file. This is the reverse 'parse_decls()' .
print_decls(printer, til, py_ordinals, flags) -> PyObject *
printer: a handler for printing text (C++: text_sink_t &)
til: the type library holding the ordinals (C++: til_t *) py_ordinals: PyObject *
flags: flags for the algorithm. A combination of PDF_*
constants (C++: uint32)
retval: >0 - the number of types exported
retval: 0 - an error occurred
retval: <0 - the negated number of types exported. There were minor
errors and the resulting output might not be compilable.
def print_tinfo(*args) ‑> qstring *
print_tinfo(prefix, indent, cmtindent, flags, tif, name, cmt) -> str
prefix: char const * indent: int cmtindent: int flags: int tif: tinfo_t const * name: char const * cmt: char const *
def print_type(*args) ‑> qstring *
Get type declaration for the specified address.
print_type(ea, prtype_flags) -> str
ea: address (C++: ea_t)
prtype_flags: combination of Type printing flags (C++: int)
return: success
def read_tinfo_bitfield_value(*args) ‑> uint64
read_tinfo_bitfield_value(typid, v, bitoff) -> uint64
typid: uint32 v: uint64 bitoff: int
def remove_abi_opts(*args) ‑> bool
remove_abi_opts(abi_opts, user_level=False) -> bool
abi_opts (C++: const char *)
user_level (C++: bool)
def remove_pointer(*args) ‑> tinfo_t
'BT_PTR' : If the current type is a pointer, return the pointed object. If the current type is not a pointer, return the current type. See also get_ptrarr_object() and get_pointed_object()
remove_pointer(tif) -> tinfo_t
tif (C++: const tinfo_t &)
def remove_tinfo_pointer(*args) ‑> PyObject *
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.
remove_tinfo_pointer(tif, name, til) -> PyObject *
tif (C++: tinfo_t *) name: char const *
til (C++: const til_t *)
def replace_ordinal_typerefs(*args) ‑> 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.
replace_ordinal_typerefs(til, tif) -> int
til: type library to use. may be NULL. (C++: til_t *)
tif: type to modify (in/out) (C++: tinfo_t *)
retval: number - of replaced subtypes, -1 on failure
def resolve_typedef(*args) ‑> type_t const *
resolve_typedef(til, type) -> type_t const *
til (C++: const til_t *)
type (C++: const type_t *)
def save_tinfo(*args) ‑> tinfo_code_t
save_tinfo(tif, til, ord, name, ntf_flags) -> tinfo_code_t
tif: tinfo_t * til: til_t * ord: size_t name: char const * ntf_flags: int
def score_tinfo(*args) ‑> uint32
score_tinfo(tif) -> uint32
tif: tinfo_t const *
def serialize_tinfo(*args) ‑> bool
serialize_tinfo(type, fields, fldcmts, tif, sudt_flags) -> bool
type: qtype * fields: qtype * fldcmts: qtype * tif: tinfo_t const * sudt_flags: int
def set_abi_name(*args) ‑> bool
Set abi name (see 'Compiler IDs' )
set_abi_name(abiname, user_level=False) -> bool
abiname (C++: const char *)
user_level (C++: bool)
def set_c_header_path(*args) ‑> void
Set include directory path the target compiler.
set_c_header_path(incdir)
incdir (C++: const char *)
def set_c_macros(*args) ‑> void
Set predefined macros for the target compiler.
set_c_macros(macros)
macros (C++: const char *)
def set_compiler(*args) ‑> bool
Change current compiler.
set_compiler(cc, flags, abiname=None) -> bool
cc: compiler to switch to (C++: const compiler_info_t &)
flags: Set compiler flags (C++: int)
abiname: ABI name (C++: const char *)
return: success
def set_compiler_id(*args) ‑> bool
Set the compiler id (see 'Compiler IDs' )
set_compiler_id(id, abiname=None) -> bool
id (C++: comp_t)
abiname (C++: const char *)
def set_compiler_string(*args) ‑> bool
set_compiler_string(compstr, user_level) -> bool
compstr: - compiler description in form <abbr>:<abiname> (C++:
const char *)
user_level: - initiated by user if TRUE (C++: bool)
return: success
def set_numbered_type(*args) ‑> tinfo_code_t
Store a type in the til. 'name' may be NULL for anonymous types. The specified ordinal must be free (no other type is using it). For ntf_flags, only 'NTF_REPLACE' is consulted.
set_numbered_type(ti, ordinal, ntf_flags, name, type, fields=None, cmt=None, fldcmts=None, sclass=None) -> tinfo_code_t
ti (C++: til_t *)
ordinal (C++: uint32)
ntf_flags (C++: int)
name (C++: const char *)
type (C++: const type_t *)
fields (C++: const p_list *)
cmt (C++: const char *)
fldcmts (C++: const p_list *)
sclass (C++: const sclass_t *)
def set_tinfo_attr(*args) ‑> bool
set_tinfo_attr(tif, ta, may_overwrite) -> bool
tif: tinfo_t * ta: type_attr_t const & may_overwrite: bool
def set_tinfo_attrs(*args) ‑> bool
set_tinfo_attrs(tif, ta) -> bool
tif: tinfo_t * ta: type_attrs_t *
def set_tinfo_property(*args) ‑> size_t
set_tinfo_property(tif, sta_prop, x) -> size_t
tif: tinfo_t * sta_prop: int x: size_t
def set_type_alias(*args) ‑> bool
Create a type alias. Redirects all references to source type to the destination type. This is equivalent to instantaneous replacement all reference to srctype by dsttype.
set_type_alias(ti, src_ordinal, dst_ordinal) -> bool
ti (C++: til_t *)
src_ordinal (C++: uint32)
dst_ordinal (C++: uint32)
def set_vftable_ea(*args) ‑> bool
Set the address of a vftable instance for a vftable type.
set_vftable_ea(ordinal, vftable_ea) -> bool
ordinal: ordinal number of the corresponding vftable type.
(C++: uint32)
vftable_ea: address of a virtual function table. (C++: ea_t)
return: success
def store_til(*args) ‑> 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()' .
store_til(ti, tildir, name) -> bool
ti: type library to store (C++: til_t *)
tildir: directory where to store the til. NULL means current
directory. (C++: const char *)
name: filename of the til. If it's an absolute path, tildir is
ignored. NB: the file extension is forced to .til (C++: const char *)
return: success
def switch_to_golang(*args) ‑> void
switch to GOLANG calling convention (to be used as default CC)
def tinfo_t_get_stock(*args) ‑> tinfo_t
tinfo_t_get_stock(id) -> tinfo_t
id: enum stock_type_id_t
def unpack_idcobj_from_bv(*args) ‑> error_t
Read a typed idc object from the byte vector.
unpack_idcobj_from_bv(obj, tif, bytes, pio_flags=0) -> error_t
obj (C++: idc_value_t *)
tif (C++: const tinfo_t &)
bytes (C++: const bytevec_t &)
pio_flags (C++: int)
def unpack_idcobj_from_idb(*args) ‑> error_t
Collection of register objects.
Read a typed idc object from the database
unpack_idcobj_from_idb(obj, tif, ea, off0, pio_flags=0) -> error_t
obj (C++: idc_value_t *)
tif (C++: const tinfo_t &)
ea (C++: ea_t)
off0 (C++: const bytevec_t *)
pio_flags (C++: int)
def unpack_object_from_bv(*args) ‑> 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
ti: Type info. 'None' can be passed.
tp: type string
fields: fields string (may be empty or None)
bytes: the bytes to unpack
pio_flags: flags used while unpacking
return:
  • tuple(0, err) on failure
  • tuple(1, obj) on success
def unpack_object_from_idb(*args) ‑> PyObject *
unpack_object_from_idb(ti, type, fields, ea, pio_flags=0) -> PyObject *
ti: til_t * type: type_t const * fields: p_list const * ea: ea_t pio_flags: int
def use_golang_cc(*args) ‑> bool
is GOLANG calling convention used by default?
def verify_argloc(*args) ‑> int
Verify 'argloc_t' .
verify_argloc(vloc, size, gaps) -> int
vloc (C++: const argloc_t &)
size: total size of the variable (C++: int)
gaps: if not NULL, specifies gaps in structure definition.
these gaps should not map to any argloc, but everything else must be covered (C++: const rangeset_t *)
return: 0 if ok, otherwise an interr code.
def verify_tinfo(*args) ‑> int
verify_tinfo(typid) -> int
typid: uint32
def visit_subtypes(*args) ‑> int
visit_subtypes(visitor, out, tif, name, cmt) -> int
visitor: tinfo_visitor_t * out: type_mods_t * tif: tinfo_t const & name: char const * cmt: char const *
def write_tinfo_bitfield_value(*args) ‑> uint64
write_tinfo_bitfield_value(typid, dst, v, bitoff) -> uint64
typid: uint32 dst: uint64 v: uint64 bitoff: int

Classes

class aloc_visitor_t (*args)
Proxy of C++ aloc_visitor_t class.
__init__(self) -> aloc_visitor_t
self: PyObject *

Methods

def visit_location(self, *args) ‑> int
visit_location(self, v, off, size) -> int
v (C++: argloc_t &)
off (C++: int)
size (C++: int)
class argloc_t (*args)
Proxy of C++ argloc_t class.
__init__(self) -> argloc_t
r: argloc_t const &

Subclasses

Methods

def advance(self, *args) ‑> bool
Move the location to point 'delta' bytes further.
advance(self, delta) -> bool
delta (C++: int)
def atype(self, *args) ‑> argloc_type_t
Get type ( 'Argument location types' )
def calc_offset(self, *args) ‑> sval_t
Calculate offset that can be used to compare 2 similar arglocs.
def compare(self, *args) ‑> int
compare(self, r) -> int
r: argloc_t const &
def consume_rrel(self, *args) ‑> void
Set register-relative location - can't be NULL.
consume_rrel(self, p)
p (C++: rrel_t *)
def consume_scattered(self, *args) ‑> void
Set distributed argument location.
consume_scattered(self, p)
p (C++: scattered_aloc_t *)
def get_biggest(self, *args) ‑> argloc_t::biggest_t
Get largest element in internal union.
def get_custom(self, *args) ‑> void *
Get custom argloc info. Use if 'atype()' == 'ALOC_CUSTOM'
def get_ea(self, *args) ‑> ea_t
Get the global address. Use when 'atype()' == 'ALOC_STATIC'
def get_reginfo(self, *args) ‑> uint32
Get all register info. Use when 'atype()' == 'ALOC_REG1' or 'ALOC_REG2'
def get_rrel(self, *args) ‑> rrel_t const &
Get register-relative info. Use when 'atype()' == 'ALOC_RREL'
def has_reg(self, *args) ‑> bool
TRUE if argloc has a register part.
def has_stkoff(self, *args) ‑> bool
TRUE if argloc has a stack part.
def in_stack(self, *args) ‑> bool
TRUE if argloc is in stack entirely.
def is_badloc(self, *args) ‑> bool
See 'ALOC_NONE' .
def is_custom(self, *args) ‑> bool
See 'ALOC_CUSTOM' .
def is_ea(self, *args) ‑> bool
See 'ALOC_STATIC' .
def is_fragmented(self, *args) ‑> bool
'is_scattered()' || 'is_reg2()'
def is_mixed_scattered(self, *args) ‑> bool
mixed scattered: consists of register and stack parts
def is_reg(self, *args) ‑> bool
'is_reg1()' || 'is_reg2()'
def is_reg1(self, *args) ‑> bool
See 'ALOC_REG1' .
def is_reg2(self, *args) ‑> bool
See 'ALOC_REG2' .
def is_rrel(self, *args) ‑> bool
See 'ALOC_RREL' .
def is_scattered(self, *args) ‑> bool
See 'ALOC_DIST' .
def is_stkoff(self, *args) ‑> bool
See 'ALOC_STACK' .
def justify_reg_high(self, *args) ‑> void
Set register offset to justify it to the upper part of _SLOTSIZE.
justify_reg_high(self, size, _slotsize)
size (C++: size_t)
_slotsize (C++: size_t)
def justify_stkoff_right(self, *args) ‑> void
Set stack offset to right-justify it in _SLOTSIZE.
justify_stkoff_right(self, size, _slotsize)
size (C++: size_t)
_slotsize (C++: size_t)
def reg1(self, *args) ‑> int
Get the register info. Use when 'atype()' == 'ALOC_REG1' or 'ALOC_REG2'
def reg2(self, *args) ‑> int
Get info for the second register. Use when 'atype()' == 'ALOC_REG2'
def regoff(self, *args) ‑> int
Get offset from the beginning of the register in bytes. Use when 'atype()' == 'ALOC_REG1'
def scattered(self, *args) ‑> scattered_aloc_t const &
Get scattered argument info. Use when 'atype()' == 'ALOC_DIST'
def set_badloc(self, *args) ‑> void
Set to invalid location.
def set_ea(self, *args) ‑> void
Set static ea location.
set_ea(self, _ea)
_ea (C++: ea_t)
def set_reg1(self, *args) ‑> void
Set register location.
set_reg1(self, reg, off=0)
reg (C++: int)
off (C++: int)
def set_reg2(self, *args) ‑> void
Set secondary register location.
set_reg2(self, _reg1, _reg2)
_reg1 (C++: int)
_reg2 (C++: int)
def set_stkoff(self, *args) ‑> void
Set stack offset location.
set_stkoff(self, off)
off (C++: sval_t)
def stkoff(self, *args) ‑> sval_t
Get the stack offset. Use if 'atype()' == 'ALOC_STACK'
def swap(self, *args) ‑> void
Assign this == r and r == this.
swap(self, r)
r (C++: argloc_t &)
class argpart_t (*args)
Proxy of C++ argpart_t class.
__init__(self, a) -> argpart_t
a: argloc_t const &

Ancestors

Instance variables

var off
argpart_t_off_get(self) -> ushort
var size
argpart_t_size_get(self) -> ushort

Methods

def bad_offset(self, *args) ‑> bool
Does this argpart have a valid offset?
def bad_size(self, *args) ‑> bool
Does this argpart have a valid size?
def swap(self, *args) ‑> void
Assign this = r and r = this.
swap(self, r)
r (C++: argpart_t &)

Inherited members

class argpartvec_t (*args)
Proxy of C++ qvector< argpart_t > class.
__init__(self) -> argpartvec_t
x: qvector< argpart_t > const &

Subclasses

Methods

def add_unique(self, *args) ‑> bool
add_unique(self, x) -> bool
x: argpart_t const &
def at(self, *args) ‑> argpart_t const &
at(self, _idx) -> argpart_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< argpart_t >::const_iterator
begin(self) -> argpart_t
begin(self) -> argpart_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< argpart_t >::const_iterator
end(self) -> argpart_t
end(self) -> argpart_t
def 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
def extract(self, *args) ‑> argpart_t *
extract(self) -> argpart_t
def find(self, *args) ‑> qvector< argpart_t >::const_iterator
find(self, x) -> argpart_t
x: argpart_t const &
find(self, x) -> argpart_t
x: argpart_t const &
def front(self)
def grow(self, *args) ‑> void
grow(self, x=argpart_t())
x: argpart_t const &
def has(self, *args) ‑> bool
has(self, x) -> bool
x: argpart_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: argpart_t * len: size_t
def insert(self, *args) ‑> qvector< argpart_t >::iterator
insert(self, it, x) -> argpart_t
it: qvector< argpart_t >::iterator x: argpart_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> argpart_t &
push_back(self, x)
x: argpart_t const &
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t x: argpart_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< argpart_t > &
def truncate(self, *args) ‑> void
truncate(self)
class argtinfo_helper_t (*args)
Proxy of C++ argtinfo_helper_t class.
__init__(self) -> argtinfo_helper_t
self: PyObject *

Instance variables

var reserved
argtinfo_helper_t_reserved_get(self) -> size_t

Methods

def has_delay_slot(self, *args) ‑> bool
The call instruction with a delay slot?.
has_delay_slot(self, arg0) -> bool
arg0: ea_t
def is_stkarg_load(self, *args) ‑> 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
is_stkarg_load(self, insn, src, dst) -> bool
insn - an ida_ua.insn_t, or an address (C++: const insn_t &)
src (C++: int *)
dst (C++: int *)
def set_op_tinfo(self, *args) ‑> bool
Set the operand type as specified.
set_op_tinfo(self, insn, x, tif, name) -> bool
insn - an ida_ua.insn_t, or an address (C++: const insn_t &)
x (C++: const op_t &)
tif (C++: const tinfo_t &)
name (C++: const char *)
def use_arg_tinfos(self, *args) ‑> void
This function is to be called by the processor module in response to ev_use_arg_types.
use_arg_tinfos(self, caller, fti, rargs)
caller (C++: ea_t)
fti (C++: func_type_data_t *)
rargs (C++: funcargvec_t *)
class array_type_data_t (*args)
Proxy of C++ array_type_data_t class.
__init__(self, b=0, n=0) -> array_type_data_t
b: size_t n: size_t

Instance variables

var base
array_type_data_t_base_get(self) -> uint32
var elem_type
array_type_data_t_elem_type_get(self) -> tinfo_t
var nelems
array_type_data_t_nelems_get(self) -> uint32

Methods

def swap(self, *args) ‑> void
set this = r and r = this
swap(self, r)
r (C++: array_type_data_t &)
class bitfield_type_data_t (*args)
Proxy of C++ bitfield_type_data_t class.
__init__(self, _nbytes=0, _width=0, _is_unsigned=False) -> bitfield_type_data_t
_nbytes: uchar _width: uchar _is_unsigned: bool

Instance variables

var is_unsigned
bitfield_type_data_t_is_unsigned_get(self) -> bool
var nbytes
bitfield_type_data_t_nbytes_get(self) -> uchar
var width
bitfield_type_data_t_width_get(self) -> uchar

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: bitfield_type_data_t const &
def swap(self, *args) ‑> void
swap(self, r)
r (C++: bitfield_type_data_t &)
class callregs_t (*args)
Proxy of C++ callregs_t class.
__init__(self) -> callregs_t
cc: cm_t

Static methods

def regcount(*args) ‑> int
regcount(cc) -> int
cc: cm_t

Instance variables

var fpregs
callregs_t_fpregs_get(self) -> intvec_t *
var gpregs
callregs_t_gpregs_get(self) -> intvec_t *
var nregs
callregs_t_nregs_get(self) -> int
var policy
callregs_t_policy_get(self) -> argreg_policy_t

Methods

def by_slots(self, *args) ‑> bool
by_slots(self) -> bool
def init_regs(self, *args) ‑> void
Init policy & registers for given CC.
init_regs(self, cc)
cc (C++: cm_t)
def reginds(self, *args) ‑> bool
Get register indexes within GP/FP arrays. (-1 -> is not present in the corresponding array)
reginds(self, gp_ind, fp_ind, r) -> bool
gp_ind (C++: int *)
fp_ind (C++: int *)
r (C++: int)
def reset(self, *args) ‑> void
Set policy and registers to invalid values.
def set(self, *args) ‑> void
Init policy & registers (arrays are -1-terminated)
set(self, _policy, gprs, fprs)
_policy (C++: argreg_policy_t)
gprs (C++: const int *)
fprs (C++: const int *)
class const_aloc_visitor_t (*args)
Proxy of C++ const_aloc_visitor_t class.
__init__(self) -> const_aloc_visitor_t
self: PyObject *

Methods

def visit_location(self, *args) ‑> int
visit_location(self, v, off, size) -> int
v (C++: const argloc_t &)
off (C++: int)
size (C++: int)
class enum_member_t (*args)
Proxy of C++ enum_member_t class.
__init__(self) -> enum_member_t

Instance variables

var cmt
enum_member_t_cmt_get(self) -> qstring *
var name
enum_member_t_name_get(self) -> qstring *
var value
enum_member_t_value_get(self) -> uint64

Methods

def swap(self, *args) ‑> void
swap(self, r)
r (C++: enum_member_t &)
class enum_member_vec_t (*args)
Proxy of C++ qvector< enum_member_t > class.
__init__(self) -> enum_member_vec_t
x: qvector< enum_member_t > const &

Subclasses

Methods

def add_unique(self, *args) ‑> bool
add_unique(self, x) -> bool
x: enum_member_t const &
def at(self, *args) ‑> enum_member_t const &
at(self, _idx) -> enum_member_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< enum_member_t >::const_iterator
begin(self) -> enum_member_t
begin(self) -> enum_member_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< enum_member_t >::const_iterator
end(self) -> enum_member_t
end(self) -> enum_member_t
def erase(self, *args) ‑> qvector< enum_member_t >::iterator
erase(self, it) -> enum_member_t
it: qvector< enum_member_t >::iterator
erase(self, first, last) -> enum_member_t
first: qvector< enum_member_t >::iterator last: qvector< enum_member_t >::iterator
def extract(self, *args) ‑> enum_member_t *
extract(self) -> enum_member_t
def find(self, *args) ‑> qvector< enum_member_t >::const_iterator
find(self, x) -> enum_member_t
x: enum_member_t const &
find(self, x) -> enum_member_t
x: enum_member_t const &
def front(self)
def grow(self, *args) ‑> void
grow(self, x=enum_member_t())
x: enum_member_t const &
def has(self, *args) ‑> bool
has(self, x) -> bool
x: enum_member_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: enum_member_t * len: size_t
def insert(self, *args) ‑> qvector< enum_member_t >::iterator
insert(self, it, x) -> enum_member_t
it: qvector< enum_member_t >::iterator x: enum_member_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> enum_member_t &
push_back(self, x)
x: enum_member_t const &
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t x: enum_member_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< enum_member_t > &
def truncate(self, *args) ‑> void
truncate(self)
class enum_type_data_t (*args)
Proxy of C++ enum_type_data_t class.
__init__(self, _bte=BTE_ALWAYS|BTE_HEX) -> enum_type_data_t
_bte: bte_t

Ancestors

Instance variables

var bte
enum_type_data_t_bte_get(self) -> bte_t
var group_sizes
enum_type_data_t_group_sizes_get(self) -> intvec_t *
var taenum_bits
enum_type_data_t_taenum_bits_get(self) -> uint32

Methods

def calc_mask(self, *args) ‑> uint64
calc_mask(self) -> uint64
def calc_nbytes(self, *args) ‑> int
calc_nbytes(self) -> int
def is_64bit(self, *args) ‑> bool
is_64bit(self) -> bool
def is_char(self, *args) ‑> bool
is_char(self) -> bool
def is_hex(self, *args) ‑> bool
is_hex(self) -> bool
def is_sdec(self, *args) ‑> bool
is_sdec(self) -> bool
def is_udec(self, *args) ‑> bool
is_udec(self) -> bool
def swap(self, *args) ‑> void
swap two instances
swap(self, r)
r (C++: enum_type_data_t &)

Inherited members

class func_type_data_t (*args)
Proxy of C++ func_type_data_t class.
__init__(self) -> func_type_data_t

Ancestors

Instance variables

var cc
func_type_data_t_cc_get(self) -> cm_t
var flags
func_type_data_t_flags_get(self) -> int
var retloc
func_type_data_t_retloc_get(self) -> argloc_t
var rettype
func_type_data_t_rettype_get(self) -> tinfo_t
var spoiled
func_type_data_t_spoiled_get(self) -> reginfovec_t
var stkargs
func_type_data_t_stkargs_get(self) -> uval_t

Methods

def dump(self, *args) ‑> bool
Dump information that is not always visible in the function prototype. (argument locations, return location, total stkarg size)
dump(self, praloc_bits=0x02) -> bool
praloc_bits (C++: int)
def get_call_method(self, *args) ‑> int
get_call_method(self) -> int
def guess_cc(self, *args) ‑> cm_t
Guess function calling convention use the following info: argument locations and 'stkargs'
guess_cc(self, purged, cc_flags) -> cm_t
purged (C++: int)
cc_flags (C++: int)
def is_golang_cc(self, *args) ‑> bool
is_golang_cc(self) -> bool
def is_high(self, *args) ‑> bool
is_high(self) -> bool
def is_noret(self, *args) ‑> bool
is_noret(self) -> bool
def is_pure(self, *args) ‑> bool
is_pure(self) -> bool
def is_vararg_cc(self, *args) ‑> bool
is_vararg_cc(self) -> bool
def swap(self, *args) ‑> void
swap(self, r)
r (C++: func_type_data_t &)

Inherited members

class funcarg_t (*args)
Proxy of C++ funcarg_t class.
__init__(self) -> funcarg_t

Instance variables

var argloc
funcarg_t_argloc_get(self) -> argloc_t
var cmt
funcarg_t_cmt_get(self) -> qstring *
var flags
funcarg_t_flags_get(self) -> uint32
var name
funcarg_t_name_get(self) -> qstring *
var type
funcarg_t_type_get(self) -> tinfo_t
class funcargvec_t (*args)
Proxy of C++ qvector< funcarg_t > class.
__init__(self) -> funcargvec_t
x: qvector< funcarg_t > const &

Subclasses

Methods

def add_unique(self, *args) ‑> bool
add_unique(self, x) -> bool
x: funcarg_t const &
def at(self, *args) ‑> funcarg_t const &
at(self, _idx) -> funcarg_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< funcarg_t >::const_iterator
begin(self) -> funcarg_t
begin(self) -> funcarg_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< funcarg_t >::const_iterator
end(self) -> funcarg_t
end(self) -> funcarg_t
def 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
def extract(self, *args) ‑> funcarg_t *
extract(self) -> funcarg_t
def find(self, *args) ‑> qvector< funcarg_t >::const_iterator
find(self, x) -> funcarg_t
x: funcarg_t const &
find(self, x) -> funcarg_t
x: funcarg_t const &
def front(self)
def grow(self, *args) ‑> void
grow(self, x=funcarg_t())
x: funcarg_t const &
def has(self, *args) ‑> bool
has(self, x) -> bool
x: funcarg_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: funcarg_t * len: size_t
def insert(self, *args) ‑> qvector< funcarg_t >::iterator
insert(self, it, x) -> funcarg_t
it: qvector< funcarg_t >::iterator x: funcarg_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> funcarg_t &
push_back(self, x)
x: funcarg_t const &
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t x: funcarg_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< funcarg_t > &
def truncate(self, *args) ‑> void
truncate(self)
class ida_lowertype_helper_t (*args)
Proxy of C++ ida_lowertype_helper_t class.
__init__(self, _tif, _ea, _pb) -> ida_lowertype_helper_t
_tif: tinfo_t const & _ea: ea_t _pb: int

Ancestors

Methods

def get_func_purged_bytes(self, *args) ‑> int
get_func_purged_bytes(self, candidate, arg3) -> int
candidate (C++: const tinfo_t &) arg3: func_type_data_t const &

Inherited members

class lowertype_helper_t (*args, **kwargs)
Proxy of C++ lowertype_helper_t class.

Subclasses

Methods

def func_has_stkframe_hole(self, *args) ‑> bool
func_has_stkframe_hole(self, candidate, candidate_data) -> bool
candidate (C++: const tinfo_t &)
candidate_data (C++: const func_type_data_t &)
def get_func_purged_bytes(self, *args) ‑> int
get_func_purged_bytes(self, candidate, candidate_data) -> int
candidate (C++: const tinfo_t &)
candidate_data (C++: const func_type_data_t &)
class predicate_t (*args)
Proxy of C++ predicate_t class.
__init__(self) -> predicate_t
self: PyObject *

Methods

def should_display(self, *args) ‑> bool
should_display(self, til, name, type, fields) -> bool
til (C++: const til_t *)
name (C++: const char *)
type (C++: const type_t *)
fields (C++: const p_list *)
class ptr_type_data_t (*args)
Proxy of C++ ptr_type_data_t class.
__init__(self, c=tinfo_t(), bps=0, p=tinfo_t(), d=0) -> ptr_type_data_t
c: tinfo_t bps: uchar p: tinfo_t d: int32

Instance variables

var based_ptr_size
ptr_type_data_t_based_ptr_size_get(self) -> uchar
var closure
ptr_type_data_t_closure_get(self) -> tinfo_t
var delta
ptr_type_data_t_delta_get(self) -> int32
var obj_type
ptr_type_data_t_obj_type_get(self) -> tinfo_t
var parent
ptr_type_data_t_parent_get(self) -> tinfo_t
var taptr_bits
ptr_type_data_t_taptr_bits_get(self) -> uchar

Methods

def is_code_ptr(self, *args) ‑> bool
Are we pointing to code?
def is_shifted(self, *args) ‑> bool
is_shifted(self) -> bool
def swap(self, *args) ‑> void
Set this = r and r = this.
swap(self, r)
r (C++: ptr_type_data_t &)
class reginfovec_t (*args)
Proxy of C++ qvector< reg_info_t > class.
__init__(self) -> reginfovec_t
x: qvector< reg_info_t > const &

Methods

def add_unique(self, *args) ‑> bool
add_unique(self, x) -> bool
x: reg_info_t const &
def append(self, *args) ‑> reg_info_t &
push_back(self, x)
x: reg_info_t const &
def at(self, *args) ‑> reg_info_t const &
__getitem__(self, i) -> reg_info_t
i: size_t
def back(self)
def begin(self, *args) ‑> qvector< reg_info_t >::const_iterator
begin(self) -> reg_info_t
begin(self) -> reg_info_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< reg_info_t >::const_iterator
end(self) -> reg_info_t
end(self) -> reg_info_t
def 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
def extract(self, *args) ‑> reg_info_t *
extract(self) -> reg_info_t
def find(self, *args) ‑> qvector< reg_info_t >::const_iterator
find(self, x) -> reg_info_t
x: reg_info_t const &
find(self, x) -> reg_info_t
x: reg_info_t const &
def front(self)
def grow(self, *args) ‑> void
grow(self, x=reg_info_t())
x: reg_info_t const &
def has(self, *args) ‑> bool
has(self, x) -> bool
x: reg_info_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: reg_info_t * len: size_t
def insert(self, *args) ‑> qvector< reg_info_t >::iterator
insert(self, it, x) -> reg_info_t
it: qvector< reg_info_t >::iterator x: reg_info_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> reg_info_t &
push_back(self, x)
x: reg_info_t const &
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t x: reg_info_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< reg_info_t > &
def truncate(self, *args) ‑> void
truncate(self)
class regobj_t (*args)
Proxy of C++ regobj_t class.
__init__(self) -> regobj_t

Instance variables

var regidx
regobj_t_regidx_get(self) -> int
var relocate
regobj_t_relocate_get(self) -> int
var value
regobj_t_value_get(self) -> bytevec_t *

Methods

def size(self, *args) ‑> size_t
size(self) -> size_t
class regobjs_t (*args)
Proxy of C++ regobjs_t class.
__init__(self) -> regobjs_t

Ancestors

Inherited members

class regobjvec_t (*args)
Proxy of C++ qvector< regobj_t > class.
__init__(self) -> regobjvec_t
x: qvector< regobj_t > const &

Subclasses

Methods

def at(self, *args) ‑> regobj_t const &
at(self, _idx) -> regobj_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< regobj_t >::const_iterator
begin(self) -> regobj_t
begin(self) -> regobj_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< regobj_t >::const_iterator
end(self) -> regobj_t
end(self) -> regobj_t
def 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
def extract(self, *args) ‑> regobj_t *
extract(self) -> regobj_t
def front(self)
def grow(self, *args) ‑> void
grow(self, x=regobj_t())
x: regobj_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: regobj_t * len: size_t
def insert(self, *args) ‑> qvector< regobj_t >::iterator
insert(self, it, x) -> regobj_t
it: qvector< regobj_t >::iterator x: regobj_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> regobj_t &
push_back(self, x)
x: regobj_t const &
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t x: regobj_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< regobj_t > &
def truncate(self, *args) ‑> void
truncate(self)
class rrel_t (*args)
Proxy of C++ rrel_t class.
__init__(self) -> rrel_t

Instance variables

var off
rrel_t_off_get(self) -> sval_t
var reg
rrel_t_reg_get(self) -> int
class scattered_aloc_t (*args)
Proxy of C++ scattered_aloc_t class.
__init__(self) -> scattered_aloc_t

Ancestors

Inherited members

class simd_info_t (*args)
Proxy of C++ simd_info_t class.
__init__(self, nm=None, sz=0, memt=BTF_UNK) -> simd_info_t
nm: char const * sz: uint16 memt: type_t

Instance variables

var memtype
simd_info_t_memtype_get(self) -> type_t
var name
simd_info_t_name_get(self) -> char const *
var size
simd_info_t_size_get(self) -> uint16
var tif
simd_info_t_tif_get(self) -> tinfo_t

Methods

def match_pattern(self, *args) ‑> bool
match_pattern(self, pattern) -> bool
pattern (C++: const simd_info_t *)
class text_sink_t (*args)
Proxy of C++ text_sink_t class.
__init__(self) -> text_sink_t
self: PyObject *
class til_symbol_t (*args)
Proxy of C++ til_symbol_t class.
__init__(self, n=None, t=None) -> til_symbol_t
n: char const * t: til_t const *

Instance variables

var name
til_symbol_t_name_get(self) -> char const *
var til
til_symbol_t_til_get(self) -> til_t
class til_t (*args)
Proxy of C++ til_t class.
__init__(self) -> til_t

Instance variables

var cc
til_t_cc_get(self) -> compiler_info_t
var desc
til_t_desc_get(self) -> char *
var flags
til_t_flags_get(self) -> uint32
var name
til_t_name_get(self) -> char *
var nbases
til_t_nbases_get(self) -> int
var nrefs
til_t_nrefs_get(self) -> int
var nstreams
til_t_nstreams_get(self) -> int
var streams
til_t_streams_get(self) -> til_stream_t **

Methods

def base(self, *args) ‑> til_t *
base(self, n) -> til_t
n: int
def is_dirty(self, *args) ‑> bool
Has the til been modified? ( 'TIL_MOD' )
def set_dirty(self, *args) ‑> void
Mark the til as modified ( 'TIL_MOD' )
class tinfo_t (*args)
Proxy of C++ tinfo_t class.
__init__(self) -> tinfo_t
decl_type: type_t
__init__(self, r) -> tinfo_t
r: tinfo_t const &

Static methods

def get_stock(*args) ‑> tinfo_t
get_stock(id) -> tinfo_t
id: enum stock_type_id_t

Methods

def append_covered(self, *args) ‑> bool
Calculate set of covered bytes for the type
append_covered(self, out, offset=0) -> bool
out: pointer to the output buffer. covered bytes will be
appended to it. (C++: rangeset_t *)
offset (C++: uint64)
def calc_gaps(self, *args) ‑> bool
Calculate set of padding bytes for the type
calc_gaps(self, out) -> bool
out: pointer to the output buffer; old buffer contents will be
lost. (C++: rangeset_t *)
def calc_purged_bytes(self, *args) ‑> int
'BT_FUNC' : Calculate number of purged bytes
def calc_score(self, *args) ‑> uint32
Calculate the type score (the higher - the nicer is the type)
def calc_udt_aligns(self, *args) ‑> bool
Calculate the udt alignments using the field offsets/sizes and the total udt size This function does not work on typerefs
calc_udt_aligns(self, sudt_flags=0x0004) -> bool
sudt_flags (C++: int)
def change_sign(self, *args) ‑> bool
Change the type sign. Works only for the types that may have sign.
change_sign(self, sign) -> bool
sign (C++: type_sign_t)
def clear(self, *args) ‑> void
Clear contents of this tinfo, and remove from the type system.
def clr_const(self, *args) ‑> void
clr_const(self)
def clr_const_volatile(self, *args) ‑> void
clr_const_volatile(self)
def clr_volatile(self, *args) ‑> void
clr_volatile(self)
def compare(self, *args) ‑> int
compare(self, r) -> int
r: tinfo_t const &
def compare_with(self, *args) ‑> bool
Compare two types, based on given flags (see 'tinfo_t comparison flags' )
compare_with(self, r, tcflags=0) -> bool
r (C++: const tinfo_t &)
tcflags (C++: int)
def convert_array_to_ptr(self, *args) ‑> bool
Convert an array into a pointer. type[] => type *
def copy(self, *args) ‑> tinfo_t
copy(self) -> tinfo_t
def create_array(self, *args) ‑> bool
create_array(self, p, decl_type=BT_ARRAY) -> bool
p (C++: const array_type_data_t &)
decl_type (C++: 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 (C++: type_t)
def create_bitfield(self, *args) ‑> bool
create_bitfield(self, p, decl_type=BT_BITFIELD) -> bool
p (C++: const bitfield_type_data_t &)
decl_type (C++: type_t)
create_bitfield(self, nbytes, width, is_unsigned=False, decl_type=BT_BITFIELD) -> bool
nbytes: uchar width: uchar is_unsigned: bool
decl_type (C++: type_t)
def create_enum(self, *args) ‑> bool
create_enum(self, p, decl_type=BTF_ENUM) -> bool
p: enum_type_data_t & decl_type: type_t
def create_forward_decl(self, *args) ‑> tinfo_code_t
Create a forward declaration. decl_type: 'BTF_STRUCT' , 'BTF_UNION' , or 'BTF_ENUM'
create_forward_decl(self, til, decl_type, name, ntf_flags=0) -> tinfo_code_t
til (C++: til_t *)
decl_type (C++: type_t)
name (C++: const char *)
ntf_flags (C++: int)
def create_func(self, *args) ‑> bool
create_func(self, p, decl_type=BT_FUNC) -> bool
p: func_type_data_t & decl_type: type_t
def create_ptr(self, *args) ‑> bool
create_ptr(self, p, decl_type=BT_PTR) -> bool
p (C++: const ptr_type_data_t &)
decl_type (C++: type_t)
create_ptr(self, tif, bps=0, decl_type=BT_PTR) -> bool
tif: tinfo_t const & bps: uchar
decl_type (C++: type_t)
def create_simple_type(self, *args) ‑> bool
create_simple_type(self, decl_type) -> bool
decl_type (C++: type_t)
def create_typedef(self, *args) ‑> void
create_typedef(self, p, decl_type=BTF_TYPEDEF, try_ordinal=True) -> bool
p (C++: const typedef_type_data_t &)
decl_type (C++: type_t)
try_ordinal (C++: bool)
create_typedef(self, til, name, decl_type=BTF_TYPEDEF, try_ordinal=True)
til: til_t const * name: char const *
decl_type (C++: type_t)
try_ordinal (C++: bool)
create_typedef(self, til, ord, decl_type=BTF_TYPEDEF)
til: til_t const * ord: uint
decl_type (C++: type_t)
def create_udt(self, *args) ‑> bool
create_udt(self, p, decl_type) -> bool
p: udt_type_data_t & decl_type: type_t
def del_attr(self, *args) ‑> bool
Del a type attribute. typerefs cannot be modified by this function.
del_attr(self, key, make_copy=True) -> bool
key (C++: const qstring &)
make_copy (C++: bool)
def del_attrs(self, *args) ‑> void
Del all type attributes. typerefs cannot be modified by this function.
def deserialize(self, *args) ‑> bool
Deserialize a type string into a 'tinfo_t' object.
deserialize(self, til, ptype, pfields=None, pfldcmts=None) -> bool
til (C++: const til_t *)
ptype (C++: const type_t **)
pfields (C++: const p_list **)
pfldcmts (C++: const p_list **)
deserialize(self, til, type, fields, cmts=None) -> bool
til (C++: const til_t *) type: type_t const * fields: p_list const * cmts: p_list const *
def dstr(self, *args) ‑> char const *
Function to facilitate debugging.
def empty(self, *args) ‑> bool
Was 'tinfo_t' initialized with some type info or not?
def equals_to(self, *args) ‑> bool
equals_to(self, r) -> bool
r (C++: const tinfo_t &)
def find_udt_member(self, *args) ‑> int
'BTF_STRUCT' , 'BTF_UNION' : Find a udt member.at the specified offset ( 'STRMEM_OFFSET' )with the specified index ( 'STRMEM_INDEX' )with the specified type ( 'STRMEM_TYPE' )with the specified name ( 'STRMEM_NAME' )
find_udt_member(self, udm, strmem_flags) -> int
udm (C++: struct udt_member_t *)
strmem_flags (C++: int)
return: the index of the found member or -1
def get_array_details(self, *args) ‑> bool
Get the array specific info.
get_array_details(self, ai) -> bool
ai (C++: array_type_data_t *)
def get_array_element(self, *args) ‑> tinfo_t
'BT_ARRAY' : get type of array element. See also 'get_ptrarr_object()'
def get_array_nelems(self, *args) ‑> int
'BT_ARRAY' : get number of elements (-1 means error)
def get_attr(self, *args) ‑> PyObject *
Get a type attribute.
get_attr(self, key, all_attrs=True) -> PyObject *
key (C++: const qstring &)
all_attrs (C++: bool)
def get_attrs(self, *args) ‑> bool
Get type attributes (all_attrs: include attributes of referenced types, if any)
get_attrs(self, tav, all_attrs=False) -> bool
tav (C++: type_attrs_t *)
all_attrs (C++: bool)
def get_bitfield_details(self, *args) ‑> bool
Get the bitfield specific info.
get_bitfield_details(self, bi) -> bool
bi (C++: bitfield_type_data_t *)
def get_declalign(self, *args) ‑> uchar
Get declared alignment of the type.
def get_decltype(self, *args) ‑> 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.
def get_enum_base_type(self, *args) ‑> type_t
Get enum base type (convert enum to integer type) Returns 'BT_UNK' if failed to convert
def get_enum_details(self, *args) ‑> bool
Get the enum specific info.
get_enum_details(self, ei) -> bool
ei (C++: enum_type_data_t *)
def get_final_ordinal(self, *args) ‑> uint32
Get final type ordinal (0 is none)
def get_final_type_name(self, *args) ‑> bool
Use in the case of typedef chain (TYPE1 -> TYPE2 -> TYPE3...TYPEn).
def get_func_details(self, *args) ‑> bool
Get only the function specific info for this 'tinfo_t' .
get_func_details(self, fi, gtd=GTD_CALC_ARGLOCS) -> bool
fi (C++: func_type_data_t *)
gtd (C++: gtd_func_t)
def get_modifiers(self, *args) ‑> type_t
get_modifiers(self) -> type_t
def get_named_type(self, *args) ‑> bool
Create a 'tinfo_t' object for an existing named type.
get_named_type(self, til, name, decl_type=BTF_TYPEDEF, resolve=True, try_ordinal=True) -> bool
til: type library to use (C++: const til_t *)
name: name of the type to link to (C++: const char *)
decl_type: if the reference was explicitly specified with the
type tag ( BTF_STRUCT / BTF_UNION / BTF_ENUM ) you may specify it. the kernel will accept only the specified tag after resolving the type. If the resolved type does not correspond to the explicitly specified tag, the type will be considered as undefined (C++: type_t)
resolve: true: immediately resolve the type and return success
code. false: return true but do not immediately resolve the type (C++: bool)
try_ordinal: true: try to replace name reference by an ordinal
reference (C++: bool)
def get_nargs(self, *args) ‑> int
'BT_FUNC' or 'BT_PTR' 'BT_FUNC' : Calculate number of arguments (-1
  • error)
def get_next_type_name(self, *args) ‑> bool
Use In the case of typedef chain (TYPE1 -> TYPE2 -> TYPE3...TYPEn).
def get_nth_arg(self, *args) ‑> tinfo_t
'BT_FUNC' or 'BT_PTR' 'BT_FUNC' : Get type of n-th arg (-1 means return type, see 'get_rettype()' )
get_nth_arg(self, n) -> tinfo_t
n (C++: int)
def get_numbered_type(self, *args) ‑> bool
Create a 'tinfo_t' object for an existing ordinal type.
get_numbered_type(self, til, ordinal, decl_type=BTF_TYPEDEF, resolve=True) -> bool
til: type library to use (C++: const til_t *)
ordinal: number of the type to link to (C++: uint32)
decl_type: if the reference was explicitly specified with the
type tag (BTF_STRUCT/BTF_UNION/BTF_ENUM) you may specify it. the kernel will accept only the specified tag after resolving the type. If the resolved type does not correspond to the explicitly specified tag, the type will be considered as undefined (C++: type_t)
resolve: true: immediately resolve the type and return success
code false: return true but do not immediately resolve the type (C++: bool)
def get_onemember_type(self, *args) ‑> tinfo_t
For objects consisting of one member entirely: return type of the member.
def get_ordinal(self, *args) ‑> uint32
Get type ordinal (only if the type was created as a numbered type, 0 if none)
def get_pointed_object(self, *args) ‑> tinfo_t
'BT_PTR' : get type of pointed object. If the current type is not a pointer, return empty type info. See also 'get_ptrarr_object()' and 'remove_pointer()'
def get_ptr_details(self, *args) ‑> bool
Get the pointer info.
get_ptr_details(self, pi) -> bool
pi (C++: ptr_type_data_t *)
def get_ptrarr_object(self, *args) ‑> 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.
def get_ptrarr_objsize(self, *args) ‑> int
'BT_PTR' & 'BT_ARRAY' : get size of pointed object or array element. On error returns -1
def get_realtype(self, *args) ‑> 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
get_realtype(self, full=False) -> type_t
full (C++: bool)
def get_rettype(self, *args) ‑> tinfo_t
'BT_FUNC' or 'BT_PTR' 'BT_FUNC' : Get the function's return type
def get_sign(self, *args) ‑> type_sign_t
Get type sign.
def get_size(self, *args) ‑> size_t
Get the type size in bytes.
get_size(self, p_effalign=None, gts_code=0) -> size_t
p_effalign: buffer for the alignment value (C++: uint32 *)
gts_code: combination of GTS_... constants (C++: int)
return: BADSIZE in case of problems
def get_til(self, *args) ‑> til_t const *
Get the type library for 'tinfo_t' .
def get_type_name(self, *args) ‑> 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()' ).
def get_udt_details(self, *args) ‑> bool
Get the udt specific info.
get_udt_details(self, udt, gtd=GTD_CALC_LAYOUT) -> bool
udt (C++: udt_type_data_t *)
gtd (C++: gtd_udt_t)
def get_udt_nmembers(self, *args) ‑> int
Get number of udt members. -1-error.
def get_unpadded_size(self, *args) ‑> size_t
Get the type size in bytes without the final padding, in bytes. For some UDTs 'get_unpadded_size()' != 'get_size()'
def has_details(self, *args) ‑> bool
Does this type refer to a nontrivial type?
def has_vftable(self, *args) ‑> bool
Has a vftable?
def is_anonymous_udt(self, *args) ‑> bool
Is an anonymous struct/union? We assume that types with names are anonymous if the name starts with $
def is_arithmetic(self, *args) ‑> bool
\isreal{is_type_arithmetic}
def is_array(self, *args) ‑> bool
\isreal{is_type_array}
def is_bitfield(self, *args) ‑> bool
\isreal{is_type_bitfld}
def is_bool(self, *args) ‑> bool
\isreal{is_type_bool}
def is_castable_to(self, *args) ‑> bool
is_castable_to(self, target) -> bool
target (C++: const tinfo_t &)
def is_char(self, *args) ‑> bool
\isreal{is_type_char}
def is_complex(self, *args) ‑> bool
\isreal{is_type_complex}
def is_const(self, *args) ‑> bool
\isreal{is_type_const}
def is_correct(self, *args) ‑> bool
Is the type object correct?. It is possible to create incorrect types. For example, we can define a function that returns a 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.
def is_decl_array(self, *args) ‑> bool
\isdecl{is_type_array}
def is_decl_bitfield(self, *args) ‑> bool
\isdecl{is_type_bitfld}
def is_decl_bool(self, *args) ‑> bool
\isdecl{is_type_bool}
def is_decl_char(self, *args) ‑> bool
\isdecl{is_type_char}
def is_decl_complex(self, *args) ‑> bool
\isdecl{is_type_complex}
def is_decl_const(self, *args) ‑> bool
\isdecl{is_type_const}
def is_decl_double(self, *args) ‑> bool
\isdecl{is_type_double}
def is_decl_enum(self, *args) ‑> bool
\isdecl{is_type_enum}
def is_decl_float(self, *args) ‑> bool
\isdecl{is_type_float}
def is_decl_floating(self, *args) ‑> bool
\isdecl{is_type_floating}
def is_decl_func(self, *args) ‑> bool
\isdecl{is_type_func}
def is_decl_int(self, *args) ‑> bool
\isdecl{is_type_int}
def is_decl_int128(self, *args) ‑> bool
\isdecl{is_type_int128}
def is_decl_int16(self, *args) ‑> bool
\isdecl{is_type_int16}
def is_decl_int32(self, *args) ‑> bool
\isdecl{is_type_int32}
def is_decl_int64(self, *args) ‑> bool
\isdecl{is_type_int64}
def is_decl_last(self, *args) ‑> bool
\isdecl{is_typeid_last}
def is_decl_ldouble(self, *args) ‑> bool
\isdecl{is_type_ldouble}
def is_decl_paf(self, *args) ‑> bool
\isdecl{is_type_paf}
def is_decl_partial(self, *args) ‑> bool
\isdecl{is_type_partial}
def is_decl_ptr(self, *args) ‑> bool
\isdecl{is_type_ptr}
def is_decl_struct(self, *args) ‑> bool
\isdecl{is_type_struct}
def is_decl_sue(self, *args) ‑> bool
\isdecl{is_type_sue}
def is_decl_tbyte(self, *args) ‑> bool
\isdecl{is_type_tbyte}
def is_decl_typedef(self, *args) ‑> bool
\isdecl{is_type_typedef}
def is_decl_uchar(self, *args) ‑> bool
\isdecl{is_type_uchar}
def is_decl_udt(self, *args) ‑> bool
\isdecl{is_type_struni}
def is_decl_uint(self, *args) ‑> bool
\isdecl{is_type_uint}
def is_decl_uint128(self, *args) ‑> bool
\isdecl{is_type_uint128}
def is_decl_uint16(self, *args) ‑> bool
\isdecl{is_type_uint16}
def is_decl_uint32(self, *args) ‑> bool
\isdecl{is_type_uint32}
def is_decl_uint64(self, *args) ‑> bool
\isdecl{is_type_uint64}
def is_decl_union(self, *args) ‑> bool
\isdecl{is_type_union}
def is_decl_unknown(self, *args) ‑> bool
\isdecl{is_type_unknown}
def is_decl_void(self, *args) ‑> bool
\isdecl{is_type_void}
def is_decl_volatile(self, *args) ‑> bool
\isdecl{is_type_volatile}
def is_double(self, *args) ‑> bool
\isreal{is_type_double}
def is_empty_udt(self, *args) ‑> bool
Is an empty struct/union? (has no fields)
def is_enum(self, *args) ‑> bool
\isreal{is_type_enum}
def is_ext_arithmetic(self, *args) ‑> bool
\isreal{is_type_ext_arithmetic}
def is_ext_integral(self, *args) ‑> bool
\isreal{is_type_ext_integral}
def is_float(self, *args) ‑> bool
\isreal{is_type_float}
def is_floating(self, *args) ‑> bool
\isreal{is_type_floating}
def is_forward_decl(self, *args) ‑> bool
Is this a forward declaration?. Forward declarations are placeholders: the type definition does not exist
def is_from_subtil(self, *args) ‑> 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
def is_func(self, *args) ‑> bool
\isreal{is_type_func}
def is_funcptr(self, *args) ‑> bool
Is this pointer to a function?
def is_high_func(self, *args) ‑> bool
'BT_FUNC' : Is high level type?
def is_int(self, *args) ‑> bool
\isreal{is_type_int}
def is_int128(self, *args) ‑> bool
\isreal{is_type_int128}
def is_int16(self, *args) ‑> bool
\isreal{is_type_int16}
def is_int32(self, *args) ‑> bool
\isreal{is_type_int32}
def is_int64(self, *args) ‑> bool
\isreal{is_type_int64}
def is_integral(self, *args) ‑> bool
\isreal{is_type_integral}
def is_ldouble(self, *args) ‑> bool
\isreal{is_type_ldouble}
def is_manually_castable_to(self, *args) ‑> bool
is_manually_castable_to(self, target) -> bool
target (C++: const tinfo_t &)
def is_one_fpval(self, *args) ‑> bool
Floating value or an object consisting of one floating member entirely.
def is_paf(self, *args) ‑> bool
\isreal{is_type_paf}
def is_partial(self, *args) ‑> bool
\isreal{is_type_partial}
def is_ptr(self, *args) ‑> bool
\isreal{is_type_ptr}
def is_ptr_or_array(self, *args) ‑> bool
\isreal{is_type_ptr_or_array}
def is_purging_cc(self, *args) ‑> bool
\tinfocc{is_purging_cc}
def is_pvoid(self, *args) ‑> bool
Is "void *"?. This function does not check the pointer attributes and type modifiers.
def is_scalar(self, *args) ‑> bool
Does the type represent a single number?
def is_shifted_ptr(self, *args) ‑> bool
Is a shifted pointer?
def is_signed(self, *args) ‑> bool
Is this a signed type?
def is_small_udt(self, *args) ‑> bool
Is a small udt? (can fit a register or a pair of registers)
def is_sse_type(self, *args) ‑> bool
Is a SSE vector type?
def is_struct(self, *args) ‑> bool
\isreal{is_type_struct}
def is_sue(self, *args) ‑> bool
\isreal{is_type_sue}
def is_tbyte(self, *args) ‑> bool
\isreal{is_type_tbyte}
def is_typeref(self, *args) ‑> bool
Is this type a type reference?. Type references cannot be modified. Once created, they do not change. Because of this, the set_... functions applied to typerefs create a new type id. Other types are modified directly.
def is_uchar(self, *args) ‑> bool
\isreal{is_type_uchar}
def is_udt(self, *args) ‑> bool
\isreal{is_type_struni}
def is_uint(self, *args) ‑> bool
\isreal{is_type_uint}
def is_uint128(self, *args) ‑> bool
\isreal{is_type_uint128}
def is_uint16(self, *args) ‑> bool
\isreal{is_type_uint16}
def is_uint32(self, *args) ‑> bool
\isreal{is_type_uint32}
def is_uint64(self, *args) ‑> bool
\isreal{is_type_uint64}
def is_union(self, *args) ‑> bool
\isreal{is_type_union}
def is_unknown(self, *args) ‑> bool
\isreal{is_type_unknown}
def is_unsigned(self, *args) ‑> bool
Is this an unsigned type?
def is_user_cc(self, *args) ‑> bool
\tinfocc{is_user_cc}
def is_vararg_cc(self, *args) ‑> bool
\tinfocc{is_vararg_cc}
def is_varstruct(self, *args) ‑> bool
Is a variable-size structure?
def is_vftable(self, *args) ‑> bool
Is a vftable type?
def is_void(self, *args) ‑> bool
\isreal{is_type_void}
def is_volatile(self, *args) ‑> bool
\isreal{is_type_volatile}
def is_well_defined(self, *args) ‑> bool
!( 'empty()' ) && !( 'is_decl_partial()' )
def present(self, *args) ‑> bool
Is the type really present? (not a reference to a missing type, for example)
def read_bitfield_value(self, *args) ‑> uint64
read_bitfield_value(self, v, bitoff) -> uint64
v: uint64 bitoff: int
def remove_ptr_or_array(self, *args) ‑> bool
Replace the current type with the ptr obj or array element. This function performs one of the following conversions:type[] => typetype* => type If the conversion is performed successfully, return true
def requires_qualifier(self, *args) ‑> bool
Requires full qualifier? (name is not unique)
requires_qualifier(self, name, offset) -> bool
name: field name (C++: const char *)
offset (C++: uint64)
return: if the name is not unique, returns true
def serialize(self, *args) ‑> PyObject *
Serialize 'tinfo_t' object into a type string.
serialize(self, sudt_flags=SUDT_FAST|SUDT_TRUNC) -> PyObject *
sudt_flags (C++: int)
def set_attr(self, *args) ‑> bool
Set a type attribute. If necessary, a new typid will be created.
set_attr(self, ta, may_overwrite=True) -> bool
ta (C++: const type_attr_t &)
may_overwrite (C++: bool)
def set_attrs(self, *args) ‑> bool
Set type attributes. If necessary, a new typid will be created. this function modifies tav! (returns old attributes, if any)
set_attrs(self, tav) -> bool
tav (C++: type_attrs_t *)
return: false: bad attributes
def set_const(self, *args) ‑> void
set_const(self)
def set_declalign(self, *args) ‑> bool
Set declared alignment of the type.
set_declalign(self, declalign) -> bool
declalign (C++: uchar)
def set_modifiers(self, *args) ‑> void
set_modifiers(self, mod)
mod: type_t
def set_named_type(self, *args) ‑> tinfo_code_t
set_named_type(self, til, name, ntf_flags=0) -> tinfo_code_t
til: til_t * name: char const * ntf_flags: int
def set_numbered_type(self, *args) ‑> 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 *
def set_symbol_type(self, *args) ‑> tinfo_code_t
set_symbol_type(self, til, name, ntf_flags=0) -> tinfo_code_t
til: til_t * name: char const * ntf_flags: int
def set_volatile(self, *args) ‑> void
set_volatile(self)
def swap(self, *args) ‑> void
Assign this = r and r = this.
swap(self, r)
r (C++: tinfo_t &)
def write_bitfield_value(self, *args) ‑> uint64
write_bitfield_value(self, dst, v, bitoff) -> uint64
dst: uint64 v: uint64 bitoff: int
class tinfo_visitor_t (*args)
Proxy of C++ tinfo_visitor_t class.
__init__(self, s=0) -> tinfo_visitor_t
s: int

Instance variables

var state
tinfo_visitor_t_state_get(self) -> int

Methods

def apply_to(self, *args) ‑> int
Call this function to initiate the traversal.
apply_to(self, tif, out=None, name=None, cmt=None) -> int
tif (C++: const tinfo_t &)
out (C++: type_mods_t *)
name (C++: const char *)
cmt (C++: const char *)
def prune_now(self, *args) ‑> void
To refuse to visit children of the current type, use this:
def visit_type(self, *args) ‑> 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 NULL) return 0 to continue the traversal. return !=0 to stop the traversal.
visit_type(self, out, tif, name, cmt) -> int
out (C++: type_mods_t *)
tif (C++: const tinfo_t &)
name (C++: const char *)
cmt (C++: const char *)
class type_attr_t (*args)
Proxy of C++ type_attr_t class.
__init__(self) -> type_attr_t

Instance variables

var key
type_attr_t_key_get(self) -> qstring *
var value
type_attr_t_value_get(self) -> bytevec_t *
class type_attrs_t (*args)
Proxy of C++ qvector< type_attr_t > class.
__init__(self) -> type_attrs_t
x: qvector< type_attr_t > const &

Methods

def at(self, *args) ‑> type_attr_t const &
at(self, _idx) -> type_attr_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< type_attr_t >::const_iterator
begin(self) -> type_attr_t
begin(self) -> type_attr_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< type_attr_t >::const_iterator
end(self) -> type_attr_t
end(self) -> type_attr_t
def 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
def extract(self, *args) ‑> type_attr_t *
extract(self) -> type_attr_t
def front(self)
def grow(self, *args) ‑> void
grow(self, x=type_attr_t())
x: type_attr_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: type_attr_t * len: size_t
def insert(self, *args) ‑> qvector< type_attr_t >::iterator
insert(self, it, x) -> type_attr_t
it: qvector< type_attr_t >::iterator x: type_attr_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> type_attr_t &
push_back(self, x)
x: type_attr_t const &
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t x: type_attr_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< type_attr_t > &
def truncate(self, *args) ‑> void
truncate(self)
class type_mods_t (*args)
Proxy of C++ type_mods_t class.
__init__(self) -> type_mods_t

Instance variables

var cmt
type_mods_t_cmt_get(self) -> qstring *
var flags
type_mods_t_flags_get(self) -> int
var name
type_mods_t_name_get(self) -> qstring *
var type
type_mods_t_type_get(self) -> tinfo_t

Methods

def clear(self, *args) ‑> void
clear(self)
def has_cmt(self, *args) ‑> bool
has_cmt(self) -> bool
def has_info(self, *args) ‑> bool
has_info(self) -> bool
def has_name(self, *args) ‑> bool
has_name(self) -> bool
def has_type(self, *args) ‑> bool
has_type(self) -> bool
def set_new_cmt(self, *args) ‑> void
set_new_cmt(self, c)
c (C++: const qstring &)
def set_new_name(self, *args) ‑> void
set_new_name(self, n)
n (C++: const qstring &)
def set_new_type(self, *args) ‑> void
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.
set_new_type(self, t)
t (C++: const tinfo_t &)
class typedef_type_data_t (*args)
Proxy of C++ typedef_type_data_t class.
__init__(self, _til, _name, _resolve=False) -> typedef_type_data_t
_til: til_t const * _name: char const * _resolve: bool
__init__(self, _til, ord, _resolve=False) -> typedef_type_data_t
_til: til_t const * ord: uint32 _resolve: bool

Instance variables

var is_ordref
typedef_type_data_t_is_ordref_get(self) -> bool
var resolve
typedef_type_data_t_resolve_get(self) -> bool
var til
typedef_type_data_t_til_get(self) -> til_t

Methods

def swap(self, *args) ‑> void
swap(self, r)
r (C++: typedef_type_data_t &)
class udt_member_t (*args)
Proxy of C++ udt_member_t class.
__init__(self) -> udt_member_t

Instance variables

var cmt
udt_member_t_cmt_get(self) -> qstring *
var effalign
udt_member_t_effalign_get(self) -> int
var fda
udt_member_t_fda_get(self) -> uchar
var name
udt_member_t_name_get(self) -> qstring *
var offset
udt_member_t_offset_get(self) -> uint64
var size
udt_member_t_size_get(self) -> uint64
var tafld_bits
udt_member_t_tafld_bits_get(self) -> uint32
var type
udt_member_t_type_get(self) -> tinfo_t

Methods

def begin(self, *args) ‑> uint64
begin(self) -> uint64
def clr_baseclass(self, *args) ‑> void
clr_baseclass(self)
def clr_unaligned(self, *args) ‑> void
clr_unaligned(self)
def clr_vftable(self, *args) ‑> void
clr_vftable(self)
def clr_virtbase(self, *args) ‑> void
clr_virtbase(self)
def end(self, *args) ‑> uint64
end(self) -> uint64
def is_anonymous_udm(self, *args) ‑> bool
is_anonymous_udm(self) -> bool
def is_baseclass(self, *args) ‑> bool
is_baseclass(self) -> bool
def is_bitfield(self, *args) ‑> bool
is_bitfield(self) -> bool
def is_unaligned(self, *args) ‑> bool
is_unaligned(self) -> bool
def is_vftable(self, *args) ‑> bool
is_vftable(self) -> bool
def is_virtbase(self, *args) ‑> bool
is_virtbase(self) -> bool
def is_zero_bitfield(self, *args) ‑> bool
is_zero_bitfield(self) -> bool
def set_baseclass(self, *args) ‑> void
set_baseclass(self)
def set_unaligned(self, *args) ‑> void
set_unaligned(self)
def set_vftable(self, *args) ‑> void
set_vftable(self)
def set_virtbase(self, *args) ‑> void
set_virtbase(self)
def swap(self, *args) ‑> void
swap(self, r)
r (C++: udt_member_t &)
class udt_type_data_t (*args)
Proxy of C++ udt_type_data_t class.
__init__(self) -> udt_type_data_t

Ancestors

Instance variables

var effalign
udt_type_data_t_effalign_get(self) -> uint32
var is_union
udt_type_data_t_is_union_get(self) -> bool
var pack
udt_type_data_t_pack_get(self) -> uchar
var sda
udt_type_data_t_sda_get(self) -> uchar
var taudt_bits
udt_type_data_t_taudt_bits_get(self) -> uint32
var total_size
udt_type_data_t_total_size_get(self) -> size_t
var unpadded_size
udt_type_data_t_unpadded_size_get(self) -> size_t

Methods

def is_cppobj(self, *args) ‑> bool
is_cppobj(self) -> bool
def is_last_baseclass(self, *args) ‑> bool
is_last_baseclass(self, idx) -> bool
idx (C++: size_t)
def is_msstruct(self, *args) ‑> bool
is_msstruct(self) -> bool
def is_unaligned(self, *args) ‑> bool
is_unaligned(self) -> bool
def is_vftable(self, *args) ‑> bool
is_vftable(self) -> bool
def set_vftable(self, *args) ‑> void
set_vftable(self)
def swap(self, *args) ‑> void
swap(self, r)
r (C++: udt_type_data_t &)

Inherited members

class udtmembervec_t (*args)
Proxy of C++ qvector< udt_member_t > class.
__init__(self) -> udtmembervec_t
x: qvector< udt_member_t > const &

Subclasses

Methods

def add_unique(self, *args) ‑> bool
add_unique(self, x) -> bool
x: udt_member_t const &
def at(self, *args) ‑> udt_member_t const &
at(self, _idx) -> udt_member_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< udt_member_t >::const_iterator
begin(self) -> udt_member_t
begin(self) -> udt_member_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< udt_member_t >::const_iterator
end(self) -> udt_member_t
end(self) -> udt_member_t
def erase(self, *args) ‑> qvector< udt_member_t >::iterator
erase(self, it) -> udt_member_t
it: qvector< udt_member_t >::iterator
erase(self, first, last) -> udt_member_t
first: qvector< udt_member_t >::iterator last: qvector< udt_member_t >::iterator
def extract(self, *args) ‑> udt_member_t *
extract(self) -> udt_member_t
def find(self, *args) ‑> qvector< udt_member_t >::const_iterator
find(self, x) -> udt_member_t
x: udt_member_t const &
find(self, x) -> udt_member_t
x: udt_member_t const &
def front(self)
def grow(self, *args) ‑> void
grow(self, x=udt_member_t())
x: udt_member_t const &
def has(self, *args) ‑> bool
has(self, x) -> bool
x: udt_member_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: udt_member_t * len: size_t
def insert(self, *args) ‑> qvector< udt_member_t >::iterator
insert(self, it, x) -> udt_member_t
it: qvector< udt_member_t >::iterator x: udt_member_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> udt_member_t &
push_back(self, x)
x: udt_member_t const &
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t x: udt_member_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< udt_member_t > &
def truncate(self, *args) ‑> void
truncate(self)
class valstr_t (*args)
Proxy of C++ valstr_t class.
__init__(self) -> valstr_t

Instance variables

var info
valstr_t_info_get(self) -> valinfo_t *
var length
valstr_t_length_get(self) -> size_t
var members
valstr_t_members_get(self) -> valstrs_t
var oneline
valstr_t_oneline_get(self) -> qstring *
var props
valstr_t_props_get(self) -> int
class valstrs_t (*args)
Proxy of C++ valstrs_t class.
__init__(self) -> valstrs_t

Ancestors

Inherited members

class valstrvec_t (*args)
Proxy of C++ qvector< valstr_t > class.
__init__(self) -> valstrvec_t
x: qvector< valstr_t > const &

Subclasses

Methods

def at(self, *args) ‑> valstr_t const &
at(self, _idx) -> valstr_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< valstr_t >::const_iterator
begin(self) -> valstr_t
begin(self) -> valstr_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< valstr_t >::const_iterator
end(self) -> valstr_t
end(self) -> valstr_t
def 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
def extract(self, *args) ‑> valstr_t *
extract(self) -> valstr_t
def front(self)
def grow(self, *args) ‑> void
grow(self, x=valstr_t())
x: valstr_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: valstr_t * len: size_t
def insert(self, *args) ‑> qvector< valstr_t >::iterator
insert(self, it, x) -> valstr_t
it: qvector< valstr_t >::iterator x: valstr_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> valstr_t &
push_back(self, x)
x: valstr_t const &
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t x: valstr_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< valstr_t > &
def truncate(self, *args) ‑> void
truncate(self)