Module index

Module ida_hexrays

IDA Plugin SDK API wrapper: hexrays

Global variables

var ACFL_BLKOPT
perform interblock transformations
var ACFL_GLBDEL
perform dead code eliminition
var ACFL_GLBPROP
perform global propagation
var ACFL_GUESS
may guess calling conventions
var ACFL_LOCOPT
perform local propagation (requires ACFL_BLKOPT)
var ALLOW_UNUSED_LABELS
ALLOW_UNUSED_LABELS = 1
var ANCHOR_BLKCMT
block comment (for ctree items)
var ANCHOR_CITEM
c-tree item
var ANCHOR_INDEX
ANCHOR_INDEX = 536870911
var ANCHOR_ITP
item type preciser
var ANCHOR_LVAR
declaration of local variable
var ANCHOR_MASK
ANCHOR_MASK = -1073741824
var ANY_FPSIZE
ANY_FPSIZE = 256
var ANY_REGSIZE
ANY_REGSIZE = 128
var BLT_0WAY
BLT_0WAY = 2
var BLT_1WAY
BLT_1WAY = 3
var BLT_2WAY
BLT_2WAY = 4
var BLT_NONE
BLT_NONE = 0
var BLT_NWAY
BLT_NWAY = 5
var BLT_STOP
BLT_STOP = 1
var BLT_XTRN
BLT_XTRN = 6
var CALC_CURLY_BRACES
CALC_CURLY_BRACES = 0
var CALL_SPOILS_ONLY_ARGS
CALL_SPOILS_ONLY_ARGS = 16384
var CFL_FINAL
call type is final, should not be changed
var CFL_HELPER
created from a decompiler helper function
var CFL_NORET
call does not return
var CFS_BOUNDS
'eamap' and 'boundaries' are ready
var CFS_LOCKED
cfunc is temporarily locked
var CFS_LVARS_HIDDEN
local variable definitions are collapsed
var CFS_TEXT
'sv' is ready (and hdrlines)
var CHF_FAKE
fake chain created by widen_chains()
var CHF_INITED
is chain initialized? (valid only after lvar allocation)
var CHF_OVER
overlapped chain
var CHF_PASSTHRU
pass-thru chain, must use the input variable to the block
var CHF_REPLACED
chain operands have been replaced?
var CHF_TERM
terminating chain; the variable does not survive across the block
var CIT_COLLAPSED
display element in collapsed form
var CMAT_BUILT
CMAT_BUILT = 1
var CMAT_CASTED
CMAT_CASTED = 7
var CMAT_CPA
CMAT_CPA = 5
var CMAT_FINAL
CMAT_FINAL = 8
var CMAT_NICE
CMAT_NICE = 3
var CMAT_TRANS1
CMAT_TRANS1 = 2
var CMAT_TRANS2
CMAT_TRANS2 = 4
var CMAT_TRANS3
CMAT_TRANS3 = 6
var CMAT_ZERO
CMAT_ZERO = 0
var CMP_A
CMP_A = 4
var CMP_AE
CMP_AE = 2
var CMP_B
CMP_B = 3
var CMP_BE
CMP_BE = 5
var CMP_GE
CMP_GE = 7
var CMP_GT
CMP_GT = 6
var CMP_LE
CMP_LE = 9
var CMP_LT
CMP_LT = 8
var CMP_NZ
CMP_NZ = 0
var CMP_Z
CMP_Z = 1
var CMT_ALL
CMT_ALL = 31
var CMT_BLOCK1
CMT_BLOCK1 = 2
var CMT_BLOCK2
CMT_BLOCK2 = 4
var CMT_FUNC
CMT_FUNC = 16
var CMT_LVAR
CMT_LVAR = 8
var CMT_NONE
CMT_NONE = 0
var CMT_TAIL
CMT_TAIL = 1
var CPBLK_FAST
do not update minbstkref and minbargref
var CPBLK_MINREF
update minbstkref and minbargref
var CPBLK_OPTJMP
del the jump insn at the end of the block if it becomes useless
var CV_FAST
do not maintain parent information
var CV_INSNS
visit only statements, prune all expressions do not use before the final ctree maturity because expressions may contain statements at intermediate stages (see cot_insn). Otherwise you risk missing statements embedded into expressions.
var CV_PARENTS
maintain parent information
var CV_POST
call the leave...() functions
var CV_PRUNE
this bit is set by visit...() to prune the walk
var CV_RESTART
restart enumeration at the top expr (apply_to_exprs)
var DECOMP_ALL_BLKS
generate microcode for unreachable blocks
var DECOMP_NO_CACHE
do not use decompilation cache
var DECOMP_NO_FRAME
do not use function frame info (only snippet mode)
var DECOMP_NO_HIDE
do not close display waitbox. see close_hexrays_waitboxes()
var DECOMP_NO_WAIT
do not display waitbox
var DECOMP_NO_XREFS
do not update global xrefs cache
var DECOMP_WARNINGS
display warnings in the output window
var EQ_CMPDEST
compare instruction destinations
var EQ_IGNCODE
ignore instruction opcodes
var EQ_IGNSIZE
ignore source operand sizes
var EQ_OPTINSN
optimize mop_d operands
var EXCLUDE_PASS_REGS
EXCLUDE_PASS_REGS = 128
var EXCLUDE_VOLATILE
EXCLUDE_VOLATILE = 1024
var EXFL_ALL
all currently defined bits
var EXFL_ALONE
standalone helper
var EXFL_CPADONE
pointer arithmetic correction done
var EXFL_CSTR
string literal
var EXFL_FPOP
floating point operation
var EXFL_JUMPOUT
jump out-of-function
var EXFL_LVALUE
expression is lvalue even if it doesn't look like it
var EXFL_PARTIAL
type of the expression is considered partial
var EXFL_UNDEF
expression uses undefined value
var EXFL_VFTABLE
is ptr to vftable (used for cot_memptr, cot_memref)
var FCI_DEAD
some return registers were determined dead
var FCI_EXPLOCS
all arglocs are specified explicitly
var FCI_FINAL
call type is final, should not be changed
var FCI_HASCALL
A function is an synthetic helper combined from several instructions and at least one of them was a call to a real functions
var FCI_HASFMT
A variadic function with recognized printf- or scanf-style format string
var FCI_NORET
call does not return
var FCI_NOSIDE
call does not have side effects
var FCI_PROP
call has been propagated
var FCI_PURE
pure function
var FCI_SPLOK
spoiled/visible_memory lists have been optimized. for some functions we can reduce them as soon as information about the arguments becomes available. in order not to try optimize them again we use this bit.
var FD_BACKWARD
search direction
var FD_DEF
look for definition
var FD_DIRTY
ignore possible implicit definitions by function calls and indirect memory access
var FD_FORWARD
search direction
var FD_USE
look for use
var FORBID_UNUSED_LABELS
FORBID_UNUSED_LABELS = 0
var FULL_XDSU
FULL_XDSU = 256
var FUNC_NAME_CONTAINING_RECORD
FUNC_NAME_CONTAINING_RECORD = 'CONTAINING_RECORD'
var FUNC_NAME_EMPTY
FUNC_NAME_EMPTY = '$empty'
var FUNC_NAME_MEMCPY
FUNC_NAME_MEMCPY = 'memcpy'
var FUNC_NAME_MEMSET
FUNC_NAME_MEMSET = 'memset'
var FUNC_NAME_MEMSET32
FUNC_NAME_MEMSET32 = 'memset32'
var FUNC_NAME_MEMSET64
FUNC_NAME_MEMSET64 = 'memset64'
var FUNC_NAME_PRESENT
FUNC_NAME_PRESENT = '$present'
var FUNC_NAME_STRCAT
FUNC_NAME_STRCAT = 'strcat'
var FUNC_NAME_STRCPY
FUNC_NAME_STRCPY = 'strcpy'
var FUNC_NAME_STRLEN
FUNC_NAME_STRLEN = 'strlen'
var FUNC_NAME_TAIL
FUNC_NAME_TAIL = 'tail'
var FUNC_NAME_VA_ARG
FUNC_NAME_VA_ARG = 'va_arg'
var FUNC_NAME_WCSCAT
FUNC_NAME_WCSCAT = 'wcscat'
var FUNC_NAME_WCSCPY
FUNC_NAME_WCSCPY = 'wcscpy'
var FUNC_NAME_WCSLEN
FUNC_NAME_WCSLEN = 'wcslen'
var FUNC_NAME_WMEMCPY
FUNC_NAME_WMEMCPY = 'wmemcpy'
var FUNC_NAME_WMEMSET
FUNC_NAME_WMEMSET = 'wmemset'
var GCA_ALLOC
enumerate only allocated chains
var GCA_EMPTY
include empty chains
var GCA_NALLOC
enumerate only non-allocated chains
var GCA_OFIRST
consider only chains of the first block
var GCA_OLAST
consider only chains of the last block
var GCA_SPEC
include chains for special registers
var GCO_DEF
is destination operand?
var GCO_REG
is register? otherwise a stack variable
var GCO_STK
a stack variable
var GCO_USE
is source operand?
var GC_ASR
GC_ASR = 1
var GC_DIRTY_ALL
GC_DIRTY_ALL = 63
var GC_END
GC_END = 3
var GC_REGS_AND_STKVARS
GC_REGS_AND_STKVARS = 0
var GC_XDSU
GC_XDSU = 2
var GLN_ALL
get both
var GLN_CURRENT
get label of the current item
var GLN_GOTO_TARGET
get goto target
var GUESSED_DATA
GUESSED_DATA = 3
var GUESSED_FUNC
GUESSED_FUNC = 2
var GUESSED_NONE
GUESSED_NONE = 0
var GUESSED_WEAK
GUESSED_WEAK = 1
var HEXRAYS_API_MAGIC
HEXRAYS_API_MAGIC = 62699504545038339
var INCLUDE_DEAD_RETREGS
INCLUDE_DEAD_RETREGS = 4096
var INCLUDE_RESTRICTED
INCLUDE_RESTRICTED = 8192
var INCLUDE_SPOILED_REGS
INCLUDE_SPOILED_REGS = 64
var INCLUDE_UNUSED_SRC
INCLUDE_UNUSED_SRC = 2048
var IPROP_ASSERT
assertion: usually mov #val, op. assertions are used to help the optimizer. assertions are ignored when generating ctree
var IPROP_CLNPOP
the purpose of the instruction is to clean stack (e.g. "pop ecx" is often used for that)
var IPROP_COMBINED
insn has been modified because of a partial reference
var IPROP_DONT_COMB
may not combine this instruction with others
var IPROP_DONT_PROP
may not propagate
var IPROP_EXTSTX
this is m_ext propagated into m_stx
var IPROP_FARCALL
call of a far function using push cs/call sequence
var IPROP_FPINSN
floating point insn
var IPROP_IGNLOWSRC
low part of the instruction source operand has been created artificially (this bit is used only for 'and x, 80...')
var IPROP_INV_JX
inverted conditional jump
var IPROP_MBARRIER
this instruction acts as a memory barrier (instructions accessing memory may not be reordered past it)
var IPROP_MULTI_MOV
bits that can be set by plugins:
the minsn was generated as part of insn that moves multiple registers (example: STM on ARM may transfer multiple registers)
var IPROP_OPTIONAL
optional instruction
var IPROP_PERSIST
persistent insn; they are not destroyed
var IPROP_SPLIT
the instruction has been split:
var IPROP_SPLIT1
into 1 byte
var IPROP_SPLIT2
into 2 bytes
var IPROP_SPLIT4
into 4 bytes
var IPROP_SPLIT8
into 8 bytes
var IPROP_TAILCALL
tail call
var IPROP_WAS_NORET
was noret icall
var IPROP_WILDMATCH
match multiple insns
var ITP_ARG1
ITP_ARG1 = 1
var ITP_ARG64
ITP_ARG64 = 64
var ITP_ASM
ITP_ASM = 66
var ITP_BLOCK1
ITP_BLOCK1 = 74
var ITP_BLOCK2
ITP_BLOCK2 = 75
var ITP_BRACE1
ITP_BRACE1 = 65
var ITP_BRACE2
ITP_BRACE2 = 72
var ITP_CASE
ITP_CASE = 1073741824
var ITP_COLON
ITP_COLON = 73
var ITP_CURLY1
ITP_CURLY1 = 70
var ITP_CURLY2
ITP_CURLY2 = 71
var ITP_DO
ITP_DO = 68
var ITP_ELSE
ITP_ELSE = 67
var ITP_EMPTY
ITP_EMPTY = 0
var ITP_INNER_LAST
ITP_INNER_LAST = 65
var ITP_SEMI
ITP_SEMI = 69
var ITP_SIGN
ITP_SIGN = 536870912
var LOCOPT_ALL
redo optimization for all blocks. if this bit is not set, only dirty blocks will be optimized
var LOCOPT_REFINE
refine return type, ok to fail
var LOCOPT_REFINE2
refine return type, try harder
var LVINF_FORCE
force allocation of a new variable. forces the decompiler to create a new variable at ll.defea
var LVINF_KEEP
preserve saved user settings regardless of vars for example, if a var loses all its user-defined attributes or even gets destroyed, keep its 'lvar_saved_info_t' . this is used for ephemeral variables that get destroyed by macro recognition.
var LVINF_NOMAP
forbid automatic mapping of the variable
var LVINF_NOPTR
variable type should not be a pointer
var LVINF_UNUSED
unused argument, corresponds to CVAR_UNUSED
var MAX_SUPPORTED_STACK_SIZE
MAX_SUPPORTED_STACK_SIZE = 1048576
var MAX_SVALUE
MAX_SVALUE = 9223372036854775807
var MAX_VALUE
MAX_VALUE = 18446744073709551615
var MAX_VLR_SIZE
MAX_VLR_SIZE = 8
var MAYMUST_ACCESS_MASK
MAYMUST_ACCESS_MASK = 1
var MAY_ACCESS
MAY_ACCESS = 1
var MBA2_ALL_FLAGS
MBA2_ALL_FLAGS = 8191
var MBA2_ARGIDX_OK
MBA2_ARGIDX_OK = 64
var MBA2_ARGIDX_SORTED
MBA2_ARGIDX_SORTED = 1024
var MBA2_CODE16_BIT
MBA2_CODE16_BIT = 2048
var MBA2_DONT_VERIFY
MBA2_DONT_VERIFY = -2147483648
var MBA2_INITIAL_FLAGS
MBA2_INITIAL_FLAGS = 3
var MBA2_IS_CTR
MBA2_IS_CTR = 16
var MBA2_IS_DTR
MBA2_IS_DTR = 32
var MBA2_LVARNAMES_OK
MBA2_LVARNAMES_OK = 1
var MBA2_LVARS_RENAMED
MBA2_LVARS_RENAMED = 2
var MBA2_NO_DUP_CALLS
MBA2_NO_DUP_CALLS = 128
var MBA2_NO_DUP_LVARS
MBA2_NO_DUP_LVARS = 256
var MBA2_OVER_CHAINS
MBA2_OVER_CHAINS = 4
var MBA2_STACK_RETVAL
MBA2_STACK_RETVAL = 4096
var MBA2_UNDEF_RETVAR
MBA2_UNDEF_RETVAR = 512
var MBA2_VALRNG_DONE
MBA2_VALRNG_DONE = 8
var MBA_ASRPROP
assertion have been propagated
var MBA_ASRTOK
assertions have been generated
var MBA_CALLS
callinfo has been built
var MBA_CHVARS
can verify chain varnums
var MBA_CMBBLK
request to combine blocks
var MBA_CMNSTK
stkvars+stkargs should be considered as one area
var MBA_COLGDL
display graph after each reduction
var MBA_DELPAIRS
pairs have been deleted once
var MBA_GLBOPT
microcode has been optimized globally
var MBA_INITIAL_FLAGS
MBA_INITIAL_FLAGS = 1459618817
var MBA_INSGDL
display instruction in graphs
var MBA_LOADED
loaded gdl, no instructions (debugging)
var MBA_LVARS0
lvar pre-allocation has been performed
var MBA_LVARS1
lvar real allocation has been performed
var MBA_NICE
apply transformations to c code
var MBA_NOFUNC
function is not present, addresses might be wrong
var MBA_NUMADDR
display definition addresses for numbers
var MBA_PASSREGS
has 'mcallinfo_t::pass_regs'
var MBA_PATTERN
microcode pattern, callinfo is present
var MBA_PRCDEFS
use precise defeas for chain-allocated lvars
var MBA_PREOPT
preoptimization stage complete
var MBA_REFINE
may refine return value size
var MBA_RETFP
function returns floating point value
var MBA_RETREF
return type has been refined
var MBA_SAVRST
save-restore analysis has been performed
var MBA_SHORT
use short display
var MBA_SPLINFO
(final_type ? idb_spoiled : spoiled_regs) is valid
var MBA_THUNK
thunk function
var MBA_VALNUM
display value numbers
var MBA_WINGR32
use wingraph32
var MBL_BACKPROP
performed backprop_cc
var MBL_CALL
call information has been built
var MBL_COMB
needs "combine" pass
var MBL_DEAD
needs "eliminate deads" pass
var MBL_DMT64
needs "demote 64bits"
var MBL_DSLOT
block for delay slot
var MBL_FAKE
fake block (after a tail call)
var MBL_GOTO
this block is a goto target
var MBL_INCONST
inconsistent lists: we are building them
var MBL_KEEP
do not remove even if unreachable
var MBL_LIST
use/def lists are ready (not dirty)
var MBL_NONFAKE
regular block
var MBL_NORET
dead end block: doesn't return execution control
var MBL_PRIV
private block - no instructions except the specified are accepted (used in patterns)
var MBL_PROP
needs 'propagation' pass
var MBL_PUSH
needs "convert push/pop instructions"
var MBL_TCAL
aritifical call block for tail calls
var MBL_VALRANGES
should optimize using value ranges
var MERR_BADARCH
MERR_BADARCH = -31
var MERR_BADBLK
MERR_BADBLK = -4
var MERR_BADCALL
MERR_BADCALL = -12
var MERR_BADFRAME
MERR_BADFRAME = -13
var MERR_BADIDB
MERR_BADIDB = -15
var MERR_BADRANGES
MERR_BADRANGES = -30
var MERR_BADSP
MERR_BADSP = -5
var MERR_BITNESS
MERR_BITNESS = -11
var MERR_BLOCK
MERR_BLOCK = 1
var MERR_BUSY
MERR_BUSY = -26
var MERR_CANCELED
MERR_CANCELED = -18
var MERR_CLOUD
MERR_CLOUD = -34
var MERR_COMPLEX
MERR_COMPLEX = -22
var MERR_DSLOT
MERR_DSLOT = -32
var MERR_EXCEPTION
MERR_EXCEPTION = -8
var MERR_EXTERN
MERR_EXTERN = -28
var MERR_FARPTR
MERR_FARPTR = -27
var MERR_FUNCSIZE
MERR_FUNCSIZE = -29
var MERR_HUGESTACK
MERR_HUGESTACK = -9
var MERR_INSN
MERR_INSN = -2
var MERR_INTERR
MERR_INTERR = -1
var MERR_LICENSE
MERR_LICENSE = -23
var MERR_LOOP
MERR_LOOP = -35
var MERR_LVARS
MERR_LVARS = -10
var MERR_MAX_ERR
MERR_MAX_ERR = 34
var MERR_MEM
MERR_MEM = -3
var MERR_OK
MERR_OK = 0
var MERR_ONLY32
MERR_ONLY32 = -24
var MERR_ONLY64
MERR_ONLY64 = -25
var MERR_OVERLAP
MERR_OVERLAP = -20
var MERR_PARTINIT
MERR_PARTINIT = -21
var MERR_PROLOG
MERR_PROLOG = -6
var MERR_RECDEPTH
MERR_RECDEPTH = -19
var MERR_REDO
MERR_REDO = -17
var MERR_SIZEOF
MERR_SIZEOF = -16
var MERR_STOP
MERR_STOP = -33
var MERR_SWITCH
MERR_SWITCH = -7
var MERR_UNKTYPE
MERR_UNKTYPE = -14
var MIN_SVALUE
MIN_SVALUE = -9223372036854775808
var MLI_CLR_FLAGS
clear LVINF_... bits
var MLI_CMT
apply lvar comment
var MLI_NAME
apply lvar name
var MLI_SET_FLAGS
set LVINF_... bits
var MLI_TYPE
apply lvar type
var MMAT_CALLS
MMAT_CALLS = 4
var MMAT_GENERATED
MMAT_GENERATED = 1
var MMAT_GLBOPT1
MMAT_GLBOPT1 = 5
var MMAT_GLBOPT2
MMAT_GLBOPT2 = 6
var MMAT_GLBOPT3
MMAT_GLBOPT3 = 7
var MMAT_LOCOPT
MMAT_LOCOPT = 3
var MMAT_LVARS
MMAT_LVARS = 8
var MMAT_PREOPTIMIZED
MMAT_PREOPTIMIZED = 2
var MMAT_ZERO
MMAT_ZERO = 0
var MMIDX_ARGS
MMIDX_ARGS = 4
var MMIDX_GLBHIGH
MMIDX_GLBHIGH = 5
var MMIDX_GLBLOW
MMIDX_GLBLOW = 0
var MMIDX_LVARS
MMIDX_LVARS = 1
var MMIDX_RETADDR
MMIDX_RETADDR = 2
var MMIDX_SHADOW
MMIDX_SHADOW = 3
var MUST_ACCESS
MUST_ACCESS = 0
var NALT_VD
this index is not used by ida
var NF_BINVDONE
temporary internal bit: inverting bits is done
var NF_BITNOT
The user asked to invert bits of the constant.
var NF_FIXED
number format has been defined by the user
var NF_NEGATE
The user asked to negate the constant.
var NF_NEGDONE
temporary internal bit: negation has been performed
var NF_VALID
internal bit: stroff or enum is valid for enums: this bit is set immediately for stroffs: this bit is set at the end of decompilation
var NORET_FORBID_ANALYSIS
NORET_FORBID_ANALYSIS = 2
var NORET_IGNORE_WAS_NORET_ICALL
NORET_IGNORE_WAS_NORET_ICALL = 1
var NOSIZE
NOSIZE = -1
var NO_CURLY_BRACES
NO_CURLY_BRACES = 1
var NO_SIDEFF
NO_SIDEFF = 0
var ONE_ACCESS_TYPE
ONE_ACCESS_TYPE = 32
var ONLY_SIDEFF
ONLY_SIDEFF = 2
var OPF_NEW_WINDOW
open new window
var OPF_NO_WAIT
do not display waitbox if decompilation happens
var OPF_REUSE
reuse existing window
var OPF_REUSE_ACTIVE
reuse existing window, only if the currently active widget is a pseudocode view
var OPF_WINDOW_MGMT_MASK
OPF_WINDOW_MGMT_MASK = 7
var OPROP_CCFLAGS
mop_n: a pc-relative value else: value of a condition code register (like mr_cc)
var OPROP_FLOAT
possibly floating value
var OPROP_IMPDONE
imported operand (a pointer) has been dereferenced
var OPROP_LOWADDR
a low address offset
var OPROP_UDEFVAL
uses undefined value
var OPROP_UDT
a struct or union
var OPTI_ADDREXPRS
optimize all address expressions (&x+N; &x-&y)
var OPTI_COMBINSNS
may combine insns (only for optimize_insn)
var OPTI_MINSTKREF
may update minstkref
var OPTI_NO_LDXOPT
the function is called after the propagation attempt, we do not optimize low/high(ldx) in this case
var RETRIEVE_ALWAYS
RETRIEVE_ALWAYS = 1
var RETRIEVE_ONCE
RETRIEVE_ONCE = 0
var ROLE_3WAYCMP0
ROLE_3WAYCMP0 = 32
var ROLE_3WAYCMP1
ROLE_3WAYCMP1 = 33
var ROLE_ABS
ROLE_ABS = 31
var ROLE_ALLOCA
ROLE_ALLOCA = 11
var ROLE_BITTEST
ROLE_BITTEST = 19
var ROLE_BITTESTANDCOMPLEMENT
ROLE_BITTESTANDCOMPLEMENT = 22
var ROLE_BITTESTANDRESET
ROLE_BITTESTANDRESET = 21
var ROLE_BITTESTANDSET
ROLE_BITTESTANDSET = 20
var ROLE_BSWAP
ROLE_BSWAP = 12
var ROLE_BUG
ROLE_BUG = 10
var ROLE_CFSUB3
ROLE_CFSUB3 = 29
var ROLE_CONTAINING_RECORD
ROLE_CONTAINING_RECORD = 14
var ROLE_EMPTY
ROLE_EMPTY = 1
var ROLE_FASTFAIL
ROLE_FASTFAIL = 15
var ROLE_IS_MUL_OK
ROLE_IS_MUL_OK = 17
var ROLE_MEMCPY
ROLE_MEMCPY = 5
var ROLE_MEMSET
ROLE_MEMSET = 2
var ROLE_MEMSET32
ROLE_MEMSET32 = 3
var ROLE_MEMSET64
ROLE_MEMSET64 = 4
var ROLE_OFSUB3
ROLE_OFSUB3 = 30
var ROLE_PRESENT
ROLE_PRESENT = 13
var ROLE_READFLAGS
ROLE_READFLAGS = 16
var ROLE_ROL
ROLE_ROL = 27
var ROLE_ROR
ROLE_ROR = 28
var ROLE_SATURATED_MUL
ROLE_SATURATED_MUL = 18
var ROLE_SSE_CMP4
ROLE_SSE_CMP4 = 39
var ROLE_SSE_CMP8
ROLE_SSE_CMP8 = 40
var ROLE_STRCAT
ROLE_STRCAT = 8
var ROLE_STRCPY
ROLE_STRCPY = 6
var ROLE_STRLEN
ROLE_STRLEN = 7
var ROLE_TAIL
ROLE_TAIL = 9
var ROLE_UNK
ROLE_UNK = 0
var ROLE_VA_ARG
ROLE_VA_ARG = 23
var ROLE_VA_COPY
ROLE_VA_COPY = 24
var ROLE_VA_END
ROLE_VA_END = 26
var ROLE_VA_START
ROLE_VA_START = 25
var ROLE_WCSCAT
ROLE_WCSCAT = 38
var ROLE_WCSCPY
ROLE_WCSCPY = 36
var ROLE_WCSLEN
ROLE_WCSLEN = 37
var ROLE_WMEMCPY
ROLE_WMEMCPY = 34
var ROLE_WMEMSET
ROLE_WMEMSET = 35
var SHINS_LDXEA
display address of ldx expressions (not used)
var SHINS_NUMADDR
display definition addresses for numbers
var SHINS_SHORT
do not display use-def chains and other attrs
var SHINS_VALNUM
display value numbers
var SIZEOF_BLOCK_CHAINS
SIZEOF_BLOCK_CHAINS = 56
var SVW_FLOAT
SVW_FLOAT = 1
var SVW_INT
SVW_INT = 0
var SVW_SOFT
SVW_SOFT = 2
var TS_DONTREF
TS_DONTREF = 33554432
var TS_MASK
TS_MASK = 234881024
var TS_NOELL
TS_NOELL = 134217728
var TS_SHRINK
TS_SHRINK = 67108864
var ULV_PRECISE_DEFEA
Use precise defea's for lvar locations.
var USE_CURLY_BRACES
USE_CURLY_BRACES = 2
var USE_KEYBOARD
USE_KEYBOARD = 0
var USE_MOUSE
USE_MOUSE = 1
var VDI_EXPR
VDI_EXPR = 1
var VDI_FUNC
VDI_FUNC = 3
var VDI_LVAR
VDI_LVAR = 2
var VDI_NONE
VDI_NONE = 0
var VDI_TAIL
VDI_TAIL = 4
var VDRUN_APPEND
Create a new file or append to existing file.
var VDRUN_CMDLINE
Called from ida's command line.
var VDRUN_LUMINA
Use lumina server.
var VDRUN_MAYSTOP
The user can cancel decompilation.
var VDRUN_NEWFILE
Create a new file or overwrite existing file.
var VDRUN_ONLYNEW
Fail if output file already exists.
var VDRUN_SENDIDB
Send problematic databases to hex-rays.com.
var VDRUN_SILENT
Silent decompilation.
var VDRUN_STATS
Print statistics into vd_stats.txt.
var VDUI_VALID
is valid?
var VDUI_VISIBLE
is visible?
var VR_AT_END
get value ranges after the instruction or at the block end, just after the last instruction (if M is NULL)
var VR_AT_START
get value ranges before the instruction or at the block start (if M is NULL)
var VR_EXACT
find exact match. if not set, the returned valrng size will be >= vivl.size
var WARN_ADDR_OUTARGS
WARN_ADDR_OUTARGS = 6
var WARN_ARRAY_INARG
WARN_ARRAY_INARG = 21
var WARN_BAD_CALL_SP
WARN_BAD_CALL_SP = 38
var WARN_BAD_FIELD_TYPE
WARN_BAD_FIELD_TYPE = 23
var WARN_BAD_INSN
WARN_BAD_INSN = 49
var WARN_BAD_MAPDST
WARN_BAD_MAPDST = 48
var WARN_BAD_PURGED
WARN_BAD_PURGED = 12
var WARN_BAD_RETVAR
WARN_BAD_RETVAR = 25
var WARN_BAD_SHADOW
WARN_BAD_SHADOW = 45
var WARN_BAD_SP
WARN_BAD_SP = 40
var WARN_BAD_STD_TYPE
WARN_BAD_STD_TYPE = 37
var WARN_BAD_STKPNT
WARN_BAD_STKPNT = 41
var WARN_BAD_STROFF
WARN_BAD_STROFF = 33
var WARN_BAD_VALRNG
WARN_BAD_VALRNG = 44
var WARN_BAD_VARSIZE
WARN_BAD_VARSIZE = 34
var WARN_CBUILD_LOOPS
WARN_CBUILD_LOOPS = 13
var WARN_CR_BADOFF
WARN_CR_BADOFF = 32
var WARN_CR_NOFIELD
WARN_CR_NOFIELD = 31
var WARN_DEP_UNK_CALLS
WARN_DEP_UNK_CALLS = 7
var WARN_EXP_LINVAR
WARN_EXP_LINVAR = 10
var WARN_FIXED_MACRO
WARN_FIXED_MACRO = 29
var WARN_FRAG_LVAR
WARN_FRAG_LVAR = 26
var WARN_GUESSED_TYPE
WARN_GUESSED_TYPE = 9
var WARN_HUGE_STKOFF
WARN_HUGE_STKOFF = 27
var WARN_ILL_ELLIPSIS
WARN_ILL_ELLIPSIS = 8
var WARN_ILL_FPU_STACK
WARN_ILL_FPU_STACK = 18
var WARN_ILL_FUNCTYPE
WARN_ILL_FUNCTYPE = 2
var WARN_ILL_PURGED
WARN_ILL_PURGED = 1
var WARN_JUMPOUT
WARN_JUMPOUT = 43
var WARN_MAX
WARN_MAX = 54
var WARN_MAX_ARGS
WARN_MAX_ARGS = 22
var WARN_MISSED_SWITCH
WARN_MISSED_SWITCH = 39
var WARN_MUST_RET_FP
WARN_MUST_RET_FP = 17
var WARN_NO_SAVE_REST
WARN_NO_SAVE_REST = 14
var WARN_ODD_ABI
WARN_ODD_ABI = 50
var WARN_ODD_ADDR_USE
WARN_ODD_ADDR_USE = 16
var WARN_ODD_INPUT_REG
WARN_ODD_INPUT_REG = 15
var WARN_OPT_VALRNG
WARN_OPT_VALRNG = 46
var WARN_OPT_VALRNG2
WARN_OPT_VALRNG2 = 52
var WARN_OPT_VALRNG3
WARN_OPT_VALRNG3 = 53
var WARN_RET_LOCREF
WARN_RET_LOCREF = 47
var WARN_SELFREF_PROP
WARN_SELFREF_PROP = 19
var WARN_UNALIGNED_ARG
WARN_UNALIGNED_ARG = 36
var WARN_UNBALANCED_STACK
WARN_UNBALANCED_STACK = 51
var WARN_UNDEF_LVAR
WARN_UNDEF_LVAR = 42
var WARN_UNINITED_REG
WARN_UNINITED_REG = 28
var WARN_UNSUPP_REG
WARN_UNSUPP_REG = 35
var WARN_VARARG_MANY
WARN_VARARG_MANY = 5
var WARN_VARARG_NOSTK
WARN_VARARG_NOSTK = 4
var WARN_VARARG_REGS
WARN_VARARG_REGS = 0
var WARN_VARARG_TCAL
WARN_VARARG_TCAL = 3
var WARN_WIDEN_CHAINS
WARN_WIDEN_CHAINS = 11
var WARN_WOULD_OVERLAP
WARN_WOULD_OVERLAP = 20
var WARN_WRITE_CONST
WARN_WRITE_CONST = 24
var WARN_WRONG_VA_OFF
WARN_WRONG_VA_OFF = 30
var WITH_ASSERTS
WITH_ASSERTS = 512
var WITH_SIDEFF
WITH_SIDEFF = 1
var bitset_align
bitset_align = 63
var bitset_shift
bitset_shift = 6
var bitset_width
bitset_width = 64
var cc_count
cc_count = 5
var cit_asm
cit_asm = 82
var cit_block
cit_block = 71
var cit_break
cit_break = 78
var cit_continue
cit_continue = 79
var cit_do
cit_do = 76
var cit_empty
cit_empty = 70
var cit_end
cit_end = 83
var cit_expr
cit_expr = 72
var cit_for
cit_for = 74
var cit_goto
cit_goto = 81
var cit_if
cit_if = 73
var cit_return
cit_return = 80
var cit_switch
cit_switch = 77
var cit_while
cit_while = 75
var cot_add
cot_add = 35
var cot_asg
cot_asg = 2
var cot_asgadd
cot_asgadd = 6
var cot_asgband
cot_asgband = 5
var cot_asgbor
cot_asgbor = 3
var cot_asgmul
cot_asgmul = 8
var cot_asgsdiv
cot_asgsdiv = 12
var cot_asgshl
cot_asgshl = 11
var cot_asgsmod
cot_asgsmod = 14
var cot_asgsshr
cot_asgsshr = 9
var cot_asgsub
cot_asgsub = 7
var cot_asgudiv
cot_asgudiv = 13
var cot_asgumod
cot_asgumod = 15
var cot_asgushr
cot_asgushr = 10
var cot_asgxor
cot_asgxor = 4
var cot_band
cot_band = 21
var cot_bnot
cot_bnot = 50
var cot_bor
cot_bor = 19
var cot_call
cot_call = 57
var cot_cast
cot_cast = 48
var cot_comma
cot_comma = 1
var cot_empty
cot_empty = 0
var cot_eq
cot_eq = 22
var cot_fadd
cot_fadd = 42
var cot_fdiv
cot_fdiv = 45
var cot_fmul
cot_fmul = 44
var cot_fneg
cot_fneg = 46
var cot_fnum
cot_fnum = 62
var cot_fsub
cot_fsub = 43
var cot_helper
cot_helper = 68
var cot_idx
cot_idx = 58
var cot_insn
cot_insn = 66
var cot_land
cot_land = 18
var cot_last
cot_last = 69
var cot_lnot
cot_lnot = 49
var cot_lor
cot_lor = 17
var cot_memptr
cot_memptr = 60
var cot_memref
cot_memref = 59
var cot_mul
cot_mul = 37
var cot_ne
cot_ne = 23
var cot_neg
cot_neg = 47
var cot_num
cot_num = 61
var cot_obj
cot_obj = 64
var cot_postdec
cot_postdec = 54
var cot_postinc
cot_postinc = 53
var cot_predec
cot_predec = 56
var cot_preinc
cot_preinc = 55
var cot_ptr
cot_ptr = 51
var cot_ref
cot_ref = 52
var cot_sdiv
cot_sdiv = 38
var cot_sge
cot_sge = 24
var cot_sgt
cot_sgt = 28
var cot_shl
cot_shl = 34
var cot_sizeof
cot_sizeof = 67
var cot_sle
cot_sle = 26
var cot_slt
cot_slt = 30
var cot_smod
cot_smod = 40
var cot_sshr
cot_sshr = 32
var cot_str
cot_str = 63
var cot_sub
cot_sub = 36
var cot_tern
cot_tern = 16
var cot_type
cot_type = 69
var cot_udiv
cot_udiv = 39
var cot_uge
cot_uge = 25
var cot_ugt
cot_ugt = 29
var cot_ule
cot_ule = 27
var cot_ult
cot_ult = 31
var cot_umod
cot_umod = 41
var cot_ushr
cot_ushr = 33
var cot_var
cot_var = 65
var cot_xor
cot_xor = 20
var hx_arglocs_overlap
hx_arglocs_overlap = 181
var hx_asgop
hx_asgop = 403
var hx_asgop_revert
hx_asgop_revert = 404
var hx_bitset_t_add
hx_bitset_t_add = 205
var hx_bitset_t_add_
hx_bitset_t_add_ = 206
var hx_bitset_t_add__
hx_bitset_t_add__ = 207
var hx_bitset_t_bitset_t
hx_bitset_t_bitset_t = 203
var hx_bitset_t_compare
hx_bitset_t_compare = 225
var hx_bitset_t_copy
hx_bitset_t_copy = 204
var hx_bitset_t_count
hx_bitset_t_count = 218
var hx_bitset_t_count_
hx_bitset_t_count_ = 219
var hx_bitset_t_cut_at
hx_bitset_t_cut_at = 211
var hx_bitset_t_dstr
hx_bitset_t_dstr = 216
var hx_bitset_t_empty
hx_bitset_t_empty = 217
var hx_bitset_t_fill_gaps
hx_bitset_t_fill_gaps = 574
var hx_bitset_t_fill_with_ones
hx_bitset_t_fill_with_ones = 221
var hx_bitset_t_goup
hx_bitset_t_goup = 226
var hx_bitset_t_has
hx_bitset_t_has = 213
var hx_bitset_t_has_all
hx_bitset_t_has_all = 214
var hx_bitset_t_has_any
hx_bitset_t_has_any = 215
var hx_bitset_t_has_common
hx_bitset_t_has_common = 222
var hx_bitset_t_intersect
hx_bitset_t_intersect = 223
var hx_bitset_t_is_subset_of
hx_bitset_t_is_subset_of = 224
var hx_bitset_t_last
hx_bitset_t_last = 220
var hx_bitset_t_shift_down
hx_bitset_t_shift_down = 212
var hx_bitset_t_sub
hx_bitset_t_sub = 208
var hx_bitset_t_sub_
hx_bitset_t_sub_ = 209
var hx_bitset_t_sub__
hx_bitset_t_sub__ = 210
var hx_block_chains_begin
hx_block_chains_begin = 117
var hx_block_chains_clear
hx_block_chains_clear = 125
var hx_block_chains_end
hx_block_chains_end = 118
var hx_block_chains_erase
hx_block_chains_erase = 124
var hx_block_chains_find
hx_block_chains_find = 122
var hx_block_chains_free
hx_block_chains_free = 127
var hx_block_chains_get
hx_block_chains_get = 121
var hx_block_chains_insert
hx_block_chains_insert = 123
var hx_block_chains_new
hx_block_chains_new = 128
var hx_block_chains_next
hx_block_chains_next = 119
var hx_block_chains_prev
hx_block_chains_prev = 120
var hx_block_chains_size
hx_block_chains_size = 126
var hx_block_chains_t_dstr
hx_block_chains_t_dstr = 310
var hx_block_chains_t_get_chain
hx_block_chains_t_get_chain = 308
var hx_block_chains_t_print
hx_block_chains_t_print = 309
var hx_boundaries_begin
hx_boundaries_begin = 104
var hx_boundaries_clear
hx_boundaries_clear = 113
var hx_boundaries_end
hx_boundaries_end = 105
var hx_boundaries_erase
hx_boundaries_erase = 112
var hx_boundaries_find
hx_boundaries_find = 110
var hx_boundaries_first
hx_boundaries_first = 108
var hx_boundaries_free
hx_boundaries_free = 115
var hx_boundaries_insert
hx_boundaries_insert = 111
var hx_boundaries_new
hx_boundaries_new = 116
var hx_boundaries_next
hx_boundaries_next = 106
var hx_boundaries_prev
hx_boundaries_prev = 107
var hx_boundaries_second
hx_boundaries_second = 109
var hx_boundaries_size
hx_boundaries_size = 114
var hx_carglist_t_compare
hx_carglist_t_compare = 455
var hx_casm_t_compare
hx_casm_t_compare = 441
var hx_cblock_t_compare
hx_cblock_t_compare = 454
var hx_ccase_t_compare
hx_ccase_t_compare = 456
var hx_ccases_t_compare
hx_ccases_t_compare = 457
var hx_cdg_insn_iterator_t_next
hx_cdg_insn_iterator_t_next = 563
var hx_cdo_t_compare
hx_cdo_t_compare = 438
var hx_cexpr_t_assign
hx_cexpr_t_assign = 419
var hx_cexpr_t_calc_type
hx_cexpr_t_calc_type = 425
var hx_cexpr_t_cleanup
hx_cexpr_t_cleanup = 422
var hx_cexpr_t_compare
hx_cexpr_t_compare = 420
var hx_cexpr_t_contains_operator
hx_cexpr_t_contains_operator = 428
var hx_cexpr_t_equal_effect
hx_cexpr_t_equal_effect = 426
var hx_cexpr_t_get_high_nbit_bound
hx_cexpr_t_get_high_nbit_bound = 429
var hx_cexpr_t_get_low_nbit_bound
hx_cexpr_t_get_low_nbit_bound = 430
var hx_cexpr_t_has_side_effects
hx_cexpr_t_has_side_effects = 432
var hx_cexpr_t_is_child_of
hx_cexpr_t_is_child_of = 427
var hx_cexpr_t_print1
hx_cexpr_t_print1 = 424
var hx_cexpr_t_put_number
hx_cexpr_t_put_number = 423
var hx_cexpr_t_replace_by
hx_cexpr_t_replace_by = 421
var hx_cexpr_t_requires_lvalue
hx_cexpr_t_requires_lvalue = 431
var hx_cfor_t_compare
hx_cfor_t_compare = 436
var hx_cfunc_parentee_t_calc_rvalue_type
hx_cfunc_parentee_t_calc_rvalue_type = 413
var hx_cfunc_t_build_c_tree
hx_cfunc_t_build_c_tree = 480
var hx_cfunc_t_cleanup
hx_cfunc_t_cleanup = 504
var hx_cfunc_t_del_orphan_cmts
hx_cfunc_t_del_orphan_cmts = 494
var hx_cfunc_t_find_item_coords
hx_cfunc_t_find_item_coords = 503
var hx_cfunc_t_find_label
hx_cfunc_t_find_label = 487
var hx_cfunc_t_gather_derefs
hx_cfunc_t_gather_derefs = 502
var hx_cfunc_t_get_boundaries
hx_cfunc_t_get_boundaries = 500
var hx_cfunc_t_get_eamap
hx_cfunc_t_get_eamap = 499
var hx_cfunc_t_get_func_type
hx_cfunc_t_get_func_type = 484
var hx_cfunc_t_get_line_item
hx_cfunc_t_get_line_item = 497
var hx_cfunc_t_get_lvars
hx_cfunc_t_get_lvars = 485
var hx_cfunc_t_get_pseudocode
hx_cfunc_t_get_pseudocode = 501
var hx_cfunc_t_get_stkoff_delta
hx_cfunc_t_get_stkoff_delta = 486
var hx_cfunc_t_get_user_cmt
hx_cfunc_t_get_user_cmt = 489
var hx_cfunc_t_get_user_iflags
hx_cfunc_t_get_user_iflags = 491
var hx_cfunc_t_get_user_union_selection
hx_cfunc_t_get_user_union_selection = 495
var hx_cfunc_t_get_warnings
hx_cfunc_t_get_warnings = 498
var hx_cfunc_t_has_orphan_cmts
hx_cfunc_t_has_orphan_cmts = 493
var hx_cfunc_t_print_dcl
hx_cfunc_t_print_dcl = 482
var hx_cfunc_t_print_func
hx_cfunc_t_print_func = 483
var hx_cfunc_t_refresh_func_ctext
hx_cfunc_t_refresh_func_ctext = 557
var hx_cfunc_t_remove_unused_labels
hx_cfunc_t_remove_unused_labels = 488
var hx_cfunc_t_save_user_cmts
hx_cfunc_t_save_user_cmts = 576
var hx_cfunc_t_save_user_iflags
hx_cfunc_t_save_user_iflags = 578
var hx_cfunc_t_save_user_labels
hx_cfunc_t_save_user_labels = 575
var hx_cfunc_t_save_user_numforms
hx_cfunc_t_save_user_numforms = 577
var hx_cfunc_t_save_user_unions
hx_cfunc_t_save_user_unions = 579
var hx_cfunc_t_set_user_cmt
hx_cfunc_t_set_user_cmt = 490
var hx_cfunc_t_set_user_iflags
hx_cfunc_t_set_user_iflags = 492
var hx_cfunc_t_set_user_union_selection
hx_cfunc_t_set_user_union_selection = 496
var hx_cfunc_t_verify
hx_cfunc_t_verify = 481
var hx_cgoto_t_compare
hx_cgoto_t_compare = 440
var hx_chain_t_append_list
hx_chain_t_append_list = 588
var hx_chain_t_append_list_
hx_chain_t_append_list_ = 307
var hx_chain_t_dstr
hx_chain_t_dstr = 306
var hx_chain_t_print
hx_chain_t_print = 305
var hx_checkout_hexrays_license
hx_checkout_hexrays_license = 558
var hx_cif_t_assign
hx_cif_t_assign = 433
var hx_cif_t_compare
hx_cif_t_compare = 434
var hx_cinsn_t_assign
hx_cinsn_t_assign = 442
var hx_cinsn_t_cleanup
hx_cinsn_t_cleanup = 445
var hx_cinsn_t_collect_free_breaks
hx_cinsn_t_collect_free_breaks = 452
var hx_cinsn_t_collect_free_continues
hx_cinsn_t_collect_free_continues = 453
var hx_cinsn_t_compare
hx_cinsn_t_compare = 443
var hx_cinsn_t_contains_insn
hx_cinsn_t_contains_insn = 451
var hx_cinsn_t_create_if
hx_cinsn_t_create_if = 447
var hx_cinsn_t_is_ordinary_flow
hx_cinsn_t_is_ordinary_flow = 450
var hx_cinsn_t_new_insn
hx_cinsn_t_new_insn = 446
var hx_cinsn_t_print
hx_cinsn_t_print = 448
var hx_cinsn_t_print1
hx_cinsn_t_print1 = 449
var hx_cinsn_t_replace_by
hx_cinsn_t_replace_by = 444
var hx_citem_locator_t_compare
hx_citem_locator_t_compare = 414
var hx_citem_t_contains_expr
hx_citem_t_contains_expr = 415
var hx_citem_t_contains_label
hx_citem_t_contains_label = 416
var hx_citem_t_find_closest_addr
hx_citem_t_find_closest_addr = 418
var hx_citem_t_find_parent_of
hx_citem_t_find_parent_of = 417
var hx_clear_cached_cfuncs
hx_clear_cached_cfuncs = 508
var hx_cloop_t_assign
hx_cloop_t_assign = 435
var hx_close_hexrays_waitbox
hx_close_hexrays_waitbox = 567
var hx_close_pseudocode
hx_close_pseudocode = 392
var hx_cnumber_t_assign
hx_cnumber_t_assign = 407
var hx_cnumber_t_compare
hx_cnumber_t_compare = 408
var hx_cnumber_t_print
hx_cnumber_t_print = 405
var hx_cnumber_t_value
hx_cnumber_t_value = 406
var hx_codegen_t_emit
hx_codegen_t_emit = 386
var hx_codegen_t_emit_
hx_codegen_t_emit_ = 387
var hx_convert_to_user_call
hx_convert_to_user_call = 199
var hx_create_cfunc
hx_create_cfunc = 582
var hx_create_field_name
hx_create_field_name = 511
var hx_create_typedef
hx_create_typedef = 174
var hx_creturn_t_compare
hx_creturn_t_compare = 439
var hx_cswitch_t_compare
hx_cswitch_t_compare = 458
var hx_ctree_item_t_get_ea
hx_ctree_item_t_get_ea = 461
var hx_ctree_item_t_get_label_num
hx_ctree_item_t_get_label_num = 462
var hx_ctree_item_t_get_lvar
hx_ctree_item_t_get_lvar = 460
var hx_ctree_item_t_get_memptr
hx_ctree_item_t_get_memptr = 459
var hx_ctree_parentee_t_recalc_parent_types
hx_ctree_parentee_t_recalc_parent_types = 412
var hx_ctree_visitor_t_apply_to
hx_ctree_visitor_t_apply_to = 410
var hx_ctree_visitor_t_apply_to_exprs
hx_ctree_visitor_t_apply_to_exprs = 411
var hx_cwhile_t_compare
hx_cwhile_t_compare = 437
var hx_decompile
hx_decompile = 505
var hx_decompile_many
hx_decompile_many = 394
var hx_dereference
hx_dereference = 469
var hx_dstr
hx_dstr = 162
var hx_dummy_ptrtype
hx_dummy_ptrtype = 171
var hx_eamap_begin
hx_eamap_begin = 91
var hx_eamap_clear
hx_eamap_clear = 100
var hx_eamap_end
hx_eamap_end = 92
var hx_eamap_erase
hx_eamap_erase = 99
var hx_eamap_find
hx_eamap_find = 97
var hx_eamap_first
hx_eamap_first = 95
var hx_eamap_free
hx_eamap_free = 102
var hx_eamap_insert
hx_eamap_insert = 98
var hx_eamap_new
hx_eamap_new = 103
var hx_eamap_next
hx_eamap_next = 93
var hx_eamap_prev
hx_eamap_prev = 94
var hx_eamap_second
hx_eamap_second = 96
var hx_eamap_size
hx_eamap_size = 101
var hx_file_printer_t_print
hx_file_printer_t_print = 160
var hx_fnumber_t_dstr
hx_fnumber_t_dstr = 255
var hx_fnumber_t_print
hx_fnumber_t_print = 254
var hx_gco_info_t_append_to_list
hx_gco_info_t_append_to_list = 397
var hx_gen_microcode
hx_gen_microcode = 506
var hx_get_ctype_name
hx_get_ctype_name = 510
var hx_get_current_operand
hx_get_current_operand = 398
var hx_get_float_type
hx_get_float_type = 168
var hx_get_hexrays_version
hx_get_hexrays_version = 390
var hx_get_int_type_by_width_and_sign
hx_get_int_type_by_width_and_sign = 169
var hx_get_member_type
hx_get_member_type = 172
var hx_get_merror_desc
hx_get_merror_desc = 144
var hx_get_mreg_name
hx_get_mreg_name = 243
var hx_get_op_signness
hx_get_op_signness = 402
var hx_get_signed_mcode
hx_get_signed_mcode = 155
var hx_get_temp_regs
hx_get_temp_regs = 389
var hx_get_type
hx_get_type = 175
var hx_get_unk_type
hx_get_unk_type = 170
var hx_get_unsigned_mcode
hx_get_unsigned_mcode = 156
var hx_get_widget_vdui
hx_get_widget_vdui = 393
var hx_getb_reginsn
hx_getb_reginsn = 336
var hx_getf_reginsn
hx_getf_reginsn = 335
var hx_graph_chains_t_for_all_chains
hx_graph_chains_t_for_all_chains = 311
var hx_graph_chains_t_release
hx_graph_chains_t_release = 312
var hx_has_cached_cfunc
hx_has_cached_cfunc = 509
var hx_hexrays_alloc
hx_hexrays_alloc = 552
var hx_hexrays_failure_t_desc
hx_hexrays_failure_t_desc = 395
var hx_hexrays_free
hx_hexrays_free = 553
var hx_install_hexrays_callback
hx_install_hexrays_callback = 512
var hx_install_microcode_filter
hx_install_microcode_filter = 200
var hx_install_optblock_handler
hx_install_optblock_handler = 149
var hx_install_optinsn_handler
hx_install_optinsn_handler = 147
var hx_is_bool_type
hx_is_bool_type = 166
var hx_is_kreg
hx_is_kreg = 388
var hx_is_mcode_propagatable
hx_is_mcode_propagatable = 152
var hx_is_nonbool_type
hx_is_nonbool_type = 165
var hx_is_small_udt
hx_is_small_udt = 164
var hx_is_type_correct
hx_is_type_correct = 163
var hx_ivl_t_compare
hx_ivl_t_compare = 228
var hx_ivl_t_dstr
hx_ivl_t_dstr = 227
var hx_ivlset_t_add
hx_ivlset_t_add = 229
var hx_ivlset_t_add_
hx_ivlset_t_add_ = 230
var hx_ivlset_t_addmasked
hx_ivlset_t_addmasked = 231
var hx_ivlset_t_compare
hx_ivlset_t_compare = 242
var hx_ivlset_t_contains
hx_ivlset_t_contains = 239
var hx_ivlset_t_count
hx_ivlset_t_count = 237
var hx_ivlset_t_dstr
hx_ivlset_t_dstr = 236
var hx_ivlset_t_has_common
hx_ivlset_t_has_common = 234
var hx_ivlset_t_has_common_
hx_ivlset_t_has_common_ = 238
var hx_ivlset_t_includes
hx_ivlset_t_includes = 240
var hx_ivlset_t_intersect
hx_ivlset_t_intersect = 241
var hx_ivlset_t_print
hx_ivlset_t_print = 235
var hx_ivlset_t_sub
hx_ivlset_t_sub = 232
var hx_ivlset_t_sub_
hx_ivlset_t_sub_ = 233
var hx_lnot
hx_lnot = 463
var hx_locate_lvar
hx_locate_lvar = 585
var hx_lvar_locator_t_compare
hx_lvar_locator_t_compare = 182
var hx_lvar_locator_t_dstr
hx_lvar_locator_t_dstr = 183
var hx_lvar_mapping_begin
hx_lvar_mapping_begin = 13
var hx_lvar_mapping_clear
hx_lvar_mapping_clear = 22
var hx_lvar_mapping_end
hx_lvar_mapping_end = 14
var hx_lvar_mapping_erase
hx_lvar_mapping_erase = 21
var hx_lvar_mapping_find
hx_lvar_mapping_find = 19
var hx_lvar_mapping_first
hx_lvar_mapping_first = 17
var hx_lvar_mapping_free
hx_lvar_mapping_free = 24
var hx_lvar_mapping_insert
hx_lvar_mapping_insert = 20
var hx_lvar_mapping_new
hx_lvar_mapping_new = 25
var hx_lvar_mapping_next
hx_lvar_mapping_next = 15
var hx_lvar_mapping_prev
hx_lvar_mapping_prev = 16
var hx_lvar_mapping_second
hx_lvar_mapping_second = 18
var hx_lvar_mapping_size
hx_lvar_mapping_size = 23
var hx_lvar_ref_t_compare
hx_lvar_ref_t_compare = 250
var hx_lvar_ref_t_var
hx_lvar_ref_t_var = 251
var hx_lvar_t_accepts_type
hx_lvar_t_accepts_type = 186
var hx_lvar_t_append_list
hx_lvar_t_append_list = 587
var hx_lvar_t_append_list_
hx_lvar_t_append_list_ = 189
var hx_lvar_t_dstr
hx_lvar_t_dstr = 184
var hx_lvar_t_is_promoted_arg
hx_lvar_t_is_promoted_arg = 185
var hx_lvar_t_set_lvar_type
hx_lvar_t_set_lvar_type = 187
var hx_lvar_t_set_width
hx_lvar_t_set_width = 188
var hx_lvars_t_find
hx_lvars_t_find = 191
var hx_lvars_t_find_lvar
hx_lvars_t_find_lvar = 192
var hx_lvars_t_find_stkvar
hx_lvars_t_find_stkvar = 190
var hx_make_num
hx_make_num = 467
var hx_make_pointer
hx_make_pointer = 173
var hx_make_ref
hx_make_ref = 468
var hx_mark_cfunc_dirty
hx_mark_cfunc_dirty = 507
var hx_mba_ranges_t_range_contains
hx_mba_ranges_t_range_contains = 566
var hx_mba_t_alloc_fict_ea
hx_mba_t_alloc_fict_ea = 569
var hx_mba_t_alloc_kreg
hx_mba_t_alloc_kreg = 570
var hx_mba_t_alloc_lvars
hx_mba_t_alloc_lvars = 366
var hx_mba_t_analyze_calls
hx_mba_t_analyze_calls = 364
var hx_mba_t_arg
hx_mba_t_arg = 380
var hx_mba_t_build_graph
hx_mba_t_build_graph = 362
var hx_mba_t_combine_blocks
hx_mba_t_combine_blocks = 375
var hx_mba_t_copy_block
hx_mba_t_copy_block = 559
var hx_mba_t_create_helper_call
hx_mba_t_create_helper_call = 586
var hx_mba_t_deserialize
hx_mba_t_deserialize = 382
var hx_mba_t_dump
hx_mba_t_dump = 367
var hx_mba_t_find_mop
hx_mba_t_find_mop = 379
var hx_mba_t_for_all_insns
hx_mba_t_for_all_insns = 377
var hx_mba_t_for_all_ops
hx_mba_t_for_all_ops = 376
var hx_mba_t_for_all_topinsns
hx_mba_t_for_all_topinsns = 378
var hx_mba_t_free_kreg
hx_mba_t_free_kreg = 571
var hx_mba_t_get_graph
hx_mba_t_get_graph = 363
var hx_mba_t_idaloc2vd
hx_mba_t_idaloc2vd = 358
var hx_mba_t_idaloc2vd_
hx_mba_t_idaloc2vd_ = 572
var hx_mba_t_insert_block
hx_mba_t_insert_block = 372
var hx_mba_t_map_fict_ea
hx_mba_t_map_fict_ea = 568
var hx_mba_t_mark_chains_dirty
hx_mba_t_mark_chains_dirty = 371
var hx_mba_t_optimize_global
hx_mba_t_optimize_global = 365
var hx_mba_t_optimize_local
hx_mba_t_optimize_local = 361
var hx_mba_t_print
hx_mba_t_print = 369
var hx_mba_t_remove_block
hx_mba_t_remove_block = 373
var hx_mba_t_remove_empty_and_unreachable_blocks
hx_mba_t_remove_empty_and_unreachable_blocks = 374
var hx_mba_t_save_snapshot
hx_mba_t_save_snapshot = 581
var hx_mba_t_serialize
hx_mba_t_serialize = 381
var hx_mba_t_set_maturity
hx_mba_t_set_maturity = 583
var hx_mba_t_term
hx_mba_t_term = 360
var hx_mba_t_vd2idaloc
hx_mba_t_vd2idaloc = 359
var hx_mba_t_vd2idaloc_
hx_mba_t_vd2idaloc_ = 573
var hx_mba_t_vdump_mba
hx_mba_t_vdump_mba = 368
var hx_mba_t_verify
hx_mba_t_verify = 370
var hx_mbl_graph_t_get_du
hx_mbl_graph_t_get_du = 385
var hx_mbl_graph_t_get_ud
hx_mbl_graph_t_get_ud = 384
var hx_mbl_graph_t_is_accessed_globally
hx_mbl_graph_t_is_accessed_globally = 383
var hx_mblock_t_append_def_list
hx_mblock_t_append_def_list = 350
var hx_mblock_t_append_use_list
hx_mblock_t_append_use_list = 349
var hx_mblock_t_build_def_list
hx_mblock_t_build_def_list = 352
var hx_mblock_t_build_lists
hx_mblock_t_build_lists = 348
var hx_mblock_t_build_use_list
hx_mblock_t_build_use_list = 351
var hx_mblock_t_dump
hx_mblock_t_dump = 339
var hx_mblock_t_find_access
hx_mblock_t_find_access = 356
var hx_mblock_t_find_first_use
hx_mblock_t_find_first_use = 353
var hx_mblock_t_find_redefinition
hx_mblock_t_find_redefinition = 354
var hx_mblock_t_for_all_insns
hx_mblock_t_for_all_insns = 343
var hx_mblock_t_for_all_ops
hx_mblock_t_for_all_ops = 344
var hx_mblock_t_for_all_uses
hx_mblock_t_for_all_uses = 345
var hx_mblock_t_get_reginsn_qty
hx_mblock_t_get_reginsn_qty = 561
var hx_mblock_t_get_valranges
hx_mblock_t_get_valranges = 357
var hx_mblock_t_get_valranges_
hx_mblock_t_get_valranges_ = 556
var hx_mblock_t_init
hx_mblock_t_init = 337
var hx_mblock_t_insert_into_block
hx_mblock_t_insert_into_block = 341
var hx_mblock_t_is_rhs_redefined
hx_mblock_t_is_rhs_redefined = 355
var hx_mblock_t_optimize_block
hx_mblock_t_optimize_block = 347
var hx_mblock_t_optimize_insn
hx_mblock_t_optimize_insn = 346
var hx_mblock_t_optimize_useless_jump
hx_mblock_t_optimize_useless_jump = 560
var hx_mblock_t_print
hx_mblock_t_print = 338
var hx_mblock_t_remove_from_block
hx_mblock_t_remove_from_block = 342
var hx_mblock_t_vdump_block
hx_mblock_t_vdump_block = 340
var hx_mcallarg_t_dstr
hx_mcallarg_t_dstr = 291
var hx_mcallarg_t_print
hx_mcallarg_t_print = 290
var hx_mcallarg_t_set_regarg
hx_mcallarg_t_set_regarg = 292
var hx_mcallinfo_t_dstr
hx_mcallinfo_t_dstr = 297
var hx_mcallinfo_t_get_type
hx_mcallinfo_t_get_type = 295
var hx_mcallinfo_t_lexcompare
hx_mcallinfo_t_lexcompare = 293
var hx_mcallinfo_t_print
hx_mcallinfo_t_print = 296
var hx_mcallinfo_t_set_type
hx_mcallinfo_t_set_type = 294
var hx_mcases_t_compare
hx_mcases_t_compare = 298
var hx_mcases_t_dstr
hx_mcases_t_dstr = 300
var hx_mcases_t_print
hx_mcases_t_print = 299
var hx_mcode_modifies_d
hx_mcode_modifies_d = 157
var hx_minsn_t__make_nop
hx_minsn_t__make_nop = 322
var hx_minsn_t_copy
hx_minsn_t_copy = 314
var hx_minsn_t_dstr
hx_minsn_t_dstr = 317
var hx_minsn_t_equal_insns
hx_minsn_t_equal_insns = 323
var hx_minsn_t_find_call
hx_minsn_t_find_call = 327
var hx_minsn_t_find_ins_op
hx_minsn_t_find_ins_op = 330
var hx_minsn_t_find_num_op
hx_minsn_t_find_num_op = 331
var hx_minsn_t_find_opcode
hx_minsn_t_find_opcode = 329
var hx_minsn_t_for_all_insns
hx_minsn_t_for_all_insns = 321
var hx_minsn_t_for_all_ops
hx_minsn_t_for_all_ops = 320
var hx_minsn_t_has_side_effects
hx_minsn_t_has_side_effects = 328
var hx_minsn_t_init
hx_minsn_t_init = 313
var hx_minsn_t_is_between
hx_minsn_t_is_between = 333
var hx_minsn_t_is_helper
hx_minsn_t_is_helper = 326
var hx_minsn_t_is_noret_call
hx_minsn_t_is_noret_call = 325
var hx_minsn_t_lexcompare
hx_minsn_t_lexcompare = 324
var hx_minsn_t_may_use_aliased_memory
hx_minsn_t_may_use_aliased_memory = 334
var hx_minsn_t_modifes_d
hx_minsn_t_modifes_d = 332
var hx_minsn_t_optimize_subtree
hx_minsn_t_optimize_subtree = 319
var hx_minsn_t_print
hx_minsn_t_print = 316
var hx_minsn_t_set_combined
hx_minsn_t_set_combined = 580
var hx_minsn_t_setaddr
hx_minsn_t_setaddr = 318
var hx_minsn_t_swap
hx_minsn_t_swap = 315
var hx_mlist_t_addmem
hx_mlist_t_addmem = 246
var hx_mlist_t_compare
hx_mlist_t_compare = 249
var hx_mlist_t_dstr
hx_mlist_t_dstr = 248
var hx_mlist_t_print
hx_mlist_t_print = 247
var hx_modify_user_lvar_info
hx_modify_user_lvar_info = 562
var hx_modify_user_lvars
hx_modify_user_lvars = 195
var hx_mop_t_apply_ld_mcode
hx_mop_t_apply_ld_mcode = 289
var hx_mop_t_assign
hx_mop_t_assign = 257
var hx_mop_t_change_size
hx_mop_t_change_size = 287
var hx_mop_t_copy
hx_mop_t_copy = 256
var hx_mop_t_create_from_insn
hx_mop_t_create_from_insn = 266
var hx_mop_t_create_from_ivlset
hx_mop_t_create_from_ivlset = 263
var hx_mop_t_create_from_mlist
hx_mop_t_create_from_mlist = 262
var hx_mop_t_create_from_scattered_vdloc
hx_mop_t_create_from_scattered_vdloc = 265
var hx_mop_t_create_from_vdloc
hx_mop_t_create_from_vdloc = 264
var hx_mop_t_dstr
hx_mop_t_dstr = 261
var hx_mop_t_equal_mops
hx_mop_t_equal_mops = 276
var hx_mop_t_erase
hx_mop_t_erase = 259
var hx_mop_t_for_all_ops
hx_mop_t_for_all_ops = 278
var hx_mop_t_for_all_scattered_submops
hx_mop_t_for_all_scattered_submops = 279
var hx_mop_t_get_stkoff
hx_mop_t_get_stkoff = 281
var hx_mop_t_is01
hx_mop_t_is01 = 273
var hx_mop_t_is_bit_reg
hx_mop_t_is_bit_reg = 271
var hx_mop_t_is_constant
hx_mop_t_is_constant = 280
var hx_mop_t_is_sign_extended_from
hx_mop_t_is_sign_extended_from = 274
var hx_mop_t_is_zero_extended_from
hx_mop_t_is_zero_extended_from = 275
var hx_mop_t_lexcompare
hx_mop_t_lexcompare = 277
var hx_mop_t_make_first_half
hx_mop_t_make_first_half = 284
var hx_mop_t_make_fpnum
hx_mop_t_make_fpnum = 268
var hx_mop_t_make_helper
hx_mop_t_make_helper = 270
var hx_mop_t_make_high_half
hx_mop_t_make_high_half = 283
var hx_mop_t_make_low_half
hx_mop_t_make_low_half = 282
var hx_mop_t_make_number
hx_mop_t_make_number = 267
var hx_mop_t_make_reg_pair
hx_mop_t_make_reg_pair = 269
var hx_mop_t_make_second_half
hx_mop_t_make_second_half = 285
var hx_mop_t_may_use_aliased_memory
hx_mop_t_may_use_aliased_memory = 272
var hx_mop_t_preserve_side_effects
hx_mop_t_preserve_side_effects = 288
var hx_mop_t_print
hx_mop_t_print = 260
var hx_mop_t_shift_mop
hx_mop_t_shift_mop = 286
var hx_mop_t_swap
hx_mop_t_swap = 258
var hx_mreg2reg
hx_mreg2reg = 146
var hx_must_mcode_close_block
hx_must_mcode_close_block = 151
var hx_negate_mcode_relation
hx_negate_mcode_relation = 153
var hx_negated_relation
hx_negated_relation = 400
var hx_new_block
hx_new_block = 464
var hx_open_pseudocode
hx_open_pseudocode = 391
var hx_operand_locator_t_compare
hx_operand_locator_t_compare = 158
var hx_parse_user_call
hx_parse_user_call = 198
var hx_partial_type_num
hx_partial_type_num = 167
var hx_print_vdloc
hx_print_vdloc = 180
var hx_qstring_printer_t_print
hx_qstring_printer_t_print = 161
var hx_reg2mreg
hx_reg2mreg = 145
var hx_remitem
hx_remitem = 399
var hx_remove_hexrays_callback
hx_remove_hexrays_callback = 513
var hx_remove_optblock_handler
hx_remove_optblock_handler = 150
var hx_remove_optinsn_handler
hx_remove_optinsn_handler = 148
var hx_rename_lvar
hx_rename_lvar = 584
var hx_restore_user_cmts
hx_restore_user_cmts = 476
var hx_restore_user_defined_calls
hx_restore_user_defined_calls = 196
var hx_restore_user_iflags
hx_restore_user_iflags = 478
var hx_restore_user_labels
hx_restore_user_labels = 475
var hx_restore_user_labels2
hx_restore_user_labels2 = 564
var hx_restore_user_lvar_settings
hx_restore_user_lvar_settings = 193
var hx_restore_user_numforms
hx_restore_user_numforms = 477
var hx_restore_user_unions
hx_restore_user_unions = 479
var hx_rlist_t_dstr
hx_rlist_t_dstr = 245
var hx_rlist_t_print
hx_rlist_t_print = 244
var hx_save_user_cmts
hx_save_user_cmts = 471
var hx_save_user_defined_calls
hx_save_user_defined_calls = 197
var hx_save_user_iflags
hx_save_user_iflags = 473
var hx_save_user_labels
hx_save_user_labels = 470
var hx_save_user_labels2
hx_save_user_labels2 = 565
var hx_save_user_lvar_settings
hx_save_user_lvar_settings = 194
var hx_save_user_numforms
hx_save_user_numforms = 472
var hx_save_user_unions
hx_save_user_unions = 474
var hx_select_udt_by_offset
hx_select_udt_by_offset = 555
var hx_send_database
hx_send_database = 396
var hx_set_type
hx_set_type = 176
var hx_stkvar_ref_t_compare
hx_stkvar_ref_t_compare = 252
var hx_stkvar_ref_t_get_stkvar
hx_stkvar_ref_t_get_stkvar = 253
var hx_swap_mcode_relation
hx_swap_mcode_relation = 154
var hx_swapped_relation
hx_swapped_relation = 401
var hx_udc_filter_t_apply
hx_udc_filter_t_apply = 202
var hx_udc_filter_t_cleanup
hx_udc_filter_t_cleanup = 589
var hx_udc_filter_t_init
hx_udc_filter_t_init = 201
var hx_udcall_map_begin
hx_udcall_map_begin = 26
var hx_udcall_map_clear
hx_udcall_map_clear = 35
var hx_udcall_map_end
hx_udcall_map_end = 27
var hx_udcall_map_erase
hx_udcall_map_erase = 34
var hx_udcall_map_find
hx_udcall_map_find = 32
var hx_udcall_map_first
hx_udcall_map_first = 30
var hx_udcall_map_free
hx_udcall_map_free = 37
var hx_udcall_map_insert
hx_udcall_map_insert = 33
var hx_udcall_map_new
hx_udcall_map_new = 38
var hx_udcall_map_next
hx_udcall_map_next = 28
var hx_udcall_map_prev
hx_udcall_map_prev = 29
var hx_udcall_map_second
hx_udcall_map_second = 31
var hx_udcall_map_size
hx_udcall_map_size = 36
var hx_user_cmts_begin
hx_user_cmts_begin = 39
var hx_user_cmts_clear
hx_user_cmts_clear = 48
var hx_user_cmts_end
hx_user_cmts_end = 40
var hx_user_cmts_erase
hx_user_cmts_erase = 47
var hx_user_cmts_find
hx_user_cmts_find = 45
var hx_user_cmts_first
hx_user_cmts_first = 43
var hx_user_cmts_free
hx_user_cmts_free = 50
var hx_user_cmts_insert
hx_user_cmts_insert = 46
var hx_user_cmts_new
hx_user_cmts_new = 51
var hx_user_cmts_next
hx_user_cmts_next = 41
var hx_user_cmts_prev
hx_user_cmts_prev = 42
var hx_user_cmts_second
hx_user_cmts_second = 44
var hx_user_cmts_size
hx_user_cmts_size = 49
var hx_user_iflags_begin
hx_user_iflags_begin = 52
var hx_user_iflags_clear
hx_user_iflags_clear = 61
var hx_user_iflags_end
hx_user_iflags_end = 53
var hx_user_iflags_erase
hx_user_iflags_erase = 60
var hx_user_iflags_find
hx_user_iflags_find = 58
var hx_user_iflags_first
hx_user_iflags_first = 56
var hx_user_iflags_free
hx_user_iflags_free = 63
var hx_user_iflags_insert
hx_user_iflags_insert = 59
var hx_user_iflags_new
hx_user_iflags_new = 64
var hx_user_iflags_next
hx_user_iflags_next = 54
var hx_user_iflags_prev
hx_user_iflags_prev = 55
var hx_user_iflags_second
hx_user_iflags_second = 57
var hx_user_iflags_size
hx_user_iflags_size = 62
var hx_user_labels_begin
hx_user_labels_begin = 78
var hx_user_labels_clear
hx_user_labels_clear = 87
var hx_user_labels_end
hx_user_labels_end = 79
var hx_user_labels_erase
hx_user_labels_erase = 86
var hx_user_labels_find
hx_user_labels_find = 84
var hx_user_labels_first
hx_user_labels_first = 82
var hx_user_labels_free
hx_user_labels_free = 89
var hx_user_labels_insert
hx_user_labels_insert = 85
var hx_user_labels_new
hx_user_labels_new = 90
var hx_user_labels_next
hx_user_labels_next = 80
var hx_user_labels_prev
hx_user_labels_prev = 81
var hx_user_labels_second
hx_user_labels_second = 83
var hx_user_labels_size
hx_user_labels_size = 88
var hx_user_numforms_begin
hx_user_numforms_begin = 0
var hx_user_numforms_clear
hx_user_numforms_clear = 9
var hx_user_numforms_end
hx_user_numforms_end = 1
var hx_user_numforms_erase
hx_user_numforms_erase = 8
var hx_user_numforms_find
hx_user_numforms_find = 6
var hx_user_numforms_first
hx_user_numforms_first = 4
var hx_user_numforms_free
hx_user_numforms_free = 11
var hx_user_numforms_insert
hx_user_numforms_insert = 7
var hx_user_numforms_new
hx_user_numforms_new = 12
var hx_user_numforms_next
hx_user_numforms_next = 2
var hx_user_numforms_prev
hx_user_numforms_prev = 3
var hx_user_numforms_second
hx_user_numforms_second = 5
var hx_user_numforms_size
hx_user_numforms_size = 10
var hx_user_unions_begin
hx_user_unions_begin = 65
var hx_user_unions_clear
hx_user_unions_clear = 74
var hx_user_unions_end
hx_user_unions_end = 66
var hx_user_unions_erase
hx_user_unions_erase = 73
var hx_user_unions_find
hx_user_unions_find = 71
var hx_user_unions_first
hx_user_unions_first = 69
var hx_user_unions_free
hx_user_unions_free = 76
var hx_user_unions_insert
hx_user_unions_insert = 72
var hx_user_unions_new
hx_user_unions_new = 77
var hx_user_unions_next
hx_user_unions_next = 67
var hx_user_unions_prev
hx_user_unions_prev = 68
var hx_user_unions_second
hx_user_unions_second = 70
var hx_user_unions_size
hx_user_unions_size = 75
var hx_valrng_t_assign
hx_valrng_t_assign = 131
var hx_valrng_t_clear
hx_valrng_t_clear = 129
var hx_valrng_t_compare
hx_valrng_t_compare = 132
var hx_valrng_t_copy
hx_valrng_t_copy = 130
var hx_valrng_t_cvt_to_cmp
hx_valrng_t_cvt_to_cmp = 143
var hx_valrng_t_cvt_to_single_value
hx_valrng_t_cvt_to_single_value = 142
var hx_valrng_t_dstr
hx_valrng_t_dstr = 141
var hx_valrng_t_has
hx_valrng_t_has = 139
var hx_valrng_t_intersect_with
hx_valrng_t_intersect_with = 136
var hx_valrng_t_inverse
hx_valrng_t_inverse = 138
var hx_valrng_t_print
hx_valrng_t_print = 140
var hx_valrng_t_reduce_size
hx_valrng_t_reduce_size = 135
var hx_valrng_t_set_cmp
hx_valrng_t_set_cmp = 134
var hx_valrng_t_set_eq
hx_valrng_t_set_eq = 133
var hx_valrng_t_unite_with
hx_valrng_t_unite_with = 137
var hx_var_ref_t_compare
hx_var_ref_t_compare = 409
var hx_vcall_helper
hx_vcall_helper = 466
var hx_vcreate_helper
hx_vcreate_helper = 465
var hx_vd_printer_t_print
hx_vd_printer_t_print = 159
var hx_vdloc_t_compare
hx_vdloc_t_compare = 178
var hx_vdloc_t_dstr
hx_vdloc_t_dstr = 177
var hx_vdloc_t_is_aliasable
hx_vdloc_t_is_aliasable = 179
var hx_vdui_t_calc_cmt_type
hx_vdui_t_calc_cmt_type = 540
var hx_vdui_t_clear
hx_vdui_t_clear = 520
var hx_vdui_t_collapse_item
hx_vdui_t_collapse_item = 549
var hx_vdui_t_collapse_lvars
hx_vdui_t_collapse_lvars = 550
var hx_vdui_t_ctree_to_disasm
hx_vdui_t_ctree_to_disasm = 539
var hx_vdui_t_del_orphan_cmts
hx_vdui_t_del_orphan_cmts = 543
var hx_vdui_t_edit_cmt
hx_vdui_t_edit_cmt = 541
var hx_vdui_t_edit_func_cmt
hx_vdui_t_edit_func_cmt = 542
var hx_vdui_t_get_current_item
hx_vdui_t_get_current_item = 522
var hx_vdui_t_get_current_label
hx_vdui_t_get_current_label = 519
var hx_vdui_t_get_number
hx_vdui_t_get_number = 518
var hx_vdui_t_invert_bits
hx_vdui_t_invert_bits = 548
var hx_vdui_t_invert_sign
hx_vdui_t_invert_sign = 547
var hx_vdui_t_jump_enter
hx_vdui_t_jump_enter = 538
var hx_vdui_t_map_lvar
hx_vdui_t_map_lvar = 532
var hx_vdui_t_refresh_cpos
hx_vdui_t_refresh_cpos = 521
var hx_vdui_t_refresh_ctext
hx_vdui_t_refresh_ctext = 516
var hx_vdui_t_refresh_view
hx_vdui_t_refresh_view = 515
var hx_vdui_t_rename_global
hx_vdui_t_rename_global = 536
var hx_vdui_t_rename_label
hx_vdui_t_rename_label = 537
var hx_vdui_t_rename_lvar
hx_vdui_t_rename_lvar = 524
var hx_vdui_t_rename_strmem
hx_vdui_t_rename_strmem = 534
var hx_vdui_t_set_global_type
hx_vdui_t_set_global_type = 535
var hx_vdui_t_set_locked
hx_vdui_t_set_locked = 514
var hx_vdui_t_set_lvar_cmt
hx_vdui_t_set_lvar_cmt = 529
var hx_vdui_t_set_lvar_type
hx_vdui_t_set_lvar_type = 527
var hx_vdui_t_set_noptr_lvar
hx_vdui_t_set_noptr_lvar = 554
var hx_vdui_t_set_num_enum
hx_vdui_t_set_num_enum = 545
var hx_vdui_t_set_num_radix
hx_vdui_t_set_num_radix = 544
var hx_vdui_t_set_num_stroff
hx_vdui_t_set_num_stroff = 546
var hx_vdui_t_set_strmem_type
hx_vdui_t_set_strmem_type = 533
var hx_vdui_t_split_item
hx_vdui_t_split_item = 551
var hx_vdui_t_switch_to
hx_vdui_t_switch_to = 517
var hx_vdui_t_ui_edit_lvar_cmt
hx_vdui_t_ui_edit_lvar_cmt = 528
var hx_vdui_t_ui_map_lvar
hx_vdui_t_ui_map_lvar = 530
var hx_vdui_t_ui_rename_lvar
hx_vdui_t_ui_rename_lvar = 523
var hx_vdui_t_ui_set_call_type
hx_vdui_t_ui_set_call_type = 525
var hx_vdui_t_ui_set_lvar_type
hx_vdui_t_ui_set_lvar_type = 526
var hx_vdui_t_ui_unmap_lvar
hx_vdui_t_ui_unmap_lvar = 531
var hx_vivl_t_dstr
hx_vivl_t_dstr = 304
var hx_vivl_t_extend_to_cover
hx_vivl_t_extend_to_cover = 301
var hx_vivl_t_intersect
hx_vivl_t_intersect = 302
var hx_vivl_t_print
hx_vivl_t_print = 303
var hxe_build_callinfo
hxe_build_callinfo = 15
var hxe_close_pseudocode
hxe_close_pseudocode = 103
var hxe_cmt_changed
hxe_cmt_changed = 115
var hxe_combine
hxe_combine = 11
var hxe_create_hint
hxe_create_hint = 108
var hxe_curpos
hxe_curpos = 107
var hxe_double_click
hxe_double_click = 106
var hxe_flowchart
hxe_flowchart = 0
var hxe_func_printed
hxe_func_printed = 13
var hxe_glbopt
hxe_glbopt = 7
var hxe_interr
hxe_interr = 10
var hxe_keyboard
hxe_keyboard = 104
var hxe_locopt
hxe_locopt = 5
var hxe_maturity
hxe_maturity = 9
var hxe_microcode
hxe_microcode = 3
var hxe_open_pseudocode
hxe_open_pseudocode = 100
var hxe_populating_popup
hxe_populating_popup = 110
var hxe_prealloc
hxe_prealloc = 6
var hxe_preoptimized
hxe_preoptimized = 4
var hxe_print_func
hxe_print_func = 12
var hxe_prolog
hxe_prolog = 2
var hxe_refresh_pseudocode
hxe_refresh_pseudocode = 102
var hxe_resolve_stkaddrs
hxe_resolve_stkaddrs = 14
var hxe_right_click
hxe_right_click = 105
var hxe_stkpnts
hxe_stkpnts = 1
var hxe_structural
hxe_structural = 8
var hxe_switch_pseudocode
hxe_switch_pseudocode = 101
var hxe_text_ready
hxe_text_ready = 109
var k
k = 'voff_t_undef'
var lxe_lvar_cmt_changed
lxe_lvar_cmt_changed = 113
var lxe_lvar_mapping_changed
lxe_lvar_mapping_changed = 114
var lxe_lvar_name_changed
lxe_lvar_name_changed = 111
var lxe_lvar_type_changed
lxe_lvar_type_changed = 112
var m_add
m_add = 12
var m_and
m_and = 20
var m_bnot
m_bnot = 7
var m_call
m_call = 56
var m_cfadd
m_cfadd = 25
var m_cfshl
m_cfshl = 27
var m_cfshr
m_cfshr = 28
var m_ext
m_ext = 62
var m_f2f
m_f2f = 67
var m_f2i
m_f2i = 63
var m_f2u
m_f2u = 64
var m_fadd
m_fadd = 69
var m_fdiv
m_fdiv = 72
var m_fmul
m_fmul = 71
var m_fneg
m_fneg = 68
var m_fsub
m_fsub = 70
var m_goto
m_goto = 55
var m_high
m_high = 11
var m_i2f
m_i2f = 65
var m_icall
m_icall = 57
var m_ijmp
m_ijmp = 54
var m_ja
m_ja = 47
var m_jae
m_jae = 45
var m_jb
m_jb = 46
var m_jbe
m_jbe = 48
var m_jcnd
m_jcnd = 42
var m_jg
m_jg = 49
var m_jge
m_jge = 50
var m_jl
m_jl = 51
var m_jle
m_jle = 52
var m_jnz
m_jnz = 43
var m_jtbl
m_jtbl = 53
var m_jz
m_jz = 44
var m_ldc
m_ldc = 3
var m_ldx
m_ldx = 2
var m_lnot
m_lnot = 6
var m_low
m_low = 10
var m_mov
m_mov = 4
var m_mul
m_mul = 14
var m_neg
m_neg = 5
var m_nop
m_nop = 0
var m_ofadd
m_ofadd = 26
var m_or
m_or = 19
var m_pop
m_pop = 60
var m_push
m_push = 59
var m_ret
m_ret = 58
var m_sar
m_sar = 24
var m_sdiv
m_sdiv = 16
var m_seta
m_seta = 36
var m_setae
m_setae = 34
var m_setb
m_setb = 35
var m_setbe
m_setbe = 37
var m_setg
m_setg = 38
var m_setge
m_setge = 39
var m_setl
m_setl = 40
var m_setle
m_setle = 41
var m_setnz
m_setnz = 32
var m_seto
m_seto = 30
var m_setp
m_setp = 31
var m_sets
m_sets = 29
var m_setz
m_setz = 33
var m_shl
m_shl = 22
var m_shr
m_shr = 23
var m_smod
m_smod = 18
var m_stx
m_stx = 1
var m_sub
m_sub = 13
var m_u2f
m_u2f = 66
var m_udiv
m_udiv = 15
var m_umod
m_umod = 17
var m_und
m_und = 61
var m_xds
m_xds = 8
var m_xdu
m_xdu = 9
var m_xor
m_xor = 21
var mop_S
mop_S = 5
var mop_a
mop_a = 10
var mop_b
mop_b = 7
var mop_c
mop_c = 12
var mop_d
mop_d = 4
var mop_f
mop_f = 8
var mop_fn
mop_fn = 13
var mop_h
mop_h = 11
var mop_l
mop_l = 9
var mop_n
mop_n = 2
var mop_p
mop_p = 14
var mop_r
mop_r = 1
var mop_sc
mop_sc = 15
var mop_str
mop_str = 3
var mop_v
mop_v = 6
var mop_z
mop_z = 0
var mr_cc
mr_cc = 5
var mr_cf
mr_cf = 0
var mr_first
mr_first = 8
var mr_none
mr_none = -1
var mr_of
mr_of = 3
var mr_pf
mr_pf = 4
var mr_sf
mr_sf = 2
var mr_zf
mr_zf = 1

Functions

def accepts_small_udts(*args) ‑> bool
Is the operator allowed on small structure or union?
accepts_small_udts(op) -> bool
op (C++: ctype_t)
def accepts_udts(*args) ‑> bool
accepts_udts(op) -> bool
op (C++: ctype_t)
def arglocs_overlap(*args) ‑> bool
Do two arglocs overlap?
arglocs_overlap(loc1, w1, loc2, w2) -> bool
loc1 (C++: const vdloc_t &)
w1 (C++: size_t)
loc2 (C++: const vdloc_t &)
w2 (C++: size_t)
def asgop(*args) ‑> ctype_t
Convert plain operator into assignment operator. For example, cot_add returns cot_asgadd.
asgop(cop) -> ctype_t
cop (C++: ctype_t)
def asgop_revert(*args) ‑> ctype_t
Convert assignment operator into plain operator. For example, cot_asgadd returns cot_add
asgop_revert(cop) -> ctype_t
cop (C++: ctype_t)
return: cot_empty is the input operator is not an assignment
operator.
def block_chains_begin(*args) ‑> block_chains_iterator_t
Get iterator pointing to the beginning of 'block_chains_t' .
block_chains_begin(set) -> block_chains_iterator_t
set (C++: const block_chains_t *)
def block_chains_clear(*args) ‑> void
Clear 'block_chains_t' .
block_chains_clear(set)
set (C++: block_chains_t *)
def block_chains_end(*args) ‑> block_chains_iterator_t
Get iterator pointing to the end of 'block_chains_t' .
block_chains_end(set) -> block_chains_iterator_t
set (C++: const block_chains_t *)
def block_chains_erase(*args) ‑> void
Erase current element from 'block_chains_t' .
block_chains_erase(set, p)
set (C++: block_chains_t *)
p (C++: block_chains_iterator_t)
def block_chains_find(*args) ‑> block_chains_iterator_t
Find the specified key in set 'block_chains_t' .
block_chains_find(set, val) -> block_chains_iterator_t
set (C++: const block_chains_t *)
val (C++: const chain_t &)
def block_chains_free(*args) ‑> void
Delete 'block_chains_t' instance.
block_chains_free(set)
set (C++: block_chains_t *)
def block_chains_get(*args) ‑> chain_t &
Get reference to the current set value.
block_chains_get(p) -> chain_t
p (C++: block_chains_iterator_t)
def block_chains_insert(*args) ‑> block_chains_iterator_t
Insert new ( 'chain_t' ) into set 'block_chains_t' .
block_chains_insert(set, val) -> block_chains_iterator_t
set (C++: block_chains_t *)
val (C++: const chain_t &)
def block_chains_new(*args) ‑> block_chains_t *
Create a new 'block_chains_t' instance.
def block_chains_next(*args) ‑> block_chains_iterator_t
Move to the next element.
block_chains_next(p) -> block_chains_iterator_t
p (C++: block_chains_iterator_t)
def block_chains_prev(*args) ‑> block_chains_iterator_t
Move to the previous element.
block_chains_prev(p) -> block_chains_iterator_t
p (C++: block_chains_iterator_t)
def block_chains_size(*args) ‑> size_t
Get size of 'block_chains_t' .
block_chains_size(set) -> size_t
set (C++: block_chains_t *)
def boundaries_begin(*args) ‑> boundaries_iterator_t
Get iterator pointing to the beginning of boundaries_t.
boundaries_begin(map) -> boundaries_iterator_t
map (C++: const boundaries_t *)
def boundaries_clear(*args) ‑> void
Clear boundaries_t.
boundaries_clear(map)
map (C++: boundaries_t *)
def boundaries_end(*args) ‑> boundaries_iterator_t
Get iterator pointing to the end of boundaries_t.
boundaries_end(map) -> boundaries_iterator_t
map (C++: const boundaries_t *)
def boundaries_erase(*args) ‑> void
Erase current element from boundaries_t.
boundaries_erase(map, p)
map (C++: boundaries_t *)
p (C++: boundaries_iterator_t)
def boundaries_find(*args) ‑> boundaries_iterator_t
Find the specified key in boundaries_t.
boundaries_find(map, key) -> boundaries_iterator_t
map (C++: const boundaries_t *)
key (C++: const cinsn_t *&)
def boundaries_first(*args) ‑> cinsn_t *const &
Get reference to the current map key.
boundaries_first(p) -> cinsn_t
p (C++: boundaries_iterator_t)
def boundaries_free(*args) ‑> void
Delete boundaries_t instance.
boundaries_free(map)
map (C++: boundaries_t *)
def boundaries_insert(*args) ‑> boundaries_iterator_t
Insert new ( 'cinsn_t' *, 'rangeset_t' ) pair into boundaries_t.
boundaries_insert(map, key, val) -> boundaries_iterator_t
map (C++: boundaries_t *)
key (C++: const cinsn_t *&)
val (C++: const rangeset_t &)
def boundaries_new(*args) ‑> boundaries_t *
Create a new boundaries_t instance.
def boundaries_next(*args) ‑> boundaries_iterator_t
Move to the next element.
boundaries_next(p) -> boundaries_iterator_t
p (C++: boundaries_iterator_t)
def boundaries_prev(*args) ‑> boundaries_iterator_t
Move to the previous element.
boundaries_prev(p) -> boundaries_iterator_t
p (C++: boundaries_iterator_t)
def boundaries_second(*args) ‑> rangeset_t &
Get reference to the current map value.
boundaries_second(p) -> rangeset_t
p (C++: boundaries_iterator_t)
def boundaries_size(*args) ‑> size_t
Get size of boundaries_t.
boundaries_size(map) -> size_t
map (C++: boundaries_t *)
def call_helper(rettype, args, *rest)
def cexpr_operands(self)
return a dictionary with the operands of a cexpr_t.
def cfunc_type(self)
Get the function's return type tinfo_t object.
def checkout_hexrays_license(*args) ‑> bool
Check out a floating decompiler license. This function will display a dialog box if the license is not available. For non-floating licenses this function is effectively no-op. It is not necessary to call this function before decompiling. If the license was not checked out, the decompiler will automatically do it. This function can be used to check out a license in advance and ensure that a license is available.
checkout_hexrays_license(silent) -> bool
silent: silently fail if the license cannot be checked out.
(C++: bool)
return: false if failed
def cinsn_details(self)
return the details pointer for the cinsn_t object depending on the value of its op member. this is one of the cblock_t, cif_t, etc. objects.
def cinsn_t_insn_is_epilog(*args) ‑> bool
cinsn_t_insn_is_epilog(insn) -> bool
insn: cinsn_t const *
def citem_to_specific_type(self)
cast the citem_t object to its more specific type, either cexpr_t or cinsn_t.
def clear_cached_cfuncs(*args) ‑> void
Flush all cached decompilation results.
def close_hexrays_waitbox(*args) ‑> void
Close the waitbox displayed by the decompiler. Useful if DECOMP_NO_HIDE was used during decompilation.
def close_pseudocode(*args) ‑> bool
Close pseudocode window.
close_pseudocode(f) -> bool
f: pointer to window (C++: TWidget *)
return: false if failed
def convert_to_user_call(*args) ‑> merror_t
try to generate user-defined call for an instruction
convert_to_user_call(udc, cdg) -> merror_t
udc (C++: const udcall_t &)
cdg (C++: codegen_t &)
return: Microcode error codes code: MERR_OK - user-defined call
generated else - error (MERR_INSN == inacceptable udc.tif)
def create_cfunc(*args) ‑> cfuncptr_t
Create a new 'cfunc_t' object.
create_cfunc(mba) -> cfuncptr_t
mba: microcode object. After creating the cfunc object it takes
the ownership of MBA. (C++: mba_t *)
def create_field_name(*args) ‑> qstring
create_field_name(type, offset=BADADDR) -> qstring
type (C++: const tinfo_t &)
offset (C++: uval_t)
def create_helper(*args)
def create_typedef(*args) ‑> tinfo_t
Create a reference to a named type.
create_typedef(name) -> tinfo_t
name: type name (C++: const char *)
return: type which refers to the specified ordinal. For example, if n
is 1, the type info which refers to ordinal type 1 is created.
create_typedef(n) -> tinfo_t
n: int
return: type which refers to the specified ordinal. For example, if n
is 1, the type info which refers to ordinal type 1 is created.
def debug_hexrays_ctree(*args) ‑> void
debug_hexrays_ctree(level, msg)
level: int msg: char const *
def decompile(ea, hf=None, flags=0)
def decompile_func(*args) ‑> cfuncptr_t
Decompile a function. Multiple decompilations of the same function return the same object.
decompile_func(pfn, hf, decomp_flags=0) -> cfuncptr_t
pfn: pointer to function to decompile (C++: func_t *)
hf: extended error information (if failed) (C++:
hexrays_failure_t *)
decomp_flags: bitwise combination of decompile() flags ...
bits (C++: int)
return: pointer to the decompilation result (a reference counted
pointer). NULL if failed.
def decompile_many(*args) ‑> bool
Batch decompilation. Decompile all or the specified functions
decompile_many(outfile, funcaddrs, flags) -> bool
outfile: name of the output file (C++: const char *)
funcaddrs: list of functions to decompile. If NULL or empty,
then decompile all nonlib functions (C++: const eavec_t *)
flags: Batch decompilation bits (C++: int)
return: true if no internal error occurred and the user has not
cancelled decompilation
def dereference(e, ptrsize, is_float=False)
def dstr(*args) ‑> char const *
Print the specified type info. This function can be used from a debugger by typing "tif->dstr()"
dstr(tif) -> char const *
tif (C++: const tinfo_t *)
def dummy_ptrtype(*args) ‑> tinfo_t
Generate a dummy pointer type
dummy_ptrtype(ptrsize, isfp) -> tinfo_t
ptrsize: size of pointed object (C++: int)
isfp: is floating point object? (C++: bool)
def eamap_begin(*args) ‑> eamap_iterator_t
Get iterator pointing to the beginning of eamap_t.
eamap_begin(map) -> eamap_iterator_t
map (C++: const eamap_t *)
def eamap_clear(*args) ‑> void
Clear eamap_t.
eamap_clear(map)
map (C++: eamap_t *)
def eamap_end(*args) ‑> eamap_iterator_t
Get iterator pointing to the end of eamap_t.
eamap_end(map) -> eamap_iterator_t
map (C++: const eamap_t *)
def eamap_erase(*args) ‑> void
Erase current element from eamap_t.
eamap_erase(map, p)
map (C++: eamap_t *)
p (C++: eamap_iterator_t)
def eamap_find(*args) ‑> eamap_iterator_t
Find the specified key in eamap_t.
eamap_find(map, key) -> eamap_iterator_t
map (C++: const eamap_t *)
key (C++: const ea_t &)
def eamap_first(*args) ‑> ea_t const &
Get reference to the current map key.
eamap_first(p) -> ea_t const &
p (C++: eamap_iterator_t)
def eamap_free(*args) ‑> void
Delete eamap_t instance.
eamap_free(map)
map (C++: eamap_t *)
def eamap_insert(*args) ‑> eamap_iterator_t
Insert new (ea_t, cinsnptrvec_t) pair into eamap_t.
eamap_insert(map, key, val) -> eamap_iterator_t
map (C++: eamap_t *)
key (C++: const ea_t &)
val (C++: const cinsnptrvec_t &)
def eamap_new(*args) ‑> eamap_t *
Create a new eamap_t instance.
def eamap_next(*args) ‑> eamap_iterator_t
Move to the next element.
eamap_next(p) -> eamap_iterator_t
p (C++: eamap_iterator_t)
def eamap_prev(*args) ‑> eamap_iterator_t
Move to the previous element.
eamap_prev(p) -> eamap_iterator_t
p (C++: eamap_iterator_t)
def eamap_second(*args) ‑> cinsnptrvec_t &
Get reference to the current map value.
eamap_second(p) -> cinsnptrvec_t
p (C++: eamap_iterator_t)
def eamap_size(*args) ‑> size_t
Get size of eamap_t.
eamap_size(map) -> size_t
map (C++: eamap_t *)
def gen_microcode(*args) ‑> mba_t *
Generate microcode of an arbitrary code snippet
gen_microcode(mbr, hf, retlist=None, decomp_flags=0, reqmat=MMAT_GLBOPT3) -> mba_t
mbr: snippet ranges (C++: const mba_ranges_t &)
hf: extended error information (if failed) (C++:
hexrays_failure_t *)
retlist: list of registers the snippet returns (C++: const
mlist_t *)
decomp_flags: bitwise combination of decompile() flags ...
bits (C++: int)
reqmat: required microcode maturity (C++: mba_maturity_t)
return: pointer to the microcode, NULL if failed.
def get_ctype_name(*args) ‑> char const *
get_ctype_name(op) -> char const *
op (C++: ctype_t)
def get_current_operand(*args) ‑> bool
Get the instruction operand under the cursor. This function determines the operand that is under the cursor in the active disassembly listing. If the operand refers to a register or stack variable, it returns true.
get_current_operand(out) -> bool
out (C++: gco_info_t *)
def get_float_type(*args) ‑> tinfo_t
Get a type of a floating point value with the specified width
get_float_type(width) -> tinfo_t
width: width of the desired type (C++: int)
return: type info object
def get_hexrays_version(*args) ‑> char const *
Get decompiler version. The returned string is of the form <major>.<minor>.<revision>.<build-date>
def get_int_type_by_width_and_sign(*args) ‑> tinfo_t
Create a type info by width and sign. Returns a simple type (examples: int, short) with the given width and sign.
get_int_type_by_width_and_sign(srcwidth, sign) -> tinfo_t
srcwidth: size of the type in bytes (C++: int)
sign: sign of the type (C++: type_sign_t)
def get_member_type(*args) ‑> bool
Get type of a structure field. This function performs validity checks of the field type. Wrong types are rejected.
get_member_type(mptr, type) -> bool
mptr: structure field (C++: const member_t *)
type: pointer to the variable where the type is returned. This
parameter can be NULL. (C++: tinfo_t *)
return: false if failed
def get_merror_desc(*args) ‑> qstring *
Get textual description of an error code
get_merror_desc(code, mba) -> str
code: Microcode error codes (C++: merror_t)
mba: the microcode array (C++: mba_t *)
return: the error address
def get_mreg_name(*args) ‑> qstring *
Get the microregister name.
get_mreg_name(reg, width, ud=None) -> str
reg (C++: mreg_t)
width: size of microregister in bytes. may be bigger than the
real register size. (C++: int)
ud: reserved, must be nullptr (C++: void *)
return: width of the printed register. this value may be less than
the WIDTH argument.
def get_op_signness(*args) ‑> type_sign_t
Get operator sign. Meaningful for sign-dependent operators, like cot_sdiv.
get_op_signness(op) -> type_sign_t
op (C++: ctype_t)
def get_signed_mcode(*args) ‑> mcode_t
get_signed_mcode(code) -> mcode_t
code (C++: mcode_t)
def get_temp_regs(*args) ‑> mlist_t const &
Get list of temporary registers. Tempregs are temporary registers that are used during code generation. They do not map to regular processor registers. They are used only to store temporary values during execution of one instruction. Tempregs may not be used to pass a value from one block to another. In other words, at the end of a block all tempregs must be dead.
def get_type(*args) ‑> bool
Get a global type. Global types are types of addressable objects and struct/union/enum types
get_type(id, tif, guess) -> bool
id: address or id of the object (C++: uval_t)
tif: buffer for the answer (C++: tinfo_t *)
guess: what kind of types to consider (C++: type_source_t)
return: success
def get_unk_type(*args) ‑> tinfo_t
Create a partial type info by width. Returns a partially defined type (examples: _DWORD, _BYTE) with the given width.
get_unk_type(size) -> tinfo_t
size: size of the type in bytes (C++: int)
def get_unsigned_mcode(*args) ‑> mcode_t
get_unsigned_mcode(code) -> mcode_t
code (C++: mcode_t)
def get_widget_vdui(*args) ‑> vdui_t *
Get the 'vdui_t' instance associated to the TWidget
get_widget_vdui(f) -> vdui_t
f: pointer to window (C++: TWidget *)
return: a vdui_t *, or NULL
def getb_reginsn(*args) ‑> minsn_t *
Skip assertions backward.
getb_reginsn(ins) -> minsn_t
ins (C++: const minsn_t *)
def getf_reginsn(*args) ‑> minsn_t *
Skip assertions forward.
getf_reginsn(ins) -> minsn_t
ins (C++: const minsn_t *)
def has_cached_cfunc(*args) ‑> bool
Do we have a cached decompilation result for 'ea'?
has_cached_cfunc(ea) -> bool
ea (C++: ea_t)
def has_mcode_seloff(*args) ‑> bool
has_mcode_seloff(op) -> bool
op (C++: mcode_t)
def hexrays_alloc(*args) ‑> void *
hexrays_alloc(size) -> void *
size (C++: size_t)
def hexrays_free(*args) ‑> void
hexrays_free(ptr)
ptr (C++: void *)
def init_hexrays_plugin(*args) ‑> bool
Check that your plugin is compatible with hex-rays decompiler. This function must be called before calling any other decompiler function.
init_hexrays_plugin(flags=0) -> bool
flags: reserved, must be 0 (C++: int)
return: true if the decompiler exists and is compatible with your
plugin
def install_hexrays_callback(callback)
Deprecated. Please use Hexrays_Hooks instead
def install_microcode_filter(*args) ‑> bool
register/unregister non-standard microcode generator
install_microcode_filter(filter, install=True) -> bool
filter: - microcode generator object (C++: microcode_filter_t
*)
install: - TRUE - register the object, FALSE - unregister (C++:
bool)
return: success
def is_additive(*args) ‑> bool
Is additive operator?
is_additive(op) -> bool
op (C++: ctype_t)
def is_allowed_on_small_struni(*args) ‑> bool
Is the operator allowed on small structure or union?
accepts_small_udts(op) -> bool
op (C++: ctype_t)
def is_assignment(*args) ‑> bool
Is assignment operator?
is_assignment(op) -> bool
op (C++: ctype_t)
def is_binary(*args) ‑> bool
Is binary operator?
is_binary(op) -> bool
op (C++: ctype_t)
def is_bitop(*args) ‑> bool
Is bit related operator?
is_bitop(op) -> bool
op (C++: ctype_t)
def is_bool_type(*args) ‑> bool
Is a boolean type?
is_bool_type(type) -> bool
type (C++: const tinfo_t &)
return: true if the type is a boolean type
def is_break_consumer(*args) ‑> bool
Does a break statement influence the specified statement code?
is_break_consumer(op) -> bool
op (C++: ctype_t)
def is_commutative(*args) ‑> bool
Is commutative operator?
is_commutative(op) -> bool
op (C++: ctype_t)
def is_inplace_def(*args) ‑> bool
Is struct/union/enum definition (not declaration)?
is_inplace_def(type) -> bool
type (C++: const tinfo_t &)
def is_kreg(*args) ‑> bool
Is a kernel register? Kernel registers are temporary registers that can be used freely. They may be used to store values that cross instruction or basic block boundaries. Kernel registers do not map to regular processor registers. See also 'mba_t::alloc_kreg()'
is_kreg(r) -> bool
r (C++: mreg_t)
def is_logical(*args) ‑> bool
Is logical operator?
is_logical(op) -> bool
op (C++: ctype_t)
def is_loop(*args) ‑> bool
Is loop statement code?
is_loop(op) -> bool
op (C++: ctype_t)
def is_lvalue(*args) ‑> bool
Is Lvalue operator?
is_lvalue(op) -> bool
op (C++: ctype_t)
def is_may_access(*args) ‑> bool
is_may_access(maymust) -> bool
maymust (C++: maymust_t)
def is_mcode_addsub(*args) ‑> bool
is_mcode_addsub(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_call(*args) ‑> bool
is_mcode_call(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_commutative(*args) ‑> bool
is_mcode_commutative(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_convertible_to_jmp(*args) ‑> bool
is_mcode_convertible_to_jmp(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_convertible_to_set(*args) ‑> bool
is_mcode_convertible_to_set(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_divmod(*args) ‑> bool
is_mcode_divmod(op) -> bool
op (C++: mcode_t)
def is_mcode_fpu(*args) ‑> bool
is_mcode_fpu(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_j1(*args) ‑> bool
is_mcode_j1(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_jcond(*args) ‑> bool
is_mcode_jcond(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_propagatable(*args) ‑> bool
May opcode be propagated? Such opcodes can be used in sub-instructions (nested instructions) There is a handful of non-propagatable opcodes, like jumps, ret, nop, etc All other regular opcodes are propagatable and may appear in a nested instruction.
is_mcode_propagatable(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_set(*args) ‑> bool
is_mcode_set(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_set1(*args) ‑> bool
is_mcode_set1(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_shift(*args) ‑> bool
is_mcode_shift(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_xdsu(*args) ‑> bool
is_mcode_xdsu(mcode) -> bool
mcode (C++: mcode_t)
def is_multiplicative(*args) ‑> bool
Is multiplicative operator?
is_multiplicative(op) -> bool
op (C++: ctype_t)
def is_nonbool_type(*args) ‑> bool
Is definitely a non-boolean type?
is_nonbool_type(type) -> bool
type (C++: const tinfo_t &)
return: true if the type is a non-boolean type (non bool and well
defined)
def is_paf(*args) ‑> bool
Is a pointer, array, or function type?
is_paf(t) -> bool
t (C++: type_t)
def is_prepost(*args) ‑> bool
Is pre/post increment/decrement operator?
is_prepost(op) -> bool
op (C++: ctype_t)
def is_ptr_or_array(*args) ‑> bool
Is a pointer or array type?
is_ptr_or_array(t) -> bool
t (C++: type_t)
def is_relational(*args) ‑> bool
Is comparison operator?
is_relational(op) -> bool
op (C++: ctype_t)
def is_signed_mcode(*args) ‑> bool
is_signed_mcode(code) -> bool
code (C++: mcode_t)
def is_small_struni(*args) ‑> bool
Is a small structure or union?
is_small_udt(tif) -> bool
tif (C++: const tinfo_t &)
return: true if the type is a small UDT (user defined type). Small
UDTs fit into a register (or pair or registers) as a rule.
def is_small_udt(*args) ‑> bool
Is a small structure or union?
is_small_udt(tif) -> bool
tif (C++: const tinfo_t &)
return: true if the type is a small UDT (user defined type). Small
UDTs fit into a register (or pair or registers) as a rule.
def is_type_correct(*args) ‑> bool
Verify a type string.
is_type_correct(ptr) -> bool
ptr (C++: const type_t *)
return: true if type string is correct
def is_unary(*args) ‑> bool
Is unary operator?
is_unary(op) -> bool
op (C++: ctype_t)
def is_unsigned_mcode(*args) ‑> bool
is_unsigned_mcode(code) -> bool
code (C++: mcode_t)
def jcnd2set(*args) ‑> mcode_t
jcnd2set(code) -> mcode_t
code (C++: mcode_t)
def lexcompare(*args) ‑> int
lexcompare(a, b) -> int
a: mop_t const & b: mop_t const &
def lnot(e)
def locate_lvar(*args) ‑> bool
Find a variable by name.
locate_lvar(out, func_ea, varname) -> bool
out: output buffer for the variable locator (C++:
lvar_locator_t *)
func_ea: function start address (C++: ea_t)
varname: variable name (C++: const char *)
return: success Since VARNAME is not always enough to find the
variable, it may decompile the function.
def lvar_mapping_begin(*args) ‑> lvar_mapping_iterator_t
Get iterator pointing to the beginning of lvar_mapping_t.
lvar_mapping_begin(map) -> lvar_mapping_iterator_t
map (C++: const lvar_mapping_t *)
def lvar_mapping_clear(*args) ‑> void
Clear lvar_mapping_t.
lvar_mapping_clear(map)
map (C++: lvar_mapping_t *)
def lvar_mapping_end(*args) ‑> lvar_mapping_iterator_t
Get iterator pointing to the end of lvar_mapping_t.
lvar_mapping_end(map) -> lvar_mapping_iterator_t
map (C++: const lvar_mapping_t *)
def lvar_mapping_erase(*args) ‑> void
Erase current element from lvar_mapping_t.
lvar_mapping_erase(map, p)
map (C++: lvar_mapping_t *)
p (C++: lvar_mapping_iterator_t)
def lvar_mapping_find(*args) ‑> lvar_mapping_iterator_t
Find the specified key in lvar_mapping_t.
lvar_mapping_find(map, key) -> lvar_mapping_iterator_t
map (C++: const lvar_mapping_t *)
key (C++: const lvar_locator_t &)
def lvar_mapping_first(*args) ‑> lvar_locator_t const &
Get reference to the current map key.
lvar_mapping_first(p) -> lvar_locator_t
p (C++: lvar_mapping_iterator_t)
def lvar_mapping_free(*args) ‑> void
Delete lvar_mapping_t instance.
lvar_mapping_free(map)
map (C++: lvar_mapping_t *)
def lvar_mapping_insert(*args) ‑> lvar_mapping_iterator_t
Insert new ( 'lvar_locator_t' , 'lvar_locator_t' ) pair into lvar_mapping_t.
lvar_mapping_insert(map, key, val) -> lvar_mapping_iterator_t
map (C++: lvar_mapping_t *)
key (C++: const lvar_locator_t &)
val (C++: const lvar_locator_t &)
def lvar_mapping_new(*args) ‑> lvar_mapping_t *
Create a new lvar_mapping_t instance.
def lvar_mapping_next(*args) ‑> lvar_mapping_iterator_t
Move to the next element.
lvar_mapping_next(p) -> lvar_mapping_iterator_t
p (C++: lvar_mapping_iterator_t)
def lvar_mapping_prev(*args) ‑> lvar_mapping_iterator_t
Move to the previous element.
lvar_mapping_prev(p) -> lvar_mapping_iterator_t
p (C++: lvar_mapping_iterator_t)
def lvar_mapping_second(*args) ‑> lvar_locator_t &
Get reference to the current map value.
lvar_mapping_second(p) -> lvar_locator_t
p (C++: lvar_mapping_iterator_t)
def lvar_mapping_size(*args) ‑> size_t
Get size of lvar_mapping_t.
lvar_mapping_size(map) -> size_t
map (C++: lvar_mapping_t *)
def make_num(*args)
def make_pointer(*args) ‑> tinfo_t
Create a pointer type. This function performs the following conversion: "type" -> "type*"
make_pointer(type) -> tinfo_t
type: object type. (C++: const tinfo_t &)
return: "type*". for example, if 'char' is passed as the argument,
def make_ref(e)
def mark_cfunc_dirty(*args) ‑> bool
Flush the cached decompilation results. Erases a cache entry for the specified function.
mark_cfunc_dirty(ea, close_views=False) -> bool
ea: function to erase from the cache (C++: ea_t)
close_views: close pseudocode windows that show the function
(C++: bool)
return: if a cache entry existed.
def mba_t_deserialize(*args) ‑> mba_t *
mba_t_deserialize(bytes) -> mba_t
bytes: uchar const *
def mcode_modifies_d(*args) ‑> bool
mcode_modifies_d(mcode) -> bool
mcode (C++: mcode_t)
def modify_user_lvar_info(*args) ‑> bool
Modify saved local variable settings of one variable.
modify_user_lvar_info(func_ea, mli_flags, info) -> bool
func_ea: function start address (C++: ea_t)
mli_flags: bits that specify which attrs defined by INFO are to
be set (C++: uint)
info: local variable info attrs (C++: const lvar_saved_info_t
&)
return: true if modified, false if invalid MLI_FLAGS passed
def modify_user_lvars(*args) ‑> bool
Modify saved local variable settings.
modify_user_lvars(entry_ea, mlv) -> bool
entry_ea: function start address (C++: ea_t)
mlv: local variable modifier (C++: user_lvar_modifier_t &)
return: true if modified variables
def mreg2reg(*args) ‑> int
Map a microregister to a processor register.
mreg2reg(reg, width) -> int
reg: microregister number (C++: mreg_t)
width: size of microregister in bytes (C++: int)
return: processor register id or -1
def must_mcode_close_block(*args) ‑> bool
Must an instruction with the given opcode be the last one in a block? Such opcodes are called closing opcodes.
must_mcode_close_block(mcode, including_calls) -> bool
mcode: instruction opcode (C++: mcode_t)
including_calls: should m_call/m_icall be considered as the
closing opcodes? If this function returns true, the opcode cannot appear in the middle of a block. Calls are a special case: unknown calls (is_unknown_call) are considered as closing opcodes. (C++: bool)
def negate_mcode_relation(*args) ‑> mcode_t
negate_mcode_relation(code) -> mcode_t
code (C++: mcode_t)
def negated_relation(*args) ‑> ctype_t
Negate a comparison operator. For example, cot_sge becomes cot_slt.
negated_relation(op) -> ctype_t
op (C++: ctype_t)
def new_block()
def op_uses_x(*args) ‑> bool
Does operator use the 'x' field of 'cexpr_t' ?
op_uses_x(op) -> bool
op (C++: ctype_t)
def op_uses_y(*args) ‑> bool
Does operator use the 'y' field of 'cexpr_t' ?
op_uses_y(op) -> bool
op (C++: ctype_t)
def op_uses_z(*args) ‑> bool
Does operator use the 'z' field of 'cexpr_t' ?
op_uses_z(op) -> bool
op (C++: ctype_t)
def open_pseudocode(*args) ‑> vdui_t *
Open pseudocode window. The specified function is decompiled and the pseudocode window is opened.
open_pseudocode(ea, flags) -> vdui_t
ea: function to decompile (C++: ea_t)
flags: a combination of OPF_ flags (C++: int)
return: false if failed
def parse_user_call(*args) ‑> bool
Convert function type declaration into internal structure
parse_user_call(udc, decl, silent) -> bool
udc: - pointer to output structure (C++: udcall_t *)
decl: - function type declaration (C++: const char *)
silent: - if TRUE: do not show warning in case of incorrect
type (C++: bool)
return: success
def partial_type_num(*args) ‑> int
Calculate number of partial subtypes.
partial_type_num(type) -> int
type (C++: const tinfo_t &)
return: number of partial subtypes. The bigger is this number, the
uglier is the type.
def print_vdloc(*args) ‑> qstring *
Print vdloc. Since vdloc does not always carry the size info, we pass it as NBYTES..
print_vdloc(loc, nbytes)
loc (C++: const vdloc_t &)
nbytes (C++: int)
def property_op_to_typename(self)
def qswap(*args) ‑> void
qswap(a, b)
a: cinsn_t & b: cinsn_t &
def reg2mreg(*args) ‑> mreg_t
Map a processor register to a microregister.
reg2mreg(reg) -> mreg_t
reg: processor register number (C++: int)
return: microregister register id or mr_none
def remitem(*args) ‑> void
remitem(e)
e (C++: const citem_t *)
def remove_hexrays_callback(callback)
Deprecated. Please use Hexrays_Hooks instead
def rename_lvar(*args) ‑> bool
Rename a local variable.
rename_lvar(func_ea, oldname, newname) -> bool
func_ea: function start address (C++: ea_t)
oldname: old name of the variable (C++: const char *)
newname: new name of the variable (C++: const char *)
return: success This is a convenience function. For bulk renaming
consider using modify_user_lvars.
def restore_user_cmts(*args) ‑> user_cmts_t *
Restore user defined comments from the database.
restore_user_cmts(func_ea) -> user_cmts_t
func_ea: the entry address of the function (C++: ea_t)
return: collection of user defined comments. The returned object must
be deleted by the caller using delete_user_cmts()
def restore_user_defined_calls(*args) ‑> bool
Restore user defined function calls from the database.
restore_user_defined_calls(udcalls, func_ea) -> bool
udcalls: ptr to output buffer (C++: udcall_map_t *)
func_ea: entry address of the function (C++: ea_t)
return: success
def restore_user_iflags(*args) ‑> user_iflags_t *
Restore user defined citem iflags from the database.
restore_user_iflags(func_ea) -> user_iflags_t
func_ea: the entry address of the function (C++: ea_t)
return: collection of user defined iflags. The returned object must
be deleted by the caller using delete_user_iflags()
def restore_user_labels(*args) ‑> user_labels_t *
Restore user defined labels from the database.
restore_user_labels(func_ea) -> user_labels_t
func_ea: the entry address of the function, ignored if FUNC !=
NULL (C++: ea_t)
return: collection of user defined labels. The returned object must
be deleted by the caller using delete_user_labels()
def restore_user_labels2(*args) ‑> user_labels_t *
restore_user_labels2(func_ea, func=None) -> user_labels_t
func_ea (C++: ea_t)
func (C++: const cfunc_t *)
def restore_user_lvar_settings(*args) ‑> bool
Restore user defined local variable settings in the database.
restore_user_lvar_settings(lvinf, func_ea) -> bool
lvinf: ptr to output buffer (C++: lvar_uservec_t *)
func_ea: entry address of the function (C++: ea_t)
return: success
def restore_user_numforms(*args) ‑> user_numforms_t *
Restore user defined number formats from the database.
restore_user_numforms(func_ea) -> user_numforms_t
func_ea: the entry address of the function (C++: ea_t)
return: collection of user defined number formats. The returned
object must be deleted by the caller using
delete_user_numforms()
def restore_user_unions(*args) ‑> user_unions_t *
Restore user defined union field selections from the database.
restore_user_unions(func_ea) -> user_unions_t
func_ea: the entry address of the function (C++: ea_t)
return: collection of union field selections The returned object must
be deleted by the caller using delete_user_unions()
def save_user_cmts(*args) ‑> void
Save user defined comments into the database.
save_user_cmts(func_ea, user_cmts)
func_ea: the entry address of the function (C++: ea_t)
user_cmts: collection of user defined comments (C++: const
user_cmts_t *)
def save_user_defined_calls(*args) ‑> void
Save user defined local function calls into the database.
save_user_defined_calls(func_ea, udcalls)
func_ea: entry address of the function (C++: ea_t)
udcalls: user-specified info about user defined function calls
(C++: const udcall_map_t &)
def save_user_iflags(*args) ‑> void
Save user defined citem iflags into the database.
save_user_iflags(func_ea, iflags)
func_ea: the entry address of the function (C++: ea_t)
iflags: collection of user defined citem iflags (C++: const
user_iflags_t *)
def save_user_labels(*args) ‑> void
Save user defined labels into the database.
save_user_labels(func_ea, user_labels)
func_ea: the entry address of the function, ignored if FUNC !=
NULL (C++: ea_t)
user_labels: collection of user defined labels (C++: const
user_labels_t *)
def save_user_labels2(*args) ‑> void
save_user_labels2(func_ea, user_labels, func=None)
func_ea (C++: ea_t)
user_labels (C++: const user_labels_t *)
func (C++: const cfunc_t *)
def save_user_lvar_settings(*args) ‑> void
Save user defined local variable settings into the database.
save_user_lvar_settings(func_ea, lvinf)
func_ea: entry address of the function (C++: ea_t)
lvinf: user-specified info about local variables (C++: const
lvar_uservec_t &)
def save_user_numforms(*args) ‑> void
Save user defined number formats into the database.
save_user_numforms(func_ea, numforms)
func_ea: the entry address of the function (C++: ea_t)
numforms: collection of user defined comments (C++: const
user_numforms_t *)
def save_user_unions(*args) ‑> void
Save user defined union field selections into the database.
save_user_unions(func_ea, unions)
func_ea: the entry address of the function (C++: ea_t)
unions: collection of union field selections (C++: const
user_unions_t *)
def select_udt_by_offset(*args) ‑> int
Select UDT
select_udt_by_offset(udts, ops, applicator) -> int
udts: list of UDT tinfo_t for the selection, if NULL or empty
then UDTs from the "Local types" will be used (C++: const qvector < tinfo_t > *)
ops: operands (C++: const ui_stroff_ops_t &)
applicator (C++: ui_stroff_applicator_t &)
def send_database(*args) ‑> void
Send the database to Hex-Rays. This function sends the current database to the Hex-Rays server. The database is sent in the compressed form over an encrypted (SSL) connection.
send_database(err, silent)
err: failure description object. Empty hexrays_failure_t
object can be used if error information is not available. (C++: const hexrays_failure_t &)
silent: if false, a dialog box will be displayed before sending
the database. (C++: bool)
def set2jcnd(*args) ‑> mcode_t
set2jcnd(code) -> mcode_t
code (C++: mcode_t)
def set_type(*args) ‑> bool
Set a global type.
set_type(id, tif, source, force=False) -> bool
id: address or id of the object (C++: uval_t)
tif: new type info (C++: const tinfo_t &)
source: where the type comes from (C++: type_source_t)
force: true means to set the type as is, false means to merge
the new type with the possibly existing old type info. (C++: bool)
return: success
def swap_mcode_relation(*args) ‑> mcode_t
swap_mcode_relation(code) -> mcode_t
code (C++: mcode_t)
def swapped_relation(*args) ‑> ctype_t
Swap a comparison operator. For example, cot_sge becomes cot_sle.
swapped_relation(op) -> ctype_t
op (C++: ctype_t)
def term_hexrays_plugin(*args) ‑> void
Stop working with hex-rays decompiler.
def udcall_map_begin(*args) ‑> udcall_map_iterator_t
Get iterator pointing to the beginning of udcall_map_t.
udcall_map_begin(map) -> udcall_map_iterator_t
map (C++: const udcall_map_t *)
def udcall_map_clear(*args) ‑> void
Clear udcall_map_t.
udcall_map_clear(map)
map (C++: udcall_map_t *)
def udcall_map_end(*args) ‑> udcall_map_iterator_t
Get iterator pointing to the end of udcall_map_t.
udcall_map_end(map) -> udcall_map_iterator_t
map (C++: const udcall_map_t *)
def udcall_map_erase(*args) ‑> void
Erase current element from udcall_map_t.
udcall_map_erase(map, p)
map (C++: udcall_map_t *)
p (C++: udcall_map_iterator_t)
def udcall_map_find(*args) ‑> udcall_map_iterator_t
Find the specified key in udcall_map_t.
udcall_map_find(map, key) -> udcall_map_iterator_t
map (C++: const udcall_map_t *)
key (C++: const ea_t &)
def udcall_map_first(*args) ‑> ea_t const &
Get reference to the current map key.
udcall_map_first(p) -> ea_t const &
p (C++: udcall_map_iterator_t)
def udcall_map_free(*args) ‑> void
Delete udcall_map_t instance.
udcall_map_free(map)
map (C++: udcall_map_t *)
def udcall_map_insert(*args) ‑> udcall_map_iterator_t
Insert new (ea_t, 'udcall_t' ) pair into udcall_map_t.
udcall_map_insert(map, key, val) -> udcall_map_iterator_t
map (C++: udcall_map_t *)
key (C++: const ea_t &)
val (C++: const udcall_t &)
def udcall_map_new(*args) ‑> udcall_map_t *
Create a new udcall_map_t instance.
def udcall_map_next(*args) ‑> udcall_map_iterator_t
Move to the next element.
udcall_map_next(p) -> udcall_map_iterator_t
p (C++: udcall_map_iterator_t)
def udcall_map_prev(*args) ‑> udcall_map_iterator_t
Move to the previous element.
udcall_map_prev(p) -> udcall_map_iterator_t
p (C++: udcall_map_iterator_t)
def udcall_map_second(*args) ‑> udcall_t &
Get reference to the current map value.
udcall_map_second(p) -> udcall_t
p (C++: udcall_map_iterator_t)
def udcall_map_size(*args) ‑> size_t
Get size of udcall_map_t.
udcall_map_size(map) -> size_t
map (C++: udcall_map_t *)
def user_cmts_begin(*args) ‑> user_cmts_iterator_t
Get iterator pointing to the beginning of user_cmts_t.
user_cmts_begin(map) -> user_cmts_iterator_t
map (C++: const user_cmts_t *)
def user_cmts_clear(*args) ‑> void
Clear user_cmts_t.
user_cmts_clear(map)
map (C++: user_cmts_t *)
def user_cmts_end(*args) ‑> user_cmts_iterator_t
Get iterator pointing to the end of user_cmts_t.
user_cmts_end(map) -> user_cmts_iterator_t
map (C++: const user_cmts_t *)
def user_cmts_erase(*args) ‑> void
Erase current element from user_cmts_t.
user_cmts_erase(map, p)
map (C++: user_cmts_t *)
p (C++: user_cmts_iterator_t)
def user_cmts_find(*args) ‑> user_cmts_iterator_t
Find the specified key in user_cmts_t.
user_cmts_find(map, key) -> user_cmts_iterator_t
map (C++: const user_cmts_t *)
key (C++: const treeloc_t &)
def user_cmts_first(*args) ‑> treeloc_t const &
Get reference to the current map key.
user_cmts_first(p) -> treeloc_t
p (C++: user_cmts_iterator_t)
def user_cmts_free(*args) ‑> void
Delete user_cmts_t instance.
user_cmts_free(map)
map (C++: user_cmts_t *)
def user_cmts_insert(*args) ‑> user_cmts_iterator_t
Insert new ( 'treeloc_t' , 'citem_cmt_t' ) pair into user_cmts_t.
user_cmts_insert(map, key, val) -> user_cmts_iterator_t
map (C++: user_cmts_t *)
key (C++: const treeloc_t &)
val (C++: const citem_cmt_t &)
def user_cmts_new(*args) ‑> user_cmts_t *
Create a new user_cmts_t instance.
def user_cmts_next(*args) ‑> user_cmts_iterator_t
Move to the next element.
user_cmts_next(p) -> user_cmts_iterator_t
p (C++: user_cmts_iterator_t)
def user_cmts_prev(*args) ‑> user_cmts_iterator_t
Move to the previous element.
user_cmts_prev(p) -> user_cmts_iterator_t
p (C++: user_cmts_iterator_t)
def user_cmts_second(*args) ‑> citem_cmt_t &
Get reference to the current map value.
user_cmts_second(p) -> citem_cmt_t
p (C++: user_cmts_iterator_t)
def user_cmts_size(*args) ‑> size_t
Get size of user_cmts_t.
user_cmts_size(map) -> size_t
map (C++: user_cmts_t *)
def user_iflags_begin(*args) ‑> user_iflags_iterator_t
Get iterator pointing to the beginning of user_iflags_t.
user_iflags_begin(map) -> user_iflags_iterator_t
map (C++: const user_iflags_t *)
def user_iflags_clear(*args) ‑> void
Clear user_iflags_t.
user_iflags_clear(map)
map (C++: user_iflags_t *)
def user_iflags_end(*args) ‑> user_iflags_iterator_t
Get iterator pointing to the end of user_iflags_t.
user_iflags_end(map) -> user_iflags_iterator_t
map (C++: const user_iflags_t *)
def user_iflags_erase(*args) ‑> void
Erase current element from user_iflags_t.
user_iflags_erase(map, p)
map (C++: user_iflags_t *)
p (C++: user_iflags_iterator_t)
def user_iflags_find(*args) ‑> user_iflags_iterator_t
Find the specified key in user_iflags_t.
user_iflags_find(map, key) -> user_iflags_iterator_t
map (C++: const user_iflags_t *)
key (C++: const citem_locator_t &)
def user_iflags_first(*args) ‑> citem_locator_t const &
Get reference to the current map key.
user_iflags_first(p) -> citem_locator_t
p (C++: user_iflags_iterator_t)
def user_iflags_free(*args) ‑> void
Delete user_iflags_t instance.
user_iflags_free(map)
map (C++: user_iflags_t *)
def user_iflags_insert(*args) ‑> user_iflags_iterator_t
Insert new ( 'citem_locator_t' , int32) pair into user_iflags_t.
user_iflags_insert(map, key, val) -> user_iflags_iterator_t
map (C++: user_iflags_t *)
key (C++: const citem_locator_t &)
val (C++: const int32 &)
def user_iflags_new(*args) ‑> user_iflags_t *
Create a new user_iflags_t instance.
def user_iflags_next(*args) ‑> user_iflags_iterator_t
Move to the next element.
user_iflags_next(p) -> user_iflags_iterator_t
p (C++: user_iflags_iterator_t)
def user_iflags_prev(*args) ‑> user_iflags_iterator_t
Move to the previous element.
user_iflags_prev(p) -> user_iflags_iterator_t
p (C++: user_iflags_iterator_t)
def user_iflags_second(*args) ‑> int32 const &
Get reference to the current map value.
user_iflags_second(p) -> int32 const &
p (C++: user_iflags_iterator_t)
def user_iflags_size(*args) ‑> size_t
Get size of user_iflags_t.
user_iflags_size(map) -> size_t
map (C++: user_iflags_t *)
def user_labels_begin(*args) ‑> user_labels_iterator_t
Get iterator pointing to the beginning of user_labels_t.
user_labels_begin(map) -> user_labels_iterator_t
map (C++: const user_labels_t *)
def user_labels_clear(*args) ‑> void
Clear user_labels_t.
user_labels_clear(map)
map (C++: user_labels_t *)
def user_labels_end(*args) ‑> user_labels_iterator_t
Get iterator pointing to the end of user_labels_t.
user_labels_end(map) -> user_labels_iterator_t
map (C++: const user_labels_t *)
def user_labels_erase(*args) ‑> void
Erase current element from user_labels_t.
user_labels_erase(map, p)
map (C++: user_labels_t *)
p (C++: user_labels_iterator_t)
def user_labels_find(*args) ‑> user_labels_iterator_t
Find the specified key in user_labels_t.
user_labels_find(map, key) -> user_labels_iterator_t
map (C++: const user_labels_t *)
key (C++: const int &)
def user_labels_first(*args) ‑> int const &
Get reference to the current map key.
user_labels_first(p) -> int const &
p (C++: user_labels_iterator_t)
def user_labels_free(*args) ‑> void
Delete user_labels_t instance.
user_labels_free(map)
map (C++: user_labels_t *)
def user_labels_insert(*args) ‑> user_labels_iterator_t
Insert new (int, qstring) pair into user_labels_t.
user_labels_insert(map, key, val) -> user_labels_iterator_t
map (C++: user_labels_t *)
key (C++: const int &)
val (C++: const qstring &)
def user_labels_new(*args) ‑> user_labels_t *
Create a new user_labels_t instance.
def user_labels_next(*args) ‑> user_labels_iterator_t
Move to the next element.
user_labels_next(p) -> user_labels_iterator_t
p (C++: user_labels_iterator_t)
def user_labels_prev(*args) ‑> user_labels_iterator_t
Move to the previous element.
user_labels_prev(p) -> user_labels_iterator_t
p (C++: user_labels_iterator_t)
def user_labels_second(*args) ‑> qstring &
Get reference to the current map value.
user_labels_second(p) -> qstring &
p (C++: user_labels_iterator_t)
def user_labels_size(*args) ‑> size_t
Get size of user_labels_t.
user_labels_size(map) -> size_t
map (C++: user_labels_t *)
def user_numforms_begin(*args) ‑> user_numforms_iterator_t
Get iterator pointing to the beginning of user_numforms_t.
user_numforms_begin(map) -> user_numforms_iterator_t
map (C++: const user_numforms_t *)
def user_numforms_clear(*args) ‑> void
Clear user_numforms_t.
user_numforms_clear(map)
map (C++: user_numforms_t *)
def user_numforms_end(*args) ‑> user_numforms_iterator_t
Get iterator pointing to the end of user_numforms_t.
user_numforms_end(map) -> user_numforms_iterator_t
map (C++: const user_numforms_t *)
def user_numforms_erase(*args) ‑> void
Erase current element from user_numforms_t.
user_numforms_erase(map, p)
map (C++: user_numforms_t *)
p (C++: user_numforms_iterator_t)
def user_numforms_find(*args) ‑> user_numforms_iterator_t
Find the specified key in user_numforms_t.
user_numforms_find(map, key) -> user_numforms_iterator_t
map (C++: const user_numforms_t *)
key (C++: const operand_locator_t &)
def user_numforms_first(*args) ‑> operand_locator_t const &
Get reference to the current map key.
user_numforms_first(p) -> operand_locator_t
p (C++: user_numforms_iterator_t)
def user_numforms_free(*args) ‑> void
Delete user_numforms_t instance.
user_numforms_free(map)
map (C++: user_numforms_t *)
def user_numforms_insert(*args) ‑> user_numforms_iterator_t
Insert new ( 'operand_locator_t' , 'number_format_t' ) pair into user_numforms_t.
user_numforms_insert(map, key, val) -> user_numforms_iterator_t
map (C++: user_numforms_t *)
key (C++: const operand_locator_t &)
val (C++: const number_format_t &)
def user_numforms_new(*args) ‑> user_numforms_t *
Create a new user_numforms_t instance.
def user_numforms_next(*args) ‑> user_numforms_iterator_t
Move to the next element.
user_numforms_next(p) -> user_numforms_iterator_t
p (C++: user_numforms_iterator_t)
def user_numforms_prev(*args) ‑> user_numforms_iterator_t
Move to the previous element.
user_numforms_prev(p) -> user_numforms_iterator_t
p (C++: user_numforms_iterator_t)
def user_numforms_second(*args) ‑> number_format_t &
Get reference to the current map value.
user_numforms_second(p) -> number_format_t
p (C++: user_numforms_iterator_t)
def user_numforms_size(*args) ‑> size_t
Get size of user_numforms_t.
user_numforms_size(map) -> size_t
map (C++: user_numforms_t *)
def user_unions_begin(*args) ‑> user_unions_iterator_t
Get iterator pointing to the beginning of user_unions_t.
user_unions_begin(map) -> user_unions_iterator_t
map (C++: const user_unions_t *)
def user_unions_clear(*args) ‑> void
Clear user_unions_t.
user_unions_clear(map)
map (C++: user_unions_t *)
def user_unions_end(*args) ‑> user_unions_iterator_t
Get iterator pointing to the end of user_unions_t.
user_unions_end(map) -> user_unions_iterator_t
map (C++: const user_unions_t *)
def user_unions_erase(*args) ‑> void
Erase current element from user_unions_t.
user_unions_erase(map, p)
map (C++: user_unions_t *)
p (C++: user_unions_iterator_t)
def user_unions_find(*args) ‑> user_unions_iterator_t
Find the specified key in user_unions_t.
user_unions_find(map, key) -> user_unions_iterator_t
map (C++: const user_unions_t *)
key (C++: const ea_t &)
def user_unions_first(*args) ‑> ea_t const &
Get reference to the current map key.
user_unions_first(p) -> ea_t const &
p (C++: user_unions_iterator_t)
def user_unions_free(*args) ‑> void
Delete user_unions_t instance.
user_unions_free(map)
map (C++: user_unions_t *)
def user_unions_insert(*args) ‑> user_unions_iterator_t
Insert new (ea_t, intvec_t) pair into user_unions_t.
user_unions_insert(map, key, val) -> user_unions_iterator_t
map (C++: user_unions_t *)
key (C++: const ea_t &)
val (C++: const intvec_t &)
def user_unions_new(*args) ‑> user_unions_t *
Create a new user_unions_t instance.
def user_unions_next(*args) ‑> user_unions_iterator_t
Move to the next element.
user_unions_next(p) -> user_unions_iterator_t
p (C++: user_unions_iterator_t)
def user_unions_prev(*args) ‑> user_unions_iterator_t
Move to the previous element.
user_unions_prev(p) -> user_unions_iterator_t
p (C++: user_unions_iterator_t)
def user_unions_second(*args) ‑> intvec_t &
Get reference to the current map value.
user_unions_second(p) -> intvec_t
p (C++: user_unions_iterator_t)
def user_unions_size(*args) ‑> size_t
Get size of user_unions_t.
user_unions_size(map) -> size_t
map (C++: user_unions_t *)

Classes

class DecompilationFailure (info)
Raised on a decompilation error.
The associated hexrays_failure_t object is stored in the 'info' member of this exception.

Ancestors

  • builtins.Exception
  • builtins.BaseException
class Hexrays_Hooks (*args)
Proxy of C++ Hexrays_Hooks class.
__init__(self, _flags=0) -> Hexrays_Hooks
_flags: uint32

Subclasses

  • ida_hexrays.__cbhooks_t

Methods

def build_callinfo(self, *args) ‑> int
Analyzing a call instruction.
build_callinfo(self, blk, type, callinfo) -> int
blk: blk->tail is the call. (C++: mblock_t *)
type: buffer for the output type. (C++: tinfo_t *)
callinfo: prepared callinfo. Should return: 1 if the function
type has been determined. The plugin should either specify the function type, either allocate and return a new mcallinfo_t object. (C++: mcallinfo_t **)
def close_pseudocode(self, *args) ‑> int
Pseudocode view is being closed.
close_pseudocode(self, vu) -> int
vu (C++: vdui_t *)
def cmt_changed(self, *args) ‑> int
Comment got changed.
cmt_changed(self, cfunc, loc, cmt) -> int
cfunc (C++: cfunc_t *)
loc (C++: const treeloc_t *)
cmt (C++: const char *)
def combine(self, *args) ‑> int
Trying to combine instructions of basic block.
combine(self, blk, insn) -> int
blk (C++: mblock_t *)
insn: Should return: 1 if combined the current instruction with
a preceding one (C++: minsn_t *)
def create_hint(self, *args) ‑> PyObject *
Create a hint for the current item. 'ui_get_custom_viewer_hint'
create_hint(self, vu) -> PyObject *
vu (C++: vdui_t *)
retval: 0 - continue collecting hints with other subscribers
retval: 1 - stop collecting hints
def curpos(self, *args) ‑> int
Current cursor position has been changed. (for example, by left- clicking or using keyboard)
curpos(self, vu) -> int
vu (C++: vdui_t *)
def double_click(self, *args) ‑> int
Mouse double click.
double_click(self, vu, shift_state) -> int
vu (C++: vdui_t *)
shift_state: Should return: 1 if the event has been handled
(C++: int)
def flowchart(self, *args) ‑> int
Flowchart has been generated.
flowchart(self, fc) -> int
fc (C++: qflow_chart_t *)
def func_printed(self, *args) ‑> int
Function text has been generated. Plugins may modify the text in 'cfunc_t::sv' . The text uses regular color codes (see 'lines.hpp' ) COLOR_ADDR is used to store pointers to ctree elements.
func_printed(self, cfunc) -> int
cfunc (C++: cfunc_t *)
def glbopt(self, *args) ‑> int
Global optimization has been finished. If microcode is modified, MERR_LOOP must be returned. It will cause a complete restart of the optimization.
glbopt(self, mba) -> int
mba: return Microcode error codes code (C++: mba_t *)
def hook(self, *args) ‑> bool
hook(self) -> bool
def interr(self, *args) ‑> int
Internal error has occurred.
interr(self, errcode) -> int
errcode (C++: int )
def keyboard(self, *args) ‑> int
Keyboard has been hit.
keyboard(self, vu, key_code, shift_state) -> int
vu (C++: vdui_t *)
key_code: VK_... (C++: int)
shift_state: Should return: 1 if the event has been handled
(C++: int)
def locopt(self, *args) ‑> int
Basic block level optimization has been finished.
locopt(self, mba) -> int
mba: return Microcode error codes code (C++: mba_t *)
def lvar_cmt_changed(self, *args) ‑> int
Local variable comment got changed.
lvar_cmt_changed(self, vu, v, cmt) -> int
vu (C++: vdui_t *)
v (C++: lvar_t *)
cmt: Please note that it is possible to read/write user
settings for lvars directly from the idb. (C++: const char *)
def lvar_mapping_changed(self, *args) ‑> int
Local variable mapping got changed.
lvar_mapping_changed(self, vu, frm, to) -> int
vu (C++: vdui_t *)
frm (C++: lvar_t *)
to: Please note that it is possible to read/write user settings
for lvars directly from the idb. (C++: lvar_t *)
def lvar_name_changed(self, *args) ‑> int
Local variable got renamed.
lvar_name_changed(self, vu, v, name, is_user_name) -> int
vu (C++: vdui_t *)
v (C++: lvar_t *)
name (C++: const char *)
is_user_name: Please note that it is possible to read/write
user settings for lvars directly from the idb. (C++: bool)
def lvar_type_changed(self, *args) ‑> int
Local variable type got changed.
lvar_type_changed(self, vu, v, tinfo) -> int
vu (C++: vdui_t *)
v (C++: lvar_t *)
tinfo: Please note that it is possible to read/write user
settings for lvars directly from the idb. (C++: const tinfo_t *)
def maturity(self, *args) ‑> int
Ctree maturity level is being changed.
maturity(self, cfunc, new_maturity) -> int
cfunc (C++: cfunc_t *)
new_maturity (C++: ctree_maturity_t)
def microcode(self, *args) ‑> int
Microcode has been generated.
microcode(self, mba) -> int
mba: return Microcode error codes code (C++: mba_t *)
def open_pseudocode(self, *args) ‑> int
New pseudocode view has been opened.
open_pseudocode(self, vu) -> int
vu (C++: vdui_t *)
def populating_popup(self, *args) ‑> int
Populating popup menu. We can add menu items now.
populating_popup(self, widget, popup_handle, vu) -> int
widget (C++: TWidget *)
popup_handle (C++: TPopupMenu *)
vu (C++: vdui_t *)
def prealloc(self, *args) ‑> int
Local variables: preallocation step begins.
prealloc(self, mba) -> int
mba: This event may occur several times. Should return: 1 if
modified microcode Negative values are Microcode error codes error codes (C++: mba_t *)
def preoptimized(self, *args) ‑> int
Microcode has been preoptimized.
preoptimized(self, mba) -> int
mba: return Microcode error codes code (C++: mba_t *)
def print_func(self, *args) ‑> int
Printing ctree and generating text.
print_func(self, cfunc, vp) -> int
cfunc (C++: cfunc_t *)
vp: Returns: 1 if text has been generated by the plugin It is
forbidden to modify ctree at this event. (C++: vc_printer_t *)
def prolog(self, *args) ‑> int
Prolog analysis has been finished.
prolog(self, mba, fc, reachable_blocks, decomp_flags) -> int
mba (C++: mba_t *)
fc (C++: qflow_chart_t *)
reachable_blocks (C++: bitset_t *)
decomp_flags: return Microcode error codes code (C++: int)
def refresh_pseudocode(self, *args) ‑> int
Existing pseudocode text has been refreshed. Adding/removing pseudocode lines is forbidden in this event.
refresh_pseudocode(self, vu) -> int
vu: See also hxe_text_ready, which happens earlier (C++:
vdui_t *)
def resolve_stkaddrs(self, *args) ‑> int
The optimizer is about to resolve stack addresses.
resolve_stkaddrs(self, mba) -> int
mba (C++: mba_t *)
def right_click(self, *args) ‑> int
Mouse right click. Use hxe_populating_popup instead, in case you want to add items in the popup menu.
right_click(self, vu) -> int
vu (C++: vdui_t *)
def stkpnts(self, *args) ‑> int
SP change points have been calculated.
stkpnts(self, mba, _sps) -> int
mba (C++: mba_t *) _sps: stkpnts_t *
def structural(self, *args) ‑> int
Structural analysis has been finished.
structural(self, ct) -> int
ct (C++: control_graph_t *)
def switch_pseudocode(self, *args) ‑> int
Existing pseudocode view has been reloaded with a new function. Its text has not been refreshed yet, only cfunc and mba pointers are ready.
switch_pseudocode(self, vu) -> int
vu (C++: vdui_t *)
def text_ready(self, *args) ‑> int
Decompiled text is ready.
text_ready(self, vu) -> int
vu: This event can be used to modify the output text (sv).
Obsolete. Please use hxe_func_printed instead. (C++: vdui_t *)
def unhook(self, *args) ‑> bool
unhook(self) -> bool
class array_of_bitsets (*args)
Proxy of C++ qvector< bitset_t > class.
__init__(self) -> array_of_bitsets
x: qvector< bitset_t > const &

Methods

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

Methods

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

Instance variables

var nbits
bit_bound_t_nbits_get(self) -> int16
var sbits
bit_bound_t_sbits_get(self) -> int16
class bitset_t (*args)
Proxy of C++ bitset_t class.
__init__(self) -> bitset_t
m: bitset_t const &

Subclasses

Methods

def add(self, *args) ‑> bool
add(self, bit) -> bool
bit (C++: int)
add(self, bit, width) -> bool
bit (C++: int) width: int
add(self, ml) -> bool
ml: bitset_t const &
def back(self, *args) ‑> int
back(self) -> int
def begin(self, *args) ‑> bitset_t::iterator
begin(self) -> iterator
def clear(self, *args) ‑> void
clear(self)
def compare(self, *args) ‑> int
compare(self, r) -> int
r: bitset_t const &
def copy(self, *args) ‑> bitset_t &
copy(self, m) -> bitset_t
m (C++: const bitset_t &)
def count(self, *args) ‑> int
count(self) -> int
bit: int
def cut_at(self, *args) ‑> bool
cut_at(self, maxbit) -> bool
maxbit (C++: int)
def dstr(self, *args) ‑> char const *
dstr(self) -> char const *
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> bitset_t::iterator
end(self) -> iterator
def fill_with_ones(self, *args) ‑> void
fill_with_ones(self, maxbit)
maxbit (C++: int)
def front(self, *args) ‑> int
front(self) -> int
def has(self, *args) ‑> bool
has(self, bit) -> bool
bit (C++: int)
def has_all(self, *args) ‑> bool
has_all(self, bit, width) -> bool
bit (C++: int)
width (C++: int)
def has_any(self, *args) ‑> bool
has_any(self, bit, width) -> bool
bit (C++: int)
width (C++: int)
def has_common(self, *args) ‑> bool
has_common(self, ml) -> bool
ml (C++: const bitset_t &)
def inc(self, *args) ‑> void
inc(self, p, n=1)
p (C++: iterator &)
n (C++: int)
def includes(self, *args) ‑> bool
includes(self, ml) -> bool
ml (C++: const bitset_t &)
def intersect(self, *args) ‑> bool
intersect(self, ml) -> bool
ml (C++: const bitset_t &)
def is_subset_of(self, *args) ‑> bool
is_subset_of(self, ml) -> bool
ml (C++: const bitset_t &)
def itat(self, *args) ‑> bitset_t::iterator
itat(self, n) -> iterator
n (C++: int)
def itv(self, *args) ‑> int
itv(self, it) -> int
it: bitset_t::const_iterator
def last(self, *args) ‑> int
last(self) -> int
def shift_down(self, *args) ‑> void
shift_down(self, shift)
shift (C++: int)
def sub(self, *args) ‑> bool
sub(self, bit) -> bool
bit (C++: int)
sub(self, bit, width) -> bool
bit (C++: int) width: int
sub(self, ml) -> bool
ml: bitset_t const &
def swap(self, *args) ‑> void
swap(self, r)
r (C++: bitset_t &)
class block_chains_iterator_t (*args)
Proxy of C++ block_chains_iterator_t class.
__init__(self) -> block_chains_iterator_t

Instance variables

var x
block_chains_iterator_t_x_get(self) -> iterator_word
class block_chains_t (*args)
Proxy of C++ block_chains_t class.
__init__(self) -> block_chains_t

Methods

def dstr(self, *args) ‑> char const *
dstr(self) -> char const *
def get_chain(self, *args) ‑> chain_t *
Get chain for the specified value offset.
get_chain(self, k, width=1) -> chain_t
k: value offset (register number or stack offset) (C++: const
voff_t &)
width: size of value in bytes (C++: int)
get_chain(self, k, width=1) -> chain_t
k: value offset (register number or stack offset) (C++: const
voff_t &)
width: size of value in bytes (C++: int)
get_chain(self, ch) -> chain_t
ch: chain_t const &
get_chain(self, ch) -> chain_t
ch: chain_t const &
def get_reg_chain(self, *args) ‑> chain_t *
Get chain for the specified register
get_reg_chain(self, reg, width=1) -> chain_t
reg: register number (C++: mreg_t)
width: size of register in bytes (C++: int)
get_reg_chain(self, reg, width=1) -> chain_t
reg: register number (C++: mreg_t)
width: size of register in bytes (C++: int)
def get_stk_chain(self, *args) ‑> chain_t *
Get chain for the specified stack offset
get_stk_chain(self, off, width=1) -> chain_t
off: stack offset (C++: sval_t)
width: size of stack value in bytes (C++: int)
get_stk_chain(self, off, width=1) -> chain_t
off: stack offset (C++: sval_t)
width: size of stack value in bytes (C++: int)
class block_chains_vec_t (*args)
Proxy of C++ qvector< block_chains_t > class.
__init__(self) -> block_chains_vec_t
x: qvector< block_chains_t > const &

Subclasses

Methods

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

Instance variables

var x
boundaries_iterator_t_x_get(self) -> iterator_word
class boundaries_t (*args)
Proxy of C++ std::map< cinsn_t *,rangeset_t > class.
__init__(self) -> boundaries_t

Class variables

var keytype
Proxy of C++ cinsn_t class.
var valuetype
Proxy of C++ rangeset_t class.

Methods

def at(self, *args) ‑> rangeset_t &
at(self, _Keyval) -> rangeset_t
_Keyval: cinsn_t *const &
def begin(self, *args)
def clear(self)
def copy(self)
def end(self, *args)
def erase(self, *args)
def find(self, *args)
def first(self, *args)
def get(self, key, default=None)
def has_key(self, key)
def insert(self, *args)
def items(self)
def iteritems(self)
def iterkeys(self)
def itervalues(self)
def keys(self)
def next(self, *args)
def pop(self, key)
Sets the value associated with the provided key.
def popitem(self)
Sets the value associated with the provided key.
def second(self, *args)
def setdefault(self, key, default=None)
Sets the value associated with the provided key.
def size(self, *args)
def values(self)
class carg_t (*args)
Proxy of C++ carg_t class.
__init__(self) -> carg_t

Ancestors

Instance variables

var formal_type
carg_t_formal_type_get(self) -> tinfo_t
var is_vararg
carg_t_is_vararg_get(self) -> bool

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: carg_t const &
def consume_cexpr(self, *args) ‑> void
consume_cexpr(self, e)
e (C++: cexpr_t *)

Inherited members

class carglist_t (*args)
Proxy of C++ carglist_t class.
__init__(self) -> carglist_t
ftype: tinfo_t const & fl: int

Ancestors

Instance variables

var flags
carglist_t_flags_get(self) -> int
var functype
carglist_t_functype_get(self) -> tinfo_t

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: carglist_t const &

Inherited members

class casm_t (*args)
Proxy of C++ casm_t class.
__init__(self, ea) -> casm_t
ea: ea_t
__init__(self, r) -> casm_t
r: casm_t const &

Ancestors

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: casm_t const &
def one_insn(self, *args) ‑> bool
one_insn(self) -> bool

Inherited members

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

Ancestors

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: cblock_t const &

Inherited members

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

Ancestors

Instance variables

var values
ccase_t_values_get(self) -> ulonglongvec_t

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: ccase_t const &
def size(self, *args) ‑> size_t
size(self) -> size_t
def value(self, *args) ‑> uint64 const &
value(self, i) -> uint64 const &
i (C++: int)

Inherited members

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

Ancestors

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: ccases_t const &

Inherited members

class cdg_insn_iterator_t (*args)
Proxy of C++ cdg_insn_iterator_t class.
__init__(self, mba_) -> cdg_insn_iterator_t
mba_: mba_t const *
__init__(self, r) -> cdg_insn_iterator_t
r: cdg_insn_iterator_t const &

Instance variables

var dslot
cdg_insn_iterator_t_dslot_get(self) -> ea_t
var dslot_insn
cdg_insn_iterator_t_dslot_insn_get(self) -> insn_t *
var ea
cdg_insn_iterator_t_ea_get(self) -> ea_t
var end
cdg_insn_iterator_t_end_get(self) -> ea_t
var is_likely_dslot
cdg_insn_iterator_t_is_likely_dslot_get(self) -> bool
var mba
cdg_insn_iterator_t_mba_get(self) -> mba_t
var severed_branch
cdg_insn_iterator_t_severed_branch_get(self) -> ea_t

Methods

def dslot_with_xrefs(self, *args) ‑> bool
dslot_with_xrefs(self) -> bool
def has_dslot(self, *args) ‑> bool
has_dslot(self) -> bool
def is_severed_dslot(self, *args) ‑> bool
is_severed_dslot(self) -> bool
def next(self, *args) ‑> merror_t
next(self, ins) -> merror_t
ins (C++: insn_t *)
def ok(self, *args) ‑> bool
ok(self) -> bool
def start(self, *args) ‑> void
start(self, rng)
rng (C++: const range_t &)
class cdo_t (*args)
Proxy of C++ cdo_t class.
__init__(self) -> cdo_t

Ancestors

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: cdo_t const &

Inherited members

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

Subclasses

Instance variables

var expr
ceinsn_t_expr_get(self) -> cexpr_t
class cexpr_t (*args)
Proxy of C++ cexpr_t class.
__init__(self) -> cexpr_t
cop: enum ctype_t _x: cexpr_t *
__init__(self, cop, _x, _y) -> cexpr_t
cop: enum ctype_t _x: cexpr_t * _y: cexpr_t *
__init__(self, cop, _x, _y, _z) -> cexpr_t
cop: enum ctype_t _x: cexpr_t * _y: cexpr_t * _z: cexpr_t *
__init__(self, r) -> cexpr_t
r: cexpr_t const &

Ancestors

Subclasses

Class variables

var op_to_typename

Instance variables

var a
var exflags
cexpr_t_exflags_get(self) -> uint32
var fpc
var helper
var insn
var m
var n
var obj_ea
var operands
return a dictionary with the operands of a cexpr_t.
var opname
var ptrsize
var refwidth
var string
var type
cexpr_t_type_get(self) -> tinfo_t
var v
var x
var y
var z

Methods

def assign(self, *args) ‑> cexpr_t &
assign(self, r) -> cexpr_t
r (C++: const cexpr_t &)
def calc_type(self, *args) ‑> void
Calculate the type of the expression. Use this function to calculate the expression type when a new expression is built
calc_type(self, recursive)
recursive: if true, types of all children expression will be
calculated before calculating our type (C++: bool)
def cleanup(self, *args) ‑> void
Cleanup the expression. This function properly deletes all children and sets the item type to cot_empty.
def compare(self, *args) ‑> int
compare(self, r) -> int
r: cexpr_t const &
def contains_comma(self, *args) ‑> bool
Does the expression contain a comma operator?
contains_comma(self, times=1) -> bool
times (C++: int)
def contains_comma_or_insn_or_label(self, *args) ‑> bool
Does the expression contain a comma operator or an embedded statement operator or a label?
contains_comma_or_insn_or_label(self, maxcommas=1) -> bool
maxcommas (C++: int)
def contains_insn(self, *args) ‑> bool
Does the expression contain an embedded statement operator?
contains_insn(self, times=1) -> bool
times (C++: int)
def contains_insn_or_label(self, *args) ‑> bool
Does the expression contain an embedded statement operator or a label?
def contains_operator(self, *args) ‑> bool
Check if the expression contains the specified operator.
contains_operator(self, needed_op, times=1) -> bool
needed_op: operator code to search for (C++: ctype_t)
times: how many times the operator code should be present (C++:
int)
return: true if the expression has at least TIMES children with
NEEDED_OP
def cpadone(self, *args) ‑> bool
Pointer arithmetic correction done for this expression?
def equal_effect(self, *args) ‑> bool
Compare two expressions. This function tries to compare two expressions in an 'intelligent' manner. For example, it knows about commutitive operators and can ignore useless casts.
equal_effect(self, r) -> bool
r: the expression to compare against the current expression
(C++: const cexpr_t &)
return: true expressions can be considered equal
def find_num_op(self, *args) ‑> cexpr_t *
Find the operand with a numeric value.
def find_op(self, *args) ‑> cexpr_t *
Find the child with the specified operator.
find_op(self, _op) -> cexpr_t
_op (C++: ctype_t)
find_op(self, _op) -> cexpr_t
_op (C++: ctype_t)
def get_1num_op(self, *args) ‑> bool
Get pointers to operands. at last one operand should be a number o1 will be pointer to the number
get_1num_op(self, o1, o2) -> bool
o1 (C++: cexpr_t **)
o2 (C++: cexpr_t **)
def get_const_value(self, *args) ‑> bool
Get expression value.
def get_high_nbit_bound(self, *args) ‑> bit_bound_t
Get max number of bits that can really be used by the expression. For example, x % 16 can yield only 4 non-zero bits, higher bits are zero
def get_low_nbit_bound(self, *args) ‑> int
Get min number of bits that are certainly required to represent the expression. For example, constant 16 always uses 5 bits: 10000.
def get_ptr_or_array(self, *args) ‑> cexpr_t *
Find pointer or array child.
def get_type_sign(self, *args) ‑> type_sign_t
Get expression sign.
def get_v(self, *args) ‑> var_ref_t *
get_v(self) -> var_ref_t
def has_side_effects(self, *args) ‑> bool
Check if the expression has side effects. Calls, pre/post inc/dec, and assignments have side effects.
def is_call_arg_of(self, *args) ‑> bool
Is call argument?
is_call_arg_of(self, parent) -> bool
parent (C++: const citem_t *)
return: true if our expression is a call argument of the specified
parent expression.
def is_call_object_of(self, *args) ‑> bool
Is call object?
is_call_object_of(self, parent) -> bool
parent (C++: const citem_t *)
return: true if our expression is the call object of the specified
parent expression.
def is_child_of(self, *args) ‑> bool
Verify if the specified item is our parent.
is_child_of(self, parent) -> bool
parent: possible parent item (C++: const citem_t *)
return: true if the specified item is our parent
def is_const_value(self, *args) ‑> bool
Check if the expression is a number with the specified value.
is_const_value(self, _v) -> bool
_v (C++: uint64)
def is_cstr(self, *args) ‑> bool
is_cstr(self) -> bool
def is_fpop(self, *args) ‑> bool
is_fpop(self) -> bool
def is_jumpout(self, *args) ‑> bool
is_jumpout(self) -> bool
def is_negative_const(self, *args) ‑> bool
Check if the expression is a negative number.
def is_nice_cond(self, *args) ‑> bool
Is nice condition?. Nice condition is a nice expression of the boolean type.
def is_nice_expr(self, *args) ‑> bool
Is nice expression? Nice expressions do not contain comma operators, embedded statements, or labels.
def is_non_negative_const(self, *args) ‑> bool
Check if the expression is a non-negative number.
def is_non_zero_const(self, *args) ‑> bool
Check if the expression is a non-zero number.
def is_odd_lvalue(self, *args) ‑> bool
is_odd_lvalue(self) -> bool
def is_type_signed(self, *args) ‑> bool
Is expression signed?
def is_type_unsigned(self, *args) ‑> bool
Is expression unsigned?
def is_undef_val(self, *args) ‑> bool
is_undef_val(self) -> bool
def is_vftable(self, *args) ‑> bool
is_vftable(self) -> bool
def is_zero_const(self, *args) ‑> bool
Check if the expression is a zero.
def maybe_ptr(self, *args) ‑> bool
May the expression be a pointer?
def numval(self, *args) ‑> uint64
Get numeric value of the expression. This function can be called only on cot_num expressions!
def print1(self, *args) ‑> void
Print expression into one line.
print1(self, func)
func: parent function. This argument is used to find out the
referenced variable names. (C++: const cfunc_t *)
def put_number(self, *args) ‑> void
Assign a number to the expression.
put_number(self, func, value, nbytes, sign=no_sign)
func: current function (C++: cfunc_t *)
value: number value (C++: uint64)
nbytes: size of the number in bytes (C++: int)
sign: number sign (C++: type_sign_t)
def requires_lvalue(self, *args) ‑> bool
Check if the expression requires an lvalue.
requires_lvalue(self, child) -> bool
child: The function will check if this child of our expression
must be an lvalue. (C++: const cexpr_t *)
return: true if child must be an lvalue.
def set_cpadone(self, *args) ‑> void
set_cpadone(self)
def set_v(self, *args) ‑> void
set_v(self, v)
v: var_ref_t const *
def set_vftable(self, *args) ‑> void
set_vftable(self)
def swap(self, *args) ‑> void
swap(self, r)
r (C++: cexpr_t &)
def theother(self, *args) ‑> cexpr_t *
Get the other operand. This function returns the other operand (not the specified one) for binary expressions.
theother(self, what) -> cexpr_t
what (C++: const cexpr_t *)
theother(self, what) -> cexpr_t
what (C++: const cexpr_t *)

Inherited members

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

Ancestors

Instance variables

var init
cfor_t_init_get(self) -> cexpr_t
var step
cfor_t_step_get(self) -> cexpr_t

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: cfor_t const &

Inherited members

class cfunc_parentee_t (*args)
Proxy of C++ cfunc_parentee_t class.
__init__(self, f, post=False) -> cfunc_parentee_t
f: cfunc_t * post: bool

Ancestors

Instance variables

var func
cfunc_parentee_t_func_get(self) -> cfunc_t

Methods

def calc_rvalue_type(self, *args) ‑> bool
Calculate rvalue type. This function tries to determine the type of the specified item based on its context. For example, if the current expression is the right side of an assignment operator, the type of its left side will be returned. This function can be used to determine the 'best' type of the specified expression.
calc_rvalue_type(self, target, e) -> bool
target: 'best' type of the expression will be returned here
(C++: tinfo_t *)
e: expression to determine the desired type (C++: const
cexpr_t *)
return: false if failed

Inherited members

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

Instance variables

var argidx
cfunc_t_argidx_get(self) -> intvec_t
var arguments
var body
cfunc_t_body_get(self) -> cinsn_t
var boundariesboundaries_t &
Get pointer to map of instruction boundaries. This function initializes the boundary map if not done yet.
var eamapeamap_t &
Get pointer to ea->insn map. This function initializes eamap if not done yet.
var entry_ea
cfunc_t_entry_ea_get(self) -> ea_t
var hdrlines
cfunc_t_hdrlines_get(self) -> int
var lvarslvars_t *
Get vector of local variables.
var maturity
cfunc_t_maturity_get(self) -> ctree_maturity_t
var mba
cfunc_t_mba_get(self) -> mba_t
var numforms
cfunc_t_numforms_get(self) -> user_numforms_t
var pseudocode : strvec_t const &
Get pointer to decompilation output: the pseudocode. This function generates pseudocode if not done yet.
var refcnt
cfunc_t_refcnt_get(self) -> int
var statebits
cfunc_t_statebits_get(self) -> int
var treeitems
cfunc_t_treeitems_get(self) -> ctree_items_t
var type
Get the function's return type tinfo_t object.
var user_cmts
cfunc_t_user_cmts_get(self) -> user_cmts_t
var user_iflags
cfunc_t_user_iflags_get(self) -> user_iflags_t
var user_labels
cfunc_t_user_labels_get(self) -> user_labels_t
var user_unions
cfunc_t_user_unions_get(self) -> user_unions_t
var warningshexwarns_t &
Get information about decompilation warnings.

Methods

def build_c_tree(self, *args) ‑> void
Generate the function body. This function (re)generates the function body from the underlying microcode.
def del_orphan_cmts(self, *args) ‑> int
Delete all orphan comments. The 'save_user_cmts()' function must be called after this call.
def find_item_coords(self, *args) ‑> PyObject *
find_item_coords(self, item, px, py) -> bool
item (C++: const citem_t *)
px (C++: int *)
py (C++: int *)
find_item_coords(self, item) -> PyObject *
item (C++: const citem_t *)
def find_label(self, *args) ‑> citem_t *
Find the label.
find_label(self, label) -> citem_t
label (C++: int)
return: pointer to the ctree item with the specified label number.
def gather_derefs(self, *args) ‑> bool
gather_derefs(self, ci, udm=None) -> bool
ci (C++: const ctree_item_t &)
udm (C++: udt_type_data_t *)
def get_boundaries(self, *args) ‑> boundaries_t &
Get pointer to map of instruction boundaries. This function initializes the boundary map if not done yet.
def get_eamap(self, *args) ‑> eamap_t &
Get pointer to ea->insn map. This function initializes eamap if not done yet.
def get_func_type(self, *args) ‑> bool
Get the function type.
get_func_type(self, type) -> bool
type: variable where the function type is returned (C++:
tinfo_t *)
return: false if failure
def get_line_item(self, *args) ‑> bool
Get ctree item for the specified cursor position. 'vdui_t::get_current_item()'
get_line_item(self, line, x, is_ctree_line, phead, pitem, ptail) -> bool
line: line of decompilation text (element of sv ) (C++: const
char *)
x: x cursor coordinate in the line (C++: int)
is_ctree_line: does the line belong to statement area? (if not,
it is assumed to belong to the declaration area) (C++: bool)
phead: ptr to the first item on the line (used to attach block
comments). May be NULL (C++: ctree_item_t *)
pitem: ptr to the current item. May be NULL (C++: ctree_item_t
*)
ptail: ptr to the last item on the line (used to attach
indented comments). May be NULL (C++: ctree_item_t *)
return: false if failed to get the current item
def get_lvars(self, *args) ‑> lvars_t *
Get vector of local variables.
def get_pseudocode(self, *args) ‑> strvec_t const &
Get pointer to decompilation output: the pseudocode. This function generates pseudocode if not done yet.
def get_stkoff_delta(self, *args) ‑> sval_t
Get stack offset delta. The local variable stack offsets retrieved by v.location.stkoff() should be adjusted before being used as stack frame offsets in IDA.
def get_user_cmt(self, *args) ‑> char const *
Retrieve a user defined comment.
get_user_cmt(self, loc, rt) -> char const *
loc: ctree location (C++: const treeloc_t &)
rt: should already retrieved comments retrieved again? (C++:
cmt_retrieval_type_t)
return: pointer to the comment string or NULL
def get_user_iflags(self, *args) ‑> int32
Retrieve citem iflags.
get_user_iflags(self, loc) -> int32
loc: citem locator (C++: const citem_locator_t &)
return: ctree item iflags bits or 0
def get_user_union_selection(self, *args) ‑> bool
Retrieve a user defined union field selection.
get_user_union_selection(self, ea, path) -> bool
ea: address (C++: ea_t)
path: out: path describing the union selection. (C++: intvec_t
*)
return: pointer to the path or NULL
def get_warnings(self, *args) ‑> hexwarns_t &
Get information about decompilation warnings.
def has_orphan_cmts(self, *args) ‑> bool
Check if there are orphan comments.
def locked(self, *args) ‑> bool
locked(self) -> bool
def print_dcl(self, *args) ‑> void
Print function prototype.
def print_func(self, *args) ‑> void
Print function text.
print_func(self, vp)
vp: printer helper class to receive the generated text. (C++:
vc_printer_t &)
def refresh_func_ctext(self, *args) ‑> void
Refresh ctext after a ctree modification. This function informs the decompiler that ctree ( 'body' ) have been modified and ctext ( 'sv' ) does not correspond to it anymore. It also refreshes the pseudocode windows if there is any.
def release(self, *args) ‑> void
release(self)
def remove_unused_labels(self, *args) ‑> void
Remove unused labels. This function check what labels are really used by the function and removes the unused ones.
def save_user_cmts(self, *args) ‑> void
Save user-defined comments into the database.
def save_user_iflags(self, *args) ‑> void
Save user-defined iflags into the database.
def save_user_labels(self, *args) ‑> void
Save user-defined labels into the database.
def save_user_numforms(self, *args) ‑> void
Save user-defined number formats into the database.
def save_user_unions(self, *args) ‑> void
Save user-defined union field selections into the database.
def set_user_cmt(self, *args) ‑> void
Set a user defined comment. This function stores the specified comment in the 'cfunc_t' structure. The 'save_user_cmts()' function must be called after it.
set_user_cmt(self, loc, cmt)
loc: ctree location (C++: const treeloc_t &)
cmt: new comment. if empty or NULL, then an existing comment is
deleted. (C++: const char *)
def set_user_iflags(self, *args) ‑> void
Set citem iflags.
set_user_iflags(self, loc, iflags)
loc: citem locator (C++: const citem_locator_t &)
iflags: new iflags (C++: int32)
def set_user_union_selection(self, *args) ‑> void
Set a union field selection. The 'save_user_unions()' function must be called after calling this function.
set_user_union_selection(self, ea, path)
ea: address (C++: ea_t)
path: in: path describing the union selection. (C++: const
intvec_t &)
def verify(self, *args) ‑> void
Verify the ctree. This function verifies the ctree. If the ctree is malformed, an internal error is generated. Use it to verify the ctree after your modifications.
verify(self, aul, even_without_debugger)
aul: Are unused labels acceptable? (C++: allow_unused_labels_t)
even_without_debugger: if false and there is no debugger, the
verification will be skipped (C++: bool)
class cfuncptr_t (*args)
Proxy of C++ qrefcnt_t< cfunc_t > class.
__init__(self, p) -> cfuncptr_t
p: cfunc_t *
__init__(self, r) -> cfuncptr_t
r: qrefcnt_t< cfunc_t > const &

Instance variables

var argidx
cfuncptr_t_argidx_get(self) -> intvec_t
var arguments
var body
cfuncptr_t_body_get(self) -> cinsn_t
var boundaries
var eamap
var entry_ea
cfuncptr_t_entry_ea_get(self) -> ea_t
var hdrlines
cfuncptr_t_hdrlines_get(self) -> int
var lvars
var maturity
cfuncptr_t_maturity_get(self) -> ctree_maturity_t
var mba
cfuncptr_t_mba_get(self) -> mba_t
var numforms
cfuncptr_t_numforms_get(self) -> user_numforms_t
var pseudocode
var refcnt
cfuncptr_t_refcnt_get(self) -> int
var statebits
cfuncptr_t_statebits_get(self) -> int
var treeitems
cfuncptr_t_treeitems_get(self) -> ctree_items_t
var type
var user_cmts
cfuncptr_t_user_cmts_get(self) -> user_cmts_t
var user_iflags
cfuncptr_t_user_iflags_get(self) -> user_iflags_t
var user_labels
cfuncptr_t_user_labels_get(self) -> user_labels_t
var user_unions
cfuncptr_t_user_unions_get(self) -> user_unions_t
var warnings

Methods

def build_c_tree(self, *args) ‑> void
build_c_tree(self)
def del_orphan_cmts(self, *args) ‑> int
del_orphan_cmts(self) -> int
def find_item_coords(self, *args) ‑> PyObject *
find_item_coords(self, item, px, py) -> bool
item: citem_t const * px: int * py: int *
find_item_coords(self, item) -> PyObject *
item: citem_t const *
def find_label(self, *args) ‑> citem_t *
find_label(self, label) -> citem_t
label: int
def gather_derefs(self, *args) ‑> bool
gather_derefs(self, ci, udm=None) -> bool
ci: ctree_item_t const & udm: udt_type_data_t *
def get_boundaries(self, *args) ‑> boundaries_t &
get_boundaries(self) -> boundaries_t
def get_eamap(self, *args) ‑> eamap_t &
get_eamap(self) -> eamap_t
def get_func_type(self, *args) ‑> bool
get_func_type(self, type) -> bool
type: tinfo_t *
def get_line_item(self, *args) ‑> bool
get_line_item(self, line, x, is_ctree_line, phead, pitem, ptail) -> bool
line: char const * x: int is_ctree_line: bool phead: ctree_item_t * pitem: ctree_item_t * ptail: ctree_item_t *
def get_lvars(self, *args) ‑> lvars_t *
get_lvars(self) -> lvars_t
def get_pseudocode(self, *args) ‑> strvec_t const &
get_pseudocode(self) -> strvec_t
def get_stkoff_delta(self, *args) ‑> sval_t
get_stkoff_delta(self) -> sval_t
def get_user_cmt(self, *args) ‑> char const *
get_user_cmt(self, loc, rt) -> char const *
loc: treeloc_t const & rt: enum cmt_retrieval_type_t
def get_user_iflags(self, *args) ‑> int32
get_user_iflags(self, loc) -> int32
loc: citem_locator_t const &
def get_user_union_selection(self, *args) ‑> bool
get_user_union_selection(self, ea, path) -> bool
ea: ea_t path: intvec_t *
def get_warnings(self, *args) ‑> hexwarns_t &
get_warnings(self) -> hexwarns_t
def has_orphan_cmts(self, *args) ‑> bool
has_orphan_cmts(self) -> bool
def locked(self, *args) ‑> bool
locked(self) -> bool
def print_dcl(self, *args) ‑> void
print_dcl(self)
def print_func(self, *args) ‑> void
print_func(self, vp)
vp: vc_printer_t &
def refresh_func_ctext(self, *args) ‑> void
refresh_func_ctext(self)
def release(self, *args) ‑> void
release(self)
def remove_unused_labels(self, *args) ‑> void
remove_unused_labels(self)
def reset(self, *args) ‑> void
reset(self)
def save_user_cmts(self, *args) ‑> void
save_user_cmts(self)
def save_user_iflags(self, *args) ‑> void
save_user_iflags(self)
def save_user_labels(self, *args) ‑> void
save_user_labels(self)
def save_user_numforms(self, *args) ‑> void
save_user_numforms(self)
def save_user_unions(self, *args) ‑> void
save_user_unions(self)
def set_user_cmt(self, *args) ‑> void
set_user_cmt(self, loc, cmt)
loc: treeloc_t const & cmt: char const *
def set_user_iflags(self, *args) ‑> void
set_user_iflags(self, loc, iflags)
loc: citem_locator_t const & iflags: int32
def set_user_union_selection(self, *args) ‑> void
set_user_union_selection(self, ea, path)
ea: ea_t path: intvec_t const &
def verify(self, *args) ‑> void
verify(self, aul, even_without_debugger)
aul: enum allow_unused_labels_t even_without_debugger: bool
class cgoto_t (*args)
Proxy of C++ cgoto_t class.
__init__(self) -> cgoto_t

Instance variables

var label_num
cgoto_t_label_num_get(self) -> int

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: cgoto_t const &
class chain_keeper_t (*args)
Proxy of C++ chain_keeper_t class.
__init__(self, _gc) -> chain_keeper_t
_gc: graph_chains_t *

Methods

def back(self, *args) ‑> block_chains_t &
back(self) -> block_chains_t
def for_all_chains(self, *args) ‑> int
for_all_chains(self, cv, gca) -> int
cv (C++: chain_visitor_t &)
gca (C++: int)
def front(self, *args) ‑> block_chains_t &
front(self) -> block_chains_t
class chain_t (*args)
Proxy of C++ chain_t class.
__init__(self) -> chain_t
t: mopt_t off: sval_t w: int v: int
__init__(self, _k, w=1) -> chain_t
_k: voff_t const & w: int

Ancestors

Instance variables

var flags
chain_t_flags_get(self) -> uchar
var varnum
chain_t_varnum_get(self) -> int
var width
chain_t_width_get(self) -> int

Methods

def append_list(self, *args) ‑> void
Append the contents of the chain to the specified list of locations.
append_list(self, mba, list)
mba (C++: const mba_t *)
list (C++: mlist_t *)
def clear_varnum(self, *args) ‑> void
clear_varnum(self)
def dstr(self, *args) ‑> char const *
dstr(self) -> char const *
def endoff(self, *args) ‑> voff_t const
endoff(self) -> voff_t
def get_reg(self, *args) ‑> mreg_t
get_reg(self) -> mreg_t
def get_stkoff(self, *args) ‑> sval_t
get_stkoff(self) -> sval_t
def includes(self, *args) ‑> bool
includes(self, r) -> bool
r (C++: const chain_t &)
def is_fake(self, *args) ‑> bool
is_fake(self) -> bool
def is_inited(self, *args) ‑> bool
is_inited(self) -> bool
def is_overlapped(self, *args) ‑> bool
is_overlapped(self) -> bool
def is_passreg(self, *args) ‑> bool
is_passreg(self) -> bool
def is_reg(self, *args) ‑> bool
is_reg(self) -> bool
def is_replaced(self, *args) ‑> bool
is_replaced(self) -> bool
def is_stkoff(self, *args) ‑> bool
is_stkoff(self) -> bool
def is_term(self, *args) ‑> bool
is_term(self) -> bool
def key(self, *args) ‑> voff_t const &
key(self) -> voff_t
def overlap(self, *args) ‑> bool
overlap(self, r) -> bool
r (C++: const chain_t &)
def set_inited(self, *args) ‑> void
set_inited(self, b)
b (C++: bool)
def set_overlapped(self, *args) ‑> void
set_overlapped(self, b)
b (C++: bool)
def set_replaced(self, *args) ‑> void
set_replaced(self, b)
b (C++: bool)
def set_term(self, *args) ‑> void
set_term(self, b)
b (C++: bool)
def set_value(self, *args) ‑> void
set_value(self, r)
r (C++: const chain_t &)

Inherited members

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

Instance variables

var parent
chain_visitor_t_parent_get(self) -> block_chains_t

Methods

def visit_chain(self, *args) ‑> int
visit_chain(self, nblock, ch) -> int
nblock (C++: int)
ch (C++: chain_t &)
class cif_t (*args)
Proxy of C++ cif_t class.
__init__(self) -> cif_t
r: cif_t const &

Ancestors

Instance variables

var ielse
cif_t_ielse_get(self) -> cinsn_t
var ithen
cif_t_ithen_get(self) -> cinsn_t

Methods

def assign(self, *args) ‑> cif_t &
assign(self, r) -> cif_t
r (C++: const cif_t &)
def cleanup(self, *args) ‑> void
cleanup(self)
def compare(self, *args) ‑> int
compare(self, r) -> int
r: cif_t const &

Inherited members

class cinsn_t (*args)
Proxy of C++ cinsn_t class.
__init__(self) -> cinsn_t
r: cinsn_t const &

Ancestors

Subclasses

Class variables

var op_to_typename

Static methods

def insn_is_epilog(*args) ‑> bool
insn_is_epilog(insn) -> bool
insn: cinsn_t const *

Instance variables

var casm
var cblock
var cdo
var cfor
var cgoto
var cif
var creturn
var cswitch
var cwhile
var details
return the details pointer for the cinsn_t object depending on the value of its op member. this is one of the cblock_t, cif_t, etc. objects.
var opname

Methods

def assign(self, *args) ‑> cinsn_t &
assign(self, r) -> cinsn_t
r (C++: const cinsn_t &)
def cleanup(self, *args) ‑> void
Cleanup the statement. This function properly deletes all children and sets the item type to cit_empty.
def collect_free_breaks(self, *args) ‑> bool
Collect free 'break' statements. This function finds all free 'break' statements within the current statement. A 'break' statement is free if it does not have a loop or switch parent that that is also within the current statement.
collect_free_breaks(self, breaks) -> bool
breaks: pointer to the variable where the vector of all found
free break statements is returned. This argument can be NULL. (C++: cinsnptrvec_t *)
return: true if some free break statements have been found
def collect_free_continues(self, *args) ‑> bool
Collect free 'continue' statements. This function finds all free 'continue' statements within the current statement. A 'continue' statement is free if it does not have a loop parent that that is also within the current statement.
collect_free_continues(self, continues) -> bool
continues: pointer to the variable where the vector of all
found free continue statements is returned. This argument can be NULL. (C++: cinsnptrvec_t *)
return: true if some free continue statements have been found
def compare(self, *args) ‑> int
compare(self, r) -> int
r: cinsn_t const &
def contains_free_break(self, *args) ‑> bool
Check if the statement has free 'break' statements.
def contains_free_continue(self, *args) ‑> bool
Check if the statement has free 'continue' statements.
def contains_insn(self, *args) ‑> bool
Check if the statement contains a statement of the specified type.
contains_insn(self, type, times=1) -> bool
type: statement opcode to look for (C++: ctype_t)
times: how many times TYPE should be present (C++: int)
return: true if the statement has at least TIMES children with opcode
== TYPE
def create_if(self, *args) ‑> cif_t &
Create a new if-statement. The current statement must be a block. The new statement will be appended to it.
create_if(self, cnd) -> cif_t
cnd: if condition. It will be deleted after being copied. (C++:
cexpr_t *)
def is_epilog(self)
def is_ordinary_flow(self, *args) ‑> bool
Check if the statement passes execution to the next statement.
def new_insn(self, *args) ‑> cinsn_t &
Create a new statement. The current statement must be a block. The new statement will be appended to it.
new_insn(self, insn_ea) -> cinsn_t
insn_ea: statement address (C++: ea_t)
def print1(self, *args) ‑> void
Print the statement into one line. Currently this function is not available.
print1(self, func)
func: parent function. This argument is used to find out the
referenced variable names. (C++: const cfunc_t *)
def swap(self, *args) ‑> void
swap(self, r)
r (C++: cinsn_t &)
def zero(self, *args) ‑> void
Overwrite with zeroes without cleaning memory or deleting children.

Inherited members

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

Methods

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

Instance variables

var used
citem_cmt_t_used_get(self) -> bool

Methods

def c_str(self, *args) ‑> char const *
c_str(self) -> char const *
class citem_locator_t (*args)
Proxy of C++ citem_locator_t class.
__init__(self, _ea, _op) -> citem_locator_t
_ea: ea_t _op: enum ctype_t
__init__(self, i) -> citem_locator_t
i: citem_t const *

Instance variables

var ea
citem_locator_t_ea_get(self) -> ea_t
var op
citem_locator_t_op_get(self) -> ctype_t

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: citem_locator_t const &
class citem_t (*args)
Proxy of C++ citem_t class.
__init__(self) -> citem_t
o: enum ctype_t

Subclasses

Instance variables

var cexpr
citem_t_cexpr_get(self) -> cexpr_t
var cinsn
citem_t_cinsn_get(self) -> cinsn_t
var ea
citem_t_ea_get(self) -> ea_t
var index
citem_t_index_get(self) -> int
var label_num
citem_t_label_num_get(self) -> int
var meminfo
var obj_id : PyObject *
_obj_id(self) -> PyObject *
var op : ctype_t
_get_op(self) -> ctype_t
var to_specific_type
cast the citem_t object to its more specific type, either cexpr_t or cinsn_t.

Methods

def contains_expr(self, *args) ‑> bool
Does the item contain an expression?
contains_expr(self, e) -> bool
e (C++: const cexpr_t *)
def contains_label(self, *args) ‑> bool
Does the item contain a label?
def find_closest_addr(self, *args) ‑> citem_t *
find_closest_addr(self, _ea) -> citem_t
_ea (C++: ea_t)
def find_parent_of(self, *args) ‑> citem_t *
Find parent of the specified item.
find_parent_of(self, sitem) -> citem_t
sitem: Item to find the parent of. The search will be performed
among the children of the item pointed by this . (C++: const citem_t *)
return: NULL if not found
find_parent_of(self, item) -> citem_t
item: citem_t const *
return: NULL if not found
def is_expr(self, *args) ‑> bool
Is an expression?
def print1(self, *args) ‑> void
Print item into one line.
print1(self, func)
func: parent function. This argument is used to find out the
referenced variable names. (C++: const cfunc_t *)
return: length of the generated text.
def replace_by(self, o)
def swap(self, *args) ‑> void
Swap two 'citem_t' .
swap(self, r)
r (C++: citem_t &)
class cloop_t (*args)
Proxy of C++ cloop_t class.
__init__(self) -> cloop_t
b: cinsn_t *
__init__(self, r) -> cloop_t
r: cloop_t const &

Ancestors

Subclasses

Instance variables

var body
cloop_t_body_get(self) -> cinsn_t

Methods

def assign(self, *args) ‑> cloop_t &
assign(self, r) -> cloop_t
r (C++: const cloop_t &)
def cleanup(self, *args) ‑> void
cleanup(self)

Inherited members

class cnumber_t (*args)
Proxy of C++ cnumber_t class.
__init__(self, _opnum=0) -> cnumber_t
_opnum: int

Instance variables

var nf
cnumber_t_nf_get(self) -> number_format_t

Methods

def assign(self, *args) ‑> void
Assign new value
assign(self, v, nbytes, sign)
v: new value (C++: uint64)
nbytes: size of the new value in bytes (C++: int)
sign: sign of the value (C++: type_sign_t)
def compare(self, *args) ‑> int
compare(self, r) -> int
r: cnumber_t const &
def value(self, *args) ‑> uint64
Get value. This function will properly extend the number sign to 64bits depending on the type sign.
value(self, type) -> uint64
type (C++: const tinfo_t &)
class codegen_t (*args, **kwargs)
Proxy of C++ codegen_t class.

Instance variables

var ignore_micro
codegen_t_ignore_micro_get(self) -> char
var ii
codegen_t_ii_get(self) -> cdg_insn_iterator_t
var insn
codegen_t_insn_get(self) -> insn_t *
var mb
codegen_t_mb_get(self) -> mblock_t
var mba
codegen_t_mba_get(self) -> mba_t

Methods

def analyze_prolog(self, *args) ‑> merror_t
Analyze prolog/epilog of the function to decompile. If prolog is found, allocate and fill 'mba->pi' structure.
analyze_prolog(self, fc, reachable) -> merror_t
fc: flow chart (C++: const class qflow_chart_t &)
reachable: bitmap of reachable blocks (C++: const class
bitset_t &)
return: error code
def emit(self, *args) ‑> minsn_t *
Emit one microinstruction. The L, R, D arguments usually mean the register number. However, they depend on CODE. For example:for m_goto and m_jcnd L is the target addressfor m_ldc L is the constant value to load
emit(self, code, width, l, r, d, offsize) -> minsn_t
code (C++: mcode_t)
width (C++: int)
l (C++: uval_t)
r (C++: uval_t)
d (C++: uval_t)
offsize (C++: int)
return: created microinstruction. can be NULL if the instruction got
immediately optimized away.
emit(self, code, l, r, d) -> minsn_t
code (C++: mcode_t)
l (C++: uval_t)
r (C++: uval_t)
d (C++: uval_t)
return: created microinstruction. can be NULL if the instruction got
immediately optimized away.
def emit_micro_mvm(self, *args) ‑> minsn_t *
Emit one microinstruction. This variant takes a data type not a size.
emit_micro_mvm(self, code, dtype, l, r, d, offsize) -> minsn_t
code (C++: mcode_t)
dtype (C++: op_dtype_t)
l (C++: uval_t)
r (C++: uval_t)
d (C++: uval_t)
offsize (C++: int)
def gen_micro(self, *args) ‑> merror_t
Generate microcode for one instruction. The instruction is in INSN
def load_effective_address(self, *args) ‑> mreg_t
Generate microcode to calculate the address of a memory operand.
load_effective_address(self, n, flags=0) -> mreg_t
n: - number of INSN operand (C++: int)
flags: - reserved for future use (C++: int)
return: register containing the operand address. mr_none - failed
(not a memory operand)
def load_operand(self, *args) ‑> mreg_t
Generate microcode to load one operand.
load_operand(self, opnum, flags=0) -> mreg_t
opnum (C++: int)
flags: - reserved for future use (C++: int)
return: register containing the operand.
def microgen_completed(self, *args) ‑> void
This method is called when the microcode generation is done.
def prepare_gen_micro(self, *args) ‑> merror_t
Setup internal data to handle new instruction. This method should be called before calling 'gen_micro()' . Usually 'gen_micro()' is called by the decompiler. You have to call this function explicitly only if you yourself call 'gen_micro()' . The instruction is in INSN
def store_operand(self, *args) ‑> bool
Generate microcode to store an operand. In case of success an arbitrary number of instructions can be generated (and even no instruction if the source and target are the same)
store_operand(self, n, mop, flags=0, outins=None) -> bool
n: - number of target INSN operand (C++: int)
mop: - operand to be stored (C++: const mop_t &)
flags: - reserved for future use (C++: int)
outins: - (OUT) the last generated instruction (C++: minsn_t
**)
return: success
class creturn_t (*args)
Proxy of C++ creturn_t class.
__init__(self) -> creturn_t

Ancestors

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: creturn_t const &

Inherited members

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

Ancestors

Instance variables

var cases
cswitch_t_cases_get(self) -> ccases_t
var mvnf
cswitch_t_mvnf_get(self) -> cnumber_t

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: cswitch_t const &

Inherited members

class ctext_position_t (*args)
Proxy of C++ ctext_position_t class.
__init__(self, _lnnum=-1, _x=0, _y=0) -> ctext_position_t
_lnnum: int _x: int _y: int

Subclasses

Instance variables

var lnnum
ctext_position_t_lnnum_get(self) -> int
var x
ctext_position_t_x_get(self) -> int
var y
ctext_position_t_y_get(self) -> int

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: ctext_position_t const &
def in_ctree(self, *args) ‑> bool
Is the cursor in the variable/type declaration area?
in_ctree(self, hdrlines) -> bool
hdrlines: Number of lines of the declaration area (C++: int)
class ctree_anchor_t (*args)
Proxy of C++ ctree_anchor_t class.
__init__(self) -> ctree_anchor_t

Instance variables

var value
ctree_anchor_t_value_get(self) -> uval_t

Methods

def get_index(self, *args) ‑> int
get_index(self) -> int
def get_itp(self, *args) ‑> item_preciser_t
get_itp(self) -> item_preciser_t
def is_blkcmt_anchor(self, *args) ‑> bool
is_blkcmt_anchor(self) -> bool
def is_citem_anchor(self, *args) ‑> bool
is_citem_anchor(self) -> bool
def is_itp_anchor(self, *args) ‑> bool
is_itp_anchor(self) -> bool
def is_lvar_anchor(self, *args) ‑> bool
is_lvar_anchor(self) -> bool
def is_valid_anchor(self, *args) ‑> bool
is_valid_anchor(self) -> bool
class ctree_item_t (*args)
Proxy of C++ ctree_item_t class.
__init__(self) -> ctree_item_t

Instance variables

var citype
ctree_item_t_citype_get(self) -> cursor_item_type_t
var e
var f
var i
var it
var l
var loc
ctree_item_t_loc_get(self) -> treeloc_t

Methods

def get_ea(self, *args) ‑> ea_t
Get address of the current item. Each ctree item has an address.
def get_label_num(self, *args) ‑> int
Get label number of the current item.
get_label_num(self, gln_flags) -> int
gln_flags: Combination of get_label_num control bits (C++:
int)
return: -1 if failed or no label
def get_lvar(self, *args) ‑> lvar_t *
Get pointer to local variable. If the current item is a local variable, this function will return pointer to its definition.
def get_memptr(self, *args) ‑> member_t *
Get pointer to structure member. If the current item is a structure field, this function will return pointer to its definition.
get_memptr(self, p_sptr=None) -> member_t *
p_sptr: pointer to the variable where the pointer to the parent
structure is returned. This parameter can be NULL. (C++: struc_t **)
return: NULL if failed
def is_citem(self, *args) ‑> bool
Is the current item is a ctree item?
class ctree_items_t (*args)
Proxy of C++ qvector< citem_t * > class.
__init__(self) -> ctree_items_t
x: qvector< citem_t * > const &

Methods

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

Ancestors

Subclasses

Methods

def recalc_parent_types(self, *args) ‑> bool
Recalculate types of parent node. If a node type has been changed, the visitor must recalculate all parent types, otherwise the ctree becomes inconsistent. If during this recalculation a parent node is added/deleted, this function returns true. In this case it is recommended to restart the traversal because the information about parent nodes is stale.

Inherited members

class ctree_visitor_t (*args)
Proxy of C++ ctree_visitor_t class.
__init__(self, _flags) -> ctree_visitor_t
_flags: int

Subclasses

Instance variables

var cv_flags
ctree_visitor_t_cv_flags_get(self) -> int
var parents
ctree_visitor_t_parents_get(self) -> ctree_items_t

Methods

def apply_to(self, *args) ‑> int
Traverse ctree. The traversal will start at the specified item and continue until of one the visit_...() functions return a non-zero value.
apply_to(self, item, parent) -> int
item: root of the ctree to traverse (C++: citem_t *)
parent: parent of the specified item. can be specified as NULL.
(C++: citem_t *)
return: 0 or a non-zero value returned by a visit_...() function
def apply_to_exprs(self, *args) ‑> int
Traverse only expressions. The traversal will start at the specified item and continue until of one the visit_...() functions return a non- zero value.
apply_to_exprs(self, item, parent) -> int
item: root of the ctree to traverse (C++: citem_t *)
parent: parent of the specified item. can be specified as NULL.
(C++: citem_t *)
return: 0 or a non-zero value returned by a visit_...() function
def clr_prune(self, *args) ‑> void
Do not prune children. This is an internal function, no need to call it.
def clr_restart(self, *args) ‑> void
Do not restart. This is an internal function, no need to call it.
def is_postorder(self, *args) ‑> bool
Should the leave...() functions be called?
def leave_expr(self, *args) ‑> int
Visit an expression after having visited its children This is a visitor function which should be overridden by a derived class to do some useful work. This visitor performs post-order traserval, i.e. an item is visited after its children.
leave_expr(self, arg0) -> int
arg0: cexpr_t *
return: 0 to continue the traversal, nonzero to stop.
def leave_insn(self, *args) ‑> int
Visit a statement after having visited its children This is a visitor function which should be overridden by a derived class to do some useful work. This visitor performs post-order traserval, i.e. an item is visited after its children.
leave_insn(self, arg0) -> int
arg0: cinsn_t *
return: 0 to continue the traversal, nonzero to stop.
def maintain_parents(self, *args) ‑> bool
Should the parent information by maintained?
def must_prune(self, *args) ‑> bool
Should the traversal skip the children of the current item?
def must_restart(self, *args) ‑> bool
Should the traversal restart?
def only_insns(self, *args) ‑> bool
Should all expressions be automatically pruned?
def parent_expr(self, *args) ‑> cexpr_t *
Get parent of the current item as an expression.
def parent_insn(self, *args) ‑> cinsn_t *
Get parent of the current item as a statement.
def prune_now(self, *args) ‑> void
Prune children. This function may be called by a visitor() to skip all children of the current item.
def set_restart(self, *args) ‑> void
Restart the travesal. Meaningful only in 'apply_to_exprs()'
def visit_expr(self, *args) ‑> int
Visit an expression. This is a visitor function which should be overridden by a derived class to do some useful work. This visitor performs pre-order traserval, i.e. an item is visited before its children.
visit_expr(self, arg0) -> int
arg0: cexpr_t *
return: 0 to continue the traversal, nonzero to stop.
def visit_insn(self, *args) ‑> int
Visit a statement. This is a visitor function which should be overridden by a derived class to do some useful work. This visitor performs pre-order traserval, i.e. an item is visited before its children.
visit_insn(self, arg0) -> int
arg0: cinsn_t *
return: 0 to continue the traversal, nonzero to stop.
class cwhile_t (*args)
Proxy of C++ cwhile_t class.
__init__(self) -> cwhile_t

Ancestors

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: cwhile_t const &

Inherited members

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

Instance variables

var x
eamap_iterator_t_x_get(self) -> iterator_word
class eamap_t (*args)
Proxy of C++ std::map< ea_t,cinsnptrvec_t > class.
__init__(self) -> eamap_t

Class variables

var keytype
int([x]) -> integer
int(x, base=10) -> integer
Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero.
If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal. >>> int('0b100', base=0) 4
var valuetype
Proxy of C++ qvector< cinsn_t * > class.

Methods

def at(self, *args) ‑> cinsnptrvec_t &
at(self, _Keyval) -> cinsnptrvec_t
_Keyval: unsigned int const &
def begin(self, *args)
def clear(self)
def copy(self)
def end(self, *args)
def erase(self, *args)
def find(self, *args)
def first(self, *args)
def get(self, key, default=None)
def has_key(self, key)
def insert(self, *args)
def items(self)
def iteritems(self)
def iterkeys(self)
def itervalues(self)
def keys(self)
def next(self, *args)
def pop(self, key)
Sets the value associated with the provided key.
def popitem(self)
Sets the value associated with the provided key.
def second(self, *args)
def setdefault(self, key, default=None)
Sets the value associated with the provided key.
def size(self, *args)
def values(self)
class fnumber_t (*args)
Proxy of C++ fnumber_t class.
__init__(self) -> fnumber_t

Instance variables

var fnum
fnumber_t_fnum_get(self) -> fpvalue_t
var nbytes
fnumber_t_nbytes_get(self) -> int

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: fnumber_t const &
def dereference_const_uint16(self, *args) ‑> uint16 const *
dereference_const_uint16(self) -> uint16 const *
def dereference_uint16(self, *args) ‑> uint16 *
dereference_uint16(self) -> uint16 *
class gco_info_t (*args)
Proxy of C++ gco_info_t class.
__init__(self) -> gco_info_t

Instance variables

var flags
gco_info_t_flags_get(self) -> int
var name
gco_info_t_name_get(self) -> qstring *
var size
gco_info_t_size_get(self) -> int

Methods

def append_to_list(self, *args) ‑> bool
Append operand info to LIST. This function converts IDA register number or stack offset to a decompiler list.
append_to_list(self, list, mba) -> bool
list: list to append to (C++: mlist_t *)
mba: microcode object (C++: const mba_t *)
def cvt_to_ivl(self, *args) ‑> vivl_t
Convert operand info to VIVL. The returned VIVL can be used, for example, in a call of get_valranges().
def is_def(self, *args) ‑> bool
is_def(self) -> bool
def is_reg(self, *args) ‑> bool
is_reg(self) -> bool
def is_use(self, *args) ‑> bool
is_use(self) -> bool
class graph_chains_t (*args)
Proxy of C++ graph_chains_t class.
__init__(self) -> graph_chains_t

Ancestors

Methods

def acquire(self, *args) ‑> void
Lock the chains.
def for_all_chains(self, *args) ‑> int
Visit all chains
for_all_chains(self, cv, gca_flags) -> int
cv: chain visitor (C++: chain_visitor_t &)
gca_flags: combination of GCA_ bits (C++: int)
def is_locked(self, *args) ‑> bool
Are the chains locked? It is a good idea to lock the chains before using them. This ensures that they won't be recalculated and reallocated during the use. See the 'chain_keeper_t' class for that.
def release(self, *args) ‑> void
Unlock the chains.
def swap(self, *args) ‑> void
swap(self, r)
r (C++: graph_chains_t &)

Inherited members

class hexrays_failure_t (*args)
Proxy of C++ hexrays_failure_t class.
__init__(self) -> hexrays_failure_t
c: enum merror_t ea: ea_t buf: char const *
__init__(self, c, ea, buf) -> hexrays_failure_t
c: enum merror_t ea: ea_t buf: qstring const &

Instance variables

var code
hexrays_failure_t_code_get(self) -> merror_t
var errea
hexrays_failure_t_errea_get(self) -> ea_t
var str
hexrays_failure_t_str_get(self) -> qstring *

Methods

def desc(self, *args) ‑> qstring
desc(self) -> qstring
class hexwarn_t (*args)
Proxy of C++ hexwarn_t class.
__init__(self) -> hexwarn_t

Instance variables

var ea
hexwarn_t_ea_get(self) -> ea_t
var id
hexwarn_t_id_get(self) -> warnid_t
var text
hexwarn_t_text_get(self) -> qstring *

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: hexwarn_t const &
class hexwarns_t (*args)
Proxy of C++ qvector< hexwarn_t > class.
__init__(self) -> hexwarns_t
x: qvector< hexwarn_t > const &

Methods

def add_unique(self, *args) ‑> bool
add_unique(self, x) -> bool
x: hexwarn_t const &
def append(self, *args) ‑> hexwarn_t &
push_back(self, x)
x: hexwarn_t const &
def at(self, *args) ‑> hexwarn_t const &
__getitem__(self, i) -> hexwarn_t
i: size_t
def back(self)
def begin(self, *args) ‑> qvector< hexwarn_t >::const_iterator
begin(self) -> hexwarn_t
begin(self) -> hexwarn_t
def capacity(self, *args) ‑> size_t
capacity(self) -> size_t
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> qvector< hexwarn_t >::const_iterator
end(self) -> hexwarn_t
end(self) -> hexwarn_t
def erase(self, *args) ‑> qvector< hexwarn_t >::iterator
erase(self, it) -> hexwarn_t
it: qvector< hexwarn_t >::iterator
erase(self, first, last) -> hexwarn_t
first: qvector< hexwarn_t >::iterator last: qvector< hexwarn_t >::iterator
def extract(self, *args) ‑> hexwarn_t *
extract(self) -> hexwarn_t
def find(self, *args) ‑> qvector< hexwarn_t >::const_iterator
find(self, x) -> hexwarn_t
x: hexwarn_t const &
find(self, x) -> hexwarn_t
x: hexwarn_t const &
def front(self)
def grow(self, *args) ‑> void
grow(self, x=hexwarn_t())
x: hexwarn_t const &
def has(self, *args) ‑> bool
has(self, x) -> bool
x: hexwarn_t const &
def inject(self, *args) ‑> void
inject(self, s, len)
s: hexwarn_t * len: size_t
def insert(self, *args) ‑> qvector< hexwarn_t >::iterator
insert(self, it, x) -> hexwarn_t
it: qvector< hexwarn_t >::iterator x: hexwarn_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def push_back(self, *args) ‑> hexwarn_t &
push_back(self, x)
x: hexwarn_t const &
def qclear(self, *args) ‑> void
qclear(self)
def reserve(self, *args) ‑> void
reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void
resize(self, _newsize, x)
_newsize: size_t x: hexwarn_t const &
resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r: qvector< hexwarn_t > &
def truncate(self, *args) ‑> void
truncate(self)
class history_item_t (*args)
Proxy of C++ history_item_t class.
__init__(self, _ea=BADADDR, _lnnum=-1, _x=0, _y=0) -> history_item_t
_ea: ea_t _lnnum: int _x: int _y: int
__init__(self, _ea, p) -> history_item_t
_ea: ea_t p: ctext_position_t const &

Ancestors

Instance variables

var ea
history_item_t_ea_get(self) -> ea_t
var end
history_item_t_end_get(self) -> ea_t

Inherited members

class history_t (*args)
Proxy of C++ qstack< history_item_t > class.
__init__(self) -> history_t

Ancestors

Methods

def append(self, *args) ‑> history_item_t &
push_back(self, x)
x: history_item_t const &
def at(self, *args) ‑> history_item_t const &
__getitem__(self, i) -> history_item_t
i: size_t
def pop(self, *args) ‑> history_item_t
pop(self) -> history_item_t
def push(self, *args) ‑> void
push(self, v)
v: history_item_t const &
def top(self, *args) ‑> history_item_t &
top(self) -> history_item_t
top(self) -> history_item_t

Inherited members

class iterator (*args)
Proxy of C++ bitset_t::iterator class.
__init__(self, n=-1) -> iterator
n: int
class ivl_t (*args)
Proxy of C++ ivl_t class.
__init__(self, _off, _size) -> ivl_t
_off: uval_t _size: uval_t

Ancestors

Methods

def clear(self, *args) ‑> void
clear(self)
def compare(self, *args) ‑> int
compare(self, r) -> int
r: ivl_t const &
def contains(self, *args) ‑> bool
contains(self, off2) -> bool
off2 (C++: uval_t)
def dstr(self, *args) ‑> char const *
dstr(self) -> char const *
def empty(self, *args) ‑> bool
empty(self) -> bool
def extend_to_cover(self, *args) ‑> bool
extend_to_cover(self, r) -> bool
r (C++: const ivl_t &)
def includes(self, *args) ‑> bool
includes(self, ivl) -> bool
ivl (C++: const ivl_t &)
def intersect(self, *args) ‑> void
intersect(self, r)
r (C++: const ivl_t &)
def overlap(self, *args) ‑> bool
overlap(self, ivl) -> bool
ivl (C++: const ivl_t &)

Inherited members

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

Instance variables

var ivl
ivl_with_name_t_ivl_get(self) -> ivl_t
var part
ivl_with_name_t_part_get(self) -> char const *
var whole
ivl_with_name_t_whole_get(self) -> char const *
class ivlset_t (*args)
Proxy of C++ ivlset_t class.
__init__(self) -> ivlset_t
ivl: ivl_t const &

Ancestors

Methods

def add(self, *args) ‑> bool
add(self, ivl) -> bool
ivl (C++: const ivl_t &)
add(self, ea, size) -> bool
ea: ea_t size: asize_t
add(self, ivs) -> bool
ivs: ivlset_t const &
def addmasked(self, *args) ‑> bool
addmasked(self, ivs, mask) -> bool
ivs (C++: const ivlset_t &)
mask (C++: const ivl_t &)
def compare(self, *args) ‑> int
compare(self, r) -> int
r: ivlset_t const &
def contains(self, *args) ‑> bool
contains(self, off) -> bool
off (C++: uval_t)
def count(self, *args) ‑> asize_t
count(self) -> asize_t
def dstr(self, *args) ‑> char const *
dstr(self) -> char const *
def has_common(self, *args) ‑> bool
has_common(self, ivl, strict=False) -> bool
ivl (C++: const ivl_t &)
strict (C++: bool)
has_common(self, ivs) -> bool
ivs: ivlset_t const &
def includes(self, *args) ‑> bool
includes(self, ivs) -> bool
ivs (C++: const ivlset_t &)
def intersect(self, *args) ‑> bool
intersect(self, ivs) -> bool
ivs (C++: const ivlset_t &)
def sub(self, *args) ‑> bool
sub(self, ivl) -> bool
ivl (C++: const ivl_t &)
sub(self, ea, size) -> bool
ea: ea_t size: asize_t
sub(self, ivs) -> bool
ivs: ivlset_t const &

Inherited members

class lvar_locator_t (*args)
Proxy of C++ lvar_locator_t class.
__init__(self) -> lvar_locator_t
loc: vdloc_t const & ea: ea_t

Subclasses

Instance variables

var defea
lvar_locator_t_defea_get(self) -> ea_t
var location
lvar_locator_t_location_get(self) -> vdloc_t

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: lvar_locator_t const &
def get_reg1(self, *args) ‑> mreg_t
Get the register number of the variable.
def get_reg2(self, *args) ‑> mreg_t
Get the number of the second register (works only for ALOC_REG2 lvars)
def get_scattered(self, *args) ‑> scattered_aloc_t &
Get information about scattered variable.
def get_stkoff(self, *args) ‑> sval_t
Get offset of the varialbe in the stack frame.
def is_reg1(self, *args) ‑> bool
Is variable located on one register?
def is_reg2(self, *args) ‑> bool
Is variable located on two registers?
def is_reg_var(self, *args) ‑> bool
Is variable located on register(s)?
def is_scattered(self, *args) ‑> bool
Is variable scattered?
def is_stk_var(self, *args) ‑> bool
Is variable located on the stack?
class lvar_mapping_iterator_t (*args)
Proxy of C++ lvar_mapping_iterator_t class.
__init__(self) -> lvar_mapping_iterator_t

Instance variables

var x
lvar_mapping_iterator_t_x_get(self) -> iterator_word
class lvar_mapping_t (*args)
Proxy of C++ std::map< lvar_locator_t,lvar_locator_t > class.
__init__(self) -> lvar_mapping_t

Methods

def at(self, *args) ‑> lvar_locator_t &
at(self, _Keyval) -> lvar_locator_t
_Keyval: lvar_locator_t const &
def size(self, *args) ‑> size_t
size(self) -> size_t
class lvar_ref_t (*args)
Proxy of C++ lvar_ref_t class.
__init__(self, m, i, o=0) -> lvar_ref_t
m: mba_t * i: int o: sval_t
__init__(self, r) -> lvar_ref_t
r: lvar_ref_t const &

Instance variables

var idx
lvar_ref_t_idx_get(self) -> int
var mba
lvar_ref_t_mba_get(self) -> mba_t
var off
lvar_ref_t_off_get(self) -> sval_t

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: lvar_ref_t const &
def swap(self, *args) ‑> void
swap(self, r)
r (C++: lvar_ref_t &)
def var(self, *args) ‑> lvar_t &
Retrieve the referenced variable.
class lvar_saved_info_t (*args)
Proxy of C++ lvar_saved_info_t class.
__init__(self) -> lvar_saved_info_t

Instance variables

var cmt
lvar_saved_info_t_cmt_get(self) -> qstring *
var flags
lvar_saved_info_t_flags_get(self) -> int
var ll
lvar_saved_info_t_ll_get(self) -> lvar_locator_t
var name
lvar_saved_info_t_name_get(self) -> qstring *
var size
lvar_saved_info_t_size_get(self) -> ssize_t
var type
lvar_saved_info_t_type_get(self) -> tinfo_t

Methods

def clear_keep(self, *args) ‑> void
clear_keep(self)
def clr_forced_lvar(self, *args) ‑> void
clr_forced_lvar(self)
def clr_nomap_lvar(self, *args) ‑> void
clr_nomap_lvar(self)
def clr_noptr_lvar(self, *args) ‑> void
clr_noptr_lvar(self)
def clr_unused_lvar(self, *args) ‑> void
clr_unused_lvar(self)
def has_info(self, *args) ‑> bool
has_info(self) -> bool
def is_forced_lvar(self, *args) ‑> bool
is_forced_lvar(self) -> bool
def is_kept(self, *args) ‑> bool
is_kept(self) -> bool
def is_nomap_lvar(self, *args) ‑> bool
is_nomap_lvar(self) -> bool
def is_noptr_lvar(self, *args) ‑> bool
is_noptr_lvar(self) -> bool
def is_unused_lvar(self, *args) ‑> bool
is_unused_lvar(self) -> bool
def set_forced_lvar(self, *args) ‑> void
set_forced_lvar(self)
def set_keep(self, *args) ‑> void
set_keep(self)
def set_nomap_lvar(self, *args) ‑> void
set_nomap_lvar(self)
def set_noptr_lvar(self, *args) ‑> void
set_noptr_lvar(self)
def set_unused_lvar(self, *args) ‑> void
set_unused_lvar(self)
class lvar_saved_infos_t (*args)
Proxy of C++ qvector< lvar_saved_info_t > class.
__init__(self) -> lvar_saved_infos_t
x: qvector< lvar_saved_info_t > const &

Methods

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

Ancestors

Instance variables

var cmt
lvar_t_cmt_get(self) -> qstring *
var defblk
lvar_t_defblk_get(self) -> int
var divisor
lvar_t_divisor_get(self) -> uint64
var has_nice_name : bool
Does the variable have a nice name?
var has_user_info : bool
Has any user-defined information?
var has_user_name : bool
Has user-defined name?
var has_user_type : bool
Has user-defined type?
var is_arg_var : bool
Is the function argument?
var is_fake_var : bool
Is fake return variable?
var is_floating_var : bool
Used by a fpu insn?
var is_mapdst_var : bool
Other variable(s) map to this var?
var is_overlapped_var : bool
Is overlapped variable?
var is_result_var : bool
Is the function result?
var is_spoiled_var : bool
Is spoiled var? (meaningful only during lvar allocation)
var is_unknown_width : bool
Do we know the width of the variable?
var mreg_done : bool
Have corresponding microregs been replaced by references to this variable?
var name
lvar_t_name_get(self) -> qstring *
var tif
lvar_t_tif_get(self) -> tinfo_t
var typed : bool
Has the variable a type?
var used : bool
Is the variable used in the code?
var width
lvar_t_width_get(self) -> int

Methods

def accepts_type(self, *args) ‑> bool
Check if the variable accept the specified type. Some types are forbidden (void, function types, wrong arrays, etc)
accepts_type(self, t, may_change_thisarg=False) -> bool
t (C++: const tinfo_t &)
may_change_thisarg (C++: bool)
def append_list(self, *args) ‑> void
Append local variable to mlist.
append_list(self, mba, lst, pad_if_scattered=False)
mba: ptr to the current mba_t (C++: const mba_t *)
lst: list to append to (C++: mlist_t *)
pad_if_scattered (C++: bool)
def clear_used(self, *args) ‑> void
clear_used(self)
def clr_arg_var(self, *args) ‑> void
clr_arg_var(self)
def clr_automapped(self, *args) ‑> void
clr_automapped(self)
def clr_decl_unused(self, *args) ‑> void
clr_decl_unused(self)
def clr_dummy_arg(self, *args) ‑> void
clr_dummy_arg(self)
def clr_fake_var(self, *args) ‑> void
clr_fake_var(self)
def clr_floating_var(self, *args) ‑> void
clr_floating_var(self)
def clr_forced_var(self, *args) ‑> void
clr_forced_var(self)
def clr_mapdst_var(self, *args) ‑> void
clr_mapdst_var(self)
def clr_mreg_done(self, *args) ‑> void
clr_mreg_done(self)
def clr_noptr_var(self, *args) ‑> void
clr_noptr_var(self)
def clr_notarg(self, *args) ‑> void
clr_notarg(self)
def clr_overlapped_var(self, *args) ‑> void
clr_overlapped_var(self)
def clr_spoiled_var(self, *args) ‑> void
clr_spoiled_var(self)
def clr_thisarg(self, *args) ‑> void
clr_thisarg(self)
def clr_unknown_width(self, *args) ‑> void
clr_unknown_width(self)
def clr_used_byref(self, *args) ‑> void
clr_used_byref(self)
def clr_user_info(self, *args) ‑> void
clr_user_info(self)
def clr_user_name(self, *args) ‑> void
clr_user_name(self)
def clr_user_type(self, *args) ‑> void
clr_user_type(self)
def has_common(self, *args) ‑> bool
Do variables overlap?
has_common(self, v) -> bool
v (C++: const lvar_t &)
def has_common_bit(self, *args) ‑> bool
Does the variable overlap with the specified location?
has_common_bit(self, loc, width2) -> bool
loc (C++: const vdloc_t &)
width2 (C++: asize_t)
def has_regname(self, *args) ‑> bool
Has a register name? (like _RAX)
def in_asm(self, *args) ‑> bool
Is variable used in an instruction translated into __asm?
def is_aliasable(self, *args) ‑> bool
Is the variable aliasable?
is_aliasable(self, mba) -> bool
mba: ptr to the current mba_t Aliasable variables may be
modified indirectly (through a pointer) (C++: const mba_t *)
def is_automapped(self, *args) ‑> bool
Was the variable automatically mapped to another variable?
def is_decl_unused(self, *args) ‑> bool
Was declared as __unused by the user? See CVAR_UNUSED.
def is_dummy_arg(self, *args) ‑> bool
Is a dummy argument (added to fill a hole in the argument list)
def is_forced_var(self, *args) ‑> bool
Is a forced variable?
def is_noptr_var(self, *args) ‑> bool
Variable type should not be a pointer.
def is_notarg(self, *args) ‑> bool
Is a local variable? (local variable cannot be an input argument)
def is_thisarg(self, *args) ‑> bool
Is 'this' argument of a C++ member function?
def is_used_byref(self, *args) ‑> bool
Was the address of the variable taken?
def set_arg_var(self, *args) ‑> void
set_arg_var(self)
def set_automapped(self, *args) ‑> void
set_automapped(self)
def set_decl_unused(self, *args) ‑> void
set_decl_unused(self)
def set_dummy_arg(self, *args) ‑> void
set_dummy_arg(self)
def set_fake_var(self, *args) ‑> void
set_fake_var(self)
def set_final_lvar_type(self, *args) ‑> void
Set final variable type.
set_final_lvar_type(self, t)
t (C++: const tinfo_t &)
def set_floating_var(self, *args) ‑> void
set_floating_var(self)
def set_forced_var(self, *args) ‑> void
set_forced_var(self)
def set_lvar_type(self, *args) ‑> bool
Set variable type Note: this function does not modify the idb, only the lvar instance in the memory. For permanent changes see modify_user_lvars() Also, the variable type is not considered as final by the decompiler and may be modified later by the type derivation. In some cases set_final_var_type() may work better, but it does not do persistent changes to the database neither.
set_lvar_type(self, t, may_fail=False) -> bool
t: new type (C++: const tinfo_t &)
may_fail: if false and type is bad, interr (C++: bool)
return: success
def set_mapdst_var(self, *args) ‑> void
set_mapdst_var(self)
def set_mreg_done(self, *args) ‑> void
set_mreg_done(self)
def set_non_typed(self, *args) ‑> void
set_non_typed(self)
def set_noptr_var(self, *args) ‑> void
set_noptr_var(self)
def set_notarg(self, *args) ‑> void
set_notarg(self)
def set_overlapped_var(self, *args) ‑> void
set_overlapped_var(self)
def set_spoiled_var(self, *args) ‑> void
set_spoiled_var(self)
def set_thisarg(self, *args) ‑> void
set_thisarg(self)
def set_typed(self, *args) ‑> void
set_typed(self)
def set_unknown_width(self, *args) ‑> void
set_unknown_width(self)
def set_used(self, *args) ‑> void
set_used(self)
def set_used_byref(self, *args) ‑> void
set_used_byref(self)
def set_user_name(self, *args) ‑> void
set_user_name(self)
def set_user_type(self, *args) ‑> void
set_user_type(self)
def set_width(self, *args) ‑> bool
Change the variable width. We call the variable size 'width', it is represents the number of bytes. This function may change the variable type using 'set_lvar_type()' .
set_width(self, w, svw_flags=0) -> bool
w: new width (C++: int)
svw_flags: combination of SVW_... bits (C++: int)
return: success
def type(self, *args) ‑> tinfo_t &
Get variable type.

Inherited members

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

Instance variables

var lmaps
lvar_uservec_t_lmaps_get(self) -> lvar_mapping_t
var lvvec
lvar_uservec_t_lvvec_get(self) -> lvar_saved_infos_t
var stkoff_delta
lvar_uservec_t_stkoff_delta_get(self) -> uval_t
var ulv_flags
lvar_uservec_t_ulv_flags_get(self) -> int

Methods

def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def find_info(self, *args) ‑> lvar_saved_info_t *
find saved user settings for given var
find_info(self, vloc) -> lvar_saved_info_t
vloc (C++: const lvar_locator_t &)
def keep_info(self, *args) ‑> void
Preserve user settings for given var.
keep_info(self, v)
v (C++: const lvar_t &)
def swap(self, *args) ‑> void
swap(self, r)
r (C++: lvar_uservec_t &)
class lvars_t (*args)
Proxy of C++ lvars_t class.
__init__(self) -> lvars_t

Ancestors

Methods

def find(self, *args) ‑> lvar_t *
Find variable at the specified location.
find(self, ll) -> lvar_t
ll: variable location (C++: const lvar_locator_t &)
return: pointer to variable or NULL
def find_input_lvar(self, *args) ‑> int
Find input variable at the specified location.
find_input_lvar(self, argloc, _size) -> int
argloc: variable location (C++: const vdloc_t &)
_size: variable size (C++: int)
return: -1 if failed, otherwise the index into the variables vector.
def find_lvar(self, *args) ‑> int
Find variable at the specified location.
find_lvar(self, location, width, defblk=-1) -> int
location: variable location (C++: const vdloc_t &)
width: variable size (C++: int)
defblk: definition block of the lvar. -1 means any block (C++:
int)
return: -1 if failed, otherwise the index into the variables vector.
def find_stkvar(self, *args) ‑> int
Find stack variable at the specified location.
find_stkvar(self, spoff, width) -> int
spoff: offset from the minimal sp (C++: sval_t)
width: variable size (C++: int)
return: -1 if failed, otherwise the index into the variables vector.

Inherited members

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

Instance variables

var fii
mba_range_iterator_t_fii_get(self) -> func_tail_iterator_t
var rii
mba_range_iterator_t_rii_get(self) -> range_chunk_iterator_t *

Methods

def chunk(self, *args) ‑> range_t const &
chunk(self) -> range_t
def is_snippet(self, *args) ‑> bool
is_snippet(self) -> bool
def next(self, *args) ‑> bool
next(self) -> bool
def set(self, *args) ‑> bool
set(self, mbr) -> bool
mbr (C++: const mba_ranges_t &)
class mba_ranges_t (*args)
Proxy of C++ mba_ranges_t class.
__init__(self, _pfn=None) -> mba_ranges_t
_pfn: func_t *
__init__(self, r) -> mba_ranges_t
r: rangevec_t const &

Instance variables

var pfn
mba_ranges_t_pfn_get(self) -> func_t *
var ranges
mba_ranges_t_ranges_get(self) -> rangevec_t

Methods

def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def is_fragmented(self, *args) ‑> bool
is_fragmented(self) -> bool
def is_snippet(self, *args) ‑> bool
is_snippet(self) -> bool
def start(self, *args) ‑> ea_t
start(self) -> ea_t
class mba_t (*args, **kwargs)
Proxy of C++ mba_t class.

Static methods

def deserialize(*args) ‑> mba_t *
deserialize(bytes) -> mba_t
bytes: uchar const *

Instance variables

var aliased_args
mba_t_aliased_args_get(self) -> ivl_t
var aliased_memory
mba_t_aliased_memory_get(self) -> ivlset_t
var aliased_vars
mba_t_aliased_vars_get(self) -> ivl_t
var argidx
mba_t_argidx_get(self) -> intvec_t
var blocks
mba_t_blocks_get(self) -> mblock_t
var cc
mba_t_cc_get(self) -> cm_t
var consumed_argregs
mba_t_consumed_argregs_get(self) -> rlist_t
var deprecated_idb_node
mba_t_deprecated_idb_node_get(self) -> netnode
var entry_ea
mba_t_entry_ea_get(self) -> ea_t
var error_ea
mba_t_error_ea_get(self) -> ea_t
var error_strarg
mba_t_error_strarg_get(self) -> qstring *
var final_type
mba_t_final_type_get(self) -> bool
var first_epilog_ea
mba_t_first_epilog_ea_get(self) -> ea_t
var fpd
mba_t_fpd_get(self) -> sval_t
var frregs
mba_t_frregs_get(self) -> sval_t
var frsize
mba_t_frsize_get(self) -> sval_t
var fti_flags
mba_t_fti_flags_get(self) -> int
var fullsize
mba_t_fullsize_get(self) -> sval_t
var gotoff_stkvars
mba_t_gotoff_stkvars_get(self) -> ivlset_t
var idb_node
var idb_spoiled
mba_t_idb_spoiled_get(self) -> reginfovec_t
var idb_type
mba_t_idb_type_get(self) -> tinfo_t
var inargoff
mba_t_inargoff_get(self) -> sval_t
var label
mba_t_label_get(self) -> qstring *
var last_prolog_ea
mba_t_last_prolog_ea_get(self) -> ea_t
var maturity
mba_t_maturity_get(self) -> mba_maturity_t
var mbr
mba_t_mbr_get(self) -> mba_ranges_t
var minargref
mba_t_minargref_get(self) -> sval_t
var minstkref
mba_t_minstkref_get(self) -> sval_t
var minstkref_ea
mba_t_minstkref_ea_get(self) -> ea_t
var natural
mba_t_natural_get(self) -> mblock_t **
var nodel_memory
mba_t_nodel_memory_get(self) -> mlist_t
var notes
mba_t_notes_get(self) -> hexwarns_t
var npurged
mba_t_npurged_get(self) -> int
var occurred_warns
mba_t_occurred_warns_get(self) -> uchar [32]
var pfn_flags
mba_t_pfn_flags_get(self) -> int
var qty
mba_t_qty_get(self) -> int
var reqmat
mba_t_reqmat_get(self) -> mba_maturity_t
var restricted_memory
mba_t_restricted_memory_get(self) -> ivlset_t
var retsize
mba_t_retsize_get(self) -> int
var retvaridx
mba_t_retvaridx_get(self) -> int
var shadow_args
mba_t_shadow_args_get(self) -> int
var spd_adjust
mba_t_spd_adjust_get(self) -> sval_t
var spoiled_list
mba_t_spoiled_list_get(self) -> mlist_t
var stacksize
mba_t_stacksize_get(self) -> sval_t
var std_ivls
mba_t_std_ivls_get(self) -> ivl_with_name_t
var tmpstk_size
mba_t_tmpstk_size_get(self) -> sval_t
var vars
mba_t_vars_get(self) -> lvars_t

Methods

def alloc_fict_ea(self, *args) ‑> ea_t
Allocate a fictional address. This function can be used to allocate a new unique address for a new instruction, if re-using any existing address leads to conflicts. For example, if the last instruction of the function modifies R0 and falls through to the next function, it will be a tail call: LDM R0!, {R4,R7} end of the function start of another function In this case R0 generates two different lvars at the same address:one modified by LDManother that represents the return value from the tail call Another example: a third-party plugin makes a copy of an instruction. This may lead to the generation of two variables at the same address. Example 3: fictional addresses can be used for new instructions created while modifying the microcode. This function can be used to allocate a new unique address for a new instruction or a variable. The fictional address is selected from an unallocated address range.
alloc_fict_ea(self, real_ea) -> ea_t
real_ea (C++: ea_t)
return: a unique fictional address
def alloc_kreg(self, *args) ‑> mreg_t
Allocate a kernel register.
alloc_kreg(self, size, check_size=True) -> mreg_t
size: size of the register in bytes (C++: size_t)
check_size: if true, only the sizes that correspond to a size
of a basic type will be accepted. (C++: bool)
return: allocated register. mr_none means failure.
def alloc_lvars(self, *args) ‑> void
Allocate local variables. Must be called only immediately after 'optimize_global()' , with no modifications to the microcode. Converts registers, stack variables, and similar operands into mop_l. This call will not fail because all necessary checks were performed in 'optimize_global()' . After this call the microcode reaches its final state.
def analyze_calls(self, *args) ‑> int
Analyze calls and determine calling conventions.
analyze_calls(self, acflags) -> int
acflags: permitted actions that are necessary for successful
detection of calling conventions. See Bits for analyze_calls() (C++: int)
return: number of calls. -1 means error.
def arg(self, *args) ‑> lvar_t const &
Get input argument of the decompiled function.
arg(self, n) -> lvar_t
n: argument number (0..nargs-1) (C++: int)
arg(self, n) -> lvar_t
n: argument number (0..nargs-1) (C++: int)
def argbase(self, *args) ‑> sval_t
argbase(self) -> sval_t
def argidx_ok(self, *args) ‑> bool
argidx_ok(self) -> bool
def argidx_sorted(self, *args) ‑> bool
argidx_sorted(self) -> bool
def bad_call_sp_detected(self, *args) ‑> bool
bad_call_sp_detected(self) -> bool
def build_graph(self, *args) ‑> merror_t
Build control flow graph. This function may be called only once. It calculates the type of each basic block and the adjacency list. 'optimize_local()' calls this function if necessary. You need to call this function only before MMAT_LOCOPT.
def calc_shins_flags(self, *args) ‑> int
calc_shins_flags(self) -> int
def callinfo_built(self, *args) ‑> bool
callinfo_built(self) -> bool
def chain_varnums_ok(self, *args) ‑> bool
chain_varnums_ok(self) -> bool
def clr_cdtr(self, *args) ‑> void
clr_cdtr(self)
def clr_mba_flags(self, *args) ‑> void
clr_mba_flags(self, f)
f (C++: int)
def clr_mba_flags2(self, *args) ‑> void
clr_mba_flags2(self, f)
f (C++: int)
def code16_bit_removed(self, *args) ‑> bool
code16_bit_removed(self) -> bool
def combine_blocks(self, *args) ‑> bool
Combine blocks. This function merges blocks constituting linear flow. It calls 'remove_empty_and_unreachable_blocks()' as well.
def common_stkvars_stkargs(self, *args) ‑> bool
common_stkvars_stkargs(self) -> bool
def copy_block(self, *args) ‑> mblock_t *
Make a copy of a block. This function makes a simple copy of the block. It does not fix the predecessor and successor lists, they must be fixed if necessary.
copy_block(self, blk, new_serial, cpblk_flags=3) -> mblock_t
blk: block to copy (C++: mblock_t *)
new_serial: position of the copied block (C++: int)
cpblk_flags: combination of Batch decompilation bits ... bits
(C++: int)
return: pointer to the new copy
def create_helper_call(self, *args) ‑> minsn_t *
Create a call of a helper function.
create_helper_call(self, ea, helper, rettype=None, callargs=None, out=None) -> minsn_t
ea: The desired address of the instruction (C++: ea_t)
helper: The helper name (C++: const char *)
rettype: The return type (NULL or empty type means 'void')
(C++: const tinfo_t *)
callargs: The helper arguments (NULL-no arguments) (C++: const
mcallargs_t *)
out: The operand where the call result should be stored. If
this argument is not NULL, "mov helper_call(), out" will be generated. Otherwise "call helper()" will be generated. Note: the size of this operand must be equal to the RETTYPE size (C++: const mop_t *)
return: pointer to the created instruction or NULL if error
def deleted_pairs(self, *args) ‑> bool
deleted_pairs(self) -> bool
def display_numaddrs(self, *args) ‑> bool
display_numaddrs(self) -> bool
def display_valnums(self, *args) ‑> bool
display_valnums(self) -> bool
def dump(self, *args) ‑> void
Dump microcode to a file. The file will be created in the directory pointed by IDA_DUMPDIR envvar. Dump will be created only if IDA is run under debugger.
def dump_mba(self, *args) ‑> void
dump_mba(self, _verify, title)
_verify (C++: bool)
title (C++: const char *)
def find_mop(self, *args) ‑> mop_t *
Find an operand in the microcode. This function tries to find the operand that matches LIST. Any operand that overlaps with LIST is considered as a match.
find_mop(self, ctx, ea, is_dest, list) -> mop_t
ctx: context information for the result (C++: op_parent_info_t
*)
ea: desired address of the operand (C++: ea_t)
is_dest: search for destination operand? this argument may be
ignored if the exact match could not be found (C++: bool)
list: list of locations the correspond to the operand (C++:
const mlist_t &)
return: pointer to the operand or NULL.
def for_all_insns(self, *args) ‑> int
Visit all instructions. This function visits all instruction and subinstructions.
for_all_insns(self, mv) -> int
mv: instruction visitor (C++: minsn_visitor_t &)
return: non-zero value returned by mv.visit_mop() or zero
def for_all_ops(self, *args) ‑> int
Visit all operands of all instructions.
for_all_ops(self, mv) -> int
mv: operand visitor (C++: mop_visitor_t &)
return: non-zero value returned by mv.visit_mop() or zero
def for_all_topinsns(self, *args) ‑> int
Visit all top level instructions.
for_all_topinsns(self, mv) -> int
mv: instruction visitor (C++: minsn_visitor_t &)
return: non-zero value returned by mv.visit_mop() or zero
def free_kreg(self, *args) ‑> void
Free a kernel register. If wrong arguments are passed, this function will generate an internal error.
free_kreg(self, reg, size)
reg: a previously allocated kernel register (C++: mreg_t)
size: size of the register in bytes (C++: size_t)
def generated_asserts(self, *args) ‑> bool
generated_asserts(self) -> bool
def get_args_region(self, *args) ‑> ivl_t const &
get_args_region(self) -> ivl_t
def get_curfunc(self, *args) ‑> func_t *
get_curfunc(self) -> func_t *
def get_graph(self, *args) ‑> mbl_graph_t *
Get control graph. Call 'build_graph()' if you need the graph before MMAT_LOCOPT.
def get_ida_argloc(self, *args) ‑> argloc_t
get_ida_argloc(self, v) -> argloc_t
v (C++: const lvar_t &)
def get_lvars_region(self, *args) ‑> ivl_t const &
get_lvars_region(self) -> ivl_t
def get_mba_flags(self, *args) ‑> int
get_mba_flags(self) -> int
def get_mba_flags2(self, *args) ‑> int
get_mba_flags2(self) -> int
def get_mblock(self, *args) ‑> mblock_t *
Get basic block by its serial number.
get_mblock(self, n) -> mblock_t
n (C++: int)
get_mblock(self, n) -> mblock_t
n (C++: int)
def get_shadow_region(self, *args) ‑> ivl_t const &
get_shadow_region(self) -> ivl_t
def get_stack_region(self, *args) ‑> ivl_t
get_stack_region(self) -> ivl_t
def get_std_region(self, *args) ‑> ivl_t const &
Get information about various memory regions. We map the stack frame to the global memory, to some unused range.
get_std_region(self, idx) -> ivl_t
idx (C++: memreg_index_t)
def graph_insns(self, *args) ‑> bool
graph_insns(self) -> bool
def has_bad_sp(self, *args) ‑> bool
has_bad_sp(self) -> bool
def has_over_chains(self, *args) ‑> bool
has_over_chains(self) -> bool
def has_passregs(self, *args) ‑> bool
has_passregs(self) -> bool
def has_stack_retval(self, *args) ‑> bool
has_stack_retval(self) -> bool
def idaloc2vd(self, *args) ‑> vdloc_t
idaloc2vd(self, loc, width) -> vdloc_t
loc (C++: const argloc_t &)
width (C++: int)
def insert_block(self, *args) ‑> mblock_t *
Insert a block in the middle of the mbl array. The very first block of microcode must be empty, it is the entry block. The very last block of microcode must be BLT_STOP, it is the exit block. Therefore inserting a new block before the entry point or after the exit block is not a good idea.
insert_block(self, bblk) -> mblock_t
bblk: the new block will be inserted before BBLK (C++: int)
return: ptr to the new block
def is_cdtr(self, *args) ‑> bool
is_cdtr(self) -> bool
def is_ctr(self, *args) ‑> bool
is_ctr(self) -> bool
def is_dtr(self, *args) ‑> bool
is_dtr(self) -> bool
def is_pattern(self, *args) ‑> bool
is_pattern(self) -> bool
def is_snippet(self, *args) ‑> bool
is_snippet(self) -> bool
def is_stkarg(self, *args) ‑> bool
is_stkarg(self, v) -> bool
v (C++: const lvar_t &)
def is_thunk(self, *args) ‑> bool
is_thunk(self) -> bool
def loaded_gdl(self, *args) ‑> bool
loaded_gdl(self) -> bool
def lvar_names_ok(self, *args) ‑> bool
lvar_names_ok(self) -> bool
def lvars_allocated(self, *args) ‑> bool
lvars_allocated(self) -> bool
def lvars_renamed(self, *args) ‑> bool
lvars_renamed(self) -> bool
def map_fict_ea(self, *args) ‑> ea_t
Resolve a fictional address. This function provides a reverse of the mapping made by 'alloc_fict_ea()' .
map_fict_ea(self, fict_ea) -> ea_t
fict_ea: fictional definition address (C++: ea_t)
return: the real instruction address
def mark_chains_dirty(self, *args) ‑> void
Mark the microcode use-def chains dirty. Call this function is any inter-block data dependencies got changed because of your modifications to the microcode. Failing to do so may cause an internal error.
def may_refine_rettype(self, *args) ‑> bool
may_refine_rettype(self) -> bool
def optimize_global(self, *args) ‑> merror_t
Optimize microcode globally. This function applies various optimization methods until we reach the fixed point. After that it preallocates lvars unless reqmat forbids it.
def optimize_local(self, *args) ‑> int
Optimize each basic block locally
optimize_local(self, locopt_bits) -> int
locopt_bits: combination of Bits for optimize_local() bits
(C++: int)
return: number of changes. 0 means nothing changed This function is
called by the decompiler, usually there is no need to call it explicitly.
def optimized(self, *args) ‑> bool
optimized(self) -> bool
def precise_defeas(self, *args) ‑> bool
precise_defeas(self) -> bool
def propagated_asserts(self, *args) ‑> bool
propagated_asserts(self) -> bool
def really_alloc(self, *args) ‑> bool
really_alloc(self) -> bool
def regargs_is_not_aligned(self, *args) ‑> bool
regargs_is_not_aligned(self) -> bool
def remove_block(self, *args) ‑> bool
Delete a block.
remove_block(self, blk) -> bool
blk: block to delete (C++: mblock_t *)
return: true if at least one of the other blocks became empty or
unreachable
def remove_empty_and_unreachable_blocks(self, *args) ‑> bool
Delete all empty and unreachable blocks. Blocks marked with MBL_KEEP won't be deleted.
def returns_fpval(self, *args) ‑> bool
returns_fpval(self) -> bool
def rtype_refined(self, *args) ‑> bool
rtype_refined(self) -> bool
def save_snapshot(self, *args) ‑> void
Create and save microcode snapshot.
save_snapshot(self, description)
description (C++: const char *)
def saverest_done(self, *args) ‑> bool
saverest_done(self) -> bool
def serialize(self, *args) ‑> void
Serialize mbl array into a sequence of bytes.
def set_maturity(self, *args) ‑> bool
Set maturity level.
set_maturity(self, mat) -> bool
mat (C++: mba_maturity_t)
return: true if it is time to stop analysis Plugins may use this
function to skip some parts of the analysis. The maturity level cannot be decreased.
def set_mba_flags(self, *args) ‑> void
set_mba_flags(self, f)
f (C++: int)
def set_mba_flags2(self, *args) ‑> void
set_mba_flags2(self, f)
f (C++: int)
def short_display(self, *args) ‑> bool
short_display(self) -> bool
def should_beautify(self, *args) ‑> bool
should_beautify(self) -> bool
def show_reduction(self, *args) ‑> bool
show_reduction(self) -> bool
def stkoff_ida2vd(self, *args) ‑> sval_t
stkoff_ida2vd(self, off) -> sval_t
off (C++: sval_t)
def stkoff_vd2ida(self, *args) ‑> sval_t
stkoff_vd2ida(self, off) -> sval_t
off (C++: sval_t)
def term(self, *args) ‑> void
term(self)
def use_frame(self, *args) ‑> bool
use_frame(self) -> bool
def use_wingraph32(self, *args) ‑> bool
use_wingraph32(self) -> bool
def valranges_done(self, *args) ‑> bool
valranges_done(self) -> bool
def vd2idaloc(self, *args) ‑> argloc_t
vd2idaloc(self, loc, width, spd) -> argloc_t
loc (C++: const vdloc_t &)
width (C++: int) spd: sval_t
vd2idaloc(self, loc, width) -> argloc_t
loc (C++: const vdloc_t &)
width (C++: int)
def verify(self, *args) ‑> void
Verify microcode consistency.
verify(self, always)
always: if false, the check will be performed only if ida runs
under debugger If any inconsistency is discovered, an internal error will be generated. We strongly recommend you to call this function before returing control to the decompiler from your callbacks, in the case if you modified the microcode. (C++: bool)
def write_to_const_detected(self, *args) ‑> bool
write_to_const_detected(self) -> bool
class mbl_array_t (*args, **kwargs)
Proxy of C++ mba_t class.

Static methods

def deserialize(*args) ‑> mba_t *
deserialize(bytes) -> mba_t
bytes: uchar const *

Instance variables

var aliased_args
mba_t_aliased_args_get(self) -> ivl_t
var aliased_memory
mba_t_aliased_memory_get(self) -> ivlset_t
var aliased_vars
mba_t_aliased_vars_get(self) -> ivl_t
var argidx
mba_t_argidx_get(self) -> intvec_t
var blocks
mba_t_blocks_get(self) -> mblock_t
var cc
mba_t_cc_get(self) -> cm_t
var consumed_argregs
mba_t_consumed_argregs_get(self) -> rlist_t
var deprecated_idb_node
mba_t_deprecated_idb_node_get(self) -> netnode
var entry_ea
mba_t_entry_ea_get(self) -> ea_t
var error_ea
mba_t_error_ea_get(self) -> ea_t
var error_strarg
mba_t_error_strarg_get(self) -> qstring *
var final_type
mba_t_final_type_get(self) -> bool
var first_epilog_ea
mba_t_first_epilog_ea_get(self) -> ea_t
var fpd
mba_t_fpd_get(self) -> sval_t
var frregs
mba_t_frregs_get(self) -> sval_t
var frsize
mba_t_frsize_get(self) -> sval_t
var fti_flags
mba_t_fti_flags_get(self) -> int
var fullsize
mba_t_fullsize_get(self) -> sval_t
var gotoff_stkvars
mba_t_gotoff_stkvars_get(self) -> ivlset_t
var idb_node
var idb_spoiled
mba_t_idb_spoiled_get(self) -> reginfovec_t
var idb_type
mba_t_idb_type_get(self) -> tinfo_t
var inargoff
mba_t_inargoff_get(self) -> sval_t
var label
mba_t_label_get(self) -> qstring *
var last_prolog_ea
mba_t_last_prolog_ea_get(self) -> ea_t
var maturity
mba_t_maturity_get(self) -> mba_maturity_t
var mbr
mba_t_mbr_get(self) -> mba_ranges_t
var minargref
mba_t_minargref_get(self) -> sval_t
var minstkref
mba_t_minstkref_get(self) -> sval_t
var minstkref_ea
mba_t_minstkref_ea_get(self) -> ea_t
var natural
mba_t_natural_get(self) -> mblock_t **
var nodel_memory
mba_t_nodel_memory_get(self) -> mlist_t
var notes
mba_t_notes_get(self) -> hexwarns_t
var npurged
mba_t_npurged_get(self) -> int
var occurred_warns
mba_t_occurred_warns_get(self) -> uchar [32]
var pfn_flags
mba_t_pfn_flags_get(self) -> int
var qty
mba_t_qty_get(self) -> int
var reqmat
mba_t_reqmat_get(self) -> mba_maturity_t
var restricted_memory
mba_t_restricted_memory_get(self) -> ivlset_t
var retsize
mba_t_retsize_get(self) -> int
var retvaridx
mba_t_retvaridx_get(self) -> int
var shadow_args
mba_t_shadow_args_get(self) -> int
var spd_adjust
mba_t_spd_adjust_get(self) -> sval_t
var spoiled_list
mba_t_spoiled_list_get(self) -> mlist_t
var stacksize
mba_t_stacksize_get(self) -> sval_t
var std_ivls
mba_t_std_ivls_get(self) -> ivl_with_name_t
var tmpstk_size
mba_t_tmpstk_size_get(self) -> sval_t
var vars
mba_t_vars_get(self) -> lvars_t

Methods

def alloc_fict_ea(self, *args) ‑> ea_t
Allocate a fictional address. This function can be used to allocate a new unique address for a new instruction, if re-using any existing address leads to conflicts. For example, if the last instruction of the function modifies R0 and falls through to the next function, it will be a tail call: LDM R0!, {R4,R7} end of the function start of another function In this case R0 generates two different lvars at the same address:one modified by LDManother that represents the return value from the tail call Another example: a third-party plugin makes a copy of an instruction. This may lead to the generation of two variables at the same address. Example 3: fictional addresses can be used for new instructions created while modifying the microcode. This function can be used to allocate a new unique address for a new instruction or a variable. The fictional address is selected from an unallocated address range.
alloc_fict_ea(self, real_ea) -> ea_t
real_ea (C++: ea_t)
return: a unique fictional address
def alloc_kreg(self, *args) ‑> mreg_t
Allocate a kernel register.
alloc_kreg(self, size, check_size=True) -> mreg_t
size: size of the register in bytes (C++: size_t)
check_size: if true, only the sizes that correspond to a size
of a basic type will be accepted. (C++: bool)
return: allocated register. mr_none means failure.
def alloc_lvars(self, *args) ‑> void
Allocate local variables. Must be called only immediately after 'optimize_global()' , with no modifications to the microcode. Converts registers, stack variables, and similar operands into mop_l. This call will not fail because all necessary checks were performed in 'optimize_global()' . After this call the microcode reaches its final state.
def analyze_calls(self, *args) ‑> int
Analyze calls and determine calling conventions.
analyze_calls(self, acflags) -> int
acflags: permitted actions that are necessary for successful
detection of calling conventions. See Bits for analyze_calls() (C++: int)
return: number of calls. -1 means error.
def arg(self, *args) ‑> lvar_t const &
Get input argument of the decompiled function.
arg(self, n) -> lvar_t
n: argument number (0..nargs-1) (C++: int)
arg(self, n) -> lvar_t
n: argument number (0..nargs-1) (C++: int)
def argbase(self, *args) ‑> sval_t
argbase(self) -> sval_t
def argidx_ok(self, *args) ‑> bool
argidx_ok(self) -> bool
def argidx_sorted(self, *args) ‑> bool
argidx_sorted(self) -> bool
def bad_call_sp_detected(self, *args) ‑> bool
bad_call_sp_detected(self) -> bool
def build_graph(self, *args) ‑> merror_t
Build control flow graph. This function may be called only once. It calculates the type of each basic block and the adjacency list. 'optimize_local()' calls this function if necessary. You need to call this function only before MMAT_LOCOPT.
def calc_shins_flags(self, *args) ‑> int
calc_shins_flags(self) -> int
def callinfo_built(self, *args) ‑> bool
callinfo_built(self) -> bool
def chain_varnums_ok(self, *args) ‑> bool
chain_varnums_ok(self) -> bool
def clr_cdtr(self, *args) ‑> void
clr_cdtr(self)
def clr_mba_flags(self, *args) ‑> void
clr_mba_flags(self, f)
f (C++: int)
def clr_mba_flags2(self, *args) ‑> void
clr_mba_flags2(self, f)
f (C++: int)
def code16_bit_removed(self, *args) ‑> bool
code16_bit_removed(self) -> bool
def combine_blocks(self, *args) ‑> bool
Combine blocks. This function merges blocks constituting linear flow. It calls 'remove_empty_and_unreachable_blocks()' as well.
def common_stkvars_stkargs(self, *args) ‑> bool
common_stkvars_stkargs(self) -> bool
def copy_block(self, *args) ‑> mblock_t *
Make a copy of a block. This function makes a simple copy of the block. It does not fix the predecessor and successor lists, they must be fixed if necessary.
copy_block(self, blk, new_serial, cpblk_flags=3) -> mblock_t
blk: block to copy (C++: mblock_t *)
new_serial: position of the copied block (C++: int)
cpblk_flags: combination of Batch decompilation bits ... bits
(C++: int)
return: pointer to the new copy
def create_helper_call(self, *args) ‑> minsn_t *
Create a call of a helper function.
create_helper_call(self, ea, helper, rettype=None, callargs=None, out=None) -> minsn_t
ea: The desired address of the instruction (C++: ea_t)
helper: The helper name (C++: const char *)
rettype: The return type (NULL or empty type means 'void')
(C++: const tinfo_t *)
callargs: The helper arguments (NULL-no arguments) (C++: const
mcallargs_t *)
out: The operand where the call result should be stored. If
this argument is not NULL, "mov helper_call(), out" will be generated. Otherwise "call helper()" will be generated. Note: the size of this operand must be equal to the RETTYPE size (C++: const mop_t *)
return: pointer to the created instruction or NULL if error
def deleted_pairs(self, *args) ‑> bool
deleted_pairs(self) -> bool
def display_numaddrs(self, *args) ‑> bool
display_numaddrs(self) -> bool
def display_valnums(self, *args) ‑> bool
display_valnums(self) -> bool
def dump(self, *args) ‑> void
Dump microcode to a file. The file will be created in the directory pointed by IDA_DUMPDIR envvar. Dump will be created only if IDA is run under debugger.
def dump_mba(self, *args) ‑> void
dump_mba(self, _verify, title)
_verify (C++: bool)
title (C++: const char *)
def find_mop(self, *args) ‑> mop_t *
Find an operand in the microcode. This function tries to find the operand that matches LIST. Any operand that overlaps with LIST is considered as a match.
find_mop(self, ctx, ea, is_dest, list) -> mop_t
ctx: context information for the result (C++: op_parent_info_t
*)
ea: desired address of the operand (C++: ea_t)
is_dest: search for destination operand? this argument may be
ignored if the exact match could not be found (C++: bool)
list: list of locations the correspond to the operand (C++:
const mlist_t &)
return: pointer to the operand or NULL.
def for_all_insns(self, *args) ‑> int
Visit all instructions. This function visits all instruction and subinstructions.
for_all_insns(self, mv) -> int
mv: instruction visitor (C++: minsn_visitor_t &)
return: non-zero value returned by mv.visit_mop() or zero
def for_all_ops(self, *args) ‑> int
Visit all operands of all instructions.
for_all_ops(self, mv) -> int
mv: operand visitor (C++: mop_visitor_t &)
return: non-zero value returned by mv.visit_mop() or zero
def for_all_topinsns(self, *args) ‑> int
Visit all top level instructions.
for_all_topinsns(self, mv) -> int
mv: instruction visitor (C++: minsn_visitor_t &)
return: non-zero value returned by mv.visit_mop() or zero
def free_kreg(self, *args) ‑> void
Free a kernel register. If wrong arguments are passed, this function will generate an internal error.
free_kreg(self, reg, size)
reg: a previously allocated kernel register (C++: mreg_t)
size: size of the register in bytes (C++: size_t)
def generated_asserts(self, *args) ‑> bool
generated_asserts(self) -> bool
def get_args_region(self, *args) ‑> ivl_t const &
get_args_region(self) -> ivl_t
def get_curfunc(self, *args) ‑> func_t *
get_curfunc(self) -> func_t *
def get_graph(self, *args) ‑> mbl_graph_t *
Get control graph. Call 'build_graph()' if you need the graph before MMAT_LOCOPT.
def get_ida_argloc(self, *args) ‑> argloc_t
get_ida_argloc(self, v) -> argloc_t
v (C++: const lvar_t &)
def get_lvars_region(self, *args) ‑> ivl_t const &
get_lvars_region(self) -> ivl_t
def get_mba_flags(self, *args) ‑> int
get_mba_flags(self) -> int
def get_mba_flags2(self, *args) ‑> int
get_mba_flags2(self) -> int
def get_mblock(self, *args) ‑> mblock_t *
Get basic block by its serial number.
get_mblock(self, n) -> mblock_t
n (C++: int)
get_mblock(self, n) -> mblock_t
n (C++: int)
def get_shadow_region(self, *args) ‑> ivl_t const &
get_shadow_region(self) -> ivl_t
def get_stack_region(self, *args) ‑> ivl_t
get_stack_region(self) -> ivl_t
def get_std_region(self, *args) ‑> ivl_t const &
Get information about various memory regions. We map the stack frame to the global memory, to some unused range.
get_std_region(self, idx) -> ivl_t
idx (C++: memreg_index_t)
def graph_insns(self, *args) ‑> bool
graph_insns(self) -> bool
def has_bad_sp(self, *args) ‑> bool
has_bad_sp(self) -> bool
def has_over_chains(self, *args) ‑> bool
has_over_chains(self) -> bool
def has_passregs(self, *args) ‑> bool
has_passregs(self) -> bool
def has_stack_retval(self, *args) ‑> bool
has_stack_retval(self) -> bool
def idaloc2vd(self, *args) ‑> vdloc_t
idaloc2vd(self, loc, width) -> vdloc_t
loc (C++: const argloc_t &)
width (C++: int)
def insert_block(self, *args) ‑> mblock_t *
Insert a block in the middle of the mbl array. The very first block of microcode must be empty, it is the entry block. The very last block of microcode must be BLT_STOP, it is the exit block. Therefore inserting a new block before the entry point or after the exit block is not a good idea.
insert_block(self, bblk) -> mblock_t
bblk: the new block will be inserted before BBLK (C++: int)
return: ptr to the new block
def is_cdtr(self, *args) ‑> bool
is_cdtr(self) -> bool
def is_ctr(self, *args) ‑> bool
is_ctr(self) -> bool
def is_dtr(self, *args) ‑> bool
is_dtr(self) -> bool
def is_pattern(self, *args) ‑> bool
is_pattern(self) -> bool
def is_snippet(self, *args) ‑> bool
is_snippet(self) -> bool
def is_stkarg(self, *args) ‑> bool
is_stkarg(self, v) -> bool
v (C++: const lvar_t &)
def is_thunk(self, *args) ‑> bool
is_thunk(self) -> bool
def loaded_gdl(self, *args) ‑> bool
loaded_gdl(self) -> bool
def lvar_names_ok(self, *args) ‑> bool
lvar_names_ok(self) -> bool
def lvars_allocated(self, *args) ‑> bool
lvars_allocated(self) -> bool
def lvars_renamed(self, *args) ‑> bool
lvars_renamed(self) -> bool
def map_fict_ea(self, *args) ‑> ea_t
Resolve a fictional address. This function provides a reverse of the mapping made by 'alloc_fict_ea()' .
map_fict_ea(self, fict_ea) -> ea_t
fict_ea: fictional definition address (C++: ea_t)
return: the real instruction address
def mark_chains_dirty(self, *args) ‑> void
Mark the microcode use-def chains dirty. Call this function is any inter-block data dependencies got changed because of your modifications to the microcode. Failing to do so may cause an internal error.
def may_refine_rettype(self, *args) ‑> bool
may_refine_rettype(self) -> bool
def optimize_global(self, *args) ‑> merror_t
Optimize microcode globally. This function applies various optimization methods until we reach the fixed point. After that it preallocates lvars unless reqmat forbids it.
def optimize_local(self, *args) ‑> int
Optimize each basic block locally
optimize_local(self, locopt_bits) -> int
locopt_bits: combination of Bits for optimize_local() bits
(C++: int)
return: number of changes. 0 means nothing changed This function is
called by the decompiler, usually there is no need to call it explicitly.
def optimized(self, *args) ‑> bool
optimized(self) -> bool
def precise_defeas(self, *args) ‑> bool
precise_defeas(self) -> bool
def propagated_asserts(self, *args) ‑> bool
propagated_asserts(self) -> bool
def really_alloc(self, *args) ‑> bool
really_alloc(self) -> bool
def regargs_is_not_aligned(self, *args) ‑> bool
regargs_is_not_aligned(self) -> bool
def remove_block(self, *args) ‑> bool
Delete a block.
remove_block(self, blk) -> bool
blk: block to delete (C++: mblock_t *)
return: true if at least one of the other blocks became empty or
unreachable
def remove_empty_and_unreachable_blocks(self, *args) ‑> bool
Delete all empty and unreachable blocks. Blocks marked with MBL_KEEP won't be deleted.
def returns_fpval(self, *args) ‑> bool
returns_fpval(self) -> bool
def rtype_refined(self, *args) ‑> bool
rtype_refined(self) -> bool
def save_snapshot(self, *args) ‑> void
Create and save microcode snapshot.
save_snapshot(self, description)
description (C++: const char *)
def saverest_done(self, *args) ‑> bool
saverest_done(self) -> bool
def serialize(self, *args) ‑> void
Serialize mbl array into a sequence of bytes.
def set_maturity(self, *args) ‑> bool
Set maturity level.
set_maturity(self, mat) -> bool
mat (C++: mba_maturity_t)
return: true if it is time to stop analysis Plugins may use this
function to skip some parts of the analysis. The maturity level cannot be decreased.
def set_mba_flags(self, *args) ‑> void
set_mba_flags(self, f)
f (C++: int)
def set_mba_flags2(self, *args) ‑> void
set_mba_flags2(self, f)
f (C++: int)
def short_display(self, *args) ‑> bool
short_display(self) -> bool
def should_beautify(self, *args) ‑> bool
should_beautify(self) -> bool
def show_reduction(self, *args) ‑> bool
show_reduction(self) -> bool
def stkoff_ida2vd(self, *args) ‑> sval_t
stkoff_ida2vd(self, off) -> sval_t
off (C++: sval_t)
def stkoff_vd2ida(self, *args) ‑> sval_t
stkoff_vd2ida(self, off) -> sval_t
off (C++: sval_t)
def term(self, *args) ‑> void
term(self)
def use_frame(self, *args) ‑> bool
use_frame(self) -> bool
def use_wingraph32(self, *args) ‑> bool
use_wingraph32(self) -> bool
def valranges_done(self, *args) ‑> bool
valranges_done(self) -> bool
def vd2idaloc(self, *args) ‑> argloc_t
vd2idaloc(self, loc, width, spd) -> argloc_t
loc (C++: const vdloc_t &)
width (C++: int) spd: sval_t
vd2idaloc(self, loc, width) -> argloc_t
loc (C++: const vdloc_t &)
width (C++: int)
def verify(self, *args) ‑> void
Verify microcode consistency.
verify(self, always)
always: if false, the check will be performed only if ida runs
under debugger If any inconsistency is discovered, an internal error will be generated. We strongly recommend you to call this function before returing control to the decompiler from your callbacks, in the case if you modified the microcode. (C++: bool)
def write_to_const_detected(self, *args) ‑> bool
write_to_const_detected(self) -> bool
class mbl_graph_t (*args, **kwargs)
Proxy of C++ mbl_graph_t class.
__init__(self) -> gdl_graph_t
self: PyObject *

Ancestors

Methods

def get_chain_stamp(self, *args) ‑> int
get_chain_stamp(self) -> int
def get_du(self, *args) ‑> graph_chains_t *
Get def-use chains.
get_du(self, gctype) -> graph_chains_t
gctype (C++: gctype_t)
def get_mblock(self, *args) ‑> mblock_t *
get_mblock(self, n) -> mblock_t
n (C++: int)
def get_ud(self, *args) ‑> graph_chains_t *
Get use-def chains.
get_ud(self, gctype) -> graph_chains_t
gctype (C++: gctype_t)
def is_du_chain_dirty(self, *args) ‑> bool
Is the def-use chain of the specified kind dirty?
is_du_chain_dirty(self, gctype) -> bool
gctype (C++: gctype_t)
def is_redefined_globally(self, *args) ‑> bool
Is LIST redefined in the graph?
is_redefined_globally(self, list, b1, b2, m1, m2, maymust=MAY_ACCESS) -> bool
list (C++: const mlist_t &)
b1 (C++: int)
b2 (C++: int)
m1 (C++: const minsn_t *)
m2 (C++: const minsn_t *)
maymust (C++: maymust_t)
def is_ud_chain_dirty(self, *args) ‑> bool
Is the use-def chain of the specified kind dirty?
is_ud_chain_dirty(self, gctype) -> bool
gctype (C++: gctype_t)
def is_used_globally(self, *args) ‑> bool
Is LIST used in the graph?
is_used_globally(self, list, b1, b2, m1, m2, maymust=MAY_ACCESS) -> bool
list (C++: const mlist_t &)
b1 (C++: int)
b2 (C++: int)
m1 (C++: const minsn_t *)
m2 (C++: const minsn_t *)
maymust (C++: maymust_t)

Inherited members

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

Instance variables

var dead_at_start
mblock_t_dead_at_start_get(self) -> mlist_t
var dnu
mblock_t_dnu_get(self) -> mlist_t
var end
mblock_t_end_get(self) -> ea_t
var flags
mblock_t_flags_get(self) -> uint32
var head
mblock_t_head_get(self) -> minsn_t
var maxbsp
mblock_t_maxbsp_get(self) -> sval_t
var maybdef
mblock_t_maybdef_get(self) -> mlist_t
var maybuse
mblock_t_maybuse_get(self) -> mlist_t
var mba
mblock_t_mba_get(self) -> mba_t
var minbargref
mblock_t_minbargref_get(self) -> sval_t
var minbstkref
mblock_t_minbstkref_get(self) -> sval_t
var mustbdef
mblock_t_mustbdef_get(self) -> mlist_t
var mustbuse
mblock_t_mustbuse_get(self) -> mlist_t
var nextb
mblock_t_nextb_get(self) -> mblock_t
var predset
mblock_t_predset_get(self) -> intvec_t
var prevb
mblock_t_prevb_get(self) -> mblock_t
var serial
mblock_t_serial_get(self) -> int
var start
mblock_t_start_get(self) -> ea_t
var succset
mblock_t_succset_get(self) -> intvec_t
var tail
mblock_t_tail_get(self) -> minsn_t
var type
mblock_t_type_get(self) -> mblock_type_t

Methods

def append_def_list(self, *args) ‑> void
Append def-list of an operand. This function calculates list of locations that may or must be modified by the operand and appends it to LIST.
append_def_list(self, list, op, maymust)
list: ptr to the output buffer. we will append to it. (C++:
mlist_t *)
op: operand to calculate the def list of (C++: const mop_t &)
maymust: should we calculate 'may-def' or 'must-def' list? see
maymust_t for more details. (C++: maymust_t)
def append_use_list(self, *args) ‑> void
Append use-list of an operand. This function calculates list of locations that may or must be used by the operand and appends it to LIST.
append_use_list(self, list, op, maymust, mask=bitrange_t(0, USHRT_MAX))
list: ptr to the output buffer. we will append to it. (C++:
mlist_t *)
op: operand to calculate the use list of (C++: const mop_t &)
maymust: should we calculate 'may-use' or 'must-use' list? see
maymust_t for more details. (C++: maymust_t)
mask: if only part of the operand should be considered, a
bitmask can be used to specify which part. example: op=AX,mask=0xFF means that we will consider only AL. (C++: bitrange_t)
def build_def_list(self, *args) ‑> mlist_t
Build def-list of an instruction. This function calculates list of locations that may or must be modified by the instruction. Examples: "stx ebx.4, ds.2, eax.4", may-list: all aliasable memory "stx ebx.4, ds.2, eax.4", must-list: empty Since STX uses EAX for indirect access, it may modify any aliasable memory. On the other hand, we cannot tell for sure which memory cells will be modified, this is why the must- list is empty.
build_def_list(self, ins, maymust) -> mlist_t
ins: instruction to calculate the def list of (C++: const
minsn_t &)
maymust: should we calculate 'may-def' or 'must-def' list? see
maymust_t for more details. (C++: maymust_t)
return: the calculated def-list
def build_lists(self, *args) ‑> int
Build def-use lists and eliminate deads.
build_lists(self, kill_deads) -> int
kill_deads: do delete dead instructions? (C++: bool)
return: the number of eliminated instructions Better mblock_t::call
make_lists_ready() rather than this function.
def build_use_list(self, *args) ‑> mlist_t
Build use-list of an instruction. This function calculates list of locations that may or must be used by the instruction. Examples: "ldx ds.2, eax.4, ebx.4", may-list: all aliasable memory "ldx ds.2, eax.4, ebx.4", must-list: empty Since LDX uses EAX for indirect access, it may access any aliasable memory. On the other hand, we cannot tell for sure which memory cells will be accessed, this is why the must-list is empty.
build_use_list(self, ins, maymust) -> mlist_t
ins: instruction to calculate the use list of (C++: const
minsn_t &)
maymust: should we calculate 'may-use' or 'must-use' list? see
maymust_t for more details. (C++: maymust_t)
return: the calculated use-list
def dump(self, *args) ‑> void
Dump block info. This function is useful for debugging, see 'mba_t::dump' for info
def dump_block(self, *args) ‑> void
dump_block(self, title)
title (C++: const char *)
def empty(self, *args) ‑> bool
empty(self) -> bool
def find_access(self, *args) ‑> minsn_t *
Find the instruction that accesses the specified operand. This function search inside one block.
find_access(self, op, parent, mend, fdflags) -> minsn_t
op: operand to search for (C++: const mop_t &)
parent (C++: minsn_t **)
mend (C++: const minsn_t *)
fdflags (C++: int)
return: the instruction that accesses the operand. this instruction
may be a sub-instruction. to find out the top level instruction, check out *p_i1. NULL means 'not found'.
def find_def(self, *args) ‑> minsn_t *
find_def(self, op, p_i1, i2, fdflags) -> minsn_t
op (C++: const mop_t &)
p_i1 (C++: minsn_t **)
i2 (C++: const minsn_t *)
fdflags (C++: int)
def find_first_use(self, *args) ‑> minsn_t *
Find the first insn that uses the specified list in the insn range.
find_first_use(self, list, i1, i2, maymust=MAY_ACCESS) -> minsn_t
list: list of locations. LIST may be modified by the function:
redefined locations will be removed from it. (C++: mlist_t *)
i1: starting instruction of the range (must be a top level
insn) (C++: const minsn_t *)
i2: end instruction of the range (must be a top level insn) i2
is excluded from the range. it can be specified as NULL. i1 and i2 must belong to the same block. (C++: const minsn_t *)
maymust: should we search in 'may-access' or 'must-access'
mode? (C++: maymust_t)
return: pointer to such instruction or NULL. Upon return LIST will
contain only locations not redefined by insns [i1..result]
def find_redefinition(self, *args) ‑> minsn_t *
Find the first insn that redefines any part of the list in the insn range.
find_redefinition(self, list, i1, i2, maymust=MAY_ACCESS) -> minsn_t
list: list of locations to check. (C++: const mlist_t &)
i1: starting instruction of the range (must be a top level
insn) (C++: const minsn_t *)
i2: end instruction of the range (must be a top level insn) i2
is excluded from the range. it can be specified as NULL. i1 and i2 must belong to the same block. (C++: const minsn_t *)
maymust: should we search in 'may-access' or 'must-access'
mode? (C++: maymust_t)
return: pointer to such instruction or NULL.
def find_use(self, *args) ‑> minsn_t *
find_use(self, op, p_i1, i2, fdflags) -> minsn_t
op (C++: const mop_t &)
p_i1 (C++: minsn_t **)
i2 (C++: const minsn_t *)
fdflags (C++: int)
def for_all_insns(self, *args) ‑> int
Visit all instructions. This function visits subinstructions too.
for_all_insns(self, mv) -> int
mv: instruction visitor (C++: minsn_visitor_t &)
return: zero or the value returned by mv.visit_insn() See also
mba_t::for_all_topinsns()
def for_all_ops(self, *args) ‑> int
Visit all operands. This function visit subinstruction operands too.
for_all_ops(self, mv) -> int
mv: operand visitor (C++: mop_visitor_t &)
return: zero or the value returned by mv.visit_mop()
def for_all_uses(self, *args) ‑> int
Visit all operands that use LIST.
for_all_uses(self, list, i1, i2, mmv) -> int
list: ptr to the list of locations. it may be modified: parts
that get redefined by the instructions in [i1,i2) will be deleted. (C++: mlist_t *)
i1: starting instruction. must be a top level insn. (C++:
minsn_t *)
i2: ending instruction (excluded). must be a top level insn.
(C++: minsn_t *)
mmv: operand visitor (C++: mlist_mop_visitor_t &)
return: zero or the value returned by mmv.visit_mop()
def get_reginsn_qty(self, *args) ‑> size_t
Calculate number of regular instructions in the block. Assertions are skipped by this function.
def get_valranges(self, *args) ‑> bool
Find possible values for a block.
get_valranges(self, res, vivl, vrflags) -> bool
res: set of value ranges (C++: valrng_t *)
vivl: what to search for (C++: const vivl_t &)
vrflags: combination of bits for get_valranges bits (C++:
int)
get_valranges(self, res, vivl, m, vrflags) -> bool
res: set of value ranges (C++: valrng_t *)
vivl: what to search for (C++: const vivl_t &) m: minsn_t const *
vrflags: combination of bits for get_valranges bits (C++:
int)
def insert_into_block(self, *args) ‑> minsn_t *
Insert instruction into the doubly linked list
insert_into_block(self, nm, om) -> minsn_t
nm: new instruction (C++: minsn_t *)
om: existing instruction, part of the doubly linked list if
NULL, then the instruction will be inserted at the beginning of the list NM will be inserted immediately after OM (C++: minsn_t *)
return: pointer to NM
def is_branch(self, *args) ‑> bool
is_branch(self) -> bool
def is_call_block(self, *args) ‑> bool
is_call_block(self) -> bool
def is_nway(self, *args) ‑> bool
is_nway(self) -> bool
def is_redefined(self, *args) ‑> bool
Is the list redefined by the specified instructions?
is_redefined(self, list, i1, i2, maymust=MAY_ACCESS) -> bool
list: list of locations to check. (C++: const mlist_t &)
i1: starting instruction of the range (must be a top level
insn) (C++: const minsn_t *)
i2: end instruction of the range (must be a top level insn) i2
is excluded from the range. it can be specified as NULL. i1 and i2 must belong to the same block. (C++: const minsn_t *)
maymust: should we search in 'may-access' or 'must-access'
mode? (C++: maymust_t)
def is_rhs_redefined(self, *args) ‑> bool
Is the right hand side of the instruction redefined the insn range? "right hand side" corresponds to the source operands of the instruction.
is_rhs_redefined(self, ins, i1, i2) -> bool
ins: instruction to consider (C++: const minsn_t *)
i1: starting instruction of the range (must be a top level
insn) (C++: const minsn_t *)
i2: end instruction of the range (must be a top level insn) i2
is excluded from the range. it can be specified as NULL. i1 and i2 must belong to the same block. (C++: const minsn_t *)
def is_simple_goto_block(self, *args) ‑> bool
is_simple_goto_block(self) -> bool
def is_simple_jcnd_block(self, *args) ‑> bool
is_simple_jcnd_block(self) -> bool
def is_unknown_call(self, *args) ‑> bool
is_unknown_call(self) -> bool
def is_used(self, *args) ‑> bool
Is the list used by the specified instruction range?
is_used(self, list, i1, i2, maymust=MAY_ACCESS) -> bool
list: list of locations. LIST may be modified by the function:
redefined locations will be removed from it. (C++: mlist_t *)
i1: starting instruction of the range (must be a top level
insn) (C++: const minsn_t *)
i2: end instruction of the range (must be a top level insn) i2
is excluded from the range. it can be specified as NULL. i1 and i2 must belong to the same block. (C++: const minsn_t *)
maymust: should we search in 'may-access' or 'must-access'
mode? (C++: maymust_t)
def lists_dirty(self, *args) ‑> bool
lists_dirty(self) -> bool
def lists_ready(self, *args) ‑> bool
lists_ready(self) -> bool
def make_lists_ready(self, *args) ‑> int
make_lists_ready(self) -> int
def make_nop(self, *args) ‑> void
Erase the instruction (convert it to nop) and mark the lists dirty. This is the recommended function to use because it also marks the block use-def lists dirty.
make_nop(self, m)
m (C++: minsn_t *)
def mark_lists_dirty(self, *args) ‑> void
mark_lists_dirty(self)
def needs_propagation(self, *args) ‑> bool
needs_propagation(self) -> bool
def npred(self, *args) ‑> int
Get number of block predecessors.
def nsucc(self, *args) ‑> int
Get number of block successors.
def optimize_block(self, *args) ‑> int
Optimize a basic block. Usually there is no need to call this function explicitly because the decompiler will call it itself if 'optinsn_t::func' or 'optblock_t::func' return non-zero.
def optimize_insn(self, *args) ‑> int
Optimize one instruction in the context of the block.
optimize_insn(self, m, optflags=0x0002|0x0004) -> int
m: pointer to a top level instruction (C++: minsn_t *)
optflags: combination of optimization flags bits (C++: int)
return: number of changes made to the block This function may change
other instructions in the block too. However, it will not destroy top level instructions (it may convert them to nop's). This function performs only intrablock modifications. See also minsn_t::optimize_solo()
def optimize_useless_jump(self, *args) ‑> int
Remove a jump at the end of the block if it is useless. This function preserves any side effects when removing a useless jump. Both conditional and unconditional jumps are handled (and jtbl too). This function deletes useless jumps, not only replaces them with a nop. (please note that \optimize_insn does not handle useless jumps).
def pred(self, *args) ‑> int
pred(self, n) -> int
n (C++: int)
def preds(self)
Iterates the list of predecessor blocks
def remove_from_block(self, *args) ‑> minsn_t *
Remove instruction from the doubly linked list
remove_from_block(self, m) -> minsn_t
m: instruction to remove The removed instruction is not
deleted, the caller gets its ownership (C++: minsn_t *)
return: pointer to the next instruction
def request_demote64(self, *args) ‑> void
request_demote64(self)
def request_propagation(self, *args) ‑> void
request_propagation(self)
def succ(self, *args) ‑> int
succ(self, n) -> int
n (C++: int)
def succs(self)
Iterates the list of successor blocks
class mcallarg_t (*args)
Proxy of C++ mcallarg_t class.
__init__(self) -> mcallarg_t
rarg: mop_t const &

Ancestors

Instance variables

var argloc
mcallarg_t_argloc_get(self) -> argloc_t
var ea
mcallarg_t_ea_get(self) -> ea_t
var flags
mcallarg_t_flags_get(self) -> uint32
var name
mcallarg_t_name_get(self) -> qstring *
var type
mcallarg_t_type_get(self) -> tinfo_t

Methods

def copy_mop(self, *args) ‑> void
copy_mop(self, op)
op (C++: const mop_t &)
def make_int(self, *args) ‑> void
make_int(self, val, val_ea, opno=0)
val (C++: int)
val_ea (C++: ea_t)
opno (C++: int)
def make_uint(self, *args) ‑> void
make_uint(self, val, val_ea, opno=0)
val (C++: int)
val_ea (C++: ea_t)
opno (C++: int)
def set_regarg(self, *args) ‑> void
set_regarg(self, mr, sz, tif)
mr (C++: mreg_t)
sz (C++: int)
tif (C++: const tinfo_t &)
set_regarg(self, mr, tif)
mr (C++: mreg_t)
tif (C++: const tinfo_t &)
set_regarg(self, mr, dt, sign=type_unsigned)
mr (C++: mreg_t) dt: char sign: type_sign_t

Inherited members

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

Methods

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

Instance variables

var args
mcallinfo_t_args_get(self) -> mcallargs_t
var call_spd
mcallinfo_t_call_spd_get(self) -> int
var callee
mcallinfo_t_callee_get(self) -> ea_t
var cc
mcallinfo_t_cc_get(self) -> cm_t
var dead_regs
mcallinfo_t_dead_regs_get(self) -> mlist_t
var flags
mcallinfo_t_flags_get(self) -> int
var fti_attrs
mcallinfo_t_fti_attrs_get(self) -> type_attrs_t
var pass_regs
mcallinfo_t_pass_regs_get(self) -> mlist_t
var retregs
mcallinfo_t_retregs_get(self) -> mopvec_t
var return_argloc
mcallinfo_t_return_argloc_get(self) -> argloc_t
var return_regs
mcallinfo_t_return_regs_get(self) -> mlist_t
var return_type
mcallinfo_t_return_type_get(self) -> tinfo_t
var role
mcallinfo_t_role_get(self) -> funcrole_t
var solid_args
mcallinfo_t_solid_args_get(self) -> int
var spoiled
mcallinfo_t_spoiled_get(self) -> mlist_t
var stkargs_top
mcallinfo_t_stkargs_top_get(self) -> int
var visible_memory
mcallinfo_t_visible_memory_get(self) -> ivlset_t

Methods

def dstr(self, *args) ‑> char const *
dstr(self) -> char const *
def get_type(self, *args) ‑> tinfo_t
get_type(self) -> tinfo_t
def is_vararg(self, *args) ‑> bool
is_vararg(self) -> bool
def lexcompare(self, *args) ‑> int
lexcompare(self, f) -> int
f (C++: const mcallinfo_t &)
def set_type(self, *args) ‑> bool
set_type(self, type) -> bool
type (C++: const tinfo_t &)
class mcases_t (*args)
Proxy of C++ mcases_t class.
__init__(self) -> mcases_t

Instance variables

var targets
mcases_t_targets_get(self) -> intvec_t
var values
mcases_t_values_get(self) -> casevec_t

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: mcases_t const &
def dstr(self, *args) ‑> char const *
dstr(self) -> char const *
def empty(self, *args) ‑> bool
empty(self) -> bool
def resize(self, *args) ‑> void
resize(self, s)
s (C++: int)
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, r)
r (C++: mcases_t &)
class microcode_filter_t (*args)
Proxy of C++ microcode_filter_t class.
__init__(self) -> microcode_filter_t
self: PyObject *

Subclasses

Methods

def apply(self, *args) ‑> merror_t
generate microcode for an instruction
apply(self, cdg) -> merror_t
cdg (C++: codegen_t &)
return: MERR_... code: MERR_OK - user-defined call generated, go to
the next instruction MERR_INSN - not generated - the caller should try the standard way else - error
def match(self, *args) ‑> bool
check if the filter object is to be appied
match(self, cdg) -> bool
cdg (C++: codegen_t &)
return: success
class minsn_t (*args)
Proxy of C++ minsn_t class.
__init__(self, _ea) -> minsn_t
_ea: ea_t
__init__(self, m) -> minsn_t
m: minsn_t const &

Instance variables

var d
minsn_t_d_get(self) -> mop_t
var ea
minsn_t_ea_get(self) -> ea_t
var iprops
minsn_t_iprops_get(self) -> int
var l
minsn_t_l_get(self) -> mop_t
var meminfo
var next
minsn_t_next_get(self) -> minsn_t
var obj_id : PyObject *
_obj_id(self) -> PyObject *
var opcode
minsn_t_opcode_get(self) -> mcode_t
var prev
minsn_t_prev_get(self) -> minsn_t
var r
minsn_t_r_get(self) -> mop_t

Methods

def clr_assert(self, *args) ‑> void
clr_assert(self)
def clr_combinable(self, *args) ‑> void
clr_combinable(self)
def clr_combined(self, *args) ‑> void
clr_combined(self)
def clr_fpinsn(self, *args) ‑> void
clr_fpinsn(self)
def clr_ignlowsrc(self, *args) ‑> void
clr_ignlowsrc(self)
def clr_multimov(self, *args) ‑> void
clr_multimov(self)
def clr_noret_icall(self, *args) ‑> void
clr_noret_icall(self)
def clr_propagatable(self, *args) ‑> void
clr_propagatable(self)
def clr_tailcall(self, *args) ‑> void
clr_tailcall(self)
def contains_call(self, *args) ‑> bool
Does the instruction contain a call?
contains_call(self, with_helpers=False) -> bool
with_helpers (C++: bool)
def contains_opcode(self, *args) ‑> bool
Does the instruction have the specified opcode? This function searches subinstructions as well.
contains_opcode(self, mcode) -> bool
mcode: opcode to search for. (C++: mcode_t)
def dstr(self, *args) ‑> char const *
Get displayable text without tags in a static buffer.
def equal_insns(self, *args) ‑> bool
Compare instructions. This is the main comparison function for instructions.
equal_insns(self, m, eqflags) -> bool
m: instruction to compare with (C++: const minsn_t &)
eqflags: combination of comparison bits bits (C++: int)
def find_call(self, *args) ‑> minsn_t *
Find a call instruction. Check for the current instruction and its subinstructions.
find_call(self, with_helpers=False) -> minsn_t
with_helpers: consider helper calls as well? (C++: bool)
def find_ins_op(self, *args) ‑> minsn_t *
Find an operand that is a subinsruction with the specified opcode. This function checks only the 'l' and 'r' operands of the current insn.
find_ins_op(self, op=m_nop) -> minsn_t
op: opcode to search for (C++: mcode_t)
return: &l or &r or NULL
def find_num_op(self, *args) ‑> mop_t *
Find a numeric operand of the current instruction. This function checks only the 'l' and 'r' operands of the current insn.
def find_opcode(self, *args) ‑> minsn_t *
Find a (sub)insruction with the specified opcode.
find_opcode(self, mcode) -> minsn_t
mcode: opcode to search for. (C++: mcode_t)
find_opcode(self, mcode) -> minsn_t
mcode: opcode to search for. (C++: mcode_t)
def for_all_insns(self, *args) ‑> int
Visit all instructions. This function visits the instruction itself and all its subinstructions.
for_all_insns(self, mv) -> int
mv: instruction visitor (C++: minsn_visitor_t &)
return: non-zero value returned by mv.visit_mop() or zero
def for_all_ops(self, *args) ‑> int
Visit all instruction operands. This function visits subinstruction operands as well.
for_all_ops(self, mv) -> int
mv: operand visitor (C++: mop_visitor_t &)
return: non-zero value returned by mv.visit_mop() or zero
def get_role(self, *args) ‑> funcrole_t
Get the function role of a call.
def get_split_size(self, *args) ‑> int
get_split_size(self) -> int
def has_side_effects(self, *args) ‑> bool
Does the instruction have a side effect?
has_side_effects(self, include_ldx_and_divs=False) -> bool
include_ldx_and_divs: consider ldx/div/mod as having side
effects? stx is always considered as having side effects. Apart from ldx/std only call may have side effects. (C++: bool)
def is_after(self, *args) ‑> bool
Is the instruction after the specified one?
is_after(self, m) -> bool
m: the instruction to compare against in the list (C++: const
minsn_t *)
def is_alloca(self, *args) ‑> bool
is_alloca(self) -> bool
def is_assert(self, *args) ‑> bool
is_assert(self) -> bool
def is_between(self, *args) ‑> bool
Is the instruction in the specified range of instructions?
is_between(self, m1, m2) -> bool
m1: beginning of the range in the doubly linked list (C++:
const minsn_t *)
m2: end of the range in the doubly linked list (excluded, may
be NULL) This function assumes that m1 and m2 belong to the same basic block and they are top level instructions. (C++: const minsn_t *)
def is_bswap(self, *args) ‑> bool
is_bswap(self) -> bool
def is_cleaning_pop(self, *args) ‑> bool
is_cleaning_pop(self) -> bool
def is_combinable(self, *args) ‑> bool
is_combinable(self) -> bool
def is_combined(self, *args) ‑> bool
is_combined(self) -> bool
def is_extstx(self, *args) ‑> bool
is_extstx(self) -> bool
def is_farcall(self, *args) ‑> bool
is_farcall(self) -> bool
def is_fpinsn(self, *args) ‑> bool
is_fpinsn(self) -> bool
def is_helper(self, *args) ‑> bool
Is a helper call with the specified name? Helper calls usually have well-known function names (see 'Well known function names' ) but they may have any other name. The decompiler does not assume any special meaning for non-well-known names.
is_helper(self, name) -> bool
name (C++: const char *)
def is_ignlowsrc(self, *args) ‑> bool
is_ignlowsrc(self) -> bool
def is_inverted_jx(self, *args) ‑> bool
is_inverted_jx(self) -> bool
def is_like_move(self, *args) ‑> bool
is_like_move(self) -> bool
def is_mbarrier(self, *args) ‑> bool
is_mbarrier(self) -> bool
def is_memcpy(self, *args) ‑> bool
is_memcpy(self) -> bool
def is_memset(self, *args) ‑> bool
is_memset(self) -> bool
def is_mov(self, *args) ‑> bool
is_mov(self) -> bool
def is_multimov(self, *args) ‑> bool
is_multimov(self) -> bool
def is_noret_call(self, *args) ‑> bool
Is a non-returing call?
is_noret_call(self, flags=0) -> bool
flags (C++: int)
def is_optional(self, *args) ‑> bool
is_optional(self) -> bool
def is_persistent(self, *args) ‑> bool
is_persistent(self) -> bool
def is_propagatable(self, *args) ‑> bool
is_propagatable(self) -> bool
def is_readflags(self, *args) ‑> bool
is_readflags(self) -> bool
def is_tailcall(self, *args) ‑> bool
is_tailcall(self) -> bool
def is_unknown_call(self, *args) ‑> bool
Is an unknown call? Unknown calls are calls without the argument list ( 'mcallinfo_t' ). Usually the argument lists are determined by 'mba_t::analyze_calls()' . Unknown calls exist until the MMAT_CALLS maturity level. See also mblock_t::is_call_block
def is_wild_match(self, *args) ‑> bool
is_wild_match(self) -> bool
def lexcompare(self, *args) ‑> int
lexcompare(self, ri) -> int
ri (C++: const minsn_t &)
def may_use_aliased_memory(self, *args) ‑> bool
Is it possible for the instruction to use aliased memory?
def modifes_d(self, *args) ‑> bool
Does the instruction modify its 'd' operand? Some instructions (e.g. m_stx) do not modify the 'd' operand.
def modifies_pair_mop(self, *args) ‑> bool
modifies_pair_mop(self) -> bool
def optimize_solo(self, *args) ‑> int
Optimize one instruction without context. This function does not have access to the instruction context (the previous and next instructions in the list, the block number, etc). It performs only basic optimizations that are available without this info.
optimize_solo(self, optflags=0) -> int
optflags: combination of optimization flags bits (C++: int)
return: number of changes, 0-unchanged See also
mblock_t::optimize_insn()
def optimize_subtree(self, *args) ‑> int
Optimize instruction in its context. Do not use this function, use mblock_t::optimize()
optimize_subtree(self, blk, top, parent, converted_call, optflags=0x0002) -> int
blk (C++: mblock_t *)
top (C++: minsn_t *)
parent (C++: minsn_t *)
converted_call (C++: ea_t *)
optflags (C++: int)
def replace_by(self, o)
def set_assert(self, *args) ‑> void
set_assert(self)
def set_cleaning_pop(self, *args) ‑> void
set_cleaning_pop(self)
def set_combinable(self, *args) ‑> void
set_combinable(self)
def set_extstx(self, *args) ‑> void
set_extstx(self)
def set_farcall(self, *args) ‑> void
set_farcall(self)
def set_fpinsn(self, *args) ‑> void
set_fpinsn(self)
def set_ignlowsrc(self, *args) ‑> void
set_ignlowsrc(self)
def set_inverted_jx(self, *args) ‑> void
set_inverted_jx(self)
def set_mbarrier(self, *args) ‑> void
set_mbarrier(self)
def set_multimov(self, *args) ‑> void
set_multimov(self)
def set_noret_icall(self, *args) ‑> void
set_noret_icall(self)
def set_optional(self, *args) ‑> void
set_optional(self)
def set_persistent(self, *args) ‑> void
set_persistent(self)
def set_split_size(self, *args) ‑> void
set_split_size(self, s)
s (C++: int)
def set_tailcall(self, *args) ‑> void
set_tailcall(self)
def set_wild_match(self, *args) ‑> void
set_wild_match(self)
def setaddr(self, *args) ‑> void
Change the instruction address. This function modifies subinstructions as well.
setaddr(self, new_ea)
new_ea (C++: ea_t)
def swap(self, *args) ‑> void
Swap two instructions. The prev/next fields are not modified by this function because it would corrupt the doubly linked list.
swap(self, m)
m (C++: minsn_t &)
def was_noret_icall(self, *args) ‑> bool
was_noret_icall(self) -> bool
def was_split(self, *args) ‑> bool
was_split(self) -> bool
class minsn_visitor_t (*args)
Proxy of C++ minsn_visitor_t class.
__init__(self, _mba=None, _blk=None, _topins=None) -> minsn_visitor_t
_mba: mba_t * _blk: mblock_t * _topins: minsn_t *

Ancestors

Methods

def visit_minsn(self, *args) ‑> int
visit_minsn(self) -> int

Inherited members

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

Instance variables

var changed
mlist_mop_visitor_t_changed_get(self) -> bool
var curins
mlist_mop_visitor_t_curins_get(self) -> minsn_t
var list
mlist_mop_visitor_t_list_get(self) -> mlist_t
var topins
mlist_mop_visitor_t_topins_get(self) -> minsn_t

Methods

def visit_mop(self, *args) ‑> int
visit_mop(self, op) -> int
op (C++: mop_t *)
class mlist_t (*args)
Proxy of C++ mlist_t class.
__init__(self) -> mlist_t
ivl: ivl_t const &
__init__(self, r, size) -> mlist_t
r: mreg_t size: int

Instance variables

var mem
mlist_t_mem_get(self) -> ivlset_t
var reg
mlist_t_reg_get(self) -> rlist_t

Methods

def add(self, *args) ‑> bool
add(self, r, size) -> bool
r (C++: mreg_t)
size (C++: int)
add(self, r) -> bool
r (C++: mreg_t)
add(self, ivl) -> bool
ivl: ivl_t const &
add(self, lst) -> bool
lst: mlist_t const &
def addmem(self, *args) ‑> bool