Describes the type information records in IDA.

The recommended way of using type info is to use the tinfo_t class. The type information is internally kept as an array of bytes terminated by 0.

Items in brackets [] are optional and sometimes are omitted. type_t… means a sequence of type_t bytes which defines a type.

@note: to work with the types of instructions or data in the database, use get_tinfo()/set_tinfo() and similar functions.

Global variables

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

custom argloc (7 or higher)

var ALOC_DIST

distributed (scattered)

var ALOC_NONE

none

var ALOC_REG1

one register (and offset within it)

var ALOC_REG2

register pair

var ALOC_RREL

register relative

var ALOC_STACK

stack offset

var ALOC_STATIC

global address

var ARGREGS_BY_SLOTS

fixed FP/GP register per each slot (like vc64)

var ARGREGS_FP_MASKS_GP

FP register also consumes one or more GP regs but not vice versa (aix ppc ABI)

var ARGREGS_GP_ONLY

GP registers used for all arguments.

var ARGREGS_INDEPENDENT

FP/GP registers used separately (like gcc64)

var ARGREGS_MIPS_O32

MIPS ABI o32.

var ARGREGS_RISCV

Risc-V API FP arguments are passed in GP registers if FP registers are exhausted and GP ones are not. Wide FP arguments are passed in GP registers. Variadic FP arguments are passed in GP registers.

var BADSIZE

bad type size

var BFA_FUNC_EXT_FORMAT

This is NOT a real attribute (used internally as marker for extended format)

var BFA_FUNC_MARKER

This is NOT a cc! (used internally as a marker)

var BFA_HIGH

high level prototype (with possibly hidden args)

var BFA_NORET

__noreturn

var BFA_PURE

__pure

var BFA_STATIC

static

var BFA_VIRTUAL

virtual

var BTE_ALWAYS

this bit MUST be present

var BTE_BITMASK

'subarrays'. In this case ANY record has the following format: * 'de' mask (has name) * 'dt' cnt * cnt records of 'de' values (cnt CAN be 0) @note: delta for ALL subsegment is ONE

var BTE_CHAR

char or hex

var BTE_HEX

hex

var BTE_OUT_MASK

output style mask

var BTE_RESERVED

must be 0, in order to distinguish from a tah-byte

var BTE_SDEC

signed decimal

var BTE_SIZE_MASK

storage size. * if == 0 then inf_get_cc_size_e() * else 1 << (n -1) = 1,2,4,8 * n == 5,6,7 are reserved

var BTE_UDEC

unsigned decimal

var BTF_BOOL

boolean

var BTF_BYTE

byte

var BTF_CHAR

signed char

var BTF_DOUBLE

double

var BTF_ENUM

enum

var BTF_FLOAT

float

var BTF_INT

int, unknown signedness

var BTF_INT128

signed 128-bit value

var BTF_INT16

signed short

var BTF_INT32

signed int

var BTF_INT64

signed long

var BTF_INT8

signed byte

var BTF_LDOUBLE

long double

var BTF_SINT

singed int

var BTF_STRUCT

struct

var BTF_TBYTE

see BTMT_SPECFLT

var BTF_TYPEDEF

typedef

var BTF_UCHAR

unsigned char

var BTF_UINT

unsigned int

var BTF_UINT128

unsigned 128-bit value

var BTF_UINT16

unsigned short

var BTF_UINT32

unsigned int

var BTF_UINT64

unsigned long

var BTF_UINT8

unsigned byte

var BTF_UNION

union

var BTF_UNK

unknown

var BTF_VOID

void

var BTMT_ARRESERV

reserved bit

var BTMT_BFLDI16

__int16

var BTMT_BFLDI32

__int32

var BTMT_BFLDI64

__int64

var BTMT_BFLDI8

__int8

var BTMT_BOOL1

size 1byte

var BTMT_BOOL2

size 2bytes - !inf_is_64bit()

var BTMT_BOOL4

size 4bytes

var BTMT_BOOL8

size 8bytes - inf_is_64bit()

var BTMT_CHAR

specify char or segment register * BT_INT8 - char * BT_INT - segment register * other BT_INT… - don't use

var BTMT_CLOSURE

closure. * if ptr to BT_FUNC - __closure. in this case next byte MUST be RESERVED_BYTE, and after it BT_FUNC * else the next byte contains sizeof(ptr) allowed values are 1 - ph.max_ptr_size * if value is bigger than ph.max_ptr_size, based_ptr_name_and_size() is called to find out the typeinfo

var BTMT_DEFBOOL

size is model specific or unknown(?)

var BTMT_DEFCALL

call method - default for model or unknown

var BTMT_DEFPTR

default for model

var BTMT_DOUBLE

double (8 bytes)

var BTMT_ENUM

enum: next byte bte_t (see below) N records: de delta(s) OR blocks (see below)

var BTMT_FAR

far

var BTMT_FARCALL

function returns by retf

var BTMT_FLOAT

float (4 bytes)

var BTMT_INTCALL

function returns by iret in this case cc MUST be 'unknown'

var BTMT_LNGDBL

long double (compiler specific)

var BTMT_NEAR

near

var BTMT_NEARCALL

function returns by retn

var BTMT_NONBASED

if set array base==0 format: dt num_elem; [tah-typeattrs]; type_t… if num_elem==0 then the array size is unknown else format: da num_elem, base; [tah-typeattrs]; type_t… used only for serialization

var BTMT_SIGNED

signed

var BTMT_SIZE0

BT_VOID - normal void; BT_UNK - don't use

var BTMT_SIZE12

size = 1 byte if BT_VOID; 2 if BT_UNK

var BTMT_SIZE128

size = 16 bytes if BT_VOID; unknown if BT_UNK (IN struct alignment - see below)

var BTMT_SIZE48

size = 4 bytes if BT_VOID; 8 if BT_UNK

var BTMT_SPECFLT

float (variable size). if processor_t::use_tbyte() then use processor_t::tbyte_size, otherwise 2 bytes

var BTMT_STRUCT

struct: MCNT records: type_t; [sdacl-typeattrs];

var BTMT_TYPEDEF

named reference always p_string name

var BTMT_UNION

union: MCNT records: type_t…

var BTMT_UNKSIGN

unknown signedness

var BTMT_USIGNED

unsigned

var BTM_CONST

const

var BTM_VOLATILE

volatile

var BT_ARRAY

array

var BT_BITFIELD

bitfield (only in struct) ['bitmasked' enum see below] next byte is dt ((size in bits << 1) | (unsigned ? 1 : 0))

var BT_BOOL

bool

var BT_COMPLEX

struct/union/enum/typedef. format: [dt N (N=field count) if !BTMT_TYPEDEF] if N == 0: p_string name (unnamed types have names "anon_…") [sdacl-typeattrs]; else, for struct & union: if N == 0x7FFE // Support for high (i.e., > 4095) members count N = deserialize_de() ALPOW = N & 0x7 MCNT = N >> 3 if MCNT == 0 empty struct if ALPOW == 0 ALIGN = get_default_align() else ALIGN = (1 << (ALPOW - 1)) [sdacl-typeattrs]; else, for enums: if N == 0x7FFE // Support for high enum entries count. N = deserialize_de() [tah-typeattrs];

var BT_FLOAT

float

var BT_FUNC

function. format: optional: CM_CC_SPOILED | num_of_spoiled_regs if num_of_spoiled_reg == BFA_FUNC_MARKER: ::bfa_byte if (bfa_byte & BFA_FUNC_EXT_FORMAT) != 0 ::fti_bits (only low bits: FTI_SPOILED,…,FTI_VIRTUAL) num_of_spoiled_reg times: spoiled reg info (see extract_spoiledreg) else bfa_byte is function attribute byte (see Function attribute byte…) else: num_of_spoiled_reg times: spoiled reg info (see extract_spoiledreg) cm_t … calling convention and memory model [tah-typeattrs]; type_t … return type; [serialized argloc_t of returned value (if CM_CC_SPECIAL{PE} && !return void); if !CM_CC_VOIDARG: dt N (N=number of parameters) if ( N == 0 ) if CM_CC_ELLIPSIS or CM_CC_SPECIALE func(…) else parameters are unknown else N records: type_t … (i.e. type of each parameter) [serialized argloc_t (if CM_CC_SPECIAL{PE})] (i.e. place of each parameter) [FAH_BYTE + de( funcarg_t::flags )]

var BT_INT

natural int. (size provided by idp module)

var BT_INT128

__int128 (for alpha & future use)

var BT_INT16

__int16

var BT_INT32

__int32

var BT_INT64

__int64

var BT_INT8

__int8

var BT_PTR

pointer. has the following format: [db sizeof(ptr)]; [tah-typeattrs]; type_t…

var BT_RESERVED

RESERVED.

var BT_SEGREG

segment register

var BT_UNK

unknown

var BT_UNKNOWN

unknown size - for parameters

var BT_UNK_BYTE

1 byte

var BT_UNK_DWORD

4 bytes

var BT_UNK_OWORD

16 bytes

var BT_UNK_QWORD

8 bytes

var BT_UNK_WORD

2 bytes

var BT_VOID

void

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

stack

var CM_CC_ELLIPSIS

cdecl + ellipsis

var CM_CC_FASTCALL

stack, purged (x86), first args are in regs (compiler-dependent)

var CM_CC_GOLANG

(Go) arguments and return value in stack

var CM_CC_INVALID

this value is invalid

var CM_CC_PASCAL

stack, purged, reverse order of args

var CM_CC_SPECIAL

usercall: locations of all arguments and the return value are explicitly specified

var CM_CC_SPECIALE

CM_CC_SPECIAL with ellipsis

var CM_CC_SPECIALP

Equal to CM_CC_SPECIAL, but with purged stack.

var CM_CC_SPOILED

This is NOT a cc! Mark of __spoil record the low nibble is count and after n {spoilreg_t} present real cm_t byte. if n == BFA_FUNC_MARKER, the next byte is the function attribute byte.

var CM_CC_STDCALL

stack, purged

var CM_CC_SWIFT

(Swift) arguments and return values in registers (compiler-dependent)

var CM_CC_THISCALL

stack, purged (x86), first arg is in reg (compiler-dependent)

var CM_CC_UNKNOWN

unknown calling convention

var CM_CC_VOIDARG

function without arguments if has other cc and argnum == 0, represent as f() - unknown list

var CM_M_FF

large: code=far, data=far

var CM_M_FN

medium: code=far, data=near

var CM_M_NF

compact: code=near, data=far

var CM_M_NN

small: code=near, data=near (or unknown if CM_UNKNOWN)

var CM_N16_F32

near 2 bytes, far 4 bytes

var CM_N32_F48

near 4 bytes, far 6 bytes

var CM_N64

if sizeof(int)>2: near 8 bytes, far 8 bytes

var CM_N8_F16

if sizeof(int)<=2: near 1 byte, far 2 bytes

var CM_UNKNOWN

unknown

var COMP_BC

Borland C++.

var COMP_BP

Delphi.

var COMP_GNU

GNU C++.

var COMP_MS

Visual C++.

var COMP_UNK

Unknown.

var COMP_UNSURE

uncertain compiler id

var COMP_VISAGE

Visual Age C++.

var COMP_WATCOM

Watcom C++.

var DEFMASK64

default bitmask 64bits

var ETF_AUTONAME

udm - generate a member name if was not specified (add_udm, set_udm_type)

var ETF_BYTIL

udm - new type was created by the type subsystem

var ETF_COMPATIBLE

new type must be compatible with the old

var ETF_FORCENAME

anyway use name, see below for more usage description

var ETF_FUNCARG

udm - member is a function argument (cannot create arrays)

var ETF_MAY_DESTROY

may destroy other members

var ETF_NO_ARRAY

add_udm, set_udm_type - do not convert type to an array on the size mismatch

var ETF_NO_LAYOUT

don't calc type layout before editing

var ETF_NO_SAVE

don't save to til (normally typerefs are saved to til) A call with ETF_NO_SAVE must be followed by a call without it. Otherwise there may be inconsistencies between the memory and the type library.

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

Denotes the first bit describing a nontrivial type.

var FRB_CHAR

Char.

var FRB_CUSTOM

*Custom data type

var FRB_ENUM

*Enumeration

var FRB_FLOAT

Floating point number (for interpreting an integer type as a floating value)

var FRB_INVBITS

Invert bits (0x01 is represented as ~0xFE)

var FRB_INVSIGN

Invert sign (0x01 is represented as -0xFF)

var FRB_LZERO

Toggle leading zeroes (used for integers)

var FRB_MASK

Mask for the value type (* means requires additional info):

var FRB_NUMB

Binary number.

var FRB_NUMD

Decimal number.

var FRB_NUMH

Hexadecimal number.

var FRB_NUMO

Octal number.

var FRB_OFFSET

*Offset

var FRB_SEG

Segment.

var FRB_SIGNED

Force signed representation.

var FRB_STRLIT

*String literal (used for arrays)

var FRB_STROFF

*Struct offset

var FRB_TABFORM

has additional tabular parameters

var FRB_UNK

Unknown.

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_CONST

const member function

var FTI_CTOR

constructor

var FTI_DEFCALL

default call

var FTI_DTOR

destructor

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

calculate func arg locations

var GTD_CALC_LAYOUT

calculate udt layout

var GTD_DEL_BITFLDS

delete udt bitfields

var GTD_NO_ARGLOCS

don't calculate func arg locations please note that the locations may have been calculated earlier

var GTD_NO_LAYOUT

don't calculate udt layout please note that udt layout may have been calculated earlier

var GTS_BASECLASS

is baseclass of a udt

var GTS_NESTED

nested type (embedded into a udt)

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_NOBASE

do not inspect base tils

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_RELAXED

accept references to unknown namespaces

var HTI_TST

test mode: discard the result

var HTI_UNP

debug: check the result by unpacking it

var MAX_ENUM_SERIAL

Max number of identical constants allowed for one enum type.

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_COPY

save a new type definition, not a typeref (tinfo_t::set_numbered_type, tinfo_t::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_NO_NAMECHK

do not validate type name (set_numbered_type, set_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 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_1LINCMT

print comments even in the one line mode

var PRTYPE_1LINE

print to one line

var PRTYPE_ARGLOCS

print function arglocs (not only for usercall)

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_HEADER

print only type header (only for definitions)

var PRTYPE_MAXSTR

limit the output length to 1024 bytes (the output may be slightly longer)

var PRTYPE_METHODS

tinfo_t: print udt methods

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_OFFSETS

print udt member offsets

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_TAIL

print only the definition tail (only for definitions, exclusive with PRTYPE_HEADER)

var PRTYPE_TYPE

print type declaration (not variable declaration)

var PT_EMPTY

accept empty decl

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_RELAXED

accept references to unknown namespaces

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 SC_AUTO

auto

var SC_EXT

extern

var SC_FRIEND

friend

var SC_REG

register

var SC_STAT

static

var SC_TYPE

typedef

var SC_UNK

unknown

var SC_VIRT

virtual

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

const char[]

var STI_ACHAR

char[]

var STI_ACUCHAR

const uint8[]

var STI_AEABI_LCMP

int __fastcall __pure(int64 x, int64 y)

var STI_AEABI_MEMCLR

void __fastcall(void *, size_t)

var STI_AEABI_MEMCPY

void __fastcall(void , const void , size_t)

var STI_AEABI_MEMSET

void __fastcall(void *, size_t, int)

var STI_AEABI_ULCMP

int __fastcall __pure(uint64 x, uint64 y)

var STI_AUCHAR

uint8[]

var STI_COMPLEX128

struct complex128_t { double real, imag; }

var STI_COMPLEX64

struct complex64_t { float real, imag; }

var STI_DONT_USE

unused stock type id; should not be used

var STI_FDELOP

void __cdecl(void *)

var STI_FPURGING

void __userpurge(int)

var STI_MSGSEND

void (void , const char *, …)

var STI_PBYTE

_BYTE *

var STI_PCCHAR

const char *

var STI_PCHAR

char *

var STI_PCUCHAR

const uint8 *

var STI_PCVOID

const void *

var STI_PINT

int *

var STI_PPVOID

void **

var STI_PUCHAR

uint8 *

var STI_PUINT

unsigned int *

var STI_PUNKNOWN

_UNKNOWN *

var STI_PVOID

void *

var STI_RTC_CHECK_2

int16 __fastcall(int16 x)

var STI_RTC_CHECK_4

int32 __fastcall(int32 x)

var STI_RTC_CHECK_8

int64 __fastcall(int64 x)

var STI_SIZE_T

size_t

var STI_SSIZE_T

ssize_t

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 union * nb: 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 number * in: udm->offset - is a member number

var STRMEM_LOWBND

get member by offset or the next member (lower bound) * in: udm->offset - is a member offset in bits

var STRMEM_MAXS

get biggest member by size.

var STRMEM_MINS

get smallest member by size.

var STRMEM_NAME

get member by name * in: udm->name - the desired member name.

var STRMEM_NEXT

get next member after the offset * in: udm->offset - is a member offset in bits

var STRMEM_OFFSET

get member by offset * in: 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_SKIP_GAPS

can be combined with STRMEM_OFFSET, STRMEM_LOWBND skip gap members

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 STRUC_SEPARATOR

structname.fieldname

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_SERDEF

serialize: if a typeref, serialize its definition

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 udm_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_BIN

enum: binary representation, if BTE_HEX only one of OCT/BIN bits can be set. they are meaningful only if BTE_HEX is used.

var TAENUM_LZERO

enum: print numbers with leading zeroes (only for HEX/OCT/BIN)

var TAENUM_NUMSIGN

enum: signed representation, if BTE_HEX

var TAENUM_OCT

enum: octal representation, if BTE_HEX

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_BYTIL

field: was the member created due to the type system

var TAFLD_FRAME_R

frame: function return address frame slot

var TAFLD_FRAME_S

frame: function saved registers frame slot

var TAFLD_GAP

field: gap member (displayed as padding in type details)

var TAFLD_METHOD

denotes a udt member function

var TAFLD_REGCMT

field: the comment is regular (if not set, it is repeatable)

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_FIXED

struct: fixed field offsets, stored in serialized form; cannot be set for unions

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 TA_VALUE_REPR

serialized value_repr_t (used for scalars and arrays)

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_ALIEN_NAME

enum member name is used in another enum

var TERR_BAD_ARG

bad argument

var TERR_BAD_ARRAY

arrays are forbidden as function arguments

var TERR_BAD_BASE

bad base class

var TERR_BAD_BF

bitfields are forbidden as function arguments

var TERR_BAD_BMASK

Bad enum member mask 0xI64X. The specified mask should not intersect with any existing mask in the enum. Zero masks are prohibited too.

var TERR_BAD_FX_SIZE

cannot extend struct beyond fixed size

var TERR_BAD_GAP

bad gap

var TERR_BAD_GROUPS

bad group sizes for bitmask enum

var TERR_BAD_INDEX

bad index d

var TERR_BAD_LAYOUT

failed to calculate the structure/union layout

var TERR_BAD_MSKVAL

bad bmask and value combination (value=0xI64X; bitmask 0xI64X)

var TERR_BAD_NAME

name s is not acceptable

var TERR_BAD_OFFSET

bad member offset s

var TERR_BAD_REPR

bad or incompatible field representation

var TERR_BAD_SERIAL

enum value has too many serials

var TERR_BAD_SIZE

bad size d

var TERR_BAD_SUBTYPE

recursive structure nesting is forbidden

var TERR_BAD_TAH

bad bits in the type attributes (TAH bits)

var TERR_BAD_TYPE

bad type

var TERR_BAD_UNIVAR

unions cannot have variable sized members

var TERR_BAD_VALUE

value 0xI64X is not acceptable

var TERR_BAD_VARLAST

variable sized member must be the last member in the structure

var TERR_DUPNAME

duplicate name s

var TERR_ENUM_SIZE

bad enum size

var TERR_GRP_NOEMPTY

could not delete group mask for not empty group 0xI64X

var TERR_NESTED

recursive structure nesting is forbidden

var TERR_NOT_COMPAT

the new type is not compatible with the old type

var TERR_NOT_IMPL

not implemented

var TERR_NO_BMASK

bitmask 0xI64X is not found

var TERR_OK

ok

var TERR_OVERLAP

the member overlaps with other members that cannot be deleted

var TERR_SAVE_ERROR

failed to save

var TERR_SERIALIZE

failed to serialize

var TERR_STOCK

stock type info cannot be modified

var TERR_STRUCT_SIZE

bad fixed structure size

var TERR_TYPE_WORSE

the new type is worse than the old type

var TERR_UNION_BF

unions cannot have bitfields

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 TVIS_CMT

new comment is present (only for udt members)

var TVIS_NAME

new name is present (only for funcargs and udt members)

var TVIS_RPTCMT

the new comment is repeatable

var TVIS_TYPE

new type info is present

var TVST_DEF

visit type definition (meaningful for typerefs)

var TVST_PRUNE

don't visit children of current type

var TYPE_BASE_MASK

the low 4 bits define the basic type

var TYPE_FLAGS_MASK

type flags - they have different meaning depending on the basic type

var TYPE_FULL_MASK

basic type with type flags

var TYPE_MODIF_MASK

modifiers. * for BT_ARRAY see Derived type: array * BT_VOID can have them ONLY in 'void *'

var TYPID_ISREF

Identifies that a type that is a typeref.

var TYPID_SHIFT

First type detail bit.

var VALSTR_OPEN

printed opening curly brace '{'

var no_sign

no sign, or unknown

var type_signed

signed type

var type_unsigned

unsigned type

Functions

def add_til(name: char const *, flags: int)

add_til(name, flags) -> int Load a til file and add it the database type libraries list. IDA will also apply function prototypes for matching function names.

@param name: (C++: const char *) til name @param flags: (C++: int) combination of Load TIL flags @return: one of Load TIL result codes

def alloc_type_ordinal(ti: til_t)

alloc_type_ordinal(ti) -> uint32 alloc_type_ordinals(ti, 1)

@param ti: (C++: til_t *)

def alloc_type_ordinals(ti: til_t, qty: int)

alloc_type_ordinals(ti, qty) -> uint32 Allocate a range of ordinal numbers for new types.

@param ti: (C++: til_t *) type library @param qty: (C++: int) number of ordinals to allocate @return: the first ordinal. 0 means failure.

def append_abi_opts(abi_opts: char const *, user_level: bool = False)

append_abi_opts(abi_opts, user_level=False) -> bool Add/remove/check ABI option General form of full abi name: abiname-opt1-opt2-… or -opt1-opt2-…

@param abi_opts: (C++: const char *) - ABI options to add/remove in form opt1-opt2-… @param user_level: (C++: bool) - initiated by user if TRUE (==SETCOMP_BY_USER) @return: success

def append_argloc(out: qtype *, vloc: argloc_t)

append_argloc(out, vloc) -> bool Serialize argument location

@param out: (C++: qtype *) @param vloc: (C++: const argloc_t &) argloc_t const &

def append_tinfo_covered(out: rangeset_t, typid: typid_t, offset: uint64)

append_tinfo_covered(out, typid, offset) -> bool

@param out: rangeset_t * @param typid: typid_t @param offset: uint64

def apply_callee_tinfo(caller: ea_t, tif: tinfo_t)

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

@param caller: (C++: ea_t) linear address of the calling instruction. must belong to a function. @param tif: (C++: const tinfo_t &) type info @return: success

def apply_cdecl(til: til_t, ea: ea_t, decl: char const *, flags: int = 0)

apply_cdecl(til, ea, decl, flags=0) -> bool Apply the specified type to the address. This function parses the declaration and calls apply_tinfo()

@param til: (C++: til_t ) type library @param ea: (C++: ea_t) linear address @param decl: (C++: const char ) type declaration in C form @param flags: (C++: int) flags to pass to apply_tinfo (TINFO_DEFINITE is always passed) @return: success

def apply_named_type(ea: ea_t, name: char const *)

apply_named_type(ea, name) -> bool Apply the specified named type to the address.

@param ea: (C++: ea_t) linear address @param name: (C++: const char *) the type name, e.g. "FILE" @return: success

def apply_once_tinfo_and_name(dea: ea_t, tif: tinfo_t, name: char const *)

apply_once_tinfo_and_name(dea, tif, name) -> bool Apply the specified type and name to the address. This function checks if the address already has a type. If the old type does not exist or the new type is 'better' than the old type, then the new type will be applied. A type is considered better if it has more information (e.g. BTMT_STRUCT is better than BT_INT). The same logic is with the name: if the address already have a meaningful name, it will be preserved. Only if the old name does not exist or it is a dummy name like byte_123, it will be replaced by the new name.

@param dea: (C++: ea_t) linear address @param tif: (C++: const tinfo_t &) type string in the internal format @param name: (C++: const char *) new name for the address @return: success

def apply_tinfo(ea: ea_t, tif: tinfo_t, flags: uint32)

apply_tinfo(ea, tif, flags) -> bool Apply the specified type to the specified address. This function sets the type and tries to convert the item at the specified address to conform the type.

@param ea: (C++: ea_t) linear address @param tif: (C++: const tinfo_t &) type string in internal format @param flags: (C++: uint32) combination of Apply tinfo flags @return: success

def apply_tinfo_to_stkarg(insn: insn_t const &, x: op_t const &, v: uval_t, tif: tinfo_t, name: char const *)

apply_tinfo_to_stkarg(insn, x, v, tif, name) -> bool Helper function for the processor modules. to be called from processor_t::use_stkarg_type

@param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) @param x: (C++: const op_t &) op_t const & @param v: (C++: uval_t) @param tif: (C++: const tinfo_t &) tinfo_t const & @param name: (C++: const char *) char const *

def apply_type(ti: til_t, type: type_t const *, fields: p_list const *, ea: ea_t, flags: int)

apply_type(ti, type, fields, ea, flags) -> bool Apply the specified type to the address

@param ti: Type info library. 'None' can be used. @param type: type_t const * @param fields: p_list const * @param ea: the address of the object @param flags: combination of TINFO_… constants or 0 @return: Boolean

def begin_type_updating(utp: update_type_t)

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

@param utp: (C++: update_type_t) enum update_type_t

def calc_c_cpp_name(name: char const *, type: tinfo_t, ccn_flags: int)

calc_c_cpp_name(name, type, ccn_flags) -> str Get C or C++ form of the name.

@param name: (C++: const char ) original (mangled or decorated) name @param type: (C++: const tinfo_t ) name type if known, otherwise nullptr @param ccn_flags: (C++: int) one of C/C++ naming flags

def calc_number_of_children(loc: argloc_t, tif: tinfo_t, dont_deref_ptr: bool = False) ‑> int

calc_number_of_children(loc, tif, dont_deref_ptr=False) -> int Calculate max number of lines of a formatted c data, when expanded (PTV_EXPAND).

@param loc: (C++: const argloc_t &) location of the data (ALOC_STATIC or ALOC_CUSTOM) @param tif: (C++: const tinfo_t &) type info @param dont_deref_ptr: (C++: bool) consider 'ea' as the ptr value @retval 0: data is not expandable @retval -1: error, see qerrno @retval else: the max number of lines

def calc_tinfo_gaps(out: rangeset_t, typid: typid_t)

calc_tinfo_gaps(out, typid) -> bool

@param out: rangeset_t * @param typid: typid_t

def calc_type_size(ti: til_t, tp: PyObject *)

calc_type_size(ti, tp) -> PyObject * Returns the size of a type

@param ti: Type info library. 'None' can be passed. @param tp: serialized type byte string @return: - None on failure - The size of the type

def choose_local_tinfo(ti: til_t, title: char const *, func: local_tinfo_predicate_t * = None, def_ord: uint32 = 0, ud: void * = None)

choose_local_tinfo(ti, title, func=None, def_ord=0, ud=None) -> uint32 Choose a type from the local type library.

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

def choose_local_tinfo_and_delta(delta: int32 *, ti: til_t, title: char const *, func: local_tinfo_predicate_t * = None, def_ord: uint32 = 0, ud: void * = None)

choose_local_tinfo_and_delta(delta, ti, title, func=None, def_ord=0, ud=None) -> uint32 Choose a type from the local type library and specify the pointer shift value.

@param delta: (C++: int32 ) pointer shift value @param ti: (C++: const til_t ) pointer to til @param title: (C++: const char ) title of listbox to display @param func: (C++: local_tinfo_predicate_t ) predicate to select types to display (maybe nullptr) @param def_ord: (C++: uint32) ordinal to position cursor before choose @param ud: (C++: void *) user data @return: == 0 means nothing is chosen, otherwise an ordinal number

def choose_named_type(out_sym: til_symbol_t, root_til: til_t, title: char const *, ntf_flags: int, predicate: predicate_t = None)

choose_named_type(out_sym, root_til, title, ntf_flags, predicate=None) -> bool Choose a type from a type library.

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

def clear_tinfo_t(_this: tinfo_t)

clear_tinfo_t(_this)

@param _this: tinfo_t *

def compact_til(ti: til_t) ‑> bool

compact_til(ti) -> bool Collect garbage in til. Must be called before storing the til.

@param ti: (C++: til_t *) @return: true if any memory was freed

def compare_tinfo(t1: typid_t, t2: typid_t, tcflags: int)

compare_tinfo(t1, t2, tcflags) -> bool

@param t1: typid_t @param t2: typid_t @param tcflags: int

def convert_pt_flags_to_hti(pt_flags: int) ‑> int

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

@param pt_flags: (C++: int)

def copy_named_type(dsttil: til_t, srctil: til_t, name: char const *)

copy_named_type(dsttil, srctil, name) -> uint32 Copy a named type from one til to another. This function will copy the specified type and all dependent types from the source type library to the destination library.

@param dsttil: (C++: til_t ) Destination til. It must have original types enabled @param srctil: (C++: const til_t ) Source til. @param name: (C++: const char *) name of the type to copy @return: ordinal number of the copied type. 0 means error

def copy_tinfo_t(_this: tinfo_t, r: tinfo_t)

copy_tinfo_t(_this, r)

@param _this: tinfo_t * @param r: tinfo_t const &

def create_enum_type(enum_name: char const *, ei: enum_type_data_t, enum_width: int, sign: type_sign_t, convert_to_bitmask: bool, enum_cmt: char const * = None)

create_enum_type(enum_name, ei, enum_width, sign, convert_to_bitmask, enum_cmt=None) -> tid_t Create type enum

@param enum_name: (C++: const char ) type name @param ei: (C++: enum_type_data_t &) enum type data @param enum_width: (C++: int) the width of an enum element allowed values: 0 (unspecified),1,2,4,8,16,32,64 @param sign: (C++: type_sign_t) enum sign @param convert_to_bitmask: (C++: bool) try convert enum to bitmask enum @param enum_cmt: (C++: const char ) enum type comment @return: enum TID

def create_numbered_type_name(ord: int32)

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

@param ord: (C++: int32)

def create_tinfo(_this: tinfo_t, bt: type_t, bt2: type_t, ptr: void *)

create_tinfo(_this, bt, bt2, ptr) -> bool

@param _this: tinfo_t * @param bt: type_t @param bt2: type_t @param ptr: void *

def default_compiler()

default_compiler() -> comp_t Get compiler specified by inf.cc.

def del_named_type(ti: til_t, name: char const *, ntf_flags: int)

del_named_type(ti, name, ntf_flags) -> bool Delete information about a symbol.

@param ti: (C++: til_t ) type library @param name: (C++: const char ) name of symbol @param ntf_flags: (C++: int) combination of Flags for named types @return: success

def del_numbered_type(ti: til_t, ordinal: uint32)

del_numbered_type(ti, ordinal) -> bool Delete a numbered type.

@param ti: (C++: til_t *) @param ordinal: (C++: uint32)

def del_til(name: char const *)

del_til(name) -> bool Unload a til file.

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

def del_tinfo_attr(tif: tinfo_t, key: qstring const &, make_copy: bool)

del_tinfo_attr(tif, key, make_copy) -> bool

@param tif: tinfo_t * @param key: qstring const & @param make_copy: bool

def del_vftable_ea(ordinal: uint32)

del_vftable_ea(ordinal) -> bool Delete the address of a vftable instance for a vftable type.

@param ordinal: (C++: uint32) ordinal number of a vftable type. @return: success

def deref_ptr(ptr_ea: ea_t *, tif: tinfo_t, closure_obj: ea_t * = None)

deref_ptr(ptr_ea, tif, closure_obj=None) -> bool Dereference a pointer.

@param ptr_ea: (C++: ea_t ) in/out parameter * in: address of the pointer * out: the pointed address @param tif: (C++: const tinfo_t &) type of the pointer @param closure_obj: (C++: ea_t ) closure object (not used yet) @return: success

def deserialize_tinfo(tif: tinfo_t, til: til_t, ptype: type_t const **, pfields: p_list const **, pfldcmts: p_list const **, cmt: char const * = None)

deserialize_tinfo(tif, til, ptype, pfields, pfldcmts, cmt=None) -> bool

@param tif: tinfo_t * @param til: til_t const * @param ptype: type_t const ** @param pfields: p_list const ** @param pfldcmts: p_list const ** @param cmt: char const *

def detach_tinfo_t(_this: tinfo_t) ‑> bool

detach_tinfo_t(_this) -> bool

@param _this: tinfo_t *

def dstr_tinfo(tif: tinfo_t)

dstr_tinfo(tif) -> char const *

@param tif: tinfo_t const *

def dump_func_type_data(fti: func_type_data_t, praloc_bits: int)

dump_func_type_data(fti, praloc_bits) -> str Use func_type_data_t::dump()

@param fti: (C++: const func_type_data_t &) func_type_data_t const & @param praloc_bits: (C++: int)

def enable_numbered_types(ti: til_t, enable: bool) ‑> bool

enable_numbered_types(ti, enable) -> bool Enable the use of numbered types in til. Currently it is impossible to disable numbered types once they are enabled

@param ti: (C++: til_t *) @param enable: (C++: bool)

def end_type_updating(utp: update_type_t)

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

@param utp: (C++: update_type_t) enum update_type_t

def extract_argloc(vloc: argloc_t, ptype: type_t const **, forbid_stkoff: bool)

extract_argloc(vloc, ptype, forbid_stkoff) -> bool Deserialize an argument location. Argument FORBID_STKOFF checks location type. It can be used, for example, to check the return location of a function that cannot return a value in the stack

@param vloc: (C++: argloc_t ) @param ptype: (C++: const type_t *) type_t const ** @param forbid_stkoff: (C++: bool)

def find_tinfo_udt_member(udm: udm_t, typid: typid_t, strmem_flags: int)

find_tinfo_udt_member(udm, typid, strmem_flags) -> int

@param udm: udm_t * @param typid: typid_t @param strmem_flags: int

def first_named_type(ti: til_t, ntf_flags: int)

first_named_type(ti, ntf_flags) -> char const * Enumerate types.

@param ti: (C++: const til_t *) type library. nullptr means the local type library for the current database. @param ntf_flags: (C++: int) combination of Flags for named types @return: Type or symbol names, depending of ntf_flags. Returns mangled names. Never returns anonymous types. To include them, enumerate types by ordinals.

def for_all_arglocs(vv: aloc_visitor_t, vloc: argloc_t, size: int, off: int = 0) ‑> int

for_all_arglocs(vv, vloc, size, off=0) -> int Compress larger argloc types and initiate the aloc visitor.

@param vv: (C++: aloc_visitor_t &) @param vloc: (C++: argloc_t &) @param size: (C++: int) @param off: (C++: int)

def for_all_const_arglocs(vv: const_aloc_visitor_t, vloc: argloc_t, size: int, off: int = 0) ‑> int

for_all_const_arglocs(vv, vloc, size, off=0) -> int See for_all_arglocs()

@param vv: (C++: const_aloc_visitor_t &) @param vloc: (C++: const argloc_t &) argloc_t const & @param size: (C++: int) @param off: (C++: int)

def free_til(ti: til_t)

free_til(ti) Free memory allocated by til.

@param ti: (C++: til_t *)

def func_has_stkframe_hole(ea: ea_t, fti: func_type_data_t)

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

@param ea: (C++: ea_t) @param fti: (C++: const func_type_data_t &) func_type_data_t const &

def gcc_layout() ‑> bool

gcc_layout() -> bool Should use the struct/union layout as done by gcc?

def gen_decorate_name(name: char const *, mangle: bool, cc: cm_t, type: tinfo_t)

gen_decorate_name(name, mangle, cc, type) -> str Generic function for decorate_name() (may be used in IDP modules)

@param name: (C++: const char ) char const * @param mangle: (C++: bool) @param cc: (C++: cm_t) @param type: (C++: const tinfo_t ) tinfo_t const *

def gen_use_arg_tinfos(_this: argtinfo_helper_t, caller: ea_t, fti: func_type_data_t, rargs: funcargvec_t)

gen_use_arg_tinfos(_this, caller, fti, rargs) Do not call this function directly, use argtinfo_helper_t.

@param _this: (C++: struct argtinfo_helper_t ) argtinfo_helper_t * @param caller: (C++: ea_t) @param fti: (C++: func_type_data_t ) @param rargs: (C++: funcargvec_t *)

def get_abi_name()

get_abi_name() -> str Get ABI name.

@return: length of the name (>=0)

def get_alias_target(ti: til_t, ordinal: uint32)

get_alias_target(ti, ordinal) -> uint32 Find the final alias destination. If the ordinal has not been aliased, return the specified ordinal itself If failed, returns 0.

@param ti: (C++: const til_t *) til_t const * @param ordinal: (C++: uint32)

def get_arg_addrs(caller: ea_t)

get_arg_addrs(caller) -> PyObject * Retrieve addresses of argument initialization instructions

@param caller: the address of the call instruction @return: list of instruction addresses

def get_base_type(t: type_t)

get_base_type(t) -> type_t Get get basic type bits (TYPE_BASE_MASK)

@param t: (C++: type_t)

def get_c_header_path()

get_c_header_path() -> str Get the include directory path of the target compiler.

def get_c_macros()

get_c_macros() -> str Get predefined macros for the target compiler.

def get_comp(comp: comp_t)

get_comp(comp) -> comp_t Get compiler bits.

@param comp: (C++: comp_t)

def get_compiler_abbr(id: comp_t)

get_compiler_abbr(id) -> char const * Get abbreviated compiler name.

@param id: (C++: comp_t)

def get_compiler_name(id: comp_t)

get_compiler_name(id) -> char const * Get full compiler name.

@param id: (C++: comp_t)

def get_compilers(ids: compvec_t *, names: qstrvec_t *, abbrs: qstrvec_t *)

get_compilers(ids, names, abbrs) Get names of all built-in compilers.

@param ids: (C++: compvec_t ) @param names: (C++: qstrvec_t ) @param abbrs: (C++: qstrvec_t *)

def get_enum_member_expr(tif: tinfo_t, serial: int, value: uint64)

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

@param tif: (C++: const tinfo_t &) enumeration type @param serial: (C++: int) which enumeration member to use (0 means the first with the given value) @param value: (C++: uint64) value to search in the enumeration type @return: success

def get_full_type(t: type_t)

get_full_type(t) -> type_t Get basic type bits + type flags (TYPE_FULL_MASK)

@param t: (C++: type_t)

def get_idainfo_by_type(tif: tinfo_t)

get_idainfo_by_type(tif) -> bool Extract information from a tinfo_t.

@param tif: (C++: const tinfo_t &) the type to inspect

def get_idainfo_by_udm(*args) ‑> bool

get_idainfo_by_udm(flags, ti, udm, refinfo_ea=BADADDR) -> bool Calculate IDA info from udt member

@param flags: (C++: flags64_t ) [out]: flags (see bytes.hpp) for udt member @param ti: (C++: opinfo_t ) [out]: additional representation information, see set_opinfo() @param udm: (C++: const udm_t &) udt member @param refinfo_ea: (C++: ea_t) if specified will be used to adjust the refinfo_t data @note: any output argument may be nullptr

def get_idati()

get_idati() -> til_t Pointer to the local type library - this til is private for each IDB file Functions that accept til_t* default to idati when is nullptr provided.

def get_named_type(til: til_t, name: char const *, ntf_flags: int)

get_named_type(til, name, ntf_flags) -> (int, bytes, bytes, NoneType, NoneType, int, int) Get a type data by its name.

@param til: the type library @param name: the type name @param 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(til: til_t, name: char const *, ntf_flags: int)

get_named_type64(til, name, ntf_flags) -> (int, bytes, NoneType, NoneType, NoneType, int, int) See get_named_type() above. @note: If the value in the 'ti' library is 32-bit, it will be sign-extended before being stored in the 'value' pointer.

@param til: til_t const * @param name: (C++: const char *) char const * @param ntf_flags: (C++: int)

def get_named_type_tid(name: char const *)

get_named_type_tid(name) -> tid_t Get named local type TID

@param name: (C++: const char *) type name @return: TID or BADADDR

def get_numbered_type(til: til_t, ordinal: uint32)

get_numbered_type(til, ordinal) -> (bytes, NoneType, NoneType, NoneType, int), (bytes, bytes, NoneType, NoneType, int) Retrieve a type by its ordinal number.

@param til: til_t const * @param ordinal: (C++: uint32)

def get_numbered_type_name(ti: til_t, ordinal: uint32)

get_numbered_type_name(ti, ordinal) -> char const * Get type name (if exists) by its ordinal. If the type is anonymous, returns "". If failed, returns nullptr

@param ti: (C++: const til_t *) til_t const * @param ordinal: (C++: uint32)

def get_ordinal_count(ti: til_t = None)

get_ordinal_count(ti=None) -> uint32 Get number of allocated ordinals.

@param ti: (C++: const til_t *) type library; nullptr means the local types for the current database. @return: 0 if ordinals have not been enabled for the til.

def get_ordinal_limit(ti: til_t = None)

get_ordinal_limit(ti=None) -> uint32 Get number of allocated ordinals + 1. If there are no allocated ordinals, return 0. To enumerate all ordinals, use: for ( uint32 i = 1; i < limit; ++i )

@param ti: (C++: const til_t *) type library; nullptr means the local types for the current database. @return: uint32(-1) if ordinals have not been enabled for the til. For local types (idati), ordinals are always enabled.

def get_scalar_bt(size: int)

get_scalar_bt(size) -> type_t

@param size: int

def get_stock_tinfo(tif: tinfo_t, id: stock_type_id_t)

get_stock_tinfo(tif, id) -> bool

@param tif: tinfo_t * @param id: enum stock_type_id_t

def get_tid_name(tid: tid_t)

get_tid_name(tid) -> str Get a type name for the specified TID

@param tid: (C++: tid_t) type TID @return: true if there is type with TID @note: this function is the inverse to get_named_type_tid

def get_tid_ordinal(tid: tid_t)

get_tid_ordinal(tid) -> uint32 Get type ordinal number for TID

@param tid: (C++: tid_t) type/enum constant/udt member TID @return: type ordinal number or 0

def get_tinfo_attr(typid: typid_t, key: qstring const &, bv: bytevec_t *, all_attrs: bool)

get_tinfo_attr(typid, key, bv, all_attrs) -> bool

@param typid: typid_t @param key: qstring const & @param bv: bytevec_t * @param all_attrs: bool

def get_tinfo_attrs(typid: typid_t, tav: type_attrs_t, include_ref_attrs: bool)

get_tinfo_attrs(typid, tav, include_ref_attrs) -> bool

@param typid: typid_t @param tav: type_attrs_t * @param include_ref_attrs: bool

def get_tinfo_by_edm_name(tif: tinfo_t, til: til_t, mname: char const *)

get_tinfo_by_edm_name(tif, til, mname) -> ssize_t

@param tif: tinfo_t * @param til: til_t const * @param mname: char const *

def get_tinfo_by_flags(out: tinfo_t, flags: flags64_t)

get_tinfo_by_flags(out, flags) -> bool Get tinfo object that corresponds to data flags

@param out: (C++: tinfo_t *) type info @param flags: (C++: flags64_t) simple flags (byte, word, …, zword)

def get_tinfo_details(typid: typid_t, bt2: type_t, buf: void *)

get_tinfo_details(typid, bt2, buf) -> bool

@param typid: typid_t @param bt2: type_t @param buf: void *

def get_tinfo_pdata(outptr: void *, typid: typid_t, what: int)

get_tinfo_pdata(outptr, typid, what) -> size_t

@param outptr: void * @param typid: typid_t @param what: int

def get_tinfo_property(typid: typid_t, gta_prop: int)

get_tinfo_property(typid, gta_prop) -> size_t

@param typid: typid_t @param gta_prop: int

def get_tinfo_property4(typid: typid_t, gta_prop: int, p1: size_t, p2: size_t, p3: size_t, p4: size_t)

get_tinfo_property4(typid, gta_prop, p1, p2, p3, p4) -> size_t

@param typid: typid_t @param gta_prop: int @param p1: size_t @param p2: size_t @param p3: size_t @param p4: size_t

def get_tinfo_size(p_effalign: uint32 *, typid: typid_t, gts_code: int)

get_tinfo_size(p_effalign, typid, gts_code) -> size_t

@param p_effalign: uint32 * @param typid: typid_t @param gts_code: int

def get_type_flags(t: type_t)

get_type_flags(t) -> type_t Get type flags (TYPE_FLAGS_MASK)

@param t: (C++: type_t)

def get_type_ordinal(ti: til_t, name: char const *)

get_type_ordinal(ti, name) -> int32 Get type ordinal by its name.

@param ti: (C++: const til_t ) til_t const * @param name: (C++: const char ) char const *

def get_udm_by_fullname(udm: udm_t, fullname: char const *)

get_udm_by_fullname(udm, fullname) -> ssize_t Get udt member by full name

@param udm: (C++: udm_t ) member, can be NULL @param fullname: (C++: const char ) udt member name in format . @return: member index into udt_type_data_t or -1

def get_vftable_ea(ordinal: uint32)

get_vftable_ea(ordinal) -> ea_t Get address of a virtual function table.

@param ordinal: (C++: uint32) ordinal number of a vftable type. @return: address of the corresponding virtual function table in the current database.

def get_vftable_ordinal(vftable_ea: ea_t)

get_vftable_ordinal(vftable_ea) -> uint32 Get ordinal number of the virtual function table.

@param vftable_ea: (C++: ea_t) address of a virtual function table. @return: ordinal number of the corresponding vftable type. 0 - failure.

def guess_func_cc(fti: func_type_data_t, npurged: int, cc_flags: int)

guess_func_cc(fti, npurged, cc_flags) -> cm_t Use func_type_data_t::guess_cc()

@param fti: (C++: const func_type_data_t &) func_type_data_t const & @param npurged: (C++: int) @param cc_flags: (C++: int)

def guess_tinfo(out: tinfo_t, id: tid_t)

guess_tinfo(out, id) -> int Generate a type information about the id from the disassembly. id can be a structure/union/enum id or an address.

@param out: (C++: tinfo_t *) @param id: (C++: tid_t) @return: one of Guess tinfo codes

def idc_get_local_type(ordinal: int, flags: int)

idc_get_local_type(ordinal, flags) -> str

@param ordinal: int @param flags: int

def idc_get_local_type_name(ordinal: int)

idc_get_local_type_name(ordinal) -> str

@param ordinal: int

def idc_get_local_type_raw(ordinal: int)

idc_get_local_type_raw(ordinal) -> (bytes, bytes)

@param ordinal: int

def idc_get_type(ea: ea_t)

idc_get_type(ea) -> str

@param ea: ea_t

def idc_get_type_raw(ea: ea_t)

idc_get_type_raw(ea) -> PyObject *

@param ea: ea_t

def idc_guess_type(ea: ea_t)

idc_guess_type(ea) -> str

@param ea: ea_t

def idc_parse_decl(ti: til_t, decl: char const *, flags: int)

idc_parse_decl(ti, decl, flags) -> (str, bytes, bytes) or None

@param ti: til_t * @param decl: char const * @param flags: int

def idc_parse_types(input: char const *, flags: int)

idc_parse_types(input, flags) -> int

@param input: char const * @param flags: int

def idc_print_type(type: type_t const *, fields: p_list const *, name: char const *, flags: int)

idc_print_type(type, fields, name, flags) -> str

@param type: type_t const * @param fields: p_list const * @param name: char const * @param flags: int

def idc_set_local_type(ordinal: int, dcl: char const *, flags: int)

idc_set_local_type(ordinal, dcl, flags) -> int

@param ordinal: int @param dcl: char const * @param flags: int

def inf_big_arg_align(*args) ‑> bool

inf_big_arg_align() -> bool inf_big_arg_align(cc) -> bool

@param cc: cm_t

def inf_huge_arg_align(*args) ‑> bool

inf_huge_arg_align() -> bool inf_huge_arg_align(cc) -> bool

@param cc: cm_t

def inf_pack_stkargs(*args) ‑> bool

inf_pack_stkargs() -> bool inf_pack_stkargs(cc) -> bool

@param cc: cm_t

def is_code_far(cm: cm_t)

is_code_far(cm) -> bool Does the given model specify far code?.

@param cm: (C++: cm_t)

def is_comp_unsure(comp: comp_t)

is_comp_unsure(comp) -> comp_t See COMP_UNSURE.

@param comp: (C++: comp_t)

def is_data_far(cm: cm_t)

is_data_far(cm) -> bool Does the given model specify far data?.

@param cm: (C++: cm_t)

def is_gcc() ‑> bool

is_gcc() -> bool Is the target compiler COMP_GNU?

def is_gcc32() ‑> bool

is_gcc32() -> bool Is the target compiler 32 bit gcc?

def is_gcc64() ‑> bool

is_gcc64() -> bool Is the target compiler 64 bit gcc?

def is_golang_cc(cc: cm_t)

is_golang_cc(cc) -> bool GO language calling convention (return value in stack)?

@param cc: (C++: cm_t)

def is_one_bit_mask(mask: uval_t)

is_one_bit_mask(mask) -> bool Is bitmask one bit?

@param mask: (C++: uval_t)

def is_ordinal_name(name: char const *, ord: uint32 * = None)

is_ordinal_name(name, ord=None) -> bool Check if the name is an ordinal name. Ordinal names have the following format: '#' + set_de(ord)

@param name: (C++: const char ) char const * @param ord: (C++: uint32 )

def is_purging_cc(cm: cm_t)

is_purging_cc(cm) -> bool Does the calling convention clean the stack arguments upon return?. @note: this function is valid only for x86 code

@param cm: (C++: cm_t)

def is_restype_enum(til: til_t, type: type_t const *)

is_restype_enum(til, type) -> bool

@param til: til_t const * @param type: type_t const *

def is_restype_struct(til: til_t, type: type_t const *)

is_restype_struct(til, type) -> bool

@param til: til_t const * @param type: type_t const *

def is_restype_struni(til: til_t, type: type_t const *)

is_restype_struni(til, type) -> bool

@param til: til_t const * @param type: type_t const *

def is_restype_void(til: til_t, type: type_t const *)

is_restype_void(til, type) -> bool

@param til: til_t const * @param type: type_t const *

def is_sdacl_byte(t: type_t)

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

@param t: (C++: type_t)

def is_swift_cc(cc: cm_t)

is_swift_cc(cc) -> bool Swift calling convention (arguments and return values in registers)?

@param cc: (C++: cm_t)

def is_tah_byte(t: type_t)

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

@param t: (C++: type_t)

def is_type_arithmetic(t: type_t)

is_type_arithmetic(t) -> bool Is the type an arithmetic type? (floating or integral)

@param t: (C++: type_t)

def is_type_array(t: type_t)

is_type_array(t) -> bool See BT_ARRAY.

@param t: (C++: type_t)

def is_type_bitfld(t: type_t)

is_type_bitfld(t) -> bool See BT_BITFIELD.

@param t: (C++: type_t)

def is_type_bool(t: type_t)

is_type_bool(t) -> bool See BTF_BOOL.

@param t: (C++: type_t)

def is_type_char(t: type_t)

is_type_char(t) -> bool Does the type specify a char value? (signed or unsigned, see Basic type: integer)

@param t: (C++: type_t)

def is_type_choosable(ti: til_t, ordinal: uint32)

is_type_choosable(ti, ordinal) -> bool Check if a struct/union type is choosable

@param ti: (C++: const til_t *) type library @param ordinal: (C++: uint32) ordinal number of a UDT type

def is_type_complex(t: type_t)

is_type_complex(t) -> bool See BT_COMPLEX.

@param t: (C++: type_t)

def is_type_const(t: type_t)

is_type_const(t) -> bool See BTM_CONST.

@param t: (C++: type_t)

def is_type_double(t: type_t)

is_type_double(t) -> bool See BTF_DOUBLE.

@param t: (C++: type_t)

def is_type_enum(t: type_t)

is_type_enum(t) -> bool See BTF_ENUM.

@param t: (C++: type_t)

def is_type_ext_arithmetic(t: type_t)

is_type_ext_arithmetic(t) -> bool Is the type an extended arithmetic type? (arithmetic or enum)

@param t: (C++: type_t)

def is_type_ext_integral(t: type_t)

is_type_ext_integral(t) -> bool Is the type an extended integral type? (integral or enum)

@param t: (C++: type_t)

def is_type_float(t: type_t)

is_type_float(t) -> bool See BTF_FLOAT.

@param t: (C++: type_t)

def is_type_floating(t: type_t)

is_type_floating(t) -> bool Is the type a floating point type?

@param t: (C++: type_t)

def is_type_func(t: type_t)

is_type_func(t) -> bool See BT_FUNC.

@param t: (C++: type_t)

def is_type_int(bt: type_t)

is_type_int(bt) -> bool Does the type_t specify one of the basic types in Basic type: integer?

@param bt: (C++: type_t)

def is_type_int128(t: type_t)

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

@param t: (C++: type_t)

def is_type_int16(t: type_t)

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

@param t: (C++: type_t)

def is_type_int32(t: type_t)

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

@param t: (C++: type_t)

def is_type_int64(t: type_t)

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

@param t: (C++: type_t)

def is_type_integral(t: type_t)

is_type_integral(t) -> bool Is the type an integral type (char/short/int/long/bool)?

@param t: (C++: type_t)

def is_type_ldouble(t: type_t)

is_type_ldouble(t) -> bool See BTF_LDOUBLE.

@param t: (C++: type_t)

def is_type_paf(t: type_t)

is_type_paf(t) -> bool Is the type a pointer, array, or function type?

@param t: (C++: type_t)

def is_type_partial(t: type_t)

is_type_partial(t) -> bool Identifies an unknown or void type with a known size (see Basic type: unknown & void)

@param t: (C++: type_t)

def is_type_ptr(t: type_t)

is_type_ptr(t) -> bool See BT_PTR.

@param t: (C++: type_t)

def is_type_ptr_or_array(t: type_t)

is_type_ptr_or_array(t) -> bool Is the type a pointer or array type?

@param t: (C++: type_t)

def is_type_struct(t: type_t)

is_type_struct(t) -> bool See BTF_STRUCT.

@param t: (C++: type_t)

def is_type_struni(t: type_t)

is_type_struni(t) -> bool Is the type a struct or union?

@param t: (C++: type_t)

def is_type_sue(t: type_t)

is_type_sue(t) -> bool Is the type a struct/union/enum?

@param t: (C++: type_t)

def is_type_tbyte(t: type_t)

is_type_tbyte(t) -> bool See BTF_FLOAT.

@param t: (C++: type_t)

def is_type_typedef(t: type_t)

is_type_typedef(t) -> bool See BTF_TYPEDEF.

@param t: (C++: type_t)

def is_type_uchar(t: type_t)

is_type_uchar(t) -> bool See BTF_UCHAR.

@param t: (C++: type_t)

def is_type_uint(t: type_t)

is_type_uint(t) -> bool See BTF_UINT.

@param t: (C++: type_t)

def is_type_uint128(t: type_t)

is_type_uint128(t) -> bool See BTF_UINT128.

@param t: (C++: type_t)

def is_type_uint16(t: type_t)

is_type_uint16(t) -> bool See BTF_UINT16.

@param t: (C++: type_t)

def is_type_uint32(t: type_t)

is_type_uint32(t) -> bool See BTF_UINT32.

@param t: (C++: type_t)

def is_type_uint64(t: type_t)

is_type_uint64(t) -> bool See BTF_UINT64.

@param t: (C++: type_t)

def is_type_union(t: type_t)

is_type_union(t) -> bool See BTF_UNION.

@param t: (C++: type_t)

def is_type_unknown(t: type_t)

is_type_unknown(t) -> bool See BT_UNKNOWN.

@param t: (C++: type_t)

def is_type_void(t: type_t)

is_type_void(t) -> bool See BTF_VOID.

@param t: (C++: type_t)

def is_type_volatile(t: type_t)

is_type_volatile(t) -> bool See BTM_VOLATILE.

@param t: (C++: type_t)

def is_typeid_last(t: type_t)

is_typeid_last(t) -> bool Is the type_t the last byte of type declaration? (there are no additional bytes after a basic type, see _BT_LAST_BASIC)

@param t: (C++: type_t)

def is_user_cc(cm: cm_t)

is_user_cc(cm) -> bool Does the calling convention specify argument locations explicitly?

@param cm: (C++: cm_t)

def is_vararg_cc(cm: cm_t)

is_vararg_cc(cm) -> bool Does the calling convention use ellipsis?

@param cm: (C++: cm_t)

def lexcompare_tinfo(t1: typid_t, t2: typid_t, arg3: int)

lexcompare_tinfo(t1, t2, arg3) -> int

@param t1: typid_t @param t2: typid_t @param arg3: int

def load_til(name: char const *, tildir: char const * = None)

load_til(name, tildir=None) -> til_t Load til from a file without adding it to the database list (see also add_til). Failure to load base tils are reported into 'errbuf'. They do not prevent loading of the main til.

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

def load_til_header(tildir: char const *, name: char const *)

load_til_header(tildir, name) -> til_t Get human-readable til description.

@param tildir: (C++: const char ) char const * @param name: (C++: const char ) char const *

def lower_type(til: til_t, tif: tinfo_t, name: char const * = None)

lower_type(til, tif, name=None, _helper=None) -> int Lower type. Inspect the type and lower all function subtypes using lower_func_type(). We call the prototypes usually encountered in source files "high level" They may have implicit arguments, array arguments, big structure retvals, etc We introduce explicit arguments (i.e. 'this' pointer) and call the result "low level prototype". See FTI_HIGH.

In order to improve heuristics for recognition of big structure retvals, it is recommended to pass a helper that will be used to make decisions. That helper will be used only for lowering 'tif', and not for the children types walked through by recursion. @retval 1: removed FTI_HIGH, @retval 2: made substantial changes @retval -1: failure

@param til: (C++: til_t ) @param tif: (C++: tinfo_t ) @param name: (C++: const char ) char const * @param _helper: (C++: lowertype_helper_t )

def new_til(name: char const *, desc: char const *)

new_til(name, desc) -> til_t Initialize a til.

@param name: (C++: const char ) char const * @param desc: (C++: const char ) char const *

def next_named_type(ti: til_t, name: char const *, ntf_flags: int)

next_named_type(ti, name, ntf_flags) -> char const * Enumerate types.

@param ti: (C++: const til_t ) type library. nullptr means the local type library for the current database. @param name: (C++: const char ) the current name. the name that follows this one will be returned. @param ntf_flags: (C++: int) combination of Flags for named types @return: Type or symbol names, depending of ntf_flags. Returns mangled names. Never returns anonymous types. To include them, enumerate types by ordinals.

def optimize_argloc(vloc: argloc_t, size: int, gaps: rangeset_t)

optimize_argloc(vloc, size, gaps) -> bool Verify and optimize scattered argloc into simple form. All new arglocs must be processed by this function. @retval true: success @retval false: the input argloc was illegal

@param vloc: (C++: argloc_t ) @param size: (C++: int) @param gaps: (C++: const rangeset_t ) rangeset_t const *

def pack_idcobj_to_bv(obj: idc_value_t const *, tif: tinfo_t, bytes: relobj_t, objoff: void *, pio_flags: int = 0)

pack_idcobj_to_bv(obj, tif, bytes, objoff, pio_flags=0) -> error_t Write a typed idc object to the byte vector. Byte vector may be non-empty, this function will append data to it

@param obj: (C++: const idc_value_t ) idc_value_t const * @param tif: (C++: const tinfo_t &) tinfo_t const & @param bytes: (C++: relobj_t ) @param objoff: (C++: void *) @param pio_flags: (C++: int)

def pack_idcobj_to_idb(obj: idc_value_t const *, tif: tinfo_t, ea: ea_t, pio_flags: int = 0)

pack_idcobj_to_idb(obj, tif, ea, pio_flags=0) -> error_t Write a typed idc object to the database.

@param obj: (C++: const idc_value_t *) idc_value_t const * @param tif: (C++: const tinfo_t &) tinfo_t const & @param ea: (C++: ea_t) @param pio_flags: (C++: int)

def pack_object_to_bv(py_obj: PyObject *, ti: til_t, type: type_t const *, fields: p_list const *, base_ea: ea_t, pio_flags: int = 0)

pack_object_to_bv(py_obj, ti, type, fields, base_ea, pio_flags=0) -> PyObject Packs a typed object to a string

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

def pack_object_to_idb(py_obj: PyObject *, ti: til_t, type: type_t const *, fields: p_list const *, ea: ea_t, pio_flags: int = 0)

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

@param py_obj: PyObject * @param ti: Type info. 'None' can be passed. @param type: type_t const * @param fields: fields string (may be empty or None) @param ea: ea to be used while packing @param pio_flags: flags used while unpacking

def parse_decl(out_tif: tinfo_t, til: til_t, decl: char const *, pt_flags: int)

parse_decl(out_tif, til, decl, pt_flags) -> str Parse ONE declaration. If the input string contains more than one declaration, the first complete type declaration (PT_TYP) or the last variable declaration (PT_VAR) will be used. @note: name & tif may be empty after the call!

@param out_tif: (C++: tinfo_t ) type info @param til: (C++: til_t ) type library to use. may be nullptr @param decl: (C++: const char *) C declaration to parse @param pt_flags: (C++: int) combination of Type parsing flags bits @retval true: ok @retval false: declaration is bad, the error message is displayed if !PT_SIL

def parse_decls(til: til_t, input: char const *, printer: printer_t *, hti_flags: int)

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

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

def print_argloc(vloc: argloc_t, size: int = 0, vflags: int = 0)

print_argloc(vloc, size=0, vflags=0) -> size_t Convert an argloc to human readable form.

@param vloc: (C++: const argloc_t &) argloc_t const & @param size: (C++: int) @param vflags: (C++: int)

def print_decls(printer: text_sink_t, til: til_t, py_ordinals: PyObject *, flags: uint32)

print_decls(printer, til, py_ordinals, flags) -> int Print types (and possibly their dependencies) in a format suitable for using in a header file. This is the reverse parse_decls().

@param printer: (C++: text_sink_t &) a handler for printing text @param til: (C++: const til_t *) the type library holding the ordinals @param py_ordinals: ordinals of types to export. nullptr means: all ordinals in til @param pdf_flags: (C++: uint32) flags for the algorithm. A combination of PDF_ constants @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(prefix: char const *, indent: int, cmtindent: int, flags: int, tif: tinfo_t, name: char const *, cmt: char const *)

print_tinfo(prefix, indent, cmtindent, flags, tif, name, cmt) -> str

@param prefix: char const * @param indent: int @param cmtindent: int @param flags: int @param tif: tinfo_t const * @param name: char const * @param cmt: char const *

def print_type(ea: ea_t, prtype_flags: int)

print_type(ea, prtype_flags) -> str Get type declaration for the specified address.

@param ea: (C++: ea_t) address @param prtype_flags: (C++: int) combination of Type printing flags @return: success

def read_tinfo_bitfield_value(typid: typid_t, v: uint64, bitoff: int)

read_tinfo_bitfield_value(typid, v, bitoff) -> uint64

@param typid: typid_t @param v: uint64 @param bitoff: int

def remove_abi_opts(abi_opts: char const *, user_level: bool = False)

remove_abi_opts(abi_opts, user_level=False) -> bool

@param abi_opts: char const * @param user_level: bool

def remove_pointer(tif: tinfo_t) ‑> tinfo_t

remove_pointer(tif) -> tinfo_t

@param 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()

def remove_tinfo_pointer(tif: tinfo_t, name: char const *, til: til_t)

remove_tinfo_pointer(tif, name, til) -> (bool, NoneType), (bool, str) Remove pointer of a type. (i.e. convert "char *" into "char"). Optionally remove the "lp" (or similar) prefix of the input name. If the input type is not a pointer, then fail.

@param tif: (C++: tinfo_t ) @param name: char const * @param til: (C++: const til_t ) til_t const *

def replace_ordinal_typerefs(til: til_t, tif: tinfo_t) ‑> int

replace_ordinal_typerefs(til, tif) -> int Replace references to ordinal types by name references. This function 'unties' the type from the current local type library and makes it easier to export it.

@param til: (C++: til_t ) type library to use. may be nullptr. @param tif: (C++: tinfo_t ) type to modify (in/out) @retval number: of replaced subtypes, -1 on failure

def resolve_typedef(til: til_t, type: type_t const *)

resolve_typedef(til, type) -> type_t const *

@param til: til_t const * @param type: type_t const *

def save_tinfo(tif: tinfo_t, til: til_t, ord: size_t, name: char const *, ntf_flags: int)

save_tinfo(tif, til, ord, name, ntf_flags) -> tinfo_code_t

@param tif: tinfo_t * @param til: til_t * @param ord: size_t @param name: char const * @param ntf_flags: int

def score_tinfo(tif: tinfo_t)

score_tinfo(tif) -> uint32

@param tif: tinfo_t const *

def serialize_tinfo(type: qtype *, fields: qtype *, fldcmts: qtype *, tif: tinfo_t, sudt_flags: int)

serialize_tinfo(type, fields, fldcmts, tif, sudt_flags) -> bool

@param type: qtype * @param fields: qtype * @param fldcmts: qtype * @param tif: tinfo_t const * @param sudt_flags: int

def set_abi_name(abiname: char const *, user_level: bool = False)

set_abi_name(abiname, user_level=False) -> bool Set abi name (see Compiler IDs)

@param abiname: (C++: const char *) char const * @param user_level: (C++: bool)

def set_c_header_path(incdir: char const *)

set_c_header_path(incdir) Set include directory path the target compiler.

@param incdir: (C++: const char *) char const *

def set_c_macros(macros: char const *)

set_c_macros(macros) Set predefined macros for the target compiler.

@param macros: (C++: const char *) char const *

def set_compiler(cc: compiler_info_t, flags: int, abiname: char const * = None)

set_compiler(cc, flags, abiname=None) -> bool Change current compiler.

@param cc: (C++: const compiler_info_t &) compiler to switch to @param flags: (C++: int) Set compiler flags @param abiname: (C++: const char *) ABI name @return: success

def set_compiler_id(id: comp_t, abiname: char const * = None)

set_compiler_id(id, abiname=None) -> bool Set the compiler id (see Compiler IDs)

@param id: (C++: comp_t) @param abiname: (C++: const char *) char const *

def set_compiler_string(compstr: char const *, user_level: bool)

set_compiler_string(compstr, user_level) -> bool

@param compstr: (C++: const char *) - compiler description in form : @param user_level: (C++: bool) - initiated by user if TRUE @return: success

def set_numbered_type(ti: til_t, ordinal: uint32, ntf_flags: int, name: char const *, type: type_t const *, fields: p_list const * = None, cmt: char const * = None, fldcmts: p_list const * = None, sclass: sclass_t const * = None)

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

@param ti: til_t * @param ordinal: uint32 @param ntf_flags: int @param name: char const * @param type: type_t const * @param fields: p_list const * @param cmt: char const * @param fldcmts: p_list const * @param sclass: sclass_t const *

def set_tinfo_attr(tif: tinfo_t, ta: type_attr_t, may_overwrite: bool) ‑> bool

set_tinfo_attr(tif, ta, may_overwrite) -> bool

@param tif: tinfo_t * @param ta: type_attr_t const & @param may_overwrite: bool

def set_tinfo_attrs(tif: tinfo_t, ta: type_attrs_t) ‑> bool

set_tinfo_attrs(tif, ta) -> bool

@param tif: tinfo_t * @param ta: type_attrs_t *

def set_tinfo_property(tif: tinfo_t, sta_prop: int, x: size_t)

set_tinfo_property(tif, sta_prop, x) -> size_t

@param tif: tinfo_t * @param sta_prop: int @param x: size_t

def set_tinfo_property4(tif: tinfo_t, sta_prop: int, p1: size_t, p2: size_t, p3: size_t, p4: size_t)

set_tinfo_property4(tif, sta_prop, p1, p2, p3, p4) -> size_t

@param tif: tinfo_t * @param sta_prop: int @param p1: size_t @param p2: size_t @param p3: size_t @param p4: size_t

def set_type_alias(ti: til_t, src_ordinal: uint32, dst_ordinal: uint32)

set_type_alias(ti, src_ordinal, dst_ordinal) -> bool Create a type alias. Redirects all references to source type to the destination type. This is equivalent to instantaneous replacement all references to srctype by dsttype.

@param ti: (C++: til_t *) @param src_ordinal: (C++: uint32) @param dst_ordinal: (C++: uint32)

def set_type_choosable(ti: til_t, ordinal: uint32, value: bool)

set_type_choosable(ti, ordinal, value) Enable/disable 'choosability' flag for a struct/union type

@param ti: (C++: til_t *) type library @param ordinal: (C++: uint32) ordinal number of a UDT type @param value: (C++: bool) flag value

def set_vftable_ea(ordinal: uint32, vftable_ea: ea_t)

set_vftable_ea(ordinal, vftable_ea) -> bool Set the address of a vftable instance for a vftable type.

@param ordinal: (C++: uint32) ordinal number of the corresponding vftable type. @param vftable_ea: (C++: ea_t) address of a virtual function table. @return: success

def store_til(ti: til_t, tildir: char const *, name: char const *)

store_til(ti, tildir, name) -> bool Store til to a file. If the til contains garbage, it will be collected before storing the til. Your plugin should call compact_til() before calling store_til().

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

def stroff_as_size(plen: int, tif: tinfo_t, value: asize_t)

stroff_as_size(plen, tif, value) -> bool Should display a structure offset expression as the structure size?

@param plen: (C++: int) @param tif: (C++: const tinfo_t &) tinfo_t const & @param value: (C++: asize_t)

def switch_to_golang()

switch_to_golang() switch to GOLANG calling convention (to be used as default CC)

def tinfo_errstr(code: tinfo_code_t)

tinfo_errstr(code) -> char const * Helper function to convert an error code into a printable string. Additional arguments are handled using the functions from err.h

@param code: (C++: tinfo_code_t) enum tinfo_code_t

def udm_t__make_gap(_this: udm_t, byteoff: uval_t, nbytes: uval_t)

udm_t__make_gap(_this, byteoff, nbytes) -> bool

@param _this: udm_t * @param byteoff: uval_t @param nbytes: uval_t

def udt_type_data_t__find_member(_this: udt_type_data_t, udm: udm_t, strmem_flags: int)

udt_type_data_t__find_member(_this, udm, strmem_flags) -> ssize_t

@param _this: udt_type_data_t const * @param udm: udm_t * @param strmem_flags: int

def udt_type_data_t__get_best_fit_member(_this: udt_type_data_t, disp: asize_t)

udt_type_data_t__get_best_fit_member(_this, disp) -> ssize_t

@param _this: udt_type_data_t const * @param disp: asize_t

def unpack_idcobj_from_bv(obj: idc_value_t *, tif: tinfo_t, bytes: bytevec_t const &, pio_flags: int = 0)

unpack_idcobj_from_bv(obj, tif, bytes, pio_flags=0) -> error_t Read a typed idc object from the byte vector.

@param obj: (C++: idc_value_t *) @param tif: (C++: const tinfo_t &) tinfo_t const & @param bytes: (C++: const bytevec_t &) bytevec_t const & @param pio_flags: (C++: int)

def unpack_idcobj_from_idb(obj: idc_value_t *, tif: tinfo_t, ea: ea_t, off0: bytevec_t const *, pio_flags: int = 0)

unpack_idcobj_from_idb(obj, tif, ea, off0, pio_flags=0) -> error_t Collection of register objects.

Read a typed idc object from the database

@param obj: (C++: idc_value_t ) @param tif: (C++: const tinfo_t &) tinfo_t const & @param ea: (C++: ea_t) @param off0: (C++: const bytevec_t ) bytevec_t const * @param pio_flags: (C++: int)

def unpack_object_from_bv(ti: til_t, type: type_t const *, fields: p_list const *, bytes: bytevec_t const &, pio_flags: int = 0)

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

@param ti: Type info. 'None' can be passed. @param type: type_t const * @param fields: fields string (may be empty or None) @param bytes: the bytes to unpack @param pio_flags: flags used while unpacking @return: - tuple(0, err) on failure - tuple(1, obj) on success

def unpack_object_from_idb(ti: til_t, type: type_t const *, fields: p_list const *, ea: ea_t, pio_flags: int = 0)

unpack_object_from_idb(ti, type, fields, ea, pio_flags=0) -> PyObject

@param ti: til_t * @param type: type_t const * @param fields: p_list const * @param ea: ea_t @param pio_flags: int

def use_golang_cc() ‑> bool

use_golang_cc() -> bool is GOLANG calling convention used by default?

def value_repr_t__from_opinfo(_this: value_repr_t, flags: flags64_t, afl: aflags_t, opinfo: opinfo_t, ap: array_parameters_t)

value_repr_t__from_opinfo(_this, flags, afl, opinfo, ap) -> bool

@param _this: value_repr_t * @param flags: flags64_t @param afl: aflags_t @param opinfo: opinfo_t const * @param ap: array_parameters_t const *

def value_repr_t__print_(_this: value_repr_t, colored: bool)

value_repr_t__print_(_this, colored) -> str

@param _this: value_repr_t const * @param colored: bool

def verify_argloc(vloc: argloc_t, size: int, gaps: rangeset_t)

verify_argloc(vloc, size, gaps) -> int Verify argloc_t.

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

def verify_tinfo(typid: typid_t)

verify_tinfo(typid) -> int

@param typid: typid_t

def visit_stroff_udms(sfv: udm_visitor_t, path: tid_t const *, disp: adiff_t *, appzero: bool)

visit_stroff_udms(sfv, path, disp, appzero) -> int Visit structure fields in a stroff expression or in a reference to a struct data variable. This function can be used to enumerate all components of an expression like 'a.b.c'.

@param sfv: (C++: udm_visitor_t &) visitor object @param path: (C++: const tid_t ) struct path (path[0] contains the initial struct id) @param disp: (C++: adiff_t ) offset into structure @param appzero: (C++: bool) should visit field at offset zero? @return: visitor result

def visit_subtypes(visitor: tinfo_visitor_t, out: type_mods_t, tif: tinfo_t, name: char const *, cmt: char const *)

visit_subtypes(visitor, out, tif, name, cmt) -> int

@param visitor: tinfo_visitor_t * @param out: type_mods_t * @param tif: tinfo_t const & @param name: char const * @param cmt: char const *

def write_tinfo_bitfield_value(typid: typid_t, dst: uint64, v: uint64, bitoff: int)

write_tinfo_bitfield_value(typid, dst, v, bitoff) -> uint64

@param typid: typid_t @param dst: uint64 @param v: uint64 @param bitoff: int

Classes

class aloc_visitor_t

Proxy of C++ aloc_visitor_t class.

init(self) -> aloc_visitor_t

@param self: PyObject *

Instance variables

var thisown

The membership flag

Methods

def visit_location(self, v: argloc_t, off: int, size: int) ‑> int

visit_location(self, v, off, size) -> int

@param v: argloc_t & @param off: int @param size: int

class argloc_t (*args)

Proxy of C++ argloc_t class.

init(self) -> argloc_t init(self, r) -> argloc_t

@param r: argloc_t const &

Subclasses

• vdloc_t
• argpart_t

Instance variables

var thisown

The membership flag

Methods

def advance(self, delta: int) ‑> bool

advance(self, delta) -> bool Move the location to point 'delta' bytes further.

@param delta: (C++: int)

def align_reg_high(self, size: size_t, _slotsize: size_t)

align_reg_high(self, size, _slotsize) Set register offset to align it to the upper part of _SLOTSIZE.

@param size: (C++: size_t) @param _slotsize: (C++: size_t)

def align_stkoff_high(self, size: size_t, _slotsize: size_t)

align_stkoff_high(self, size, _slotsize) Set stack offset to align to the upper part of _SLOTSIZE.

@param size: (C++: size_t) @param _slotsize: (C++: size_t)

def atype(self)

atype(self) -> argloc_type_t Get type (Argument location types)

def calc_offset(self)

calc_offset(self) -> sval_t Calculate offset that can be used to compare 2 similar arglocs.

def compare(self, r: argloc_t) ‑> int

compare(self, r) -> int

@param r: argloc_t const &

def consume_rrel(self, p: rrel_t)

consume_rrel(self, p) Set register-relative location - can't be nullptr.

@param p: (C++: rrel_t *)

def consume_scattered(self, p: scattered_aloc_t)

consume_scattered(self, p) Set distributed argument location.

@param p: (C++: scattered_aloc_t *) scattered_aloc_t const &

def get_biggest(self)

get_biggest(self) -> argloc_t::biggest_t Get largest element in internal union.

def get_custom(self)

get_custom(self) -> void * Get custom argloc info. Use if atype() == ALOC_CUSTOM

def get_ea(self)

get_ea(self) -> ea_t Get the global address. Use when atype() == ALOC_STATIC

def get_reginfo(self)

get_reginfo(self) -> uint32 Get all register info. Use when atype() == ALOC_REG1 or ALOC_REG2

def get_rrel(self, *args)

get_rrel(self) -> rrel_t Get register-relative info. Use when atype() == ALOC_RREL

def has_reg(self) ‑> bool

has_reg(self) -> bool TRUE if argloc has a register part.

def has_stkoff(self) ‑> bool

has_stkoff(self) -> bool TRUE if argloc has a stack part.

def in_stack(self) ‑> bool

in_stack(self) -> bool TRUE if argloc is in stack entirely.

def is_badloc(self) ‑> bool

is_badloc(self) -> bool See ALOC_NONE.

def is_custom(self) ‑> bool

is_custom(self) -> bool See ALOC_CUSTOM.

def is_ea(self) ‑> bool

is_ea(self) -> bool See ALOC_STATIC.

def is_fragmented(self) ‑> bool

is_fragmented(self) -> bool is_scattered() || is_reg2()

def is_mixed_scattered(self) ‑> bool

is_mixed_scattered(self) -> bool mixed scattered: consists of register and stack parts

def is_reg(self) ‑> bool

is_reg(self) -> bool is_reg1() || is_reg2()

def is_reg1(self) ‑> bool

is_reg1(self) -> bool See ALOC_REG1.

def is_reg2(self) ‑> bool

is_reg2(self) -> bool See ALOC_REG2.

def is_rrel(self) ‑> bool

is_rrel(self) -> bool See ALOC_RREL.

def is_scattered(self) ‑> bool

is_scattered(self) -> bool See ALOC_DIST.

def is_stkoff(self) ‑> bool

is_stkoff(self) -> bool See ALOC_STACK.

def reg1(self) ‑> int

reg1(self) -> int Get the register info. Use when atype() == ALOC_REG1 or ALOC_REG2

def reg2(self) ‑> int

reg2(self) -> int Get info for the second register. Use when atype() == ALOC_REG2

def regoff(self) ‑> int

regoff(self) -> int Get offset from the beginning of the register in bytes. Use when atype() == ALOC_REG1

def scattered(self, *args)

scattered(self) -> scattered_aloc_t Get scattered argument info. Use when atype() == ALOC_DIST

def set_badloc(self)

set_badloc(self) Set to invalid location.

def set_ea(self, _ea: ea_t)

set_ea(self, _ea) Set static ea location.

@param _ea: (C++: ea_t)

def set_reg1(self, reg: int, off: int = 0)

set_reg1(self, reg, off=0) Set register location.

@param reg: (C++: int) @param off: (C++: int)

def set_reg2(self, _reg1: int, _reg2: int)

set_reg2(self, _reg1, _reg2) Set secondary register location.

@param _reg1: (C++: int) @param _reg2: (C++: int)

def set_stkoff(self, off: sval_t)

set_stkoff(self, off) Set stack offset location.

@param off: (C++: sval_t)

def stkoff(self)

stkoff(self) -> sval_t Get the stack offset. Use if atype() == ALOC_STACK

def swap(self, r: argloc_t)

swap(self, r) Assign this == r and r == this.

@param r: (C++: argloc_t &)

class argpart_t (*args)

Proxy of C++ argpart_t class.

init(self, a) -> argpart_t

@param a: argloc_t const &

init(self) -> argpart_t

Ancestors

• argloc_t

Instance variables

var off : ushort

offset from the beginning of the argument

var size : ushort

the number of bytes

Methods

def bad_offset(self) ‑> bool

bad_offset(self) -> bool Does this argpart have a valid offset?

def bad_size(self) ‑> bool

bad_size(self) -> bool Does this argpart have a valid size?

def swap(self, r: argpart_t)

swap(self, r) Assign this = r and r = this.

@param r: (C++: argpart_t &)

Inherited members

• argloc_t:
  • advance
  • align_reg_high
  • align_stkoff_high
  • atype
  • calc_offset
  • compare
  • consume_rrel
  • consume_scattered
  • get_biggest
  • get_custom
  • get_ea
  • get_reginfo
  • get_rrel
  • has_reg
  • has_stkoff
  • in_stack
  • is_badloc
  • is_custom
  • is_ea
  • is_fragmented
  • is_mixed_scattered
  • is_reg
  • is_reg1
  • is_reg2
  • is_rrel
  • is_scattered
  • is_stkoff
  • reg1
  • reg2
  • regoff
  • scattered
  • set_badloc
  • set_ea
  • set_reg1
  • set_reg2
  • set_stkoff
  • stkoff
  • thisown

class argpartvec_t (*args)

Proxy of C++ qvector< argpart_t > class.

init(self) -> argpartvec_t init(self, x) -> argpartvec_t

@param x: qvector< argpart_t > const &

Subclasses

• scattered_aloc_t

Instance variables

var thisown

The membership flag

Methods

def add_unique(self, x: argpart_t) ‑> bool

add_unique(self, x) -> bool

@param x: argpart_t const &

def at(self, _idx: size_t)

at(self, _idx) -> argpart_t

@param _idx: size_t

def back(self)

def begin(self, *args)

begin(self) -> argpart_t

def capacity(self)

capacity(self) -> size_t

def clear(self)

clear(self)

def empty(self) ‑> bool

empty(self) -> bool

def end(self, *args)

end(self) -> argpart_t

def erase(self, *args)

erase(self, it) -> argpart_t

@param it: qvector< argpart_t >::iterator

erase(self, first, last) -> argpart_t

@param first: qvector< argpart_t >::iterator @param last: qvector< argpart_t >::iterator

def extract(self)

extract(self) -> argpart_t

def find(self, *args)

find(self, x) -> argpart_t

@param x: argpart_t const &

def front(self)

def grow(self, *args)

grow(self, x=argpart_t())

@param x: argpart_t const &

def has(self, x: argpart_t) ‑> bool

has(self, x) -> bool

@param x: argpart_t const &

def inject(self, s: argpart_t, len: size_t)

inject(self, s, len)

@param s: argpart_t * @param len: size_t

def insert(self, it: argpart_t, x: argpart_t)

insert(self, it, x) -> argpart_t

@param it: qvector< argpart_t >::iterator @param x: argpart_t const &

def pop_back(self)

pop_back(self)

def push_back(self, *args)

push_back(self, x)

@param x: argpart_t const &

push_back(self) -> argpart_t

def qclear(self)

qclear(self)

def reserve(self, cnt: size_t)

reserve(self, cnt)

@param cnt: size_t

def resize(self, *args)

resize(self, _newsize, x)

@param _newsize: size_t @param x: argpart_t const &

resize(self, _newsize)

@param _newsize: size_t

def size(self)

size(self) -> size_t

def swap(self, r: argpartvec_t)

swap(self, r)

@param r: qvector< argpart_t > &

def truncate(self)

truncate(self)

class argtinfo_helper_t

Proxy of C++ argtinfo_helper_t class.

init(self) -> argtinfo_helper_t

@param self: PyObject *

Instance variables

var reserved : size_t

reserved

var thisown

The membership flag

Methods

def has_delay_slot(self, arg0: ea_t)

has_delay_slot(self, arg0) -> bool The call instruction with a delay slot?.

@param arg0: ea_t

def is_stkarg_load(self, insn: insn_t const &, src: int *, dst: int *)

is_stkarg_load(self, insn, src, dst) -> bool Is the current insn a stkarg load?. if yes: * src: index of the source operand in insn_t::ops * dst: index of the destination operand in insn_t::ops insn_t::ops[dst].addr is expected to have the stack offset

@param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) @param src: (C++: int ) @param dst: (C++: int )

def set_op_tinfo(self, insn: insn_t const &, x: op_t const &, tif: tinfo_t, name: char const *)

set_op_tinfo(self, insn, x, tif, name) -> bool Set the operand type as specified.

@param insn: (C++: const insn_t &) an ida_ua.insn_t, or an address (C++: const insn_t &) @param x: (C++: const op_t &) op_t const & @param tif: (C++: const tinfo_t &) tinfo_t const & @param name: (C++: const char *) char const *

def use_arg_tinfos(self, caller: ea_t, fti: func_type_data_t, rargs: funcargvec_t)

use_arg_tinfos(self, caller, fti, rargs) This function is to be called by the processor module in response to ev_use_arg_types.

@param caller: (C++: ea_t) @param fti: (C++: func_type_data_t ) @param rargs: (C++: funcargvec_t )

class array_type_data_t (b: size_t = 0, n: size_t = 0)

Proxy of C++ array_type_data_t class.

init(self, b=0, n=0) -> array_type_data_t

@param b: size_t @param n: size_t

Instance variables

var base : uint32

array base

var elem_type : tinfo_t

element type

var nelems : uint32

number of elements

var thisown

The membership flag

Methods

def swap(self, r: array_type_data_t)

swap(self, r) set this = r and r = this

@param r: (C++: array_type_data_t &)

class bitfield_type_data_t

Proxy of C++ bitfield_type_data_t class.

init(self, _nbytes=0, _width=0, _is_unsigned=False) -> bitfield_type_data_t

@param _nbytes: uchar @param _width: uchar @param _is_unsigned: bool

Instance variables

var is_unsigned : bool

is bitfield unsigned?

var nbytes : uchar

enclosing type size (1,2,4,8 bytes)

var thisown

The membership flag

var width : uchar

number of bits

Methods

def compare(self, r: bitfield_type_data_t) ‑> int

compare(self, r) -> int

@param r: bitfield_type_data_t const &

def is_valid_bitfield(self) ‑> bool

is_valid_bitfield(self) -> bool

def swap(self, r: bitfield_type_data_t)

swap(self, r)

@param r: bitfield_type_data_t &

class callregs_t (*args)

Proxy of C++ callregs_t class.

init(self) -> callregs_t init(self, cc) -> callregs_t

@param cc: cm_t

Class variables

var FPREGS

var GPREGS

Static methods

def regcount(cc: cm_t)

regcount(cc) -> int Get max number of registers may be used in a function call.

@param cc: (C++: cm_t)

Instance variables

var fpregs : intvec_t

array of fp registers

var gpregs : intvec_t

array of gp registers

var nregs : int

max number of registers that can be used in a call

var policy : argreg_policy_t

argument policy

var thisown

The membership flag

Methods

def by_slots(self) ‑> bool

by_slots(self) -> bool

def init_regs(self, cc: cm_t)

init_regs(self, cc) Init policy & registers for given CC.

@param cc: (C++: cm_t)

def reginds(self, gp_ind: int *, fp_ind: int *, r: int)

reginds(self, gp_ind, fp_ind, r) -> bool Get register indexes within GP/FP arrays. (-1 -> is not present in the corresponding array)

@param gp_ind: (C++: int ) @param fp_ind: (C++: int ) @param r: (C++: int)

def reset(self)

reset(self) Set policy and registers to invalid values.

def set(self, _policy: argreg_policy_t, gprs: int const *, fprs: int const *)

set(self, _policy, gprs, fprs) Init policy & registers (arrays are -1-terminated)

@param _policy: (C++: argreg_policy_t) enum argreg_policy_t @param gprs: (C++: const int ) int const * @param fprs: (C++: const int ) int const *

def set_registers(self, kind: callregs_t::reg_kind_t, first_reg: int, last_reg: int)

set_registers(self, kind, first_reg, last_reg)

@param kind: enum callregs_t::reg_kind_t @param first_reg: int @param last_reg: int

def swap(self, r: callregs_t)

swap(self, r) swap two instances

@param r: (C++: callregs_t &)

class const_aloc_visitor_t

Proxy of C++ const_aloc_visitor_t class.

init(self) -> const_aloc_visitor_t

@param self: PyObject *

Instance variables

var thisown

The membership flag

Methods

def visit_location(self, v: argloc_t, off: int, size: int) ‑> int

visit_location(self, v, off, size) -> int

@param v: argloc_t const & @param off: int @param size: int

class custom_data_type_info_t

Proxy of C++ custom_data_type_info_t class.

init(self) -> custom_data_type_info_t

Instance variables

var dtid : int16

data type id

var fid : int16

data format ids

var thisown

The membership flag

class edm_t

Proxy of C++ edm_t class.

init(self) -> edm_t

Instance variables

var cmt : qstring

cmt

var name : qstring

name

var thisown

The membership flag

var value : uint64

value

Methods

def get_tid(self)

get_tid(self) -> tid_t

def swap(self, r: edm_t)

swap(self, r)

@param r: edm_t &

class enum_member_t

Proxy of C++ edm_t class.

init(self) -> edm_t

Instance variables

var cmt : qstring

cmt

var name : qstring

name

var thisown

The membership flag

var value : uint64

value

Methods

def get_tid(self)

get_tid(self) -> tid_t

def swap(self, r: edm_t)

swap(self, r)

@param r: edm_t &

class edmvec_t (*args)

Proxy of C++ qvector< edm_t > class.

init(self) -> edmvec_t init(self, x) -> edmvec_t

@param x: qvector< edm_t > const &

Subclasses

• enum_type_data_t

Instance variables

var thisown

The membership flag

Methods

def add_unique(self, x: edm_t) ‑> bool

add_unique(self, x) -> bool

@param x: edm_t const &

def at(self, _idx: size_t)

at(self, _idx) -> edm_t

@param _idx: size_t

def back(self)

def begin(self, *args)

begin(self) -> edm_t

def capacity(self)

capacity(self) -> size_t

def clear(self)

clear(self)

def empty(self) ‑> bool

empty(self) -> bool

def end(self, *args)

end(self) -> edm_t

def erase(self, *args)

erase(self, it) -> edm_t

@param it: qvector< edm_t >::iterator

erase(self, first, last) -> edm_t

@param first: qvector< edm_t >::iterator @param last: qvector< edm_t >::iterator

def extract(self)

extract(self) -> edm_t

def find(self, *args)

find(self, x) -> edm_t

@param x: edm_t const &

def front(self)

def grow(self, *args)

grow(self, x=edm_t())

@param x: edm_t const &

def has(self, x: edm_t) ‑> bool

has(self, x) -> bool

@param x: edm_t const &

def inject(self, s: edm_t, len: size_t)

inject(self, s, len)

@param s: edm_t * @param len: size_t

def insert(self, it: edm_t, x: edm_t)

insert(self, it, x) -> edm_t

@param it: qvector< edm_t >::iterator @param x: edm_t const &

def pop_back(self)

pop_back(self)

def push_back(self, *args)

push_back(self, x)

@param x: edm_t const &

push_back(self) -> edm_t

def qclear(self)

qclear(self)

def reserve(self, cnt: size_t)

reserve(self, cnt)

@param cnt: size_t

def resize(self, *args)

resize(self, _newsize, x)

@param _newsize: size_t @param x: edm_t const &

resize(self, _newsize)

@param _newsize: size_t

def size(self)

size(self) -> size_t

def swap(self, r: edmvec_t)

swap(self, r)

@param r: qvector< edm_t > &

def truncate(self)

truncate(self)

class enum_member_vec_t (*args)

Proxy of C++ qvector< edm_t > class.

init(self) -> edmvec_t init(self, x) -> edmvec_t

@param x: qvector< edm_t > const &

Subclasses

• enum_type_data_t

Instance variables

var thisown

The membership flag

Methods

def add_unique(self, x: edm_t) ‑> bool

add_unique(self, x) -> bool

@param x: edm_t const &

def at(self, _idx: size_t)

at(self, _idx) -> edm_t

@param _idx: size_t

def back(self)

def begin(self, *args)

begin(self) -> edm_t

def capacity(self)

capacity(self) -> size_t

def clear(self)

clear(self)

def empty(self) ‑> bool

empty(self) -> bool

def end(self, *args)

end(self) -> edm_t

def erase(self, *args)

erase(self, it) -> edm_t

@param it: qvector< edm_t >::iterator

erase(self, first, last) -> edm_t

@param first: qvector< edm_t >::iterator @param last: qvector< edm_t >::iterator

def extract(self)

extract(self) -> edm_t

def find(self, *args)

find(self, x) -> edm_t

@param x: edm_t const &

def front(self)

def grow(self, *args)

grow(self, x=edm_t())

@param x: edm_t const &

def has(self, x: edm_t) ‑> bool

has(self, x) -> bool

@param x: edm_t const &

def inject(self, s: edm_t, len: size_t)

inject(self, s, len)

@param s: edm_t * @param len: size_t

def insert(self, it: edm_t, x: edm_t)

insert(self, it, x) -> edm_t

@param it: qvector< edm_t >::iterator @param x: edm_t const &

def pop_back(self)

pop_back(self)

def push_back(self, *args)

push_back(self, x)

@param x: edm_t const &

push_back(self) -> edm_t

def qclear(self)

qclear(self)

def reserve(self, cnt: size_t)

reserve(self, cnt)

@param cnt: size_t

def resize(self, *args)

resize(self, _newsize, x)

@param _newsize: size_t @param x: edm_t const &

resize(self, _newsize)

@param _newsize: size_t

def size(self)

size(self) -> size_t

def swap(self, r: edmvec_t)

swap(self, r)

@param r: qvector< edm_t > &

def truncate(self)

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

@param _bte: bte_t

Ancestors

• edmvec_t

Instance variables

var bte : bte_t

enum member sizes (shift amount) and style. do not manually set BTE_BITMASK, use set_enum_is_bitmask()

var group_sizes : intvec_t

if present, specifies bitmask group sizes each non-trivial group starts with a mask member

var taenum_bits : uint32

Type attributes for enums

Methods

def add_constant(self, name: char const *, value: uint64, cmt: char const * = None)

add_constant(self, name, value, cmt=None) add constant for regular enum

@param name: (C++: const char ) char const * @param value: (C++: uint64) @param cmt: (C++: const char ) char const *

def all_constants(self)

Generate tupples of all constants except of bitmasks. Each tupple is: [0] constant index [1] enum member index of group start [2] group size In case of regular enum the second element of tupple is 0 and the third element of tupple is the number of enum members.

def all_groups(self, skip_trivial=False)

Generate tuples for bitmask enum groups. Each tupple is: [0] enum member index of group start [1] group size Tupples may include or not the group with 1 element.

def calc_mask(self)

calc_mask(self) -> uint64

def calc_nbytes(self) ‑> int

calc_nbytes(self) -> int get the width of enum in bytes

def find_member(self, *args)

find_member(self, name, _from=0, to=size_t(-1)) -> ssize_t find member (constant or bmask) by value

@param name: char const * @param from: (C++: size_t) @param to: (C++: size_t)

find_member(self, value, serial, _from=0, to=size_t(-1), vmask=uint64(-1)) -> ssize_t

@param value: uint64 @param serial: uchar @param from: size_t @param to: size_t @param vmask: uint64

def get_constant_group(self, *args)

get_constant_group(self, group_start_index, group_size, idx) -> bool get group parameters for the constant, valid for bitmask enum

@param group_start_index: (C++: size_t ) index of the group mask @param group_size: (C++: size_t ) group size (>=1) @param idx: (C++: size_t) constant index @return: success get_constant_group(self, idx) -> PyObject *

@param idx: size_t

def get_enum_radix(self) ‑> int

get_enum_radix(self) -> int Get enum constant radix

@return: radix or 1 for BTE_CHAR

def get_max_serial(self, value: uint64)

get_max_serial(self, value) -> uchar return the maximum serial for the value

@param value: (C++: uint64)

def get_serial(self, index: size_t)

get_serial(self, index) -> uchar returns serial for the constant

@param index: (C++: size_t)

def get_value_repr(self, repr: value_repr_t)

get_value_repr(self, repr) -> tinfo_code_t get enum radix and other representation info

@param repr: (C++: value_repr_t *) value display info

def has_lzero(self) ‑> bool

has_lzero(self) -> bool

def is_bf(self) ‑> bool

is_bf(self) -> bool is bitmask or ordinary enum?

def is_bin(self) ‑> bool

is_bin(self) -> bool

def is_char(self) ‑> bool

is_char(self) -> bool

def is_dec(self) ‑> bool

is_dec(self) -> bool

def is_group_mask_at(self, idx: size_t)

is_group_mask_at(self, idx) -> bool is the enum member at IDX a non-trivial group mask? a trivial group consist of one bit and has just one member, which can be considered as a mask or a bitfield constant

@param idx: (C++: size_t) index @return: success

def is_hex(self) ‑> bool

is_hex(self) -> bool

def is_number_signed(self) ‑> bool

is_number_signed(self) -> bool

def is_oct(self) ‑> bool

is_oct(self) -> bool

def is_sbin(self) ‑> bool

is_sbin(self) -> bool

def is_shex(self) ‑> bool

is_shex(self) -> bool

def is_soct(self) ‑> bool

is_soct(self) -> bool

def is_udec(self) ‑> bool

is_udec(self) -> bool

def is_valid_group_sizes(self) ‑> bool

is_valid_group_sizes(self) -> bool is valid group sizes

def set_enum_radix(self, radix: int, sign: bool)

set_enum_radix(self, radix, sign) Set radix to display constants

@param radix: (C++: int) radix with the special case 1 to display as character @param sign: (C++: bool)

def set_lzero(self, on: bool)

set_lzero(self, on)

@param on: bool

def set_nbytes(self, nbytes: int) ‑> bool

set_nbytes(self, nbytes) -> bool set enum width (nbytes)

@param nbytes: (C++: int)

def set_value_repr(self, repr: value_repr_t)

set_value_repr(self, repr) -> tinfo_code_t set enum radix and other representation info

@param repr: (C++: const value_repr_t &) value display info

def store_64bit_values(self) ‑> bool

store_64bit_values(self) -> bool

def swap(self, r: enum_type_data_t)

swap(self, r) swap two instances

@param r: (C++: enum_type_data_t &)

Inherited members

• edmvec_t:
  • add_unique
  • at
  • begin
  • capacity
  • clear
  • empty
  • end
  • erase
  • extract
  • find
  • grow
  • has
  • inject
  • insert
  • pop_back
  • push_back
  • qclear
  • reserve
  • resize
  • size
  • thisown
  • truncate

class func_type_data_t

Proxy of C++ func_type_data_t class.

init(self) -> func_type_data_t

Ancestors

• funcargvec_t

Instance variables

var cc : cm_t

calling convention

var flags : int

Function type data property bits

var retloc : argloc_t

return location

var rettype : tinfo_t

return type

var spoiled : reginfovec_t

spoiled register information. if spoiled register info is present, it overrides the standard spoil info (eax, edx, ecx for x86)

var stkargs : uval_t

size of stack arguments (not used in build_func_type)

Methods

def dump(self, praloc_bits: int = 2) ‑> bool

dump(self, praloc_bits=0x02) -> bool Dump information that is not always visible in the function prototype. (argument locations, return location, total stkarg size)

@param praloc_bits: (C++: int)

def find_argument(self, *args)

find_argument(self, name, _from=0, to=size_t(-1)) -> ssize_t find argument by name

@param name: (C++: const char *) char const * @param from: (C++: size_t) @param to: (C++: size_t)

def get_call_method(self) ‑> int

get_call_method(self) -> int

def guess_cc(self, purged: int, cc_flags: int)

guess_cc(self, purged, cc_flags) -> cm_t Guess function calling convention use the following info: argument locations and 'stkargs'

@param purged: (C++: int) @param cc_flags: (C++: int)

def is_const(self) ‑> bool

is_const(self) -> bool

def is_ctor(self) ‑> bool

is_ctor(self) -> bool

def is_dtor(self) ‑> bool

is_dtor(self) -> bool

def is_golang_cc(self) ‑> bool

is_golang_cc(self) -> bool

def is_high(self) ‑> bool

is_high(self) -> bool

def is_noret(self) ‑> bool

is_noret(self) -> bool

def is_pure(self) ‑> bool

is_pure(self) -> bool

def is_static(self) ‑> bool

is_static(self) -> bool

def is_swift_cc(self) ‑> bool

is_swift_cc(self) -> bool

def is_vararg_cc(self) ‑> bool

is_vararg_cc(self) -> bool

def is_virtual(self) ‑> bool

is_virtual(self) -> bool

def swap(self, r: func_type_data_t)

swap(self, r)

@param r: func_type_data_t &

Inherited members

• funcargvec_t:
  • add_unique
  • at
  • begin
  • capacity
  • clear
  • empty
  • end
  • erase
  • extract
  • find
  • grow
  • has
  • inject
  • insert
  • pop_back
  • push_back
  • qclear
  • reserve
  • resize
  • size
  • thisown
  • truncate

class funcarg_t

Proxy of C++ funcarg_t class.

init(self) -> funcarg_t

Instance variables

var argloc : argloc_t

argument location

var cmt : qstring

argument comment (may be empty)

var flags : uint32

Function argument property bits

var name : qstring

argument name (may be empty)

var thisown

The membership flag

var type : tinfo_t

argument type

class funcargvec_t (*args)

Proxy of C++ qvector< funcarg_t > class.

init(self) -> funcargvec_t init(self, x) -> funcargvec_t

@param x: qvector< funcarg_t > const &

Subclasses

• func_type_data_t

Instance variables

var thisown

The membership flag

Methods

def add_unique(self, x: funcarg_t) ‑> bool

add_unique(self, x) -> bool

@param x: funcarg_t const &

def at(self, _idx: size_t)

at(self, _idx) -> funcarg_t

@param _idx: size_t

def back(self)

def begin(self, *args)

begin(self) -> funcarg_t

def capacity(self)

capacity(self) -> size_t

def clear(self)

clear(self)

def empty(self) ‑> bool

empty(self) -> bool

def end(self, *args)

end(self) -> funcarg_t

def erase(self, *args)

erase(self, it) -> funcarg_t

@param it: qvector< funcarg_t >::iterator

erase(self, first, last) -> funcarg_t

@param first: qvector< funcarg_t >::iterator @param last: qvector< funcarg_t >::iterator

def extract(self)

extract(self) -> funcarg_t

def find(self, *args)

find(self, x) -> funcarg_t

@param x: funcarg_t const &

def front(self)

def grow(self, *args)

grow(self, x=funcarg_t())

@param x: funcarg_t const &

def has(self, x: funcarg_t) ‑> bool

has(self, x) -> bool

@param x: funcarg_t const &

def inject(self, s: funcarg_t, len: size_t)

inject(self, s, len)

@param s: funcarg_t * @param len: size_t

def insert(self, it: funcarg_t, x: funcarg_t)

insert(self, it, x) -> funcarg_t

@param it: qvector< funcarg_t >::iterator @param x: funcarg_t const &

def pop_back(self)

pop_back(self)

def push_back(self, *args)

push_back(self, x)

@param x: funcarg_t const &

push_back(self) -> funcarg_t

def qclear(self)

qclear(self)

def reserve(self, cnt: size_t)

reserve(self, cnt)

@param cnt: size_t

def resize(self, *args)

resize(self, _newsize, x)

@param _newsize: size_t @param x: funcarg_t const &

resize(self, _newsize)

@param _newsize: size_t

def size(self)

size(self) -> size_t

def swap(self, r: funcargvec_t)

swap(self, r)

@param r: qvector< funcarg_t > &

def truncate(self)

truncate(self)

class ida_lowertype_helper_t (_tif: tinfo_t, _ea: ea_t, _pb: int)

Proxy of C++ ida_lowertype_helper_t class.

init(self, _tif, _ea, _pb) -> ida_lowertype_helper_t

@param _tif: tinfo_t const & @param _ea: ea_t @param _pb: int

Ancestors

• lowertype_helper_t

Methods

def get_func_purged_bytes(self, candidate: tinfo_t, arg3: func_type_data_t) ‑> int

get_func_purged_bytes(self, candidate, arg3) -> int

@param candidate: tinfo_t const & @param arg3: func_type_data_t const &

Inherited members

• lowertype_helper_t:
  • func_has_stkframe_hole
  • thisown

class lowertype_helper_t (*args, **kwargs)

Proxy of C++ lowertype_helper_t class.

Subclasses

• ida_lowertype_helper_t

Instance variables

var thisown

The membership flag

Methods

def func_has_stkframe_hole(self, candidate: tinfo_t, candidate_data: func_type_data_t) ‑> bool

func_has_stkframe_hole(self, candidate, candidate_data) -> bool

@param candidate: tinfo_t const & @param candidate_data: func_type_data_t const &

def get_func_purged_bytes(self, candidate: tinfo_t, candidate_data: func_type_data_t) ‑> int

get_func_purged_bytes(self, candidate, candidate_data) -> int

@param candidate: tinfo_t const & @param candidate_data: func_type_data_t const &

class predicate_t

Proxy of C++ predicate_t class.

init(self) -> predicate_t

@param self: PyObject *

Instance variables

var thisown

The membership flag

Methods

def should_display(self, til: til_t, name: char const *, type: type_t const *, fields: p_list const *)

should_display(self, til, name, type, fields) -> bool

@param til: til_t const * @param name: char const * @param type: type_t const * @param fields: p_list const *

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

@param c: tinfo_t @param bps: uchar @param p: tinfo_t @param d: int32

Instance variables

var based_ptr_size : uchar

based_ptr_size

var closure : tinfo_t

cannot have both closure and based_ptr_size

var delta : int32

Offset from the beginning of the parent struct.

var obj_type : tinfo_t

pointed object type

var parent : tinfo_t

Parent struct.

var taptr_bits : uchar

TAH bits.

var thisown

The membership flag

Methods

def is_code_ptr(self) ‑> bool

is_code_ptr(self) -> bool Are we pointing to code?

def is_shifted(self) ‑> bool

is_shifted(self) -> bool

def swap(self, r: ptr_type_data_t)

swap(self, r) Set this = r and r = this.

@param r: (C++: ptr_type_data_t &)

class reginfovec_t (*args)

Proxy of C++ qvector< reg_info_t > class.

init(self) -> reginfovec_t init(self, x) -> reginfovec_t

@param x: qvector< reg_info_t > const &

Instance variables

var thisown

The membership flag

Methods

def add_unique(self, x: reg_info_t)

add_unique(self, x) -> bool

@param x: reg_info_t const &

def append(self, *args)

push_back(self, x)

@param x: reg_info_t const &

push_back(self) -> reg_info_t

def at(self, i: size_t)

getitem(self, i) -> reg_info_t

@param i: size_t

def back(self)

def begin(self, *args)

begin(self) -> reg_info_t

def capacity(self)

capacity(self) -> size_t

def clear(self)

clear(self)

def empty(self) ‑> bool

empty(self) -> bool

def end(self, *args)

end(self) -> reg_info_t

def erase(self, *args)

erase(self, it) -> reg_info_t

@param it: qvector< reg_info_t >::iterator

erase(self, first, last) -> reg_info_t

@param first: qvector< reg_info_t >::iterator @param last: qvector< reg_info_t >::iterator

def extract(self)

extract(self) -> reg_info_t

def find(self, *args)

find(self, x) -> reg_info_t

@param x: reg_info_t const &

def front(self)

def grow(self, *args)

grow(self, x=reg_info_t())

@param x: reg_info_t const &

def has(self, x: reg_info_t)

has(self, x) -> bool

@param x: reg_info_t const &

def inject(self, s: reg_info_t, len: size_t)

inject(self, s, len)

@param s: reg_info_t * @param len: size_t

def insert(self, it: reg_info_t, x: reg_info_t)

insert(self, it, x) -> reg_info_t

@param it: qvector< reg_info_t >::iterator @param x: reg_info_t const &

def pop_back(self)

pop_back(self)

def push_back(self, *args)

push_back(self, x)

@param x: reg_info_t const &

push_back(self) -> reg_info_t

def qclear(self)

qclear(self)

def reserve(self, cnt: size_t)

reserve(self, cnt)

@param cnt: size_t

def resize(self, *args)

resize(self, _newsize, x)

@param _newsize: size_t @param x: reg_info_t const &

resize(self, _newsize)

@param _newsize: size_t

def size(self)

size(self) -> size_t

def swap(self, r: reginfovec_t)

swap(self, r)

@param r: qvector< reg_info_t > &

def truncate(self)

truncate(self)

class regobj_t

Proxy of C++ regobj_t class.

init(self) -> regobj_t

Instance variables

var regidx : int

index into dbg->registers

var relocate : int

0-plain num, 1-must relocate

var thisown

The membership flag

var value : bytevec_t

value

Methods

def size(self)

size(self) -> size_t

class regobjs_t

Proxy of C++ regobjs_t class.

init(self) -> regobjs_t

Ancestors

• regobjvec_t

Inherited members

• regobjvec_t:
  • at
  • begin
  • capacity
  • clear
  • empty
  • end
  • erase
  • extract
  • grow
  • inject
  • insert
  • pop_back
  • push_back
  • qclear
  • reserve
  • resize
  • size
  • swap
  • thisown
  • truncate

class regobjvec_t (*args)

Proxy of C++ qvector< regobj_t > class.

init(self) -> regobjvec_t init(self, x) -> regobjvec_t

@param x: qvector< regobj_t > const &

Subclasses

• regobjs_t

Instance variables

var thisown

The membership flag

Methods

def at(self, _idx: size_t)

at(self, _idx) -> regobj_t

@param _idx: size_t

def back(self)

def begin(self, *args)

begin(self) -> regobj_t

def capacity(self)

capacity(self) -> size_t

def clear(self)

clear(self)

def empty(self) ‑> bool

empty(self) -> bool

def end(self, *args)

end(self) -> regobj_t

def erase(self, *args)

erase(self, it) -> regobj_t

@param it: qvector< regobj_t >::iterator

erase(self, first, last) -> regobj_t

@param first: qvector< regobj_t >::iterator @param last: qvector< regobj_t >::iterator

def extract(self)

extract(self) -> regobj_t

def front(self)

def grow(self, *args)

grow(self, x=regobj_t())

@param x: regobj_t const &

def inject(self, s: regobj_t, len: size_t)

inject(self, s, len)

@param s: regobj_t * @param len: size_t

def insert(self, it: regobj_t, x: regobj_t)

insert(self, it, x) -> regobj_t

@param it: qvector< regobj_t >::iterator @param x: regobj_t const &

def pop_back(self)

pop_back(self)

def push_back(self, *args)

push_back(self, x)

@param x: regobj_t const &

push_back(self) -> regobj_t

def qclear(self)

qclear(self)

def reserve(self, cnt: size_t)

reserve(self, cnt)

@param cnt: size_t

def resize(self, *args)

resize(self, _newsize, x)

@param _newsize: size_t @param x: regobj_t const &

resize(self, _newsize)

@param _newsize: size_t

def size(self)

size(self) -> size_t

def swap(self, r: regobjvec_t)

swap(self, r)

@param r: qvector< regobj_t > &

def truncate(self)

truncate(self)

class rrel_t

Proxy of C++ rrel_t class.

init(self) -> rrel_t

Instance variables

var off : sval_t

displacement from the address pointed by the register

var reg : int

register index (into ph.reg_names)

var thisown

The membership flag

class scattered_aloc_t

Proxy of C++ scattered_aloc_t class.

init(self) -> scattered_aloc_t

Ancestors

• argpartvec_t

Inherited members

• argpartvec_t:
  • add_unique
  • at
  • begin
  • capacity
  • clear
  • empty
  • end
  • erase
  • extract
  • find
  • grow
  • has
  • inject
  • insert
  • pop_back
  • push_back
  • qclear
  • reserve
  • resize
  • size
  • swap
  • thisown
  • truncate

class simd_info_t (*args)

Proxy of C++ simd_info_t class.

init(self, nm=None, sz=0, memt=BTF_UNK) -> simd_info_t

@param nm: char const * @param sz: uint16 @param memt: type_t

Instance variables

var memtype : type_t

member type BTF_INT8/16/32/64/128, BTF_UINT8/16/32/64/128 BTF_INT - integrals of any size/sign BTF_FLOAT, BTF_DOUBLE BTF_TBYTE - floatings of any size BTF_UNION - union of integral and floating types BTF_UNK - undefined

var name : char const *

name of SIMD type (nullptr-undefined)

var size : uint16

SIMD type size in bytes (0-undefined)

var thisown

The membership flag

var tif : tinfo_t

SIMD type (empty-undefined)

Methods

def match_pattern(self, pattern: simd_info_t) ‑> bool

match_pattern(self, pattern) -> bool

@param pattern: simd_info_t const *

class stkarg_area_info_t

Proxy of C++ stkarg_area_info_t class.

init(self) -> stkarg_area_info_t

Instance variables

var cb : size_t

cb

var linkage_area : sval_t

Size of the linkage area. explanations at: \link{https://www.ibm.com/docs/en/xl- fortran-aix/16.1.0?topic=conventions-linkage-area} examples: pc: 0, hppa: 0, ppc aix: 0x18 (equal to stkarg_offset)

var shadow_size : sval_t

Size of the shadow area. explanations at: \link{https://stackoverflow.com/questions/30190132/what-is-the-shadow-space- in-x64-assembly} examples: x64 Visual Studio C++: 0x20, x64 gcc: 0, ppc aix: 0x20

var stkarg_offset : sval_t

Offset from the SP to the first stack argument (can include linkage area) examples: pc: 0, hppa: -0x34, ppc aix: 0x18

var thisown

The membership flag

class text_sink_t

Proxy of C++ text_sink_t class.

init(self) -> text_sink_t

@param self: PyObject *

Instance variables

var thisown

The membership flag

class til_symbol_t (n: char const * = None, t: til_t = None)

Proxy of C++ til_symbol_t class.

init(self, n=None, t=None) -> til_symbol_t

@param n: char const * @param t: til_t const *

Instance variables

var name : char const *

symbol name

var thisown

The membership flag

var til : til_t const *

pointer to til

class til_t

Proxy of C++ til_t class.

init(self) -> til_t

Instance variables

var cc : compiler_info_t

information about the target compiler

var desc : char *

human readable til description

var flags : uint32

Type info library property bits

var name : char *

short file name (without path and extension)

var nbases : int

number of base tils

var nrefs : int

number of references to the til

var nstreams : int

number of extra streams

var streams : til_stream_t **

symbol stream storage

var thisown

The membership flag

var type_names

Methods

def base(self, n: int)

base(self, n) -> til_t tils that our til is based on

@param n: int

def find_base(self, n: char const *)

find_base(self, n) -> til_t Find the base til with the provided name

@param n: (C++: const char *) the base til name @return: the found til_t, or nullptr

def get_type_names(self)

def is_dirty(self) ‑> bool

is_dirty(self) -> bool Has the til been modified? (TIL_MOD)

def set_dirty(self)

set_dirty(self) Mark the til as modified (TIL_MOD)

class til_type_ref_t

Proxy of C++ til_type_ref_t class.

init(self) -> til_type_ref_t

Instance variables

var bf_bitoff : int

bf_bitoff

var bucket_start : uint64

bucket_start

var cb : size_t

cb

var cursor : tif_cursor_t

cursor

var edm : edm_t

BTF_ENUM: the current enum member.

var fa : funcarg_t const *

BT_FUNC: the current argument, nullptr - ellipsis.

var is_detached : bool

is_detached

var is_forward : bool

is_forward

var is_writable : bool

is_writable

var kind : type_t

kind

var last_udm_offset : uint64

last_udm_offset

var memidx : ssize_t

memidx

var nmembers : size_t

nmembers

var offset : uint64

offset

var ordinal : uint32

ordinal

var thisown

The membership flag

var tif : tinfo_t

tif

var total_size : size_t

total_size

var udm : udm_t

BTF_STRUCT or BTF_UNION: the current member.

var unpadded_size : size_t

unpadded_size

Methods

def clear(self)

clear(self)

def is_enum(self) ‑> bool

is_enum(self) -> bool

def is_func(self) ‑> bool

is_func(self) -> bool

def is_struct(self) ‑> bool

is_struct(self) -> bool

def is_typedef(self) ‑> bool

is_typedef(self) -> bool

def is_udt(self) ‑> bool

is_udt(self) -> bool

def is_union(self) ‑> bool

is_union(self) -> bool

def on_member(self) ‑> bool

on_member(self) -> bool

class tinfo_t (*args)

Proxy of C++ tinfo_t class.

init(self) -> tinfo_t init(self, decl_type) -> tinfo_t

@param decl_type: type_t

init(self, r) -> tinfo_t

@param r: tinfo_t const &

Class variables

var ENUMBM_AUTO

convert to bitmask if the outcome is nice and useful

var ENUMBM_OFF

convert to ordinal enum

var ENUMBM_ON

convert to bitmask enum

Static methods

def get_stock(id: stock_type_id_t)

get_stock(id) -> tinfo_t Get stock type information. This function can be used to get tinfo_t for some common types. The same tinfo_t will be returned for the same id, thus saving memory and increasing the speed Please note that retrieving the STI_SIZE_T or STI_SSIZE_T stock type, will also have the side-effect of adding that type to the 'idati' TIL, under the well-known name 'size_t' or 'ssize_t' (respectively). The same is valid for STI_COMPLEX64 and STI_COMPLEX64 stock types with names 'complex64_t' and 'complex128_t' (respectively).

@param id: (C++: stock_type_id_t) enum stock_type_id_t

Instance variables

var thisown

The membership flag

Methods

def add_edm(self, *args)

add_edm(self, edm, bmask=bmask64_t(-1), etf_flags=0, idx=-1) -> tinfo_code_t Add a new enum member (a new symbolic constant)

@param edm: (C++: const edm_t &) the constant name, value, and comment @param bmask: (C++: bmask64_t) bmask of the group to add the constant to @note: 1. For non-bitmask enum push back constant, BMASK is not used (set it ot -1), never failed 2. For bitmask enum: * if VAL and BMASK are not agreed, return TERR_BAD_MSKVAL * if group with BMASK exists, push back constant to group * otherwise use constant as bitmask for a new group @note: ETF_NO_SAVE is ignored

def add_funcarg(self, farg: funcarg_t, etf_flags: uint = 0, idx: ssize_t = -1)

add_funcarg(self, farg, etf_flags=0, idx=-1) -> tinfo_code_t Add a function argument.

@param farg: (C++: const funcarg_t &) argument to add @param etf_flags: (C++: uint) type changing flags flags @param idx: (C++: ssize_t) the index in the funcarg array where the new funcarg should be placed. if the specified index cannot be honored because it would spoil the funcarg sorting order, it is silently ignored. @note: ETF_NO_SAVE is ignored

def add_udm(self, udm: udm_t, etf_flags: uint = 0, times: size_t = 1, idx: ssize_t = -1)

add_udm(self, udm, etf_flags=0, times=1, idx=-1) -> tinfo_code_t Add a structure/union member.

@param udm: (C++: const udm_t &) member to add @param etf_flags: (C++: uint) type changing flags flags @param times: (C++: size_t) how many times to add. if times > 1, the member name will be appended a suffix like "_2" and so on @param idx: (C++: ssize_t) the index in the udm array where the new udm should be placed. if the specified index cannot be honored because it would spoil the udm sorting order, it is silently ignored. @note: ETF_NO_SAVE is ignored

def append_covered(self, out: rangeset_t, offset: uint64 = 0)

append_covered(self, out, offset=0) -> bool Calculate set of covered bytes for the type

@param out: (C++: rangeset_t *) pointer to the output buffer. covered bytes will be appended to it. @param offset: (C++: uint64) delta in bytes to add to all calculations. used internally during recurion.

def calc_enum_mask(self)

calc_enum_mask(self) -> uint64

def calc_gaps(self, out: rangeset_t)

calc_gaps(self, out) -> bool Calculate set of padding bytes for the type

@param out: (C++: rangeset_t *) pointer to the output buffer; old buffer contents will be lost.

def calc_purged_bytes(self) ‑> int

calc_purged_bytes(self) -> int

def calc_score(self)

calc_score(self) -> uint32 Calculate the type score (the higher - the nicer is the type)

def calc_udt_aligns(self, sudt_flags: int = 4) ‑> bool

calc_udt_aligns(self, sudt_flags=0x0004) -> bool Calculate the udt alignments using the field offsets/sizes and the total udt size This function does not work on typerefs

@param sudt_flags: (C++: int)

def change_sign(self, sign: type_sign_t)

change_sign(self, sign) -> bool Change the type sign. Works only for the types that may have sign.

@param sign: (C++: type_sign_t)

def clear(self)

clear(self) Clear contents of this tinfo, and remove from the type system.

def clr_const(self) ‑> bool

clr_const(self) -> bool

def clr_const_volatile(self) ‑> bool

clr_const_volatile(self) -> bool

def clr_decl_const_volatile(self)

clr_decl_const_volatile(self)

def clr_volatile(self) ‑> bool

clr_volatile(self) -> bool

def compare(self, r: tinfo_t) ‑> int

compare(self, r) -> int

@param r: tinfo_t const &

def compare_with(self, r: tinfo_t, tcflags: int = 0) ‑> bool

compare_with(self, r, tcflags=0) -> bool Compare two types, based on given flags (see tinfo_t comparison flags)

@param r: (C++: const tinfo_t &) tinfo_t const & @param tcflags: (C++: int)

def convert_array_to_ptr(self) ‑> bool

convert_array_to_ptr(self) -> bool Convert an array into a pointer. type[] => type *

def copy(self) ‑> tinfo_t

copy(self) -> tinfo_t

def copy_type(self, *args)

copy_type(self, til, name, ntf_flags=0x0001|0x1000) -> tinfo_code_t

@param til: til_t * @param name: char const * @param ntf_flags: int

def create_array(self, *args) ‑> bool

create_array(self, p, decl_type=BT_ARRAY) -> bool

@param p: array_type_data_t const & @param decl_type: type_t

create_array(self, tif, nelems=0, base=0, decl_type=BT_ARRAY) -> bool

@param tif: tinfo_t const & @param nelems: uint32 @param base: uint32 @param decl_type: type_t

def create_bitfield(self, *args) ‑> bool

create_bitfield(self, p, decl_type=BT_BITFIELD) -> bool

@param p: bitfield_type_data_t const & @param decl_type: type_t

create_bitfield(self, nbytes, width, is_unsigned=False, decl_type=BT_BITFIELD) -> bool

@param nbytes: uchar @param width: uchar @param is_unsigned: bool @param decl_type: type_t

def create_enum(self, *args) ‑> bool

create_enum(self, p, decl_type=BTF_ENUM) -> bool

@param p: enum_type_data_t & @param decl_type: type_t

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

create_forward_decl(self, til, decl_type, name, ntf_flags=0) -> tinfo_code_t Create a forward declaration. decl_type: BTF_STRUCT, BTF_UNION, or BTF_ENUM

@param til: (C++: til_t ) @param decl_type: (C++: type_t) @param name: (C++: const char ) char const * @param ntf_flags: (C++: int)

def create_func(self, *args) ‑> bool

create_func(self, p, decl_type=BT_FUNC) -> bool

@param p: func_type_data_t & @param decl_type: type_t

def create_ptr(self, *args) ‑> bool

create_ptr(self, p, decl_type=BT_PTR) -> bool

@param p: ptr_type_data_t const & @param decl_type: type_t

create_ptr(self, tif, bps=0, decl_type=BT_PTR) -> bool

@param tif: tinfo_t const & @param bps: uchar @param decl_type: type_t

def create_simple_type(self, decl_type: type_t)

create_simple_type(self, decl_type) -> bool

@param decl_type: type_t

def create_typedef(self, *args)

create_typedef(self, p, decl_type=BTF_TYPEDEF, try_ordinal=True) -> bool

@param p: typedef_type_data_t const & @param decl_type: type_t @param try_ordinal: bool

create_typedef(self, til, name, decl_type=BTF_TYPEDEF, try_ordinal=True)

@param til: til_t const * @param name: char const * @param decl_type: type_t @param try_ordinal: bool

create_typedef(self, til, ord, decl_type=BTF_TYPEDEF)

@param til: til_t const * @param ord: uint @param decl_type: type_t

def create_udt(self, *args) ‑> bool

create_udt(self, p) -> bool

@param p: udt_type_data_t &

create_udt(self, p, decl_type) -> bool

@param p: udt_type_data_t & @param decl_type: type_t

def del_attr(self, key: qstring const &, make_copy: bool = True)

del_attr(self, key, make_copy=True) -> bool Del a type attribute. typerefs cannot be modified by this function.

@param key: (C++: const qstring &) qstring const & @param make_copy: (C++: bool)

def del_attrs(self)

del_attrs(self) Del all type attributes. typerefs cannot be modified by this function.

def del_edm(self, idx: size_t, etf_flags: uint = 0)

del_edm(self, idx, etf_flags=0) -> tinfo_code_t

@param idx: size_t @param etf_flags: uint

def del_edms(self, idx1: size_t, idx2: size_t, etf_flags: uint = 0)

del_edms(self, idx1, idx2, etf_flags=0) -> tinfo_code_t Delete enum members

@param idx1: (C++: size_t) index in edmvec_t @param idx2: (C++: size_t) index in edmvec_t or size_t(-1) @param etf_flags: (C++: uint) etf_flag_t Delete enum members in [idx1, idx2) @note: For bitmask enum, the first member of a non-trivial group (having 2 or more members) is considered as a group mask. It is impossible to delete the group mask of a non-trivial group, other members of the group must be deleted first. Empty groups are automatically deleted.

def del_funcarg(self, idx: size_t, etf_flags: uint = 0)

del_funcarg(self, idx, etf_flags=0) -> tinfo_code_t

@param idx: size_t @param etf_flags: uint

def del_funcargs(self, idx1: size_t, idx2: size_t, etf_flags: uint = 0)

del_funcargs(self, idx1, idx2, etf_flags=0) -> tinfo_code_t Delete function arguments

@param idx1: (C++: size_t) index in funcargvec_t @param idx2: (C++: size_t) index in funcargvec_t or size_t(-1) @param etf_flags: (C++: uint) etf_flag_t Delete function arguments in [idx1, idx2)

def del_udm(self, index: size_t, etf_flags: uint = 0)

del_udm(self, index, etf_flags=0) -> tinfo_code_t Delete a structure/union member.

@param index: (C++: size_t) @param etf_flags: (C++: uint)

def del_udms(self, idx1: size_t, idx2: size_t, etf_flags: uint = 0)

del_udms(self, idx1, idx2, etf_flags=0) -> tinfo_code_t Delete structure/union members in the range [idx1, idx2)

@param idx1: (C++: size_t) @param idx2: (C++: size_t) @param etf_flags: (C++: uint)

def deserialize(self, *args) ‑> bool

deserialize(self, til, ptype, pfields=None, pfldcmts=None, cmt=None) -> bool Deserialize a type string into a tinfo_t object.

@param til: (C++: const til_t ) til_t const * @param ptype: (C++: const qtype ) type_t const ** @param pfields: (C++: const qtype ) p_list const ** @param pfldcmts: (C++: const qtype ) p_list const ** @param cmt: (C++: const char *) char const *

deserialize(self, til, type, fields, cmts=None) -> bool

@param til: til_t const * @param type: type_t const * @param fields: p_list const * @param cmts: p_list const *

def detach(self) ‑> bool

detach(self) -> bool Detach tinfo_t from the underlying type. After calling this finction, tinfo_t will lose its link to the underlying named or numbered type (if any) and will become a reference to a unique type. After that, any modifications to tinfo_t will affect only its type.

def dstr(self)

dstr(self) -> char const * Function to facilitate debugging.

def edit_edm(self, *args)

edit_edm(self, idx, value, bmask=bmask64_t(-1), etf_flags=0) -> tinfo_code_t Change constant value and/or bitmask

@param idx: (C++: size_t) index in edmvec_t @param value: (C++: uint64) old or new value @param bmask: (C++: bmask64_t) old or new bitmask @note: if new bitmask is specified the index of constant may be changed

def empty(self) ‑> bool

empty(self) -> bool Was tinfo_t initialized with some type info or not?

def equals_to(self, r: tinfo_t) ‑> bool

equals_to(self, r) -> bool

@param r: tinfo_t const &

def expand_udt(self, idx: size_t, delta: adiff_t, etf_flags: uint = 0)

expand_udt(self, idx, delta, etf_flags=0) -> tinfo_code_t Expand/shrink a structure by adding/removing a gap before the specified member.

@param idx: (C++: size_t) index of the member @param delta: (C++: adiff_t) number of bytes to add or remove @param etf_flags: (C++: uint) etf_flag_t Please note that it is impossible to add a gap at the very end of a structure. However, adding before a regular member is possible. This function can be used to remove gaps in the middle of a structure by specifying a negative delta value. @note: It is possible to add/remove a gap at the end of a fixed structure. Use IDX equal to the number of members for that.

def find_edm(self, *args)

find_edm(self, edm, value, bmask=bmask64_t(-1), serial=0) -> ssize_t Find enum member

@param edm: (C++: edm_t *) enum type member, may be nullptr @param value: uint64 @param bmask: bmask64_t @return: member index, otherwise returns -1. find_edm(self, edm, name) -> ssize_t

@param edm: edm_t * @param name: char const *

def find_udm(self, *args) ‑> int

find_udm(self, udm, strmem_flags) -> int BTF_STRUCT,BTF_UNION: Find an udt member by name

@param udm: udm_t * @param strmem_flags: (C++: int)

@return: the index of the found member or -1 find_udm(self, offset, strmem_flags=0) -> int

@param offset: uint64 @param strmem_flags: int

find_udm(self, name, strmem_flags=0) -> int

@param name: char const * @param strmem_flags: int

def find_udt_member(self, *args) ‑> int

find_udm(self, udm, strmem_flags) -> int BTF_STRUCT,BTF_UNION: Find an udt member by name

@param udm: udm_t * @param strmem_flags: (C++: int)

@return: the index of the found member or -1 find_udm(self, offset, strmem_flags=0) -> int

@param offset: uint64 @param strmem_flags: int

find_udm(self, name, strmem_flags=0) -> int

@param name: char const * @param strmem_flags: int

def force_tid(self)

force_tid(self) -> tid_t Get the type tid. Create if it does not exist yet. If the type comes from a base til, the type will be copied to the local til and a new tid will be created for it. (if the type comes from a base til, it does not have a tid yet). If the type comes from the local til, this function is equivalent to get_tid()

@return: tid or BADADDR

def get_alias_target(self)

get_alias_target(self) -> uint32 Get type alias If the type has no alias, return 0.

def get_array_details(self, ai: array_type_data_t) ‑> bool

get_array_details(self, ai) -> bool Get the array specific info.

@param ai: (C++: array_type_data_t *)

def get_array_element(self) ‑> tinfo_t

get_array_element(self) -> tinfo_t

def get_array_nelems(self) ‑> int

get_array_nelems(self) -> int

def get_attr(self, key: qstring const &, all_attrs: bool = True)

get_attr(self, key, all_attrs=True) -> PyObject Get a type attribute.

@param key: (C++: const qstring &) qstring const & @param all_attrs: (C++: bool)

def get_attrs(self, tav: type_attrs_t, all_attrs: bool = False) ‑> bool

get_attrs(self, tav, all_attrs=False) -> bool Get type attributes (all_attrs: include attributes of referenced types, if any)

@param tav: (C++: type_attrs_t *) @param all_attrs: (C++: bool)

def get_bit_buckets(self, buckets: range64vec_t)

get_bit_buckets(self, buckets) -> bool ::BT_STRUCT: get bit buckets Bit buckets are used to layout bitfields

@param buckets: (C++: range64vec_t *) @return: false if wrong type was passed

def get_bitfield_details(self, bi: bitfield_type_data_t) ‑> bool

get_bitfield_details(self, bi) -> bool Get the bitfield specific info.

@param bi: (C++: bitfield_type_data_t *)

def get_declalign(self)

get_declalign(self) -> uchar Get declared alignment of the type.

def get_decltype(self)

get_decltype(self) -> type_t Get declared type (without resolving type references; they are returned as is). Obviously this is a very fast function and should be used instead of get_realtype() if possible. Please note that for typerefs this function will return BTF_TYPEDEF. To determine if a typeref is a typedef, use is_typedef()

def get_edm(self, edm: edm_t, idx: size_t)

get_edm(self, edm, idx) -> tinfo_code_t Get enum member

@param edm: (C++: edm_t *) enum type member @param idx: (C++: size_t) enum member index

def get_edm_by_name(self, mname: char const *, til: til_t = None)

get_edm_by_name(self, mname, til=None) -> ssize_t Retrieve enum tinfo using enum member name

@param mname: (C++: const char ) enum type member name @param til: (C++: const til_t ) type library @return: member index, otherwise returns -1. If the function fails, THIS object becomes empty.

def get_edm_by_tid(self, edm: edm_t, tid: tid_t)

get_edm_by_tid(self, edm, tid) -> ssize_t

@param edm: edm_t * @param tid: tid_t

def get_edm_tid(self, idx: size_t)

get_edm_tid(self, idx) -> tid_t Get enum member TID

@param idx: (C++: size_t) enum member index @return: tid or BADADDR The tid is used to collect xrefs to the member, it can be passed to xref-related functions instead of the address.

def get_enum_base_type(self)

get_enum_base_type(self) -> type_t Get enum base type (convert enum to integer type) Returns BT_UNK if failed to convert

def get_enum_details(self, ei: enum_type_data_t) ‑> bool

get_enum_details(self, ei) -> bool Get the enum specific info.

@param ei: (C++: enum_type_data_t *)

def get_enum_nmembers(self)

get_enum_nmembers(self) -> size_t Get number of enum members.

@return: BADSIZE if error

def get_enum_radix(self) ‑> int

get_enum_radix(self) -> int Get enum constant radix

@return: radix or 1 for BTE_CHAR enum_type_data_t::get_enum_radix()

def get_enum_repr(self, repr: value_repr_t)

get_enum_repr(self, repr) -> tinfo_code_t Set the representation of enum members.

@param repr: (C++: value_repr_t *) value_repr_t

def get_enum_width(self) ‑> int

get_enum_width(self) -> int Get enum width

@return: width of enum base type in bytes, 0 - unspecified, or -1 enum_type_data_t::calc_nbytes()

def get_final_element(self) ‑> tinfo_t

get_final_element(self) -> tinfo_t repeat recursively: if an array, return the type of its element; else return the type itself.

def get_final_ordinal(self)

get_final_ordinal(self) -> uint32 Get final type ordinal (0 if none)

def get_final_type_name(self) ‑> bool

get_final_type_name(self) -> bool Use in the case of typedef chain (TYPE1 -> TYPE2 -> TYPE3…TYPEn).

@return: the name of the last type in the chain (TYPEn). if there is no chain, returns TYPE1

def get_forward_type(self)

get_forward_type(self) -> type_t Get type of a forward declaration. For a forward declaration this function returns its base type. In other cases it returns BT_UNK

def get_frame_func(self)

get_frame_func(self) -> ea_t Get function address for the frame.

def get_func_details(self, fi: func_type_data_t, gtd: gtd_func_t = 0)

get_func_details(self, fi, gtd=GTD_CALC_ARGLOCS) -> bool Get only the function specific info for this tinfo_t.

@param fi: (C++: func_type_data_t *) @param gtd: (C++: gtd_func_t) enum gtd_func_t

def get_func_frame(self, pfn: func_t const *)

get_func_frame(self, pfn) -> bool Create a tinfo_t object for the function frame

@param pfn: (C++: const func_t *) function

def get_innermost_member_type(self, bitoffset: uint64)

get_innermost_member_type(self, bitoffset) -> tinfo_t Get the innermost member type at the given offset

@param bitoffset: (C++: uint64) bit offset into the structure @retval the: innermost member type

def get_innermost_udm(self, bitoffset: uint64)

get_innermost_udm(self, bitoffset) -> tinfo_t Get the innermost member at the given offset

@param bitoffset: (C++: uint64) bit offset into the structure @retval udt: with the innermost member @retval empty: type if it is not a struct type or OFFSET could not be found

def get_methods(self, methods: udtmembervec_t) ‑> bool

get_methods(self, methods) -> bool

@param BT_COMPLEX: get a list of member functions declared in this udt. @return: false if no member functions exist

def get_modifiers(self)

get_modifiers(self) -> type_t

def get_named_type(self, *args) ‑> bool

get_named_type(self, til, name, decl_type=BTF_TYPEDEF, resolve=True, try_ordinal=True) -> bool

@param til: til_t const * @param name: char const * @param decl_type: type_t @param resolve: bool @param try_ordinal: bool

get_named_type(self, name, decl_type=BTF_TYPEDEF, resolve=True, try_ordinal=True) -> bool

@param name: char const * @param decl_type: type_t @param resolve: bool @param try_ordinal: bool

def get_nargs(self) ‑> int

get_nargs(self) -> int BT_FUNC or BT_PTR BT_FUNC: Calculate number of arguments (-1 - error)

def get_next_type_name(self) ‑> bool

get_next_type_name(self) -> bool Use In the case of typedef chain (TYPE1 -> TYPE2 -> TYPE3…TYPEn).

@return: the name of the next type in the chain (TYPE2). if there is no chain, returns failure

def get_nice_type_name(self) ‑> bool

get_nice_type_name(self) -> bool Get the beautified type name. Get the referenced name and apply regular expressions from goodname.cfg to beautify the name

def get_nth_arg(self, n: int) ‑> tinfo_t

get_nth_arg(self, n) -> tinfo_t BT_FUNC or BT_PTR BT_FUNC: Get type of n-th arg (-1 means return type, see get_rettype())

@param n: (C++: int)

def get_numbered_type(self, *args) ‑> bool

get_numbered_type(self, til, ordinal, decl_type=BTF_TYPEDEF, resolve=True) -> bool

@param til: til_t const * @param ordinal: uint32 @param decl_type: type_t @param resolve: bool

get_numbered_type(self, ordinal, decl_type=BTF_TYPEDEF, resolve=True) -> bool

@param ordinal: uint32 @param decl_type: type_t @param resolve: bool

def get_onemember_type(self) ‑> tinfo_t

get_onemember_type(self) -> tinfo_t For objects consisting of one member entirely: return type of the member.

def get_ordinal(self)

get_ordinal(self) -> uint32 Get type ordinal (only if the type was created as a numbered type, 0 if none)

def get_pointed_object(self) ‑> tinfo_t

get_pointed_object(self) -> tinfo_t

def get_ptr_details(self, pi: ptr_type_data_t) ‑> bool

get_ptr_details(self, pi) -> bool Get the pointer info.

@param pi: (C++: ptr_type_data_t *)

def get_ptrarr_object(self) ‑> tinfo_t

get_ptrarr_object(self) -> tinfo_t BT_PTR & BT_ARRAY: get the pointed object or array element. If the current type is not a pointer or array, return empty type info.

def get_ptrarr_objsize(self) ‑> int

get_ptrarr_objsize(self) -> int BT_PTR & BT_ARRAY: get size of pointed object or array element. On error returns -1

def get_realtype(self, full: bool = False)

get_realtype(self, full=False) -> type_t Get the resolved base type. Deserialization options: * if full=true, the referenced type will be deserialized fully, this may not always be desirable (slows down things) * if full=false, we just return the base type, the referenced type will be resolved again later if necessary (this may lead to multiple resolvings of the same type) imho full=false is a better approach because it does not perform unnecessary actions just in case. however, in some cases the caller knows that it is very likely that full type info will be required. in those cases full=true makes sense

@param full: (C++: bool)

def get_rettype(self) ‑> tinfo_t

get_rettype(self) -> tinfo_t BT_FUNC or BT_PTR BT_FUNC: Get the function's return type

def get_sign(self)

get_sign(self) -> type_sign_t Get type sign.

def get_size(self, p_effalign: uint32 * = None, gts_code: int = 0)

get_size(self, p_effalign=None, gts_code=0) -> size_t Get the type size in bytes.

@param p_effalign: (C++: uint32 *) buffer for the alignment value @param gts_code: (C++: int) combination of GTS_… constants @return: BADSIZE in case of problems

def get_stkvar(self, insn: insn_t const &, x: op_t const, v: sval_t)

get_stkvar(self, insn, x, v) -> ssize_t Retrieve frame tinfo for a stack variable

@param insn: (C++: const insn_t &) the instruction @param x: (C++: const op_t *) reference to instruction operand, may be nullptr @param v: (C++: sval_t) immediate value in the operand (usually x.addr) @return: returns the member index, otherwise returns -1. if the function fails, THIS object becomes empty.

def get_tid(self)

get_tid(self) -> tid_t Get the type tid Each type in the local type library has a so-called tid associated with it. The tid is used to collect xrefs to the type. The tid is created when the type is created in the local type library and does not change afterwards. It can be passed to xref-related functions instead of the address.

@return: tid or BADADDR @note: types that do not come from a type library (that exist only in the memory) can not have a tid.

def get_til(self)

get_til(self) -> til_t Get the type library for tinfo_t.

def get_type_by_tid(self, tid: tid_t)

get_type_by_tid(self, tid) -> bool

@param tid: tid_t

def get_type_cmt(self) ‑> int

get_type_cmt(self) -> int Get type comment

@return: 0-failed, 1-returned regular comment, 2-returned repeatable comment

def get_type_name(self) ‑> bool

get_type_name(self) -> bool Does a type refer to a name?. If yes, fill the provided buffer with the type name and return true. Names are returned for numbered types too: either a user- defined nice name or, if a user-provided name does not exist, an ordinal name (like #xx, see create_numbered_type_name()).

def get_type_rptcmt(self) ‑> bool

get_type_rptcmt(self) -> bool Get type comment only if it is repeatable.

def get_udm_by_tid(self, udm: udm_t, tid: tid_t)

get_udm_by_tid(self, udm, tid) -> ssize_t Retrive tinfo using type TID or struct/enum member MID

@param udm: (C++: udm_t *) [out]: place to save the found member to, may be nullptr @param tid: (C++: tid_t) tid can denote a type tid or a member tid. @return: if a member tid was specified, returns the member index, otherwise returns -1. if the function fails, THIS object becomes empty.

def get_udm_tid(self, idx: size_t)

get_udm_tid(self, idx) -> tid_t Get udt member TID

@param idx: (C++: size_t) the index of udt the member @return: tid or BADADDR The tid is used to collect xrefs to the member, it can be passed to xref-related functions instead of the address.

def get_udt_details(self, udt: udt_type_data_t, gtd: gtd_udt_t = 0)

get_udt_details(self, udt, gtd=GTD_CALC_LAYOUT) -> bool Get the udt specific info.

@param udt: (C++: udt_type_data_t *) @param gtd: (C++: gtd_udt_t) enum gtd_udt_t

def get_udt_nmembers(self) ‑> int

get_udt_nmembers(self) -> int Get number of udt members. -1-error.

def get_unpadded_size(self)

get_unpadded_size(self) -> size_t Get the type size in bytes without the final padding, in bytes. For some UDTs get_unpadded_size() != get_size()

def has_details(self) ‑> bool

has_details(self) -> bool Does this type refer to a nontrivial type?

def has_union(self) ‑> bool

has_union(self) -> bool Has a member of type "union"?

def has_vftable(self) ‑> bool

has_vftable(self) -> bool Has a vftable?

def is_aliased(self) ‑> bool

is_aliased(self) -> bool

def is_anonymous_udt(self) ‑> bool

is_anonymous_udt(self) -> bool Is an anonymous struct/union? We assume that types with names are anonymous if the name starts with $

def is_arithmetic(self) ‑> bool

is_arithmetic(self) -> bool is_type_arithmetic(get_realtype())

def is_array(self) ‑> bool

is_array(self) -> bool is_type_array(get_realtype())

def is_bitfield(self) ‑> bool

is_bitfield(self) -> bool is_type_bitfld(get_realtype())

def is_bitmask_enum(self) ‑> bool

is_bitmask_enum(self) -> bool Is bitmask enum?

@return: true for bitmask enum and false in other cases enum_type_data_t::is_bf()

def is_bool(self) ‑> bool

is_bool(self) -> bool is_type_bool(get_realtype())

def is_castable_to(self, target: tinfo_t) ‑> bool

is_castable_to(self, target) -> bool

@param target: tinfo_t const &

def is_char(self) ‑> bool

is_char(self) -> bool is_type_char(get_realtype())

def is_complex(self) ‑> bool

is_complex(self) -> bool is_type_complex(get_realtype())

def is_const(self) ‑> bool

is_const(self) -> bool is_type_const(get_realtype())

def is_correct(self) ‑> bool

is_correct(self) -> bool Is the type object correct?. It is possible to create incorrect types. For example, we can define a function that returns an enum and then delete the enum type. If this function returns false, the type should not be used in disassembly. Please note that this function does not verify all involved types: for example, pointers to undefined types are permitted.

def is_decl_array(self) ‑> bool

is_decl_array(self) -> bool is_type_array(get_decltype())

def is_decl_bitfield(self) ‑> bool

is_decl_bitfield(self) -> bool is_type_bitfld(get_decltype())

def is_decl_bool(self) ‑> bool

is_decl_bool(self) -> bool is_type_bool(get_decltype())

def is_decl_char(self) ‑> bool

is_decl_char(self) -> bool is_type_char(get_decltype())

def is_decl_complex(self) ‑> bool

is_decl_complex(self) -> bool is_type_complex(get_decltype())

def is_decl_const(self) ‑> bool

is_decl_const(self) -> bool is_type_const(get_decltype())

def is_decl_double(self) ‑> bool

is_decl_double(self) -> bool is_type_double(get_decltype())

def is_decl_enum(self) ‑> bool

is_decl_enum(self) -> bool is_type_enum(get_decltype())

def is_decl_float(self) ‑> bool

is_decl_float(self) -> bool is_type_float(get_decltype())

def is_decl_floating(self) ‑> bool

is_decl_floating(self) -> bool is_type_floating(get_decltype())

def is_decl_func(self) ‑> bool

is_decl_func(self) -> bool is_type_func(get_decltype())

def is_decl_int(self) ‑> bool

is_decl_int(self) -> bool is_type_int(get_decltype())

def is_decl_int128(self) ‑> bool

is_decl_int128(self) -> bool is_type_int128(get_decltype())

def is_decl_int16(self) ‑> bool

is_decl_int16(self) -> bool is_type_int16(get_decltype())

def is_decl_int32(self) ‑> bool

is_decl_int32(self) -> bool is_type_int32(get_decltype())

def is_decl_int64(self) ‑> bool

is_decl_int64(self) -> bool is_type_int64(get_decltype())

def is_decl_last(self) ‑> bool

is_decl_last(self) -> bool is_typeid_last(get_decltype())

def is_decl_ldouble(self) ‑> bool

is_decl_ldouble(self) -> bool is_type_ldouble(get_decltype())

def is_decl_paf(self) ‑> bool

is_decl_paf(self) -> bool is_type_paf(get_decltype())

def is_decl_partial(self) ‑> bool

is_decl_partial(self) -> bool is_type_partial(get_decltype())

def is_decl_ptr(self) ‑> bool

is_decl_ptr(self) -> bool is_type_ptr(get_decltype())

def is_decl_struct(self) ‑> bool

is_decl_struct(self) -> bool is_type_struct(get_decltype())

def is_decl_sue(self) ‑> bool

is_decl_sue(self) -> bool is_type_sue(get_decltype())

def is_decl_tbyte(self) ‑> bool

is_decl_tbyte(self) -> bool is_type_tbyte(get_decltype())

def is_decl_typedef(self) ‑> bool

is_decl_typedef(self) -> bool is_type_typedef(get_decltype())

def is_decl_uchar(self) ‑> bool

is_decl_uchar(self) -> bool is_type_uchar(get_decltype())

def is_decl_udt(self) ‑> bool

is_decl_udt(self) -> bool is_type_struni(get_decltype())

def is_decl_uint(self) ‑> bool

is_decl_uint(self) -> bool is_type_uint(get_decltype())

def is_decl_uint128(self) ‑> bool

is_decl_uint128(self) -> bool is_type_uint128(get_decltype())

def is_decl_uint16(self) ‑> bool

is_decl_uint16(self) -> bool is_type_uint16(get_decltype())

def is_decl_uint32(self) ‑> bool

is_decl_uint32(self) -> bool is_type_uint32(get_decltype())

def is_decl_uint64(self) ‑> bool

is_decl_uint64(self) -> bool is_type_uint64(get_decltype())

def is_decl_union(self) ‑> bool

is_decl_union(self) -> bool is_type_union(get_decltype())

def is_decl_unknown(self) ‑> bool

is_decl_unknown(self) -> bool is_type_unknown(get_decltype())

def is_decl_void(self) ‑> bool

is_decl_void(self) -> bool is_type_void(get_decltype())

def is_decl_volatile(self) ‑> bool

is_decl_volatile(self) -> bool is_type_volatile(get_decltype())

def is_double(self) ‑> bool

is_double(self) -> bool is_type_double(get_realtype())

def is_empty_enum(self) ‑> bool

is_empty_enum(self) -> bool Is an empty enum? (has no constants)

def is_empty_udt(self) ‑> bool

is_empty_udt(self) -> bool Is an empty struct/union? (has no fields)

def is_enum(self) ‑> bool

is_enum(self) -> bool is_type_enum(get_realtype())

def is_ext_arithmetic(self) ‑> bool

is_ext_arithmetic(self) -> bool is_type_ext_arithmetic(get_realtype())

def is_ext_integral(self) ‑> bool

is_ext_integral(self) -> bool is_type_ext_integral(get_realtype())

def is_fixed_struct(self) ‑> bool

is_fixed_struct(self) -> bool Is a structure with fixed offsets?

def is_float(self) ‑> bool

is_float(self) -> bool is_type_float(get_realtype())

def is_floating(self) ‑> bool

is_floating(self) -> bool is_type_floating(get_realtype())

def is_forward_decl(self) ‑> bool

is_forward_decl(self) -> bool Is this a forward declaration?. Forward declarations are placeholders: the type definition does not exist

def is_forward_enum(self) ‑> bool

is_forward_enum(self) -> bool

def is_forward_struct(self) ‑> bool

is_forward_struct(self) -> bool

def is_forward_union(self) ‑> bool

is_forward_union(self) -> bool

def is_frame(self) ‑> bool

is_frame(self) -> bool Is a function frame?

def is_from_subtil(self) ‑> bool

is_from_subtil(self) -> bool Was the named type found in some base type library (not the top level type library)?. If yes, it usually means that the type comes from some loaded type library, not the local type library for the database

def is_func(self) ‑> bool

is_func(self) -> bool is_type_func(get_realtype())

def is_funcptr(self) ‑> bool

is_funcptr(self) -> bool Is this pointer to a function?

def is_high_func(self) ‑> bool

is_high_func(self) -> bool

def is_int(self) ‑> bool

is_int(self) -> bool is_type_int(get_realtype())

def is_int128(self) ‑> bool

is_int128(self) -> bool is_type_int128(get_realtype())

def is_int16(self) ‑> bool

is_int16(self) -> bool is_type_int16(get_realtype())

def is_int32(self) ‑> bool

is_int32(self) -> bool is_type_int32(get_realtype())

def is_int64(self) ‑> bool

is_int64(self) -> bool is_type_int64(get_realtype())

def is_integral(self) ‑> bool

is_integral(self) -> bool is_type_integral(get_realtype())

def is_ldouble(self) ‑> bool

is_ldouble(self) -> bool is_type_ldouble(get_realtype())

def is_manually_castable_to(self, target: tinfo_t) ‑> bool

is_manually_castable_to(self, target) -> bool

@param target: tinfo_t const &

def is_one_fpval(self) ‑> bool

is_one_fpval(self) -> bool Floating value or an object consisting of one floating member entirely.

def is_paf(self) ‑> bool

is_paf(self) -> bool is_type_paf(get_realtype())

def is_partial(self) ‑> bool

is_partial(self) -> bool is_type_partial(get_realtype())

def is_ptr(self) ‑> bool

is_ptr(self) -> bool is_type_ptr(get_realtype())

def is_ptr_or_array(self) ‑> bool

is_ptr_or_array(self) -> bool is_type_ptr_or_array(get_realtype())

def is_punknown(self) ‑> bool

is_punknown(self) -> bool Is "_UNKNOWN *"?. This function does not check the pointer attributes and type modifiers.

def is_purging_cc(self) ‑> bool

is_purging_cc(self) -> bool is_purging_cc(get_cc())

def is_pvoid(self) ‑> bool

is_pvoid(self) -> bool Is "void *"?. This function does not check the pointer attributes and type modifiers.

def is_scalar(self) ‑> bool

is_scalar(self) -> bool Does the type represent a single number?

def is_shifted_ptr(self) ‑> bool

is_shifted_ptr(self) -> bool Is a shifted pointer?

def is_signed(self) ‑> bool

is_signed(self) -> bool Is this a signed type?

def is_small_udt(self) ‑> bool

is_small_udt(self) -> bool Is a small udt? (can fit a register or a pair of registers)

def is_sse_type(self) ‑> bool

is_sse_type(self) -> bool Is a SSE vector type?

def is_struct(self) ‑> bool

is_struct(self) -> bool is_type_struct(get_realtype())

def is_sue(self) ‑> bool

is_sue(self) -> bool is_type_sue(get_realtype())

def is_tbyte(self) ‑> bool

is_tbyte(self) -> bool is_type_tbyte(get_realtype())

def is_typedef(self) ‑> bool

is_typedef(self) -> bool Is this a typedef?. This function will return true for a reference to a local type that is declared as a typedef.

def is_typeref(self) ‑> bool

is_typeref(self) -> bool Is this type a type reference?.

def is_uchar(self) ‑> bool

is_uchar(self) -> bool is_type_uchar(get_realtype())

def is_udm_by_til(self, idx: size_t)

is_udm_by_til(self, idx) -> bool Was the member created due to the type system

@param idx: (C++: size_t) index of the member

def is_udt(self) ‑> bool

is_udt(self) -> bool is_type_struni(get_realtype())

def is_uint(self) ‑> bool

is_uint(self) -> bool is_type_uint(get_realtype())

def is_uint128(self) ‑> bool

is_uint128(self) -> bool is_type_uint128(get_realtype())

def is_uint16(self) ‑> bool

is_uint16(self) -> bool is_type_uint16(get_realtype())

def is_uint32(self) ‑> bool

is_uint32(self) -> bool is_type_uint32(get_realtype())

def is_uint64(self) ‑> bool

is_uint64(self) -> bool is_type_uint64(get_realtype())

def is_union(self) ‑> bool

is_union(self) -> bool is_type_union(get_realtype())

def is_unknown(self) ‑> bool

is_unknown(self) -> bool is_type_unknown(get_realtype())

def is_unsigned(self) ‑> bool

is_unsigned(self) -> bool Is this an unsigned type?

def is_user_cc(self) ‑> bool

is_user_cc(self) -> bool is_user_cc(get_cc())

def is_vararg_cc(self) ‑> bool

is_vararg_cc(self) -> bool is_vararg_cc(get_cc())

def is_varmember(self) ‑> bool

is_varmember(self) -> bool Can the type be of a variable struct member? This function checks for: is_array() && array.nelems==0 Such a member can be only the very last member of a structure

def is_varstruct(self) ‑> bool

is_varstruct(self) -> bool Is a variable-size structure?

def is_vftable(self) ‑> bool

is_vftable(self) -> bool Is a vftable type?

def is_void(self) ‑> bool

is_void(self) -> bool is_type_void(get_realtype())

def is_volatile(self) ‑> bool

is_volatile(self) -> bool is_type_volatile(get_realtype())

def is_well_defined(self) ‑> bool

is_well_defined(self) -> bool !(empty()) && !(is_decl_partial()) && !(is_punknown())

def parse(self, decl: char const *, til: til_t = None, pt_flags: int = 0)

parse(self, decl, til=None, pt_flags=0) -> bool Convenience function to parse a string with a type declaration

@param decl: (C++: const char ) a type declaration @param til: (C++: til_t ) type library to use @param pt_flags: (C++: int) combination of Type parsing flags bits

def present(self) ‑> bool

present(self) -> bool Is the type really present? (not a reference to a missing type, for example)

def read_bitfield_value(self, v: uint64, bitoff: int)

read_bitfield_value(self, v, bitoff) -> uint64

@param v: uint64 @param bitoff: int

def remove_ptr_or_array(self) ‑> bool

remove_ptr_or_array(self) -> bool Replace the current type with the ptr obj or array element. This function performs one of the following conversions: * type[] => type * type* => type If the conversion is performed successfully, return true

def rename_edm(self, idx: size_t, name: char const *, etf_flags: uint = 0)

rename_edm(self, idx, name, etf_flags=0) -> tinfo_code_t Rename a enum member

@param idx: (C++: size_t) index in edmvec_t @param name: (C++: const char *) new name @param etf_flags: (C++: uint) etf_flag_t ETF_FORCENAME may be used in case of TERR_ALIEN_NAME @note: ETF_NO_SAVE is ignored

def rename_funcarg(self, index: size_t, name: char const *, etf_flags: uint = 0)

rename_funcarg(self, index, name, etf_flags=0) -> tinfo_code_t Rename a function argument. The new name must be unique.

@param index: (C++: size_t) argument index in the function array @param name: (C++: const char *) new name @param etf_flags: (C++: uint) etf_flag_t @note: ETF_NO_SAVE is ignored

def rename_type(self, name: char const *, ntf_flags: int = 0)

rename_type(self, name, ntf_flags=0) -> tinfo_code_t Rename a type

@param name: (C++: const char *) new type name @param ntf_flags: (C++: int) Flags for named types @note: The change is saved immediately

def rename_udm(self, index: size_t, name: char const *, etf_flags: uint = 0)

rename_udm(self, index, name, etf_flags=0) -> tinfo_code_t Rename a structure/union member. The new name must be unique. @note: ETF_NO_SAVE is ignored

@param index: (C++: size_t) @param name: (C++: const char *) char const * @param etf_flags: (C++: uint)

def requires_qualifier(self, name: char const *, offset: uint64)

requires_qualifier(self, name, offset) -> bool Requires full qualifier? (name is not unique)

@param name: (C++: const char *) field name @param offset: (C++: uint64) field offset in bits @return: if the name is not unique, returns true

def save_type(self, *args)

save_type(self, ntf_flags=0x0001|0x0004) -> tinfo_code_t

@param ntf_flags: int

def serialize(self, *args)

serialize(self, sudt_flags=SUDT_FAST|SUDT_TRUNC) -> PyObject Serialize tinfo_t object into a type string.

@param sudt_flags: (C++: int)

def set_attr(self, ta: type_attr_t, may_overwrite: bool = True) ‑> bool

set_attr(self, ta, may_overwrite=True) -> bool Set a type attribute. If necessary, a new typid will be created.

@param ta: (C++: const type_attr_t &) type_attr_t const & @param may_overwrite: (C++: bool)

def set_attrs(self, tav: type_attrs_t) ‑> bool

set_attrs(self, tav) -> bool Set type attributes. If necessary, a new typid will be created. this function modifies tav! (returns old attributes, if any)

@param tav: (C++: type_attrs_t *) @return: false: bad attributes

def set_const(self)

set_const(self)

def set_declalign(self, declalign: uchar)

set_declalign(self, declalign) -> bool

@param declalign: uchar

def set_edm_cmt(self, idx: size_t, cmt: char const *, etf_flags: uint = 0)

set_edm_cmt(self, idx, cmt, etf_flags=0) -> tinfo_code_t Set a comment for an enum member. Such comments are always considered as repeatable.

@param idx: (C++: size_t) index in edmvec_t @param cmt: (C++: const char *) comment @param etf_flags: (C++: uint) etf_flag_t

def set_enum_is_bitmask(self, *args)

set_enum_is_bitmask(self, stance=ENUMBM_ON, etf_flags=0) -> tinfo_code_t

@param stance: enum tinfo_t::bitmask_cvt_stance_t @param etf_flags: uint

def set_enum_radix(self, radix: int, sign: bool, etf_flags: uint = 0)

set_enum_radix(self, radix, sign, etf_flags=0) -> tinfo_code_t Set enum radix to display constants

@param radix: (C++: int) radix 2, 4, 8, 16, with the special case 1 to display as character @param sign: (C++: bool) display as signed or unsigned @param etf_flags: (C++: uint) etf_flag_t

def set_enum_repr(self, repr: value_repr_t, etf_flags: uint = 0)

set_enum_repr(self, repr, etf_flags=0) -> tinfo_code_t Set the representation of enum members.

@param repr: (C++: const value_repr_t &) value_repr_t @param etf_flags: (C++: uint) etf_flag_t

def set_enum_sign(self, sign: type_sign_t, etf_flags: uint = 0)

set_enum_sign(self, sign, etf_flags=0) -> tinfo_code_t Set enum sign

@param sign: (C++: type_sign_t) @param etf_flags: (C++: uint) etf_flag_t

def set_enum_width(self, nbytes: int, etf_flags: uint = 0)

set_enum_width(self, nbytes, etf_flags=0) -> tinfo_code_t Set the width of enum base type

@param nbytes: (C++: int) width of enum base type, allowed values: 0 (unspecified),1,2,4,8,16,32,64 @param etf_flags: (C++: uint) etf_flag_t

def set_fixed_struct(self, on: bool = True)

set_fixed_struct(self, on=True) -> tinfo_code_t Declare struct member offsets as fixed. For such structures, IDA will not recalculate the member offsets. If a member does not fit into its place anymore, it will be deleted. This function works only with structures (not unions).

@param on: (C++: bool)

def set_func_cc(self, cc: cm_t, etf_flags: uint = 0)

set_func_cc(self, cc, etf_flags=0) -> tinfo_code_t Set function calling convention.

@param cc: (C++: cm_t) @param etf_flags: (C++: uint)

def set_func_retloc(self, argloc: argloc_t, etf_flags: uint = 0)

set_func_retloc(self, argloc, etf_flags=0) -> tinfo_code_t Set location of function return value.

@param argloc: (C++: const argloc_t &) new location for the return value @param etf_flags: (C++: uint) etf_flag_t @return: tinfo_code_t

def set_func_rettype(self, tif: tinfo_t, etf_flags: uint = 0)

set_func_rettype(self, tif, etf_flags=0) -> tinfo_code_t Set function return type .

@param tif: (C++: const tinfo_t &) new type for the return type @param etf_flags: (C++: uint) etf_flag_t @return: tinfo_code_t

def set_funcarg_loc(self, index: size_t, argloc: argloc_t, etf_flags: uint = 0)

set_funcarg_loc(self, index, argloc, etf_flags=0) -> tinfo_code_t Set location of a function argument.

@param index: (C++: size_t) argument index in the function array @param argloc: (C++: const argloc_t &) new location for the argument @param etf_flags: (C++: uint) etf_flag_t @return: tinfo_code_t

def set_funcarg_type(self, index: size_t, tif: tinfo_t, etf_flags: uint = 0)

set_funcarg_type(self, index, tif, etf_flags=0) -> tinfo_code_t Set type of a function argument.

@param index: (C++: size_t) argument index in the function array @param tif: (C++: const tinfo_t &) new type for the argument @param etf_flags: (C++: uint) etf_flag_t @return: tinfo_code_t

def set_methods(self, methods: udtmembervec_t) ‑> bool

set_methods(self, methods) -> bool

@param BT_COMPLEX: set the list of member functions. This function consumes 'methods' (makes it empty). @return: false if this type is not a udt, or if the given list is empty

def set_modifiers(self, mod: type_t)

set_modifiers(self, mod)

@param mod: type_t

def set_named_type(self, til: til_t, name: char const *, ntf_flags: int = 0)

set_named_type(self, til, name, ntf_flags=0) -> tinfo_code_t

@param til: til_t * @param name: char const * @param ntf_flags: int

def set_numbered_type(self, til: til_t, ord: uint32, ntf_flags: int = 0, name: char const * = None)

set_numbered_type(self, til, ord, ntf_flags=0, name=None) -> tinfo_code_t

@param til: til_t * @param ord: uint32 @param ntf_flags: int @param name: char const *

def set_struct_size(self, new_size: size_t)

set_struct_size(self, new_size) -> tinfo_code_t Explicitly specify the struct size. This function works only with fixed structures. The new struct size can be equal or higher the unpadded struct size (IOW, all existing members should fit into the specified size).

@param new_size: (C++: size_t) new structure size in bytes

def set_symbol_type(self, til: til_t, name: char const *, ntf_flags: int = 0)

set_symbol_type(self, til, name, ntf_flags=0) -> tinfo_code_t

@param til: til_t * @param name: char const * @param ntf_flags: int

def set_type_alias(self, dest_ord: uint32)

set_type_alias(self, dest_ord) -> bool Set type alias Redirects all references to source type to the destination type. This is equivalent to instantaneous replacement all references to srctype by dsttype.

@param dest_ord: (C++: uint32)

def set_type_alignment(self, declalign: uchar, etf_flags: uint = 0)

set_type_alignment(self, declalign, etf_flags=0) -> tinfo_code_t Set type alignment.

@param declalign: (C++: uchar) @param etf_flags: (C++: uint)

def set_type_cmt(self, cmt: char const *, is_regcmt: bool = False, etf_flags: uint = 0)

set_type_cmt(self, cmt, is_regcmt=False, etf_flags=0) -> tinfo_code_t Set type comment This function works only for non-trivial types

@param cmt: (C++: const char *) char const * @param is_regcmt: (C++: bool) @param etf_flags: (C++: uint)

def set_udm_by_til(self, idx: size_t, on: bool = True, etf_flags: uint = 0)

set_udm_by_til(self, idx, on=True, etf_flags=0) -> tinfo_code_t The member is created due to the type system

@param idx: (C++: size_t) index of the member @param on: (C++: bool) @param etf_flags: (C++: uint) etf_flag_t

def set_udm_cmt(self, index: size_t, cmt: char const *, is_regcmt: bool = False, etf_flags: uint = 0)

set_udm_cmt(self, index, cmt, is_regcmt=False, etf_flags=0) -> tinfo_code_t Set a comment for a structure/union member. A member may have just one comment, and it is either repeatable or regular.

@param index: (C++: size_t) @param cmt: (C++: const char *) char const * @param is_regcmt: (C++: bool) @param etf_flags: (C++: uint)

def set_udm_repr(self, index: size_t, repr: value_repr_t, etf_flags: uint = 0)

set_udm_repr(self, index, repr, etf_flags=0) -> tinfo_code_t Set the representation of a structure/union member.

@param index: (C++: size_t) @param repr: (C++: const value_repr_t &) value_repr_t const & @param etf_flags: (C++: uint)

def set_udm_type(self, index: size_t, tif: tinfo_t, etf_flags: uint = 0, repr: value_repr_t = None)

set_udm_type(self, index, tif, etf_flags=0, repr=None) -> tinfo_code_t Set type of a structure/union member.

@param index: (C++: size_t) member index in the udm array @param tif: (C++: const tinfo_t &) new type for the member @param etf_flags: (C++: uint) etf_flag_t @param repr: (C++: const value_repr_t *) new representation for the member (optional) @return: tinfo_code_t

def set_udt_alignment(self, sda: int, etf_flags: uint = 0)

set_udt_alignment(self, sda, etf_flags=0) -> tinfo_code_t Set declared structure alignment (sda) This alignment supersedes the alignment returned by get_declalign() and is really used when calculating the struct layout. However, the effective structure alignment may differ from sda because of packing. The type editing functions (they accept etf_flags) may overwrite this attribute.

@param sda: (C++: int) @param etf_flags: (C++: uint)

def set_udt_pack(self, pack: int, etf_flags: uint = 0)

set_udt_pack(self, pack, etf_flags=0) -> tinfo_code_t Set structure packing. The value controls how little a structure member alignment can be. Example: if pack=1, then it is possible to align a double to a byte. attribute((aligned(1))) double x; However, if pack=3, a double will be aligned to 8 (2**3) even if requested to be aligned to a byte. pack==0 will have the same effect. The type editing functions (they accept etf_flags) may overwrite this attribute.

@param pack: (C++: int) @param etf_flags: (C++: uint)

def set_volatile(self)

set_volatile(self)

def swap(self, r: tinfo_t)

swap(self, r) Assign this = r and r = this.

@param r: (C++: tinfo_t &)

def write_bitfield_value(self, dst: uint64, v: uint64, bitoff: int)

write_bitfield_value(self, dst, v, bitoff) -> uint64

@param dst: uint64 @param v: uint64 @param bitoff: int

class tinfo_visitor_t (s: int = 0)

Proxy of C++ tinfo_visitor_t class.

init(self, s=0) -> tinfo_visitor_t

@param s: int

Instance variables

var state : int

tinfo visitor states

var thisown

The membership flag

Methods

def apply_to(self, tif: tinfo_t, out: type_mods_t = None, name: char const * = None, cmt: char const * = None)

apply_to(self, tif, out=None, name=None, cmt=None) -> int Call this function to initiate the traversal.

@param tif: (C++: const tinfo_t &) tinfo_t const & @param out: (C++: type_mods_t ) @param name: (C++: const char ) char const * @param cmt: (C++: const char *) char const *

def prune_now(self)

prune_now(self) To refuse to visit children of the current type, use this:

def visit_type(self, out: type_mods_t, tif: tinfo_t, name: char const *, cmt: char const *)

visit_type(self, out, tif, name, cmt) -> int Visit a subtype. this function must be implemented in the derived class. it may optionally fill out with the new type info. this can be used to modify types (in this case the 'out' argument of apply_to() may not be nullptr) return 0 to continue the traversal. return !=0 to stop the traversal.

@param out: (C++: type_mods_t ) @param tif: (C++: const tinfo_t &) tinfo_t const & @param name: (C++: const char ) char const * @param cmt: (C++: const char *) char const *

class type_attr_t

Proxy of C++ type_attr_t class.

init(self) -> type_attr_t

Instance variables

var key : qstring

one symbol keys are reserved to be used by the kernel the ones starting with an underscore are reserved too

var thisown

The membership flag

var value : bytevec_t

attribute bytes

class type_attrs_t (*args)

Proxy of C++ qvector< type_attr_t > class.

init(self) -> type_attrs_t init(self, x) -> type_attrs_t

@param x: qvector< type_attr_t > const &

Instance variables

var thisown

The membership flag

Methods

def at(self, _idx: size_t)

at(self, _idx) -> type_attr_t

@param _idx: size_t

def back(self)

def begin(self, *args)

begin(self) -> type_attr_t

def capacity(self)

capacity(self) -> size_t

def clear(self)

clear(self)

def empty(self) ‑> bool

empty(self) -> bool

def end(self, *args)

end(self) -> type_attr_t

def erase(self, *args)

erase(self, it) -> type_attr_t

@param it: qvector< type_attr_t >::iterator

erase(self, first, last) -> type_attr_t

@param first: qvector< type_attr_t >::iterator @param last: qvector< type_attr_t >::iterator

def extract(self)

extract(self) -> type_attr_t

def front(self)

def grow(self, *args)

grow(self, x=type_attr_t())

@param x: type_attr_t const &

def inject(self, s: type_attr_t, len: size_t)

inject(self, s, len)

@param s: type_attr_t * @param len: size_t

def insert(self, it: type_attr_t, x: type_attr_t)

insert(self, it, x) -> type_attr_t

@param it: qvector< type_attr_t >::iterator @param x: type_attr_t const &

def pop_back(self)

pop_back(self)

def push_back(self, *args)

push_back(self, x)

@param x: type_attr_t const &

push_back(self) -> type_attr_t

def qclear(self)

qclear(self)

def reserve(self, cnt: size_t)

reserve(self, cnt)

@param cnt: size_t

def resize(self, *args)

resize(self, _newsize, x)

@param _newsize: size_t @param x: type_attr_t const &

resize(self, _newsize)

@param _newsize: size_t

def size(self)

size(self) -> size_t

def swap(self, r: type_attrs_t)

swap(self, r)

@param r: qvector< type_attr_t > &

def truncate(self)

truncate(self)

class type_mods_t

Proxy of C++ type_mods_t class.

init(self) -> type_mods_t

Instance variables

var cmt : qstring

comment for current type

var flags : int

Type modification bits

var name : qstring

current type name

var thisown

The membership flag

var type : tinfo_t

current type

Methods

def clear(self)

clear(self)

def has_cmt(self) ‑> bool

has_cmt(self) -> bool

def has_info(self) ‑> bool

has_info(self) -> bool

def has_name(self) ‑> bool

has_name(self) -> bool

def has_type(self) ‑> bool

has_type(self) -> bool

def is_rptcmt(self) ‑> bool

is_rptcmt(self) -> bool

def set_new_cmt(self, c: qstring const &, rptcmt: bool)

set_new_cmt(self, c, rptcmt)

@param c: qstring const & @param rptcmt: bool

def set_new_name(self, n: qstring const &)

set_new_name(self, n)

@param n: qstring const &

def set_new_type(self, t: tinfo_t)

set_new_type(self, t) The visit_type() function may optionally save the modified type info. Use the following functions for that. The new name and comment will be applied only if the current tinfo element has storage for them.

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

class typedef_type_data_t (*args)

Proxy of C++ typedef_type_data_t class.

init(self, _til, _name, _resolve=False) -> typedef_type_data_t

@param _til: til_t const * @param _name: char const * @param _resolve: bool

init(self, _til, ord, _resolve=False) -> typedef_type_data_t

@param _til: til_t const * @param ord: uint32 @param _resolve: bool

Instance variables

var is_ordref : bool

is reference by ordinal?

var name : char const *

is_ordref=false: target type name. we do not own this pointer!

var ordinal : uint32

is_ordref=true: type ordinal number

var resolve : bool

should resolve immediately?

var thisown

The membership flag

var til : til_t const *

type library to use when resolving

Methods

def swap(self, r: typedef_type_data_t)

swap(self, r)

@param r: typedef_type_data_t &

class udm_t

Proxy of C++ udm_t class.

init(self) -> udm_t

Instance variables

var cmt : qstring

member comment

var effalign : int

effective field alignment (in bytes)

var fda : uchar

field alignment (shift amount)

var name : qstring

member name

var offset : uint64

member offset in bits

var repr : value_repr_t

radix, refinfo, strpath, custom_id, strtype

var size : uint64

size in bits

var tafld_bits : uint32

TAH bits.

var thisown

The membership flag

var type : tinfo_t

member type

Methods

def begin(self)

begin(self) -> uint64

def can_be_dtor(self) ‑> bool

can_be_dtor(self) -> bool

def can_rename(self) ‑> bool

can_rename(self) -> bool

def clr_baseclass(self)

clr_baseclass(self)

def clr_method(self)

clr_method(self)

def clr_unaligned(self)

clr_unaligned(self)

def clr_vftable(self)

clr_vftable(self)

def clr_virtbase(self)

clr_virtbase(self)

def end(self)

end(self) -> uint64

def is_anonymous_udm(self) ‑> bool

is_anonymous_udm(self) -> bool

def is_baseclass(self) ‑> bool

is_baseclass(self) -> bool

def is_bitfield(self) ‑> bool

is_bitfield(self) -> bool

def is_by_til(self) ‑> bool

is_by_til(self) -> bool

def is_gap(self) ‑> bool

is_gap(self) -> bool

def is_method(self) ‑> bool

is_method(self) -> bool

def is_regcmt(self) ‑> bool

is_regcmt(self) -> bool

def is_retaddr(self) ‑> bool

is_retaddr(self) -> bool

def is_savregs(self) ‑> bool

is_savregs(self) -> bool

def is_special_member(self) ‑> bool

is_special_member(self) -> bool

def is_unaligned(self) ‑> bool

is_unaligned(self) -> bool

def is_vftable(self) ‑> bool

is_vftable(self) -> bool

def is_virtbase(self) ‑> bool

is_virtbase(self) -> bool

def is_zero_bitfield(self) ‑> bool

is_zero_bitfield(self) -> bool

def make_gap(self, byteoff: uval_t, nbytes: uval_t)

make_gap(self, byteoff, nbytes) -> bool

@param byteoff: uval_t @param nbytes: uval_t

def set_baseclass(self, on: bool = True)

set_baseclass(self, on=True)

@param on: bool

def set_by_til(self, on: bool = True)

set_by_til(self, on=True)

@param on: bool

def set_method(self, on: bool = True)

set_method(self, on=True)

@param on: bool

def set_regcmt(self, on: bool = True)

set_regcmt(self, on=True)

@param on: bool

def set_retaddr(self, on: bool = True)

set_retaddr(self, on=True)

@param on: bool

def set_savregs(self, on: bool = True)

set_savregs(self, on=True)

@param on: bool

def set_unaligned(self, on: bool = True)

set_unaligned(self, on=True)

@param on: bool

def set_value_repr(self, r: value_repr_t)

set_value_repr(self, r)

@param r: value_repr_t const &

def set_vftable(self, on: bool = True)

set_vftable(self, on=True)

@param on: bool

def set_virtbase(self, on: bool = True)

set_virtbase(self, on=True)

@param on: bool

def swap(self, r: udm_t)

swap(self, r)

@param r: udm_t &

class udt_member_t

Proxy of C++ udm_t class.

init(self) -> udm_t

Instance variables

var cmt : qstring

member comment

var effalign : int

effective field alignment (in bytes)

var fda : uchar

field alignment (shift amount)

var name : qstring

member name

var offset : uint64

member offset in bits

var repr : value_repr_t

radix, refinfo, strpath, custom_id, strtype

var size : uint64

size in bits

var tafld_bits : uint32

TAH bits.

var thisown

The membership flag

var type : tinfo_t

member type

Methods

def begin(self)

begin(self) -> uint64

def can_be_dtor(self) ‑> bool

can_be_dtor(self) -> bool

def can_rename(self) ‑> bool

can_rename(self) -> bool

def clr_baseclass(self)

clr_baseclass(self)

def clr_method(self)

clr_method(self)

def clr_unaligned(self)

clr_unaligned(self)

def clr_vftable(self)

clr_vftable(self)

def clr_virtbase(self)

clr_virtbase(self)

def end(self)

end(self) -> uint64

def is_anonymous_udm(self) ‑> bool

is_anonymous_udm(self) -> bool

def is_baseclass(self) ‑> bool

is_baseclass(self) -> bool

def is_bitfield(self) ‑> bool

is_bitfield(self) -> bool

def is_by_til(self) ‑> bool

is_by_til(self) -> bool

def is_gap(self) ‑> bool

is_gap(self) -> bool

def is_method(self) ‑> bool

is_method(self) -> bool

def is_regcmt(self) ‑> bool

is_regcmt(self) -> bool

def is_retaddr(self) ‑> bool

is_retaddr(self) -> bool

def is_savregs(self) ‑> bool

is_savregs(self) -> bool

def is_special_member(self) ‑> bool

is_special_member(self) -> bool

def is_unaligned(self) ‑> bool

is_unaligned(self) -> bool

def is_vftable(self) ‑> bool

is_vftable(self) -> bool

def is_virtbase(self) ‑> bool

is_virtbase(self) -> bool

def is_zero_bitfield(self) ‑> bool

is_zero_bitfield(self) -> bool

def make_gap(self, byteoff: uval_t, nbytes: uval_t)

make_gap(self, byteoff, nbytes) -> bool

@param byteoff: uval_t @param nbytes: uval_t

def set_baseclass(self, on: bool = True)

set_baseclass(self, on=True)

@param on: bool

def set_by_til(self, on: bool = True)

set_by_til(self, on=True)

@param on: bool

def set_method(self, on: bool = True)

set_method(self, on=True)

@param on: bool

def set_regcmt(self, on: bool = True)

set_regcmt(self, on=True)

@param on: bool

def set_retaddr(self, on: bool = True)

set_retaddr(self, on=True)

@param on: bool

def set_savregs(self, on: bool = True)

set_savregs(self, on=True)

@param on: bool

def set_unaligned(self, on: bool = True)

set_unaligned(self, on=True)

@param on: bool

def set_value_repr(self, r: value_repr_t)

set_value_repr(self, r)

@param r: value_repr_t const &

def set_vftable(self, on: bool = True)

set_vftable(self, on=True)

@param on: bool

def set_virtbase(self, on: bool = True)

set_virtbase(self, on=True)

@param on: bool

def swap(self, r: udm_t)

swap(self, r)

@param r: udm_t &

class udm_visitor_t

Proxy of C++ udm_visitor_t class.

init(self) -> udm_visitor_t

@param self: PyObject *

Instance variables

var thisown

The membership flag

Methods

def visit_udm(self, tid: tid_t, tif: tinfo_t, udt: udt_type_data_t, idx: ssize_t)

visit_udm(self, tid, tif, udt, idx) -> int

@param tid: (C++: tid_t) udt tid @param tif: (C++: const tinfo_t ) udt type info (may be nullptr for corrupted idbs) @param udt: (C++: const udt_type_data_t ) udt type data (may be nullptr for corrupted idbs) @param idx: (C++: ssize_t) the index of udt the member (may be -1 if udm was not found)

class udt_type_data_t

Proxy of C++ udt_type_data_t class.

init(self) -> udt_type_data_t

Ancestors

• udtmembervec_t
• udtmembervec_template_t

Instance variables

var effalign : uint32

effective structure alignment (in bytes)

var is_union : bool

is union or struct?

var pack : uchar

pragma pack() alignment (shift amount)

var sda : uchar

declared structure alignment (shift amount+1). 0 - unspecified

var taudt_bits : uint32

TA… and TAUDT… bits.

var total_size : size_t

total structure size in bytes

var unpadded_size : size_t

unpadded structure size in bytes

var version : uchar

version of udt_type_data_t

Methods

def find_member(self, *args)

find_member(self, pattern_udm, strmem_flags) -> ssize_t

@param pattern_udm: udm_t * @param strmem_flags: int

find_member(self, name) -> ssize_t

@param name: char const *

find_member(self, bit_offset) -> ssize_t

@param bit_offset: uint64

def get_best_fit_member(self, disp: asize_t)

get_best_fit_member(self, disp) -> ssize_t Get member that is most likely referenced by the specified offset. Useful for offsets > sizeof(struct).

@param disp: (C++: asize_t)

def is_cppobj(self) ‑> bool

is_cppobj(self) -> bool

def is_fixed(self) ‑> bool

is_fixed(self) -> bool

def is_last_baseclass(self, idx: size_t)

is_last_baseclass(self, idx) -> bool

@param idx: size_t

def is_msstruct(self) ‑> bool

is_msstruct(self) -> bool

def is_unaligned(self) ‑> bool

is_unaligned(self) -> bool

def is_vftable(self) ‑> bool

is_vftable(self) -> bool

def set_fixed(self, on: bool = True)

set_fixed(self, on=True)

@param on: bool

def set_vftable(self, on: bool = True)

set_vftable(self, on=True)

@param on: bool

def swap(self, r: udt_type_data_t)

swap(self, r)

@param r: udt_type_data_t &

Inherited members

• udtmembervec_t:
  • add_unique
  • at
  • begin
  • capacity
  • clear
  • empty
  • end
  • erase
  • extract
  • find
  • grow
  • has
  • inject
  • insert
  • pop_back
  • push_back
  • qclear
  • reserve
  • resize
  • size
  • thisown
  • truncate

class udtmembervec_t

Proxy of C++ udtmembervec_t class.

init(self) -> udtmembervec_t

Ancestors

• udtmembervec_template_t

Subclasses

• udt_type_data_t

Inherited members

• udtmembervec_template_t:
  • add_unique
  • at
  • begin
  • capacity
  • clear
  • empty
  • end
  • erase
  • extract
  • find
  • grow
  • has
  • inject
  • insert
  • pop_back
  • push_back
  • qclear
  • reserve
  • resize
  • size
  • swap
  • thisown
  • truncate

class udtmembervec_template_t (*args)

Proxy of C++ qvector< udm_t > class.

init(self) -> udtmembervec_template_t init(self, x) -> udtmembervec_template_t

@param x: qvector< udm_t > const &

Subclasses

• udtmembervec_t

Instance variables

var thisown

The membership flag

Methods

def add_unique(self, x: udm_t) ‑> bool

add_unique(self, x) -> bool

@param x: udm_t const &

def at(self, _idx: size_t)

at(self, _idx) -> udm_t

@param _idx: size_t

def back(self)

def begin(self, *args)

begin(self) -> udm_t

def capacity(self)

capacity(self) -> size_t

def clear(self)

clear(self)

def empty(self) ‑> bool

empty(self) -> bool

def end(self, *args)

end(self) -> udm_t

def erase(self, *args)

erase(self, it) -> udm_t

@param it: qvector< udm_t >::iterator

erase(self, first, last) -> udm_t

@param first: qvector< udm_t >::iterator @param last: qvector< udm_t >::iterator

def extract(self)

extract(self) -> udm_t

def find(self, *args)

find(self, x) -> udm_t

@param x: udm_t const &

def front(self)

def grow(self, *args)

grow(self, x=udm_t())

@param x: udm_t const &

def has(self, x: udm_t) ‑> bool

has(self, x) -> bool

@param x: udm_t const &

def inject(self, s: udm_t, len: size_t)

inject(self, s, len)

@param s: udm_t * @param len: size_t

def insert(self, it: udm_t, x: udm_t)

insert(self, it, x) -> udm_t

@param it: qvector< udm_t >::iterator @param x: udm_t const &

def pop_back(self)

pop_back(self)

def push_back(self, *args)

push_back(self, x)

@param x: udm_t const &

push_back(self) -> udm_t

def qclear(self)

qclear(self)

def reserve(self, cnt: size_t)

reserve(self, cnt)

@param cnt: size_t

def resize(self, *args)

resize(self, _newsize, x)

@param _newsize: size_t @param x: udm_t const &

resize(self, _newsize)

@param _newsize: size_t

def size(self)

size(self) -> size_t

def swap(self, r: udtmembervec_template_t)

swap(self, r)

@param r: qvector< udm_t > &

def truncate(self)

truncate(self)

class valstr_t

Proxy of C++ valstr_t class.

init(self) -> valstr_t

Instance variables

var info : valinfo_t *

additional info

var length : size_t

length if printed on one line

var members : valstrs_t *

strings for members, each member separately

var oneline : qstring

result if printed on one line in UTF-8 encoding

var props : int

temporary properties, used internally

var thisown

The membership flag

class valstrs_t

Proxy of C++ valstrs_t class.

init(self) -> valstrs_t

Ancestors

• valstrvec_t

Inherited members

• valstrvec_t:
  • at
  • begin
  • capacity
  • clear
  • empty
  • end
  • erase
  • extract
  • grow
  • inject
  • insert
  • pop_back
  • push_back
  • qclear
  • reserve
  • resize
  • size
  • swap
  • thisown
  • truncate

class valstrvec_t (*args)

Proxy of C++ qvector< valstr_t > class.

init(self) -> valstrvec_t init(self, x) -> valstrvec_t

@param x: qvector< valstr_t > const &

Subclasses

• valstrs_t

Instance variables

var thisown

The membership flag

Methods

def at(self, _idx: size_t)

at(self, _idx) -> valstr_t

@param _idx: size_t

def back(self)

def begin(self, *args)

begin(self) -> valstr_t

def capacity(self)

capacity(self) -> size_t

def clear(self)

clear(self)

def empty(self) ‑> bool

empty(self) -> bool

def end(self, *args)

end(self) -> valstr_t

def erase(self, *args)

erase(self, it) -> valstr_t

@param it: qvector< valstr_t >::iterator

erase(self, first, last) -> valstr_t

@param first: qvector< valstr_t >::iterator @param last: qvector< valstr_t >::iterator

def extract(self)

extract(self) -> valstr_t

def front(self)

def grow(self, *args)

grow(self, x=valstr_t())

@param x: valstr_t const &

def inject(self, s: valstr_t, len: size_t)

inject(self, s, len)

@param s: valstr_t * @param len: size_t

def insert(self, it: valstr_t, x: valstr_t)

insert(self, it, x) -> valstr_t

@param it: qvector< valstr_t >::iterator @param x: valstr_t const &

def pop_back(self)

pop_back(self)

def push_back(self, *args)

push_back(self, x)

@param x: valstr_t const &

push_back(self) -> valstr_t

def qclear(self)

qclear(self)

def reserve(self, cnt: size_t)

reserve(self, cnt)

@param cnt: size_t

def resize(self, *args)

resize(self, _newsize, x)

@param _newsize: size_t @param x: valstr_t const &

resize(self, _newsize)

@param _newsize: size_t

def size(self)

size(self) -> size_t

def swap(self, r: valstrvec_t)

swap(self, r)

@param r: qvector< valstr_t > &

def truncate(self)

truncate(self)

class value_repr_t

Proxy of C++ value_repr_t class.

init(self) -> value_repr_t

Instance variables

var ap : array_parameters_t

FRB_TABFORM, AP_SIGNED is ignored, use FRB_SIGNED instead

var bits : uint64

bits

var cd : custom_data_type_info_t

FRB_CUSTOM.

var delta : adiff_t

FRB_STROFF.

var ri : refinfo_t

FRB_OFFSET.

var strtype : int32

FRB_STRLIT.

var thisown

The membership flag

var type_ordinal : uint32

FRB_STROFF, FRB_ENUM.

Methods

def clear(self)

clear(self)

def empty(self) ‑> bool

empty(self) -> bool

def from_opinfo(self, flags: flags64_t, afl: aflags_t, opinfo: opinfo_t, _ap: array_parameters_t)

from_opinfo(self, flags, afl, opinfo, _ap) -> bool

@param flags: flags64_t @param afl: aflags_t @param opinfo: opinfo_t const * @param _ap: array_parameters_t const *

def get_vtype(self)

get_vtype(self) -> uint64

def has_lzeroes(self) ‑> bool

has_lzeroes(self) -> bool

def has_tabform(self) ‑> bool

has_tabform(self) -> bool

def init_ap(self, _ap: array_parameters_t)

init_ap(self, _ap)

@param _ap: array_parameters_t *

def is_custom(self) ‑> bool

is_custom(self) -> bool

def is_enum(self) ‑> bool

is_enum(self) -> bool

def is_offset(self) ‑> bool

is_offset(self) -> bool

def is_signed(self) ‑> bool

is_signed(self) -> bool

def is_strlit(self) ‑> bool

is_strlit(self) -> bool

def is_stroff(self) ‑> bool

is_stroff(self) -> bool

def is_typref(self) ‑> bool

is_typref(self) -> bool

def parse_value_repr(self, *args) ‑> bool

parse_value_repr(self, attr, target_type=BTF_STRUCT) -> bool

@param attr: qstring const & @param target_type: type_t

def set_ap(self, _ap: array_parameters_t)

set_ap(self, _ap)

@param _ap: array_parameters_t const &

def set_lzeroes(self, on: bool)

set_lzeroes(self, on)

@param on: bool

def set_signed(self, on: bool)

set_signed(self, on)

@param on: bool

def set_tabform(self, on: bool)

set_tabform(self, on)

@param on: bool

def set_vtype(self, vt: uint64)

set_vtype(self, vt)

@param vt: uint64

def swap(self, r: value_repr_t)

swap(self, r)

@param r: value_repr_t &