Module index

Module ida_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
Unused labels are permitted.
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 size of floating operand is permitted
var ANY_REGSIZE
any register size is permitted
var BLT_0WAY
does not have successors (tail is a noret function)
var BLT_1WAY
passes execution to one block (regular or goto block)
var BLT_2WAY
passes execution to two blocks (conditional jump)
var BLT_NONE
unknown block type
var BLT_NWAY
passes execution to many blocks (switch idiom)
var BLT_STOP
stops execution regularly (must be the last block)
var BLT_XTRN
external block (out of function address)
var CALC_CURLY_BRACES
print curly braces if necessary
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 ctree item in collapsed form
var CMAT_BUILT
just generated
var CMAT_CASTED
added necessary casts
var CMAT_CPA
corrected pointer arithmetic
var CMAT_FINAL
ready-to-use
var CMAT_NICE
nicefied expressions
var CMAT_TRANS1
applied first wave of transformations
var CMAT_TRANS2
applied second wave of transformations
var CMAT_TRANS3
applied third wave of transformations
var CMAT_ZERO
does not exist
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
All comments.
var CMT_BLOCK1
Anterioir block comment.
var CMT_BLOCK2
Posterior block comment.
var CMT_FUNC
Function comment.
var CMT_LVAR
Local variable comment.
var CMT_NONE
No comment is possible.
var CMT_TAIL
Indented comment.
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_GXREFS_DEFLT
the default behavior: do not update the global xrefs cache upon decompile() call, but when the pseudocode text is generated (e.g., through cfunc_t.get_pseudocode())
var DECOMP_GXREFS_FORCE
update the global xrefs cache immediately
var DECOMP_GXREFS_NOUPD
do not update the global xrefs cache
var DECOMP_NO_CACHE
do not use decompilation cache (snippets are never cached)
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
Obsolete. Use DECOMP_GXREFS_NOUPD.
var DECOMP_VOID_MBA
return empty mba object (to be used with gen_microcode)
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
Unused labels cause interr.
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_MORESTACK
FUNC_NAME_MORESTACK = 'runtime_morestack'
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
all the above and assertions
var GC_DIRTY_ALL
bitmask to represent all chains
var GC_END
number of chain types
var GC_REGS_AND_STKVARS
registers and stkvars (restricted memory only)
var GC_XDSU
only registers calculated with FULL_XDSU
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
IPROP_ASSERT = 128
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_UNMERGED
'goto' instruction was transformed info 'call'
var IPROP_WAS_NORET
was noret icall
var IPROP_WILDMATCH
match multiple insns
var ITP_ARG1
, (64 entries are reserved for 64 call arguments)
var ITP_ARG64
ITP_ARG64 = 64
var ITP_ASM
__asm-line
var ITP_BLOCK1
opening block comment. this comment is printed before the item (other comments are indented and printed after the item)
var ITP_BLOCK2
closing block comment.
var ITP_BRACE1
ITP_BRACE1 = 65
var ITP_BRACE2
)
var ITP_CASE
bit for switch cases
var ITP_COLON
: (label)
var ITP_CURLY1
{
var ITP_CURLY2
}
var ITP_DO
do-line
var ITP_ELSE
else-line
var ITP_EMPTY
nothing
var ITP_INNER_LAST
ITP_INNER_LAST = 65
var ITP_SEMI
semicolon
var ITP_SIGN
if this bit is set too, then we have a negative case value
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_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_SPLIT
split allocation of a new variable. forces the decompiler to create a new variable at ll.defea
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 = 131071
var MBA2_ARGIDX_OK
may verify input argument list?
var MBA2_ARGIDX_SORTED
args finally sorted according to ABI (e.g. reverse stkarg order in Borland)
var MBA2_CODE16_BIT
the code16 bit removed
var MBA2_DONT_VERIFY
Do not verify microcode. This flag is recomended to be set only when debugging decompiler plugins
var MBA2_HAS_OUTLINES
calls to outlined code have been inlined
var MBA2_INITIAL_FLAGS
MBA2_INITIAL_FLAGS = 3
var MBA2_IS_CTR
is constructor?
var MBA2_IS_DTR
is destructor?
var MBA2_LVARNAMES_OK
may verify lvar_names?
var MBA2_LVARS_RENAMED
accept empty names now?
var MBA2_NO_DUP_CALLS
forbid multiple calls with the same ea
var MBA2_NO_DUP_LVARS
forbid multiple lvars with the same ea
var MBA2_NO_FRAME
do not use function frame info (only snippet mode)
var MBA2_OVER_CHAINS
has overlapped chains?
var MBA2_PROP_COMPLEX
allow propagation of more complex variable definitions
var MBA2_STACK_RETVAL
the return value is on the stack
var MBA2_UNDEF_RETVAR
return value is undefined
var MBA2_VALRNG_DONE
calculated valranges?
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
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
current architecture is not supported
var MERR_BADBLK
bad block found
var MERR_BADCALL
could not determine call arguments
var MERR_BADFRAME
function frame is wrong
var MERR_BADIDB
inconsistent database information
var MERR_BADRANGES
bad input ranges
var MERR_BADSP
positive sp value has been found
var MERR_BITNESS
16-bit functions cannot be decompiled
var MERR_BLOCK
no error, switch to new block
var MERR_BUSY
already decompiling a function
var MERR_CANCELED
decompilation has been cancelled
var MERR_CLOUD
MERR_CLOUD = -34
var MERR_COMPLEX
too complex function
var MERR_DSLOT
bad instruction in the delay slot
var MERR_EXCEPTION
exception analysis failed
var MERR_EXTERN
special segments cannot be decompiled
var MERR_FARPTR
far memory model is supported only for pc
var MERR_FUNCSIZE
too big function
var MERR_HUGESTACK
stack frame is too big
var MERR_INSN
cannot convert to microcode
var MERR_INTERR
internal error
var MERR_LICENSE
no license available
var MERR_LOOP
internal code: redo last loop (never reported)
var MERR_LVARS
local variable allocation failed
var MERR_MAX_ERR
MERR_MAX_ERR = 34
var MERR_MEM
not enough memory
var MERR_OK
ok
var MERR_ONLY32
only 32-bit functions can be decompiled for the current database
var MERR_ONLY64
only 64-bit functions can be decompiled for the current database
var MERR_OVERLAP
variables would overlap: s
var MERR_PARTINIT
partially initialized variable s
var MERR_PROLOG
prolog analysis failed
var MERR_RECDEPTH
max recursion depth reached during lvar allocation
var MERR_REDO
redecompilation has been requested
var MERR_SIZEOF
wrong basic type sizes in compiler settings
var MERR_STOP
no error, stop the analysis
var MERR_SWITCH
wrong switch idiom
var MERR_UNKTYPE
undefined type s (currently unused error code)
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
detected call arguments. see also hxe_calls_done
var MMAT_GENERATED
generated microcode
var MMAT_GLBOPT1
performed the first pass of global optimization
var MMAT_GLBOPT2
most global optimization passes are done
var MMAT_GLBOPT3
completed all global optimization. microcode is fixed now.
var MMAT_LOCOPT
local optimization of each basic block is complete. control flow graph is ready too.
var MMAT_LVARS
allocated local variables
var MMAT_PREOPTIMIZED
preoptimized pass is complete
var MMAT_ZERO
microcode does not exist
var MMIDX_ARGS
MMIDX_ARGS = 4
var MMIDX_GLBHIGH
global memory: high part
var MMIDX_GLBLOW
global memory: low part
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
wrong or unexisting operand size
var NO_CURLY_BRACES
don't print curly braces
var NO_SIDEFF
change operand size but ignore side effects if you decide to keep the changed operand, handle_new_size() must be called
var ONE_ACCESS_TYPE
ONE_ACCESS_TYPE = 32
var ONLY_SIDEFF
only handle side effects
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
OPROP_CCFLAGS = 8
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 comment even if it has been used.
var RETRIEVE_ONCE
Retrieve comment if it has not been used yet.
var ROLE_3WAYCMP0
3-way compare helper, returns -1/0/1
var ROLE_3WAYCMP1
3-way compare helper, returns 0/1/2
var ROLE_ABS
integer absolute value
var ROLE_ALLOCA
alloca() function
var ROLE_BITTEST
[lock] bt
var ROLE_BITTESTANDCOMPLEMENT
[lock] btc
var ROLE_BITTESTANDRESET
[lock] btr
var ROLE_BITTESTANDSET
[lock] bts
var ROLE_BSWAP
bswap() function (any size)
var ROLE_BUG
BUG() helper macro: never returns, causes exception.
var ROLE_CFSUB3
carry flag after subtract with carry
var ROLE_CONTAINING_RECORD
CONTAINING_RECORD() macro.
var ROLE_EMPTY
empty, does not do anything (maybe spoils regs)
var ROLE_FASTFAIL
__fastfail()
var ROLE_IS_MUL_OK
is_mul_ok
var ROLE_MEMCPY
memcpy(void *dst, const void *src, size_t count);
var ROLE_MEMSET
memset(void *dst, uchar value, size_t count);
var ROLE_MEMSET32
memset32(void *dst, uint32 value, size_t count);
var ROLE_MEMSET64
memset64(void *dst, uint64 value, size_t count);
var ROLE_OFSUB3
overflow flag after subtract with carry
var ROLE_PRESENT
present() function (used in patterns)
var ROLE_READFLAGS
__readeflags, __readcallersflags
var ROLE_ROL
rotate left
var ROLE_ROR
rotate right
var ROLE_SATURATED_MUL
saturated_mul
var ROLE_SSE_CMP4
e.g. _mm_cmpgt_ss
var ROLE_SSE_CMP8
e.g. _mm_cmpgt_sd
var ROLE_STRCAT
strcat(char *dst, const char *src);
var ROLE_STRCPY
strcpy(char *dst, const char *src);
var ROLE_STRLEN
strlen(const char *src);
var ROLE_TAIL
char *tail(const char *str);
var ROLE_UNK
unknown function role
var ROLE_VA_ARG
va_arg() macro
var ROLE_VA_COPY
va_copy() function
var ROLE_VA_END
va_end() function
var ROLE_VA_START
va_start() function
var ROLE_WCSCAT
wchar_t *wcscat(wchar_t *dst, const wchar_t *src)
var ROLE_WCSCPY
wchar_t *wcscpy(wchar_t *dst, const wchar_t *src);
var ROLE_WCSLEN
size_t wcslen(const wchar_t *s)
var ROLE_WMEMCPY
wchar_t *wmemcpy(wchar_t *dst, const wchar_t *src, size_t n)
var ROLE_WMEMSET
wchar_t *wmemset(wchar_t *dst, wchar_t wc, size_t n)
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
print curly braces without any checks
var USE_KEYBOARD
Keyboard.
var USE_MOUSE
Mouse.
var VDI_EXPR
c-tree item
var VDI_FUNC
the function itself (the very first line with the function prototype)
var VDI_LVAR
declaration of local variable
var VDI_NONE
undefined
var VDI_TAIL
cursor is at (beyond) the line end (commentable line)
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 nullptr)
var VR_AT_START
get value ranges before the instruction or at the block start (if M is nullptr)
var VR_EXACT
find exact match. if not set, the returned valrng size will be >= vivl.size
var WARN_ADDR_OUTARGS
6 cannot handle address arithmetics in outgoing argument area of stack frame - unused
var WARN_ARRAY_INARG
21 array has been used for an input argument
var WARN_BAD_CALL_SP
38 bad sp value at call
var WARN_BAD_FIELD_TYPE
23 incorrect structure member type for s::s, ignored
var WARN_BAD_INSN
49 bad instruction
var WARN_BAD_MAPDST
48 too short map destination 's' for variable 's'
var WARN_BAD_PURGED
12 inconsistent function type and number of purged bytes
var WARN_BAD_RETVAR
25 wrong return variable
var WARN_BAD_SHADOW
45 ignored the value written to the shadow area of the succeeding call
var WARN_BAD_SP
40 positive sp value a has been found
var WARN_BAD_STD_TYPE
37 corrupted or unexisting local type 's'
var WARN_BAD_STKPNT
41 wrong sp change point
var WARN_BAD_STROFF
33 user specified stroff has not been processed: s
var WARN_BAD_VALRNG
44 values range analysis failed
var WARN_BAD_VARSIZE
34 inconsistent variable size for 's'
var WARN_CBUILD_LOOPS
13 too many cbuild loops
var WARN_CR_BADOFF
32 CONTAINING_RECORD: too small offset d for struct 's'
var WARN_CR_NOFIELD
31 CONTAINING_RECORD: no field 's' in struct 's' at d
var WARN_DEP_UNK_CALLS
7 found interdependent unknown calls
var WARN_EXP_LINVAR
10 failed to expand a linear variable
var WARN_FIXED_MACRO
29 fixed broken macro-insn
var WARN_FRAG_LVAR
26 fragmented variable at s may be wrong
var WARN_GUESSED_TYPE
9 using guessed type s;
var WARN_HUGE_STKOFF
27 exceedingly huge offset into the stack frame
var WARN_ILL_ELLIPSIS
8 erroneously detected ellipsis type has been ignored
var WARN_ILL_FPU_STACK
18 inconsistent fpu stack
var WARN_ILL_FUNCTYPE
2 invalid function type 's' has been ignored
var WARN_ILL_PURGED
1 odd caller purged bytes d, correcting
var WARN_JUMPOUT
43 control flows out of bounds
var WARN_MAX
may be used in notes as a placeholder when the warning id is not available
var WARN_MAX_ARGS
22 too many input arguments, some ignored
var WARN_MISSED_SWITCH
39 wrong markup of switch jump, skipped it
var WARN_MUST_RET_FP
17 function return type is incorrect (must be floating point)
var WARN_NO_SAVE_REST
14 could not find valid save-restore pair for s
var WARN_ODD_ABI
50 encountered odd instruction for the current ABI
var WARN_ODD_ADDR_USE
16 odd use of a variable address
var WARN_ODD_INPUT_REG
15 odd input register s
var WARN_OPT_USELESS_JCND
54 simplified comparisons for 's': s became s
var WARN_OPT_VALRNG
46 conditional instruction was optimized away because s
var WARN_OPT_VALRNG2
52 mask 0xX is shortened because s <= 0xX"
var WARN_OPT_VALRNG3
53 masking with 0XX was optimized away because s <= 0xX
var WARN_RET_LOCREF
47 returning address of temporary local variable 's'
var WARN_SELFREF_PROP
19 self-referencing variable has been detected
var WARN_UNALIGNED_ARG
36 unaligned function argument 's'
var WARN_UNBALANCED_STACK
51 unbalanced stack, ignored a potential tail call
var WARN_UNDEF_LVAR
42 variable 's' is possibly undefined
var WARN_UNINITED_REG
28 reference to an uninitialized register has been removed: s
var WARN_UNSUPP_REG
35 unsupported processor register 's'
var WARN_VARARG_MANY
5 too many varargs, some ignored
var WARN_VARARG_NOSTK
4 call vararg without local stack
var WARN_VARARG_REGS
0 cannot handle register arguments in vararg function, discarded them
var WARN_VARARG_TCAL
3 cannot handle tail call to vararg
var WARN_WIDEN_CHAINS
11 failed to widen chains
var WARN_WOULD_OVERLAP
20 variables would overlap: s
var WARN_WRITE_CONST
24 write access to const memory at a has been detected
var WARN_WRONG_VA_OFF
30 wrong offset of va_list variable
var WITH_ASSERTS
WITH_ASSERTS = 512
var WITH_SIDEFF
change operand size and handle side effects
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
asm-statement
var cit_block
block-statement: { ... }
var cit_break
break-statement
var cit_continue
continue-statement
var cit_do
do-statement
var cit_empty
instruction types start here
var cit_end
cit_end = 83
var cit_expr
expression-statement: expr;
var cit_for
for-statement
var cit_goto
goto-statement
var cit_if
if-statement
var cit_return
return-statement
var cit_switch
switch-statement
var cit_while
while-statement
var cot_add
x + y
var cot_asg
x = y
var cot_asgadd
x += y
var cot_asgband
x &= y
var cot_asgbor
x |= y
var cot_asgmul
x *= y
var cot_asgsdiv
x /= y signed
var cot_asgshl
x <<= y
var cot_asgsmod
x %= y signed
var cot_asgsshr
x >>= y signed
var cot_asgsub
x -= y
var cot_asgudiv
x /= y unsigned
var cot_asgumod
x %= y unsigned
var cot_asgushr
x >>= y unsigned
var cot_asgxor
x ^= y
var cot_band
x & y
var cot_bnot
~x
var cot_bor
x | y
var cot_call
x(...)
var cot_cast
(type)x
var cot_comma
x, y
var cot_empty
cot_empty = 0
var cot_eq
x == y int or fpu (see EXFL_FPOP)
var cot_fadd
x + y fp
var cot_fdiv
x / y fp
var cot_fmul
x * y fp
var cot_fneg
-x fp
var cot_fnum
fpc
var cot_fsub
x - y fp
var cot_helper
arbitrary name
var cot_idx
x[y]
var cot_insn
instruction in expression, internal representation only
var cot_land
x && y
var cot_last
cot_last = 69
var cot_lnot
!x
var cot_lor
x || y
var cot_memptr
x->m, access size in 'ptrsize'
var cot_memref
x.m
var cot_mul
x * y
var cot_ne
x != y int or fpu (see EXFL_FPOP)
var cot_neg
-x
var cot_num
n
var cot_obj
obj_ea
var cot_postdec
x-
var cot_postinc
x++
var cot_predec
-x
var cot_preinc
++x
var cot_ptr
*x, access size in 'ptrsize'
var cot_ref
&x
var cot_sdiv
x / y signed
var cot_sge
x >= y signed or fpu (see EXFL_FPOP)
var cot_sgt
x > y signed or fpu (see EXFL_FPOP)
var cot_shl
x << y
var cot_sizeof
sizeof(x)
var cot_sle
x <= y signed or fpu (see EXFL_FPOP)
var cot_slt
x < y signed or fpu (see EXFL_FPOP)
var cot_smod
x % y signed
var cot_sshr
x >> y signed
var cot_str
string constant (user representation)
var cot_sub
x - y
var cot_tern
x ? y : z
var cot_type
arbitrary type
var cot_udiv
x / y unsigned
var cot_uge
x >= y unsigned
var cot_ugt
x > y unsigned
var cot_ule
x <= y unsigned
var cot_ult
x < y unsigned
var cot_umod
x % y unsigned
var cot_ushr
x >> y unsigned
var cot_var
v
var cot_xor
x ^ y
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_dstr
hx_cexpr_t_dstr = 598
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_maybe_ptr
hx_cexpr_t_maybe_ptr = 593
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_change_hexrays_config
hx_change_hexrays_config = 603
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_dstr
hx_cinsn_t_dstr = 599
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_dstr
hx_ctree_item_t_dstr = 601
var hx_ctree_item_t_get_ea
hx_ctree_item_t_get_ea = 461
var hx_ctree_item_t_get_edm
hx_ctree_item_t_get_edm = 608
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_item_t_get_udm
hx_ctree_item_t_get_udm = 607
var hx_ctree_item_t_print
hx_ctree_item_t_print = 600
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_curfunc
hx_mba_t_get_curfunc = 590
var hx_mba_t_get_func_output_lists
hx_mba_t_get_func_output_lists = 604
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_lvar_name
hx_mba_t_set_lvar_name = 602
var hx_mba_t_set_maturity
hx_mba_t_set_maturity = 583
var hx_mba_t_stkoff_ida2vd
hx_mba_t_stkoff_ida2vd = 597
var hx_mba_t_stkoff_vd2ida
hx_mba_t_stkoff_vd2ida = 596
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_deserialize
hx_minsn_t_deserialize = 595
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_modifies_d
hx_minsn_t_modifies_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_serialize
hx_minsn_t_serialize = 594
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__make_gvar
hx_mop_t__make_gvar = 591
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_gvar
hx_mop_t_make_gvar = 592
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_rename_udm
hx_vdui_t_rename_udm = 605
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_set_udm_type
hx_vdui_t_set_udm_type = 606
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
Analyzing a call instruction.
var hxe_callinfo_built
A call instruction has been anallyzed.
var hxe_calls_done
All calls have been analyzed.
var hxe_close_pseudocode
Pseudocode view is being closed.
var hxe_cmt_changed
Comment got changed.
var hxe_combine
Trying to combine instructions of basic block.
var hxe_create_hint
Create a hint for the current item.
see: ui_get_custom_viewer_hint
retval 0: continue collecting hints with other subscribers
retval 1: stop collecting hints
var hxe_curpos
Current cursor position has been changed. (for example, by left-clicking or using keyboard)
var hxe_double_click
Mouse double click.
var hxe_flowchart
Flowchart has been generated.
var hxe_func_printed
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 items.
var hxe_glbopt
Global optimization has been finished. If microcode is modified, MERR_LOOP must be returned. It will cause a complete restart of the optimization.
var hxe_interr
Internal error has occurred.
var hxe_keyboard
Keyboard has been hit.
var hxe_locopt
Basic block level optimization has been finished.
var hxe_maturity
Ctree maturity level is being changed.
var hxe_microcode
Microcode has been generated.
var hxe_open_pseudocode
New pseudocode view has been opened.
var hxe_populating_popup
Populating popup menu. We can add menu items now.
var hxe_prealloc
Local variables: preallocation step begins.
var hxe_preoptimized
Microcode has been preoptimized.
var hxe_print_func
Printing ctree and generating text.
var hxe_prolog
Prolog analysis has been finished.
var hxe_refresh_pseudocode
Existing pseudocode text has been refreshed. Adding/removing pseudocode lines is forbidden in this event.
var hxe_resolve_stkaddrs
The optimizer is about to resolve stack addresses.
var hxe_right_click
Mouse right click. Use hxe_populating_popup instead, in case you want to add items in the popup menu.
var hxe_stkpnts
SP change points have been calculated.
var hxe_structural
Structural analysis has been finished.
var hxe_switch_pseudocode
Existing pseudocode view has been reloaded with a new function. Its text has not been refreshed yet, only cfunc and mba pointers are ready.
var hxe_text_ready
Decompiled text is ready.
var k
k = 'voff_t_undef'
var lxe_lvar_cmt_changed
Local variable comment got changed.
var lxe_lvar_mapping_changed
Local variable mapping got changed.
var lxe_lvar_name_changed
Local variable got renamed.
var lxe_lvar_type_changed
Local variable type got changed.
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
local stack variable (they exist until MMAT_LVARS)
var mop_a
mop_a = 10
var mop_b
micro basic block (mblock_t)
var mop_c
mcases
var mop_d
result of another instruction
var mop_f
list of arguments
var mop_fn
floating point constant
var mop_h
helper function
var mop_l
local variable
var mop_n
immediate number constant
var mop_p
operand pair
var mop_r
register (they exist until MMAT_LVARS)
var mop_sc
scattered
var mop_str
immediate string constant (user representation)
var mop_v
global variable
var mop_z
none
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
accepts_small_udts(op) -> bool
Is the operator allowed on small structure or union?
op: (C++: ctype_t) enum ctype_t
def accepts_udts(*args) ‑> bool
accepts_udts(op) -> bool
op: enum ctype_t
def arglocs_overlap(*args) ‑> bool
arglocs_overlap(loc1, w1, loc2, w2) -> bool
Do two arglocs overlap?
loc1: (C++: const vdloc_t &) vdloc_t const &
w1: (C++: size_t)
loc2: (C++: const vdloc_t &) vdloc_t const &
w2: (C++: size_t)
def asgop(*args) ‑> ctype_t
asgop(cop) -> ctype_t
Convert plain operator into assignment operator. For example, cot_add returns cot_asgadd.
cop: (C++: ctype_t) enum ctype_t
def asgop_revert(*args) ‑> ctype_t
asgop_revert(cop) -> ctype_t
Convert assignment operator into plain operator. For example, cot_asgadd returns cot_add
cop: (C++: ctype_t) enum ctype_t
return: cot_empty is the input operator is not an assignment operator.
def block_chains_begin(*args) ‑> block_chains_iterator_t
block_chains_begin(set) -> block_chains_iterator_t
Get iterator pointing to the beginning of block_chains_t.
set: (C++: const block_chains_t *) block_chains_t const *
def block_chains_clear(*args) ‑> void
block_chains_clear(set)
Clear block_chains_t.
set: (C++: block_chains_t *)
def block_chains_end(*args) ‑> block_chains_iterator_t
block_chains_end(set) -> block_chains_iterator_t
Get iterator pointing to the end of block_chains_t.
set: (C++: const block_chains_t *) block_chains_t const *
def block_chains_erase(*args) ‑> void
block_chains_erase(set, p)
Erase current element from block_chains_t.
set: (C++: block_chains_t *)
p: (C++: block_chains_iterator_t)
def block_chains_find(*args) ‑> block_chains_iterator_t
block_chains_find(set, val) -> block_chains_iterator_t
Find the specified key in set block_chains_t.
set: (C++: const block_chains_t *) block_chains_t const *
val: (C++: const chain_t &) chain_t const &
def block_chains_free(*args) ‑> void
block_chains_free(set)
Delete block_chains_t instance.
set: (C++: block_chains_t *)
def block_chains_get(*args) ‑> chain_t &
block_chains_get(p) -> chain_t
Get reference to the current set value.
p: (C++: block_chains_iterator_t)
def block_chains_insert(*args) ‑> block_chains_iterator_t
block_chains_insert(set, val) -> block_chains_iterator_t
Insert new (chain_t) into set block_chains_t.
set: (C++: block_chains_t *)
val: (C++: const chain_t &) chain_t const &
def block_chains_new(*args) ‑> block_chains_t *
block_chains_new() -> block_chains_t
Create a new block_chains_t instance.
def block_chains_next(*args) ‑> block_chains_iterator_t
block_chains_next(p) -> block_chains_iterator_t
Move to the next element.
p: (C++: block_chains_iterator_t)
def block_chains_prev(*args) ‑> block_chains_iterator_t
block_chains_prev(p) -> block_chains_iterator_t
Move to the previous element.
p: (C++: block_chains_iterator_t)
def block_chains_size(*args) ‑> size_t
block_chains_size(set) -> size_t
Get size of block_chains_t.
set: (C++: block_chains_t *)
def boundaries_begin(*args) ‑> boundaries_iterator_t
boundaries_begin(map) -> boundaries_iterator_t
Get iterator pointing to the beginning of boundaries_t.
map: (C++: const boundaries_t *) boundaries_t const *
def boundaries_clear(*args) ‑> void
boundaries_clear(map)
Clear boundaries_t.
map: (C++: boundaries_t *)
def boundaries_end(*args) ‑> boundaries_iterator_t
boundaries_end(map) -> boundaries_iterator_t
Get iterator pointing to the end of boundaries_t.
map: (C++: const boundaries_t *) boundaries_t const *
def boundaries_erase(*args) ‑> void
boundaries_erase(map, p)
Erase current element from boundaries_t.
map: (C++: boundaries_t *)
p: (C++: boundaries_iterator_t)
def boundaries_find(*args) ‑> boundaries_iterator_t
boundaries_find(map, key) -> boundaries_iterator_t
Find the specified key in boundaries_t.
map: (C++: const boundaries_t *) boundaries_t const *
key: (C++: const cinsn_t *&) cinsn_t const *
def boundaries_first(*args) ‑> cinsn_t *const &
boundaries_first(p) -> cinsn_t
Get reference to the current map key.
p: (C++: boundaries_iterator_t)
def boundaries_free(*args) ‑> void
boundaries_free(map)
Delete boundaries_t instance.
map: (C++: boundaries_t *)
def boundaries_insert(*args) ‑> boundaries_iterator_t
boundaries_insert(map, key, val) -> boundaries_iterator_t
Insert new (cinsn_t *, rangeset_t) pair into boundaries_t.
map: (C++: boundaries_t *)
key: (C++: const cinsn_t *&) cinsn_t const *
val: (C++: const rangeset_t &) rangeset_t const &
def boundaries_new(*args) ‑> boundaries_t *
boundaries_new() -> boundaries_t
Create a new boundaries_t instance.
def boundaries_next(*args) ‑> boundaries_iterator_t
boundaries_next(p) -> boundaries_iterator_t
Move to the next element.
p: (C++: boundaries_iterator_t)
def boundaries_prev(*args) ‑> boundaries_iterator_t
boundaries_prev(p) -> boundaries_iterator_t
Move to the previous element.
p: (C++: boundaries_iterator_t)
def boundaries_second(*args) ‑> rangeset_t &
boundaries_second(p) -> rangeset_t
Get reference to the current map value.
p: (C++: boundaries_iterator_t)
def boundaries_size(*args) ‑> size_t
boundaries_size(map) -> size_t
Get size of boundaries_t.
map: (C++: boundaries_t *)
def call_helper(rettype, args, *rest)
Create a helper call.
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 change_hexrays_config(*args) ‑> bool
change_hexrays_config(directive) -> bool
Parse DIRECTIVE and update the current configuration variables. For the syntax see hexrays.cfg
directive: (C++: const char *) char const *
def checkout_hexrays_license(*args) ‑> bool
checkout_hexrays_license(silent) -> 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.
silent: (C++: bool) silently fail if the license cannot be checked out.
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
clear_cached_cfuncs()
Flush all cached decompilation results.
def close_hexrays_waitbox(*args) ‑> void
close_hexrays_waitbox()
Close the waitbox displayed by the decompiler. Useful if DECOMP_NO_HIDE was used during decompilation.
def close_pseudocode(*args) ‑> bool
close_pseudocode(f) -> bool
Close pseudocode window.
f: (C++: TWidget *) pointer to window
return: false if failed
def convert_to_user_call(*args) ‑> merror_t
convert_to_user_call(udc, cdg) -> merror_t
try to generate user-defined call for an instruction
udc: (C++: const udcall_t &) udcall_t const &
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_cfunc(mba) -> cfuncptr_t
Create a new cfunc_t object.
mba: (C++: mba_t *) microcode object. After creating the cfunc object it takes the
ownership of MBA.
def create_empty_mba(*args) ‑> mba_t *
create_empty_mba(mbr, hf=None) -> mba_t
Create an empty microcode object.
mbr: (C++: const mba_ranges_t &) mba_ranges_t const &
hf: (C++: hexrays_failure_t *)
def create_field_name(*args) ‑> qstring
create_field_name(type, offset=BADADDR) -> qstring
type: tinfo_t const &
offset: uval_t
def create_helper(*args)
Create a helper object..
def create_typedef(*args) ‑> tinfo_t
create_typedef(name) -> tinfo_t
Create a reference to an ordinal type.
name: char const *
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
def debug_hexrays_ctree(*args) ‑> void
debug_hexrays_ctree(level, msg)
level: int
msg: char const *
def decompile(ea, hf=None, flags=0)
Decompile a function.
ea an address belonging to the function, or an ida_funcs.func_t object
hf extended error information (if failed)
flags decomp_flags bitwise combination of DECOMP\_... bits
return the decompilation result (a cfunc\_t wrapper), or None
def decompile_func(*args) ‑> cfuncptr_t
decompile_func(pfn, hf=None, decomp_flags=0) -> cfuncptr_t
Decompile a function. Multiple decompilations of the same function return the same object.
pfn: (C++: func_t *) pointer to function to decompile
hf: (C++: hexrays_failure_t *) extended error information (if failed)
decomp_flags: (C++: int) bitwise combination of decompile() flags... bits
return: pointer to the decompilation result (a reference counted pointer).
nullptr if failed.
def decompile_many(*args) ‑> bool
decompile_many(outfile, funcaddrs, flags) -> bool
Batch decompilation. Decompile all or the specified functions
outfile: (C++: const char *) name of the output file
funcaddrs: (C++: const eavec_t *) list of functions to decompile. If nullptr or empty, then
decompile all nonlib functions
flags: (C++: int) Batch decompilation bits
return: true if no internal error occurred and the user has not cancelled
decompilation
def dereference(e, ptrsize, is_float=False)
Dereference a pointer. This function dereferences a pointer expression. It performs the following conversion: "ptr" => "*ptr" It can handle discrepancies in the pointer type and the access size.
return: dereferenced expression
def dstr(*args) ‑> char const *
dstr(tif) -> char const *
Print the specified type info. This function can be used from a debugger by typing "tif->dstr()"
tif: (C++: const tinfo_t *) tinfo_t const *
def dummy_ptrtype(*args) ‑> tinfo_t
dummy_ptrtype(ptrsize, isfp) -> tinfo_t
Generate a dummy pointer type
ptrsize: (C++: int) size of pointed object
isfp: (C++: bool) is floating point object?
def eamap_begin(*args) ‑> eamap_iterator_t
eamap_begin(map) -> eamap_iterator_t
Get iterator pointing to the beginning of eamap_t.
map: (C++: const eamap_t *) eamap_t const *
def eamap_clear(*args) ‑> void
eamap_clear(map)
Clear eamap_t.
map: (C++: eamap_t *)
def eamap_end(*args) ‑> eamap_iterator_t
eamap_end(map) -> eamap_iterator_t
Get iterator pointing to the end of eamap_t.
map: (C++: const eamap_t *) eamap_t const *
def eamap_erase(*args) ‑> void
eamap_erase(map, p)
Erase current element from eamap_t.
map: (C++: eamap_t *)
p: (C++: eamap_iterator_t)
def eamap_find(*args) ‑> eamap_iterator_t
eamap_find(map, key) -> eamap_iterator_t
Find the specified key in eamap_t.
map: (C++: const eamap_t *) eamap_t const *
key: (C++: const ea_t &) ea_t const &
def eamap_first(*args) ‑> ea_t const &
eamap_first(p) -> ea_t const &
Get reference to the current map key.
p: (C++: eamap_iterator_t)
def eamap_free(*args) ‑> void
eamap_free(map)
Delete eamap_t instance.
map: (C++: eamap_t *)
def eamap_insert(*args) ‑> eamap_iterator_t
eamap_insert(map, key, val) -> eamap_iterator_t
Insert new (ea_t, cinsnptrvec_t) pair into eamap_t.
map: (C++: eamap_t *)
key: (C++: const ea_t &) ea_t const &
val: (C++: const cinsnptrvec_t &) cinsnptrvec_t const &
def eamap_new(*args) ‑> eamap_t *
eamap_new() -> eamap_t
Create a new eamap_t instance.
def eamap_next(*args) ‑> eamap_iterator_t
eamap_next(p) -> eamap_iterator_t
Move to the next element.
p: (C++: eamap_iterator_t)
def eamap_prev(*args) ‑> eamap_iterator_t
eamap_prev(p) -> eamap_iterator_t
Move to the previous element.
p: (C++: eamap_iterator_t)
def eamap_second(*args) ‑> cinsnptrvec_t &
eamap_second(p) -> cinsnptrvec_t
Get reference to the current map value.
p: (C++: eamap_iterator_t)
def eamap_size(*args) ‑> size_t
eamap_size(map) -> size_t
Get size of eamap_t.
map: (C++: eamap_t *)
def gen_microcode(*args) ‑> mba_t *
gen_microcode(mbr, hf=None, retlist=None, decomp_flags=0, reqmat=MMAT_GLBOPT3) -> mba_t
Generate microcode of an arbitrary code snippet
mbr: (C++: const mba_ranges_t &) snippet ranges
hf: (C++: hexrays_failure_t *) extended error information (if failed)
retlist: (C++: const mlist_t *) list of registers the snippet returns
decomp_flags: (C++: int) bitwise combination of decompile() flags... bits
reqmat: (C++: mba_maturity_t) required microcode maturity
return: pointer to the microcode, nullptr if failed.
def get_ctype_name(*args) ‑> char const *
get_ctype_name(op) -> char const *
op: enum ctype_t
def get_current_operand(*args) ‑> bool
get_current_operand(out) -> 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.
out: (C++: gco_info_t *) [out]: output buffer
def get_float_type(*args) ‑> tinfo_t
get_float_type(width) -> tinfo_t
Get a type of a floating point value with the specified width
width: (C++: int) width of the desired type
return: type info object
def get_hexrays_version(*args) ‑> char const *
get_hexrays_version() -> char const *
Get decompiler version. The returned string is of the form <major>.<minor>.<revision>.<build-date>
return: pointer to version string. For example: "2.0.0.140605"
def get_int_type_by_width_and_sign(*args) ‑> tinfo_t
get_int_type_by_width_and_sign(srcwidth, sign) -> tinfo_t
Create a type info by width and sign. Returns a simple type (examples: int, short) with the given width and sign.
srcwidth: (C++: int) size of the type in bytes
sign: (C++: type_sign_t) sign of the type
def get_member_type(*args) ‑> bool
get_member_type(mptr, type) -> bool
Get type of a structure field. This function performs validity checks of the field type. Wrong types are rejected.
mptr: (C++: const member_t *) structure field
type: (C++: tinfo_t *) pointer to the variable where the type is returned. This parameter
can be nullptr.
return: false if failed
def get_merror_desc(*args) ‑> qstring *
get_merror_desc(code, mba) -> str
Get textual description of an error code
code: (C++: merror_t) Microcode error codes
mba: (C++: mba_t *) the microcode array
return: the error address
def get_mreg_name(*args) ‑> qstring *
get_mreg_name(reg, width, ud=None) -> str
Get the microregister name.
reg: (C++: mreg_t) microregister number
width: (C++: int) size of microregister in bytes. may be bigger than the real
register size.
ud: (C++: void *) reserved, must be nullptr
return: width of the printed register. this value may be less than the WIDTH
argument.
def get_op_signness(*args) ‑> type_sign_t
get_op_signness(op) -> type_sign_t
Get operator sign. Meaningful for sign-dependent operators, like cot_sdiv.
op: (C++: ctype_t) enum ctype_t
def get_signed_mcode(*args) ‑> mcode_t
get_signed_mcode(code) -> mcode_t
code: enum mcode_t
def get_temp_regs(*args) ‑> mlist_t const &
get_temp_regs() -> mlist_t
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_type(id, tif, guess) -> bool
Get a global type. Global types are types of addressable objects and struct/union/enum types
id: (C++: uval_t) address or id of the object
tif: (C++: tinfo_t *) buffer for the answer
guess: (C++: type_source_t) what kind of types to consider
return: success
def get_unk_type(*args) ‑> tinfo_t
get_unk_type(size) -> tinfo_t
Create a partial type info by width. Returns a partially defined type (examples: _DWORD, _BYTE) with the given width.
size: (C++: int) size of the type in bytes
def get_unsigned_mcode(*args) ‑> mcode_t
get_unsigned_mcode(code) -> mcode_t
code: enum mcode_t
def get_widget_vdui(*args) ‑> vdui_t *
get_widget_vdui(f) -> vdui_t
Get the vdui_t instance associated to the TWidget
f: (C++: TWidget *) pointer to window
return: a vdui_t *, or nullptr
def getb_reginsn(*args) ‑> minsn_t *
getb_reginsn(ins) -> minsn_t
ins: minsn_t *
def getf_reginsn(*args) ‑> minsn_t *
getf_reginsn(ins) -> minsn_t
ins: minsn_t *
def has_cached_cfunc(*args) ‑> bool
has_cached_cfunc(ea) -> bool
Do we have a cached decompilation result for 'ea'?
ea: (C++: ea_t)
def has_mcode_seloff(*args) ‑> bool
has_mcode_seloff(op) -> bool
op: enum mcode_t
def hexrays_alloc(*args) ‑> void *
hexrays_alloc(size) -> void *
size: size_t
def hexrays_free(*args) ‑> void
hexrays_free(ptr)
ptr: void *
def init_hexrays_plugin(*args) ‑> bool
init_hexrays_plugin(flags=0) -> bool
Check that your plugin is compatible with hex-rays decompiler. This function must be called before calling any other decompiler function.
flags: (C++: int) reserved, must be 0
return: true if the decompiler exists and is compatible with your plugin
def install_hexrays_callback(callback)
Deprecated. Please use Hexrays_Hooks instead Install handler for decompiler events.
return: false if failed
def install_microcode_filter(*args) ‑> bool
install_microcode_filter(filter, install=True) -> bool
register/unregister non-standard microcode generator
filter: (C++: microcode_filter_t *) - microcode generator object
install: (C++: bool) - TRUE - register the object, FALSE - unregister
return: success
def is_additive(*args) ‑> bool
is_additive(op) -> bool
Is additive operator?
op: (C++: ctype_t) enum ctype_t
def is_allowed_on_small_struni(*args) ‑> bool
accepts_small_udts(op) -> bool
Is the operator allowed on small structure or union?
op: (C++: ctype_t) enum ctype_t
def is_assignment(*args) ‑> bool
is_assignment(op) -> bool
Is assignment operator?
op: (C++: ctype_t) enum ctype_t
def is_binary(*args) ‑> bool
is_binary(op) -> bool
Is binary operator?
op: (C++: ctype_t) enum ctype_t
def is_bitop(*args) ‑> bool
is_bitop(op) -> bool
Is bit related operator?
op: (C++: ctype_t) enum ctype_t
def is_bool_type(*args) ‑> bool
is_bool_type(type) -> bool
Is a boolean type?
type: (C++: const tinfo_t &) tinfo_t const &
return: true if the type is a boolean type
def is_break_consumer(*args) ‑> bool
is_break_consumer(op) -> bool
Does a break statement influence the specified statement code?
op: (C++: ctype_t) enum ctype_t
def is_commutative(*args) ‑> bool
is_commutative(op) -> bool
Is commutative operator?
op: (C++: ctype_t) enum ctype_t
def is_inplace_def(*args) ‑> bool
is_inplace_def(type) -> bool
Is struct/union/enum definition (not declaration)?
type: (C++: const tinfo_t &) tinfo_t const &
def is_kreg(*args) ‑> bool
is_kreg(r) -> 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()
r: (C++: mreg_t)
def is_logical(*args) ‑> bool
is_logical(op) -> bool
Is logical operator?
op: (C++: ctype_t) enum ctype_t
def is_loop(*args) ‑> bool
is_loop(op) -> bool
Is loop statement code?
op: (C++: ctype_t) enum ctype_t
def is_lvalue(*args) ‑> bool
is_lvalue(op) -> bool
Is Lvalue operator?
op: (C++: ctype_t) enum ctype_t
def is_may_access(*args) ‑> bool
is_may_access(maymust) -> bool
maymust: maymust_t
def is_mcode_addsub(*args) ‑> bool
is_mcode_addsub(mcode) -> bool
mcode: enum mcode_t
def is_mcode_call(*args) ‑> bool
is_mcode_call(mcode) -> bool
mcode: enum mcode_t
def is_mcode_commutative(*args) ‑> bool
is_mcode_commutative(mcode) -> bool
mcode: enum mcode_t
def is_mcode_convertible_to_jmp(*args) ‑> bool
is_mcode_convertible_to_jmp(mcode) -> bool
mcode: enum mcode_t
def is_mcode_convertible_to_set(*args) ‑> bool
is_mcode_convertible_to_set(mcode) -> bool
mcode: enum mcode_t
def is_mcode_divmod(*args) ‑> bool
is_mcode_divmod(op) -> bool
op: enum mcode_t
def is_mcode_fpu(*args) ‑> bool
is_mcode_fpu(mcode) -> bool
mcode: enum mcode_t
def is_mcode_j1(*args) ‑> bool
is_mcode_j1(mcode) -> bool
mcode: enum mcode_t
def is_mcode_jcond(*args) ‑> bool
is_mcode_jcond(mcode) -> bool
mcode: enum mcode_t
def is_mcode_propagatable(*args) ‑> bool
is_mcode_propagatable(mcode) -> 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.
mcode: (C++: mcode_t) enum mcode_t
def is_mcode_set(*args) ‑> bool
is_mcode_set(mcode) -> bool
mcode: enum mcode_t
def is_mcode_set1(*args) ‑> bool
is_mcode_set1(mcode) -> bool
mcode: enum mcode_t
def is_mcode_shift(*args) ‑> bool
is_mcode_shift(mcode) -> bool
mcode: enum mcode_t
def is_mcode_xdsu(*args) ‑> bool
is_mcode_xdsu(mcode) -> bool
mcode: enum mcode_t
def is_multiplicative(*args) ‑> bool
is_multiplicative(op) -> bool
Is multiplicative operator?
op: (C++: ctype_t) enum ctype_t
def is_nonbool_type(*args) ‑> bool
is_nonbool_type(type) -> bool
Is definitely a non-boolean type?
type: (C++: const tinfo_t &) tinfo_t const &
return: true if the type is a non-boolean type (non bool and well defined)
def is_paf(*args) ‑> bool
is_paf(t) -> bool
Is a pointer, array, or function type?
t: (C++: type_t)
def is_prepost(*args) ‑> bool
is_prepost(op) -> bool
Is pre/post increment/decrement operator?
op: (C++: ctype_t) enum ctype_t
def is_ptr_or_array(*args) ‑> bool
is_ptr_or_array(t) -> bool
Is a pointer or array type?
t: (C++: type_t)
def is_relational(*args) ‑> bool
is_relational(op) -> bool
Is comparison operator?
op: (C++: ctype_t) enum ctype_t
def is_signed_mcode(*args) ‑> bool
is_signed_mcode(code) -> bool
code: enum mcode_t
def is_small_struni(*args) ‑> bool
is_small_udt(tif) -> bool
Is a small structure or union?
tif: (C++: const tinfo_t &) tinfo_t const &
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_small_udt(tif) -> bool
Is a small structure or union?
tif: (C++: const tinfo_t &) tinfo_t const &
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
is_type_correct(ptr) -> bool
Verify a type string.
ptr: (C++: const type_t *) type_t const *
return: true if type string is correct
def is_unary(*args) ‑> bool
is_unary(op) -> bool
Is unary operator?
op: (C++: ctype_t) enum ctype_t
def is_unsigned_mcode(*args) ‑> bool
is_unsigned_mcode(code) -> bool
code: enum mcode_t
def jcnd2set(*args) ‑> mcode_t
jcnd2set(code) -> mcode_t
code: enum mcode_t
def lexcompare(*args) ‑> int
lexcompare(a, b) -> int
a: mop_t const &
b: mop_t const &
def lnot(e)
Logically negate the specified expression. The specified expression will be logically negated. For example, "x == y" is converted into "x != y" by this function.
return: logically negated expression.
def locate_lvar(*args) ‑> bool
locate_lvar(out, func_ea, varname) -> bool
Find a variable by name.
out: (C++: lvar_locator_t *) output buffer for the variable locator
func_ea: (C++: ea_t) function start address
varname: (C++: const char *) variable name
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
lvar_mapping_begin(map) -> lvar_mapping_iterator_t
Get iterator pointing to the beginning of lvar_mapping_t.
map: (C++: const lvar_mapping_t *) lvar_mapping_t const *
def lvar_mapping_clear(*args) ‑> void
lvar_mapping_clear(map)
Clear lvar_mapping_t.
map: (C++: lvar_mapping_t *)
def lvar_mapping_end(*args) ‑> lvar_mapping_iterator_t
lvar_mapping_end(map) -> lvar_mapping_iterator_t
Get iterator pointing to the end of lvar_mapping_t.
map: (C++: const lvar_mapping_t *) lvar_mapping_t const *
def lvar_mapping_erase(*args) ‑> void
lvar_mapping_erase(map, p)
Erase current element from lvar_mapping_t.
map: (C++: lvar_mapping_t *)
p: (C++: lvar_mapping_iterator_t)
def lvar_mapping_find(*args) ‑> lvar_mapping_iterator_t
lvar_mapping_find(map, key) -> lvar_mapping_iterator_t
Find the specified key in lvar_mapping_t.
map: (C++: const lvar_mapping_t *) lvar_mapping_t const *
key: (C++: const lvar_locator_t &) lvar_locator_t const &
def lvar_mapping_first(*args) ‑> lvar_locator_t const &
lvar_mapping_first(p) -> lvar_locator_t
Get reference to the current map key.
p: (C++: lvar_mapping_iterator_t)
def lvar_mapping_free(*args) ‑> void
lvar_mapping_free(map)
Delete lvar_mapping_t instance.
map: (C++: lvar_mapping_t *)
def lvar_mapping_insert(*args) ‑> lvar_mapping_iterator_t
lvar_mapping_insert(map, key, val) -> lvar_mapping_iterator_t
Insert new (lvar_locator_t, lvar_locator_t) pair into lvar_mapping_t.
map: (C++: lvar_mapping_t *)
key: (C++: const lvar_locator_t &) lvar_locator_t const &
val: (C++: const lvar_locator_t &) lvar_locator_t const &
def lvar_mapping_new(*args) ‑> lvar_mapping_t *
lvar_mapping_new() -> lvar_mapping_t
Create a new lvar_mapping_t instance.
def lvar_mapping_next(*args) ‑> lvar_mapping_iterator_t
lvar_mapping_next(p) -> lvar_mapping_iterator_t
Move to the next element.
p: (C++: lvar_mapping_iterator_t)
def lvar_mapping_prev(*args) ‑> lvar_mapping_iterator_t
lvar_mapping_prev(p) -> lvar_mapping_iterator_t
Move to the previous element.
p: (C++: lvar_mapping_iterator_t)
def lvar_mapping_second(*args) ‑> lvar_locator_t &
lvar_mapping_second(p) -> lvar_locator_t
Get reference to the current map value.
p: (C++: lvar_mapping_iterator_t)
def lvar_mapping_size(*args) ‑> size_t
lvar_mapping_size(map) -> size_t
Get size of lvar_mapping_t.
map: (C++: lvar_mapping_t *)
def make_num(*args)
Create a number expression
def make_pointer(*args) ‑> tinfo_t
make_pointer(type) -> tinfo_t
Create a pointer type. This function performs the following conversion: "type" -> "type*"
type: (C++: const tinfo_t &) object type.
return: "type*". for example, if 'char' is passed as the argument,
def make_ref(e)
Create a reference. This function performs the following conversion: "obj" => "&obj". It can handle casts, annihilate "&*", and process other special cases.
def mark_cfunc_dirty(*args) ‑> bool
mark_cfunc_dirty(ea, close_views=False) -> bool
Flush the cached decompilation results. Erases a cache entry for the specified function.
ea: (C++: ea_t) function to erase from the cache
close_views: (C++: bool) close pseudocode windows that show the function
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: enum mcode_t
def modify_user_lvar_info(*args) ‑> bool
modify_user_lvar_info(func_ea, mli_flags, info) -> bool
Modify saved local variable settings of one variable.
func_ea: (C++: ea_t) function start address
mli_flags: (C++: uint) bits that specify which attrs defined by INFO are to be set
info: (C++: const lvar_saved_info_t &) local variable info attrs
return: true if modified, false if invalid MLI_FLAGS passed
def modify_user_lvars(*args) ‑> bool
modify_user_lvars(entry_ea, mlv) -> bool
Modify saved local variable settings.
entry_ea: (C++: ea_t) function start address
mlv: (C++: user_lvar_modifier_t &) local variable modifier
return: true if modified variables
def mreg2reg(*args) ‑> int
mreg2reg(reg, width) -> int
Map a microregister to a processor register.
reg: (C++: mreg_t) microregister number
width: (C++: int) size of microregister in bytes
return: processor register id or -1
def must_mcode_close_block(*args) ‑> bool
must_mcode_close_block(mcode, including_calls) -> bool
Must an instruction with the given opcode be the last one in a block? Such opcodes are called closing opcodes.
mcode: (C++: mcode_t) instruction opcode
including_calls: (C++: bool) 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.
def negate_mcode_relation(*args) ‑> mcode_t
negate_mcode_relation(code) -> mcode_t
code: enum mcode_t
def negated_relation(*args) ‑> ctype_t
negated_relation(op) -> ctype_t
Negate a comparison operator. For example, cot_sge becomes cot_slt.
op: (C++: ctype_t) enum ctype_t
def new_block()
Create a new block-statement.
def op_uses_x(*args) ‑> bool
op_uses_x(op) -> bool
Does operator use the 'x' field of cexpr_t?
op: (C++: ctype_t) enum ctype_t
def op_uses_y(*args) ‑> bool
op_uses_y(op) -> bool
Does operator use the 'y' field of cexpr_t?
op: (C++: ctype_t) enum ctype_t
def op_uses_z(*args) ‑> bool
op_uses_z(op) -> bool
Does operator use the 'z' field of cexpr_t?
op: (C++: ctype_t) enum ctype_t
def open_pseudocode(*args) ‑> vdui_t *
open_pseudocode(ea, flags) -> vdui_t
Open pseudocode window. The specified function is decompiled and the pseudocode window is opened.
ea: (C++: ea_t) function to decompile
flags: (C++: int) a combination of OPF_ flags
return: false if failed
def parse_user_call(*args) ‑> bool
parse_user_call(udc, decl, silent) -> bool
Convert function type declaration into internal structure
udc: (C++: udcall_t *) - pointer to output structure
decl: (C++: const char *) - function type declaration
silent: (C++: bool) - if TRUE: do not show warning in case of incorrect type
return: success
def partial_type_num(*args) ‑> int
partial_type_num(type) -> int
Calculate number of partial subtypes.
type: (C++: const tinfo_t &) tinfo_t const &
return: number of partial subtypes. The bigger is this number, the uglier is
the type.
def print_vdloc(*args) ‑> qstring *
print_vdloc(loc, nbytes) -> str
Print vdloc. Since vdloc does not always carry the size info, we pass it as NBYTES..
loc: (C++: const vdloc_t &) vdloc_t const &
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
reg2mreg(reg) -> mreg_t
Map a processor register to a microregister.
reg: (C++: int) processor register number
return: microregister register id or mr_none
def remitem(*args) ‑> void
remitem(e)
e: citem_t const *
def remove_hexrays_callback(callback)
Deprecated. Please use Hexrays_Hooks instead Uninstall handler for decompiler events.
return: number of uninstalled handlers.
def rename_lvar(*args) ‑> bool
rename_lvar(func_ea, oldname, newname) -> bool
Rename a local variable.
func_ea: (C++: ea_t) function start address
oldname: (C++: const char *) old name of the variable
newname: (C++: const char *) new name of the variable
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_cmts(func_ea) -> user_cmts_t
Restore user defined comments from the database.
func_ea: (C++: ea_t) the entry address of the function
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_calls(udcalls, func_ea) -> bool
Restore user defined function calls from the database.
udcalls: (C++: udcall_map_t *) ptr to output buffer
func_ea: (C++: ea_t) entry address of the function
return: success
def restore_user_iflags(*args) ‑> user_iflags_t *
restore_user_iflags(func_ea) -> user_iflags_t
Restore user defined citem iflags from the database.
func_ea: (C++: ea_t) the entry address of the function
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_labels(func_ea) -> user_labels_t
Restore user defined labels from the database.
func_ea: (C++: ea_t) the entry address of the function, ignored if FUNC != nullptr
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: ea_t
func: cfunc_t const *
def restore_user_lvar_settings(*args) ‑> bool
restore_user_lvar_settings(lvinf, func_ea) -> bool
Restore user defined local variable settings in the database.
lvinf: (C++: lvar_uservec_t *) ptr to output buffer
func_ea: (C++: ea_t) entry address of the function
return: success
def restore_user_numforms(*args) ‑> user_numforms_t *
restore_user_numforms(func_ea) -> user_numforms_t
Restore user defined number formats from the database.
func_ea: (C++: ea_t) the entry address of the function
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_unions(func_ea) -> user_unions_t
Restore user defined union field selections from the database.
func_ea: (C++: ea_t) the entry address of the function
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_cmts(func_ea, user_cmts)
Save user defined comments into the database.
func_ea: (C++: ea_t) the entry address of the function
user_cmts: (C++: const user_cmts_t *) collection of user defined comments
def save_user_defined_calls(*args) ‑> void
save_user_defined_calls(func_ea, udcalls)
Save user defined local function calls into the database.
func_ea: (C++: ea_t) entry address of the function
udcalls: (C++: const udcall_map_t &) user-specified info about user defined function calls
def save_user_iflags(*args) ‑> void
save_user_iflags(func_ea, iflags)
Save user defined citem iflags into the database.
func_ea: (C++: ea_t) the entry address of the function
iflags: (C++: const user_iflags_t *) collection of user defined citem iflags
def save_user_labels(*args) ‑> void
save_user_labels(func_ea, user_labels)
Save user defined labels into the database.
func_ea: (C++: ea_t) the entry address of the function, ignored if FUNC != nullptr
user_labels: (C++: const user_labels_t *) collection of user defined labels
def save_user_labels2(*args) ‑> void
save_user_labels2(func_ea, user_labels, func=None)
func_ea: ea_t
user_labels: user_labels_t const *
func: cfunc_t const *
def save_user_lvar_settings(*args) ‑> void
save_user_lvar_settings(func_ea, lvinf)
Save user defined local variable settings into the database.
func_ea: (C++: ea_t) entry address of the function
lvinf: (C++: const lvar_uservec_t &) user-specified info about local variables
def save_user_numforms(*args) ‑> void
save_user_numforms(func_ea, numforms)
Save user defined number formats into the database.
func_ea: (C++: ea_t) the entry address of the function
numforms: (C++: const user_numforms_t *) collection of user defined comments
def save_user_unions(*args) ‑> void
save_user_unions(func_ea, unions)
Save user defined union field selections into the database.
func_ea: (C++: ea_t) the entry address of the function
unions: (C++: const user_unions_t *) collection of union field selections
def select_udt_by_offset(*args) ‑> int
select_udt_by_offset(udts, ops, applicator) -> int
Select UDT
udts: (C++: const qvector< tinfo_t > *) list of UDT tinfo_t for the selection, if nullptr or empty then
UDTs from the "Local types" will be used
ops: (C++: const ui_stroff_ops_t &) operands
applicator: (C++: ui_stroff_applicator_t &) callback will be called to apply the selection for every
operand
def send_database(*args) ‑> void
send_database(err, silent)
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.
err: (C++: const hexrays_failure_t &) failure description object. Empty hexrays_failure_t object can be
used if error information is not available.
silent: (C++: bool) if false, a dialog box will be displayed before sending the
database.
def set2jcnd(*args) ‑> mcode_t
set2jcnd(code) -> mcode_t
code: enum mcode_t
def set_type(*args) ‑> bool
set_type(id, tif, source, force=False) -> bool
Set a global type.
id: (C++: uval_t) address or id of the object
tif: (C++: const tinfo_t &) new type info
source: (C++: type_source_t) where the type comes from
force: (C++: bool) true means to set the type as is, false means to merge the new
type with the possibly existing old type info.
return: success
def swap_mcode_relation(*args) ‑> mcode_t
swap_mcode_relation(code) -> mcode_t
code: enum mcode_t
def swapped_relation(*args) ‑> ctype_t
swapped_relation(op) -> ctype_t
Swap a comparison operator. For example, cot_sge becomes cot_sle.
op: (C++: ctype_t) enum ctype_t
def term_hexrays_plugin(*args) ‑> void
term_hexrays_plugin()
Stop working with hex-rays decompiler.
def udcall_map_begin(*args) ‑> udcall_map_iterator_t
udcall_map_begin(map) -> udcall_map_iterator_t
Get iterator pointing to the beginning of udcall_map_t.
map: (C++: const udcall_map_t *) udcall_map_t const *
def udcall_map_clear(*args) ‑> void
udcall_map_clear(map)
Clear udcall_map_t.
map: (C++: udcall_map_t *)
def udcall_map_end(*args) ‑> udcall_map_iterator_t
udcall_map_end(map) -> udcall_map_iterator_t
Get iterator pointing to the end of udcall_map_t.
map: (C++: const udcall_map_t *) udcall_map_t const *
def udcall_map_erase(*args) ‑> void
udcall_map_erase(map, p)
Erase current element from udcall_map_t.
map: (C++: udcall_map_t *)
p: (C++: udcall_map_iterator_t)
def udcall_map_find(*args) ‑> udcall_map_iterator_t
udcall_map_find(map, key) -> udcall_map_iterator_t
Find the specified key in udcall_map_t.
map: (C++: const udcall_map_t *) udcall_map_t const *
key: (C++: const ea_t &) ea_t const &
def udcall_map_first(*args) ‑> ea_t const &
udcall_map_first(p) -> ea_t const &
Get reference to the current map key.
p: (C++: udcall_map_iterator_t)
def udcall_map_free(*args) ‑> void
udcall_map_free(map)
Delete udcall_map_t instance.
map: (C++: udcall_map_t *)
def udcall_map_insert(*args) ‑> udcall_map_iterator_t
udcall_map_insert(map, key, val) -> udcall_map_iterator_t
Insert new (ea_t, udcall_t) pair into udcall_map_t.
map: (C++: udcall_map_t *)
key: (C++: const ea_t &) ea_t const &
val: (C++: const udcall_t &) udcall_t const &
def udcall_map_new(*args) ‑> udcall_map_t *
udcall_map_new() -> udcall_map_t *
Create a new udcall_map_t instance.
def udcall_map_next(*args) ‑> udcall_map_iterator_t
udcall_map_next(p) -> udcall_map_iterator_t
Move to the next element.
p: (C++: udcall_map_iterator_t)
def udcall_map_prev(*args) ‑> udcall_map_iterator_t
udcall_map_prev(p) -> udcall_map_iterator_t
Move to the previous element.
p: (C++: udcall_map_iterator_t)
def udcall_map_second(*args) ‑> udcall_t &
udcall_map_second(p) -> udcall_t
Get reference to the current map value.
p: (C++: udcall_map_iterator_t)
def udcall_map_size(*args) ‑> size_t
udcall_map_size(map) -> size_t
Get size of udcall_map_t.
map: (C++: udcall_map_t *)
def user_cmts_begin(*args) ‑> user_cmts_iterator_t
user_cmts_begin(map) -> user_cmts_iterator_t
Get iterator pointing to the beginning of user_cmts_t.
map: (C++: const user_cmts_t *) user_cmts_t const *
def user_cmts_clear(*args) ‑> void
user_cmts_clear(map)
Clear user_cmts_t.
map: (C++: user_cmts_t *)
def user_cmts_end(*args) ‑> user_cmts_iterator_t
user_cmts_end(map) -> user_cmts_iterator_t
Get iterator pointing to the end of user_cmts_t.
map: (C++: const user_cmts_t *) user_cmts_t const *
def user_cmts_erase(*args) ‑> void
user_cmts_erase(map, p)
Erase current element from user_cmts_t.
map: (C++: user_cmts_t *)
p: (C++: user_cmts_iterator_t)
def user_cmts_find(*args) ‑> user_cmts_iterator_t
user_cmts_find(map, key) -> user_cmts_iterator_t
Find the specified key in user_cmts_t.
map: (C++: const user_cmts_t *) user_cmts_t const *
key: (C++: const treeloc_t &) treeloc_t const &
def user_cmts_first(*args) ‑> treeloc_t const &
user_cmts_first(p) -> treeloc_t
Get reference to the current map key.
p: (C++: user_cmts_iterator_t)
def user_cmts_free(*args) ‑> void
user_cmts_free(map)
Delete user_cmts_t instance.
map: (C++: user_cmts_t *)
def user_cmts_insert(*args) ‑> user_cmts_iterator_t
user_cmts_insert(map, key, val) -> user_cmts_iterator_t
Insert new (treeloc_t, citem_cmt_t) pair into user_cmts_t.
map: (C++: user_cmts_t *)
key: (C++: const treeloc_t &) treeloc_t const &
val: (C++: const citem_cmt_t &) citem_cmt_t const &
def user_cmts_new(*args) ‑> user_cmts_t *
user_cmts_new() -> user_cmts_t
Create a new user_cmts_t instance.
def user_cmts_next(*args) ‑> user_cmts_iterator_t
user_cmts_next(p) -> user_cmts_iterator_t
Move to the next element.
p: (C++: user_cmts_iterator_t)
def user_cmts_prev(*args) ‑> user_cmts_iterator_t
user_cmts_prev(p) -> user_cmts_iterator_t
Move to the previous element.
p: (C++: user_cmts_iterator_t)
def user_cmts_second(*args) ‑> citem_cmt_t &
user_cmts_second(p) -> citem_cmt_t
Get reference to the current map value.
p: (C++: user_cmts_iterator_t)
def user_cmts_size(*args) ‑> size_t
user_cmts_size(map) -> size_t
Get size of user_cmts_t.
map: (C++: user_cmts_t *)
def user_iflags_begin(*args) ‑> user_iflags_iterator_t
user_iflags_begin(map) -> user_iflags_iterator_t
Get iterator pointing to the beginning of user_iflags_t.
map: (C++: const user_iflags_t *) user_iflags_t const *
def user_iflags_clear(*args) ‑> void
user_iflags_clear(map)
Clear user_iflags_t.
map: (C++: user_iflags_t *)
def user_iflags_end(*args) ‑> user_iflags_iterator_t
user_iflags_end(map) -> user_iflags_iterator_t
Get iterator pointing to the end of user_iflags_t.
map: (C++: const user_iflags_t *) user_iflags_t const *
def user_iflags_erase(*args) ‑> void
user_iflags_erase(map, p)
Erase current element from user_iflags_t.
map: (C++: user_iflags_t *)
p: (C++: user_iflags_iterator_t)
def user_iflags_find(*args) ‑> user_iflags_iterator_t
user_iflags_find(map, key) -> user_iflags_iterator_t
Find the specified key in user_iflags_t.
map: (C++: const user_iflags_t *) user_iflags_t const *
key: (C++: const citem_locator_t &) citem_locator_t const &
def user_iflags_first(*args) ‑> citem_locator_t const &
user_iflags_first(p) -> citem_locator_t
Get reference to the current map key.
p: (C++: user_iflags_iterator_t)
def user_iflags_free(*args) ‑> void
user_iflags_free(map)
Delete user_iflags_t instance.
map: (C++: user_iflags_t *)
def user_iflags_insert(*args) ‑> user_iflags_iterator_t
user_iflags_insert(map, key, val) -> user_iflags_iterator_t
Insert new (citem_locator_t, int32) pair into user_iflags_t.
map: (C++: user_iflags_t *)
key: (C++: const citem_locator_t &) citem_locator_t const &
val: (C++: const int32 &) int32 const &
def user_iflags_new(*args) ‑> user_iflags_t *
user_iflags_new() -> user_iflags_t
Create a new user_iflags_t instance.
def user_iflags_next(*args) ‑> user_iflags_iterator_t
user_iflags_next(p) -> user_iflags_iterator_t
Move to the next element.
p: (C++: user_iflags_iterator_t)
def user_iflags_prev(*args) ‑> user_iflags_iterator_t
user_iflags_prev(p) -> user_iflags_iterator_t
Move to the previous element.
p: (C++: user_iflags_iterator_t)
def user_iflags_second(*args) ‑> int32 const &
user_iflags_second(p) -> int32 const &
Get reference to the current map value.
p: (C++: user_iflags_iterator_t)
def user_iflags_size(*args) ‑> size_t
user_iflags_size(map) -> size_t
Get size of user_iflags_t.
map: (C++: user_iflags_t *)
def user_labels_begin(*args) ‑> user_labels_iterator_t
user_labels_begin(map) -> user_labels_iterator_t
Get iterator pointing to the beginning of user_labels_t.
map: (C++: const user_labels_t *) user_labels_t const *
def user_labels_clear(*args) ‑> void
user_labels_clear(map)
Clear user_labels_t.
map: (C++: user_labels_t *)
def user_labels_end(*args) ‑> user_labels_iterator_t
user_labels_end(map) -> user_labels_iterator_t
Get iterator pointing to the end of user_labels_t.
map: (C++: const user_labels_t *) user_labels_t const *
def user_labels_erase(*args) ‑> void
user_labels_erase(map, p)
Erase current element from user_labels_t.
map: (C++: user_labels_t *)
p: (C++: user_labels_iterator_t)
def user_labels_find(*args) ‑> user_labels_iterator_t
user_labels_find(map, key) -> user_labels_iterator_t
Find the specified key in user_labels_t.
map: (C++: const user_labels_t *) user_labels_t const *
key: (C++: const int &) int const &
def user_labels_first(*args) ‑> int const &
user_labels_first(p) -> int const &
Get reference to the current map key.
p: (C++: user_labels_iterator_t)
def user_labels_free(*args) ‑> void
user_labels_free(map)
Delete user_labels_t instance.
map: (C++: user_labels_t *)
def user_labels_insert(*args) ‑> user_labels_iterator_t
user_labels_insert(map, key, val) -> user_labels_iterator_t
Insert new (int, qstring) pair into user_labels_t.
map: (C++: user_labels_t *)
key: (C++: const int &) int const &
val: (C++: const qstring &) qstring const &
def user_labels_new(*args) ‑> user_labels_t *
user_labels_new() -> user_labels_t
Create a new user_labels_t instance.
def user_labels_next(*args) ‑> user_labels_iterator_t
user_labels_next(p) -> user_labels_iterator_t
Move to the next element.
p: (C++: user_labels_iterator_t)
def user_labels_prev(*args) ‑> user_labels_iterator_t
user_labels_prev(p) -> user_labels_iterator_t
Move to the previous element.
p: (C++: user_labels_iterator_t)
def user_labels_second(*args) ‑> qstring &
user_labels_second(p) -> qstring &
Get reference to the current map value.
p: (C++: user_labels_iterator_t)
def user_labels_size(*args) ‑> size_t
user_labels_size(map) -> size_t
Get size of user_labels_t.
map: (C++: user_labels_t *)
def user_numforms_begin(*args) ‑> user_numforms_iterator_t
user_numforms_begin(map) -> user_numforms_iterator_t
Get iterator pointing to the beginning of user_numforms_t.
map: (C++: const user_numforms_t *) user_numforms_t const *
def user_numforms_clear(*args) ‑> void
user_numforms_clear(map)
Clear user_numforms_t.
map: (C++: user_numforms_t *)
def user_numforms_end(*args) ‑> user_numforms_iterator_t
user_numforms_end(map) -> user_numforms_iterator_t
Get iterator pointing to the end of user_numforms_t.
map: (C++: const user_numforms_t *) user_numforms_t const *
def user_numforms_erase(*args) ‑> void
user_numforms_erase(map, p)
Erase current element from user_numforms_t.
map: (C++: user_numforms_t *)
p: (C++: user_numforms_iterator_t)
def user_numforms_find(*args) ‑> user_numforms_iterator_t
user_numforms_find(map, key) -> user_numforms_iterator_t
Find the specified key in user_numforms_t.
map: (C++: const user_numforms_t *) user_numforms_t const *
key: (C++: const operand_locator_t &) operand_locator_t const &
def user_numforms_first(*args) ‑> operand_locator_t const &
user_numforms_first(p) -> operand_locator_t
Get reference to the current map key.
p: (C++: user_numforms_iterator_t)
def user_numforms_free(*args) ‑> void
user_numforms_free(map)
Delete user_numforms_t instance.
map: (C++: user_numforms_t *)
def user_numforms_insert(*args) ‑> user_numforms_iterator_t
user_numforms_insert(map, key, val) -> user_numforms_iterator_t
Insert new (operand_locator_t, number_format_t) pair into user_numforms_t.
map: (C++: user_numforms_t *)
key: (C++: const operand_locator_t &) operand_locator_t const &
val: (C++: const number_format_t &) number_format_t const &
def user_numforms_new(*args) ‑> user_numforms_t *
user_numforms_new() -> user_numforms_t
Create a new user_numforms_t instance.
def user_numforms_next(*args) ‑> user_numforms_iterator_t
user_numforms_next(p) -> user_numforms_iterator_t
Move to the next element.
p: (C++: user_numforms_iterator_t)
def user_numforms_prev(*args) ‑> user_numforms_iterator_t
user_numforms_prev(p) -> user_numforms_iterator_t
Move to the previous element.
p: (C++: user_numforms_iterator_t)
def user_numforms_second(*args) ‑> number_format_t &
user_numforms_second(p) -> number_format_t
Get reference to the current map value.
p: (C++: user_numforms_iterator_t)
def user_numforms_size(*args) ‑> size_t
user_numforms_size(map) -> size_t
Get size of user_numforms_t.
map: (C++: user_numforms_t *)
def user_unions_begin(*args) ‑> user_unions_iterator_t
user_unions_begin(map) -> user_unions_iterator_t
Get iterator pointing to the beginning of user_unions_t.
map: (C++: const user_unions_t *) user_unions_t const *
def user_unions_clear(*args) ‑> void
user_unions_clear(map)
Clear user_unions_t.
map: (C++: user_unions_t *)
def user_unions_end(*args) ‑> user_unions_iterator_t
user_unions_end(map) -> user_unions_iterator_t
Get iterator pointing to the end of user_unions_t.
map: (C++: const user_unions_t *) user_unions_t const *
def user_unions_erase(*args) ‑> void
user_unions_erase(map, p)
Erase current element from user_unions_t.
map: (C++: user_unions_t *)
p: (C++: user_unions_iterator_t)
def user_unions_find(*args) ‑> user_unions_iterator_t
user_unions_find(map, key) -> user_unions_iterator_t
Find the specified key in user_unions_t.
map: (C++: const user_unions_t *) user_unions_t const *
key: (C++: const ea_t &) ea_t const &
def user_unions_first(*args) ‑> ea_t const &
user_unions_first(p) -> ea_t const &
Get reference to the current map key.
p: (C++: user_unions_iterator_t)
def user_unions_free(*args) ‑> void
user_unions_free(map)
Delete user_unions_t instance.
map: (C++: user_unions_t *)
def user_unions_insert(*args) ‑> user_unions_iterator_t
user_unions_insert(map, key, val) -> user_unions_iterator_t
Insert new (ea_t, intvec_t) pair into user_unions_t.
map: (C++: user_unions_t *)
key: (C++: const ea_t &) ea_t const &
val: (C++: const intvec_t &) intvec_t const &
def user_unions_new(*args) ‑> user_unions_t *
user_unions_new() -> user_unions_t
Create a new user_unions_t instance.
def user_unions_next(*args) ‑> user_unions_iterator_t
user_unions_next(p) -> user_unions_iterator_t
Move to the next element.
p: (C++: user_unions_iterator_t)
def user_unions_prev(*args) ‑> user_unions_iterator_t
user_unions_prev(p) -> user_unions_iterator_t
Move to the previous element.
p: (C++: user_unions_iterator_t)
def user_unions_second(*args) ‑> intvec_t &
user_unions_second(p) -> intvec_t
Get reference to the current map value.
p: (C++: user_unions_iterator_t)
def user_unions_size(*args) ‑> size_t
user_unions_size(map) -> size_t
Get size of user_unions_t.
map: (C++: user_unions_t *)

Classes

class DecompilationFailure (*args, **kwargs)
Common base class for all non-exit exceptions.

Ancestors

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

Subclasses

  • ida_hexrays.__cbhooks_t

Methods

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

Subclasses

Methods

def add(self, *args) ‑> bool
add(self, bit) -> bool
bit: int
add(self, bit, width) -> bool
bit: 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: bitset_t const &
def count(self, *args) ‑> int
count(self) -> int
count(self, bit) -> int
bit: int
def cut_at(self, *args) ‑> bool
cut_at(self, maxbit) -> bool
maxbit: 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: int
def front(self, *args) ‑> int
front(self) -> int
def has(self, *args) ‑> bool
has(self, bit) -> bool
bit: int
def has_all(self, *args) ‑> bool
has_all(self, bit, width) -> bool
bit: int
width: int
def has_any(self, *args) ‑> bool
has_any(self, bit, width) -> bool
bit: int
width: int
def has_common(self, *args) ‑> bool
has_common(self, ml) -> bool
ml: bitset_t const &
def inc(self, *args) ‑> void
inc(self, p, n=1)
p: bitset_t::iterator &
n: int
def includes(self, *args) ‑> bool
includes(self, ml) -> bool
ml: bitset_t const &
def intersect(self, *args) ‑> bool
intersect(self, ml) -> bool
ml: bitset_t const &
def is_subset_of(self, *args) ‑> bool
is_subset_of(self, ml) -> bool
ml: bitset_t const &
def itat(self, *args) ‑> bitset_t::iterator
itat(self, n) -> iterator
n: 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: int
def sub(self, *args) ‑> bool
sub(self, bit) -> bool
bit: int
sub(self, bit, width) -> bool
bit: int
width: int
sub(self, ml) -> bool
ml: bitset_t const &
def swap(self, *args) ‑> void
swap(self, r)
r: 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
x
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(self, k, width=1) -> chain_t
k: voff_t const &
width: int
get_chain(self, ch) -> chain_t
ch: chain_t const &
def get_reg_chain(self, *args) ‑> chain_t *
get_reg_chain(self, reg, width=1) -> chain_t
reg: mreg_t
width: int
def get_stk_chain(self, *args) ‑> chain_t *
get_stk_chain(self, off, width=1) -> chain_t
off: sval_t
width: int
class block_chains_vec_t (*args)
Proxy of C++ qvector< block_chains_t > class.
__init__(self) -> block_chains_vec_t
__init__(self, x) -> 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
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
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 &
push_back(self) -> block_chains_t
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
x
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
formal parameter type (if known)
var is_vararg
is a vararg (matches ...)

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: cexpr_t *

Inherited members

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

Ancestors

Instance variables

var flags
call flags
var functype
function object type

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
List of case values. if empty, then 'default' case

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: 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
dslot
var dslot_insn
dslot_insn
var ea
ea
var end
end
var is_likely_dslot
is_likely_dslot
var mba
mba
var severed_branch
severed_branch

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: insn_t *
def ok(self, *args) ‑> bool
ok(self) -> bool
def start(self, *args) ‑> void
start(self, rng)
rng: range_t const &
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
Expression of the statement.
class cexpr_t (*args)
Proxy of C++ cexpr_t class.
__init__(self) -> cexpr_t
__init__(self, cexpr_op, _x, _y=None, _z=None) -> cexpr_t
cexpr_op: 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
argument list (used for cot_call)
var exflags
Expression attributes
var fpc
used for cot_fnum
var helper
helper name (used for cot_helper)
var insn
an embedded statement, they are prohibited at the final maturity stage (CMAT_FINAL)
var m
member offset (used for cot_memptr, cot_memref) for unions, the member number
var n
used for cot_num
var obj_ea
used for cot_obj
var operands
return a dictionary with the operands of a cexpr_t.
var opname
var ptrsize
memory access size (used for cot_ptr, cot_memptr)
var refwidth
how many bytes are accessed? (-1: none)
var string
utf8 string constant, user representation (used for cot_str)
var type
expression type. must be carefully maintained
var v
used for cot_var
var x
the first operand of the expression
var y
the second operand of the expression
var z
the third operand of the expression

Methods

def assign(self, *args) ‑> cexpr_t &
assign(self, r) -> cexpr_t
r: cexpr_t const &
def calc_type(self, *args) ‑> void
calc_type(self, recursive)
Calculate the type of the expression. Use this function to calculate the expression type when a new expression is built
recursive: (C++: bool) if true, types of all children expression will be calculated
before calculating our type
def cleanup(self, *args) ‑> void
cleanup(self)
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
contains_comma(self, times=1) -> bool
Does the expression contain a comma operator?
times: (C++: int)
def contains_comma_or_insn_or_label(self, *args) ‑> bool
contains_comma_or_insn_or_label(self, maxcommas=1) -> bool
Does the expression contain a comma operator or an embedded statement operator or a label?
maxcommas: (C++: int)
def contains_insn(self, *args) ‑> bool
contains_insn(self, times=1) -> bool
Does the expression contain an embedded statement operator?
times: (C++: int)
def contains_insn_or_label(self, *args) ‑> bool
contains_insn_or_label(self) -> bool
Does the expression contain an embedded statement operator or a label?
def contains_operator(self, *args) ‑> bool
contains_operator(self, needed_op, times=1) -> bool
Check if the expression contains the specified operator.
needed_op: (C++: ctype_t) operator code to search for
times: (C++: int) how many times the operator code should be present
return: true if the expression has at least TIMES children with NEEDED_OP
def cpadone(self, *args) ‑> bool
cpadone(self) -> bool
Pointer arithmetic correction done for this expression?
def dstr(self, *args) ‑> char const *
dstr(self) -> char const *
def equal_effect(self, *args) ‑> bool
equal_effect(self, r) -> 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.
r: (C++: const cexpr_t &) the expression to compare against the current expression
return: true expressions can be considered equal
def find_num_op(self, *args) ‑> cexpr_t *
find_num_op(self) -> cexpr_t
def find_op(self, *args) ‑> cexpr_t *
find_op(self, _op) -> cexpr_t
_op: enum ctype_t
def get_1num_op(self, *args) ‑> bool
get_1num_op(self, o1, o2) -> bool
o1: cexpr_t **
o2: cexpr_t **
def get_const_value(self, *args) ‑> bool
get_const_value(self) -> bool
Get expression value.
return: true if the expression is a number.
def get_high_nbit_bound(self, *args) ‑> bit_bound_t
get_high_nbit_bound(self) -> 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_low_nbit_bound(self) -> 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 *
get_ptr_or_array(self) -> cexpr_t
Find pointer or array child.
def get_type_sign(self, *args) ‑> type_sign_t
get_type_sign(self) -> 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
has_side_effects(self) -> 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_arg_of(self, parent) -> bool
Is call argument?
parent: (C++: const citem_t *) citem_t const *
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_of(self, parent) -> bool
Is call object?
parent: (C++: const citem_t *) citem_t const *
return: true if our expression is the call object of the specified parent
expression.
def is_child_of(self, *args) ‑> bool
is_child_of(self, parent) -> bool
Verify if the specified item is our parent.
parent: (C++: const citem_t *) possible parent item
return: true if the specified item is our parent
def is_const_value(self, *args) ‑> bool
is_const_value(self, _v) -> bool
Check if the expression is a number with the specified value.
_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
is_negative_const(self) -> bool
Check if the expression is a negative number.
def is_nice_cond(self, *args) ‑> bool
is_nice_cond(self) -> bool
Is nice condition?. Nice condition is a nice expression of the boolean type.
def is_nice_expr(self, *args) ‑> bool
is_nice_expr(self) -> bool
Is nice expression? Nice expressions do not contain comma operators, embedded statements, or labels.
def is_non_negative_const(self, *args) ‑> bool
is_non_negative_const(self) -> bool
Check if the expression is a non-negative number.
def is_non_zero_const(self, *args) ‑> bool
is_non_zero_const(self) -> 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_type_signed(self) -> bool
Is expression signed?
def is_type_unsigned(self, *args) ‑> bool
is_type_unsigned(self) -> 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
is_zero_const(self) -> bool
Check if the expression is a zero.
def maybe_ptr(self, *args) ‑> bool
maybe_ptr(self) -> bool
May the expression be a pointer?
def numval(self, *args) ‑> uint64
numval(self) -> uint64
Get numeric value of the expression. This function can be called only on cot_num expressions!
def print1(self, *args) ‑> void
print1(self, func)
Print expression into one line.
func: (C++: const cfunc_t *) parent function. This argument is used to find out the referenced
variable names.
def put_number(self, *args) ‑> void
put_number(self, func, value, nbytes, sign=no_sign)
Assign a number to the expression.
func: (C++: cfunc_t *) current function
value: (C++: uint64) number value
nbytes: (C++: int) size of the number in bytes
sign: (C++: type_sign_t) number sign
def requires_lvalue(self, *args) ‑> bool
requires_lvalue(self, child) -> bool
Check if the expression requires an lvalue.
child: (C++: const cexpr_t *) The function will check if this child of our expression must be an
lvalue.
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: cexpr_t &
def theother(self, *args) ‑> cexpr_t *
theother(self, what) -> cexpr_t
what: cexpr_t const *

Inherited members

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

Ancestors

Instance variables

var init
Initialization expression.
var step
Step expression.

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
Pointer to current function.

Methods

def calc_rvalue_type(self, *args) ‑> bool
calc_rvalue_type(self, target, e) -> 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.
target: (C++: tinfo_t *) 'best' type of the expression will be returned here
e: (C++: const cexpr_t *) expression to determine the desired type
return: false if failed

Inherited members

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

Instance variables

var argidx
list of arguments (indexes into vars)
var arguments
var body
function body, must be a block
var boundariesboundaries_t &
get_boundaries(self) -> boundaries_t
Get pointer to map of instruction boundaries. This function initializes the boundary map if not done yet.
var eamapeamap_t &
get_eamap(self) -> eamap_t
Get pointer to ea->insn map. This function initializes eamap if not done yet.
var entry_ea
function entry address
var hdrlines
number of lines in the declaration area
var lvarslvars_t *
get_lvars(self) -> lvars_t
Get vector of local variables.
return: pointer to the vector of local variables. If you modify this vector,
the ctree must be regenerated in order to have correct cast operators. Use build_c_tree() for that. Removing lvars should be done carefully: all references in ctree and microcode must be corrected after that.
var maturity
maturity level
var mba
underlying microcode
var numforms
user-defined number formats.
var pseudocode : strvec_t const &
get_pseudocode(self) -> strvec_t
Get pointer to decompilation output: the pseudocode. This function generates pseudocode if not done yet.
var refcnt
reference count to this object. use cfuncptr_t
var statebits
current cfunc_t state. see cfunc state bits
var treeitems
vector of ctree items
var type
Get the function's return type tinfo_t object.
var user_cmts
user-defined comments.
var user_iflags
user-defined item flags ctree item iflags bits
var user_labels
user-defined labels.
var user_unions
user-defined union field selections.
var warningshexwarns_t &
get_warnings(self) -> hexwarns_t
Get information about decompilation warnings.
return: reference to the vector of warnings

Methods

def build_c_tree(self, *args) ‑> void
build_c_tree(self)
Generate the function body. This function (re)generates the function body from the underlying microcode.
def del_orphan_cmts(self, *args) ‑> int
del_orphan_cmts(self) -> 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: 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
Find the label.
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: ctree_item_t const &
udm: udt_type_data_t *
def get_boundaries(self, *args) ‑> boundaries_t &
get_boundaries(self) -> 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_eamap(self) -> eamap_t
Get pointer to ea->insn map. This function initializes eamap if not done yet.
def get_func_type(self, *args) ‑> bool
get_func_type(self, type) -> bool
Get the function type.
type: (C++: tinfo_t *) variable where the function type is returned
return: false if failure
def get_line_item(self, *args) ‑> bool
get_line_item(self, line, x, is_ctree_line, phead, pitem, ptail) -> bool
Get ctree item for the specified cursor position.
line: (C++: const char *) line of decompilation text (element of sv)
x: (C++: int) x cursor coordinate in the line
is_ctree_line: (C++: bool) does the line belong to statement area? (if not, it is
assumed to belong to the declaration area)
phead: (C++: ctree_item_t *) ptr to the first item on the line (used to attach block comments).
May be nullptr
pitem: (C++: ctree_item_t *) ptr to the current item. May be nullptr
ptail: (C++: ctree_item_t *) ptr to the last item on the line (used to attach indented
comments). May be nullptr
see: vdui_t::get_current_item()
return: false if failed to get the current item
def get_lvars(self, *args) ‑> lvars_t *
get_lvars(self) -> lvars_t
Get vector of local variables.
return: pointer to the vector of local variables. If you modify this vector,
the ctree must be regenerated in order to have correct cast operators. Use build_c_tree() for that. Removing lvars should be done carefully: all references in ctree and microcode must be corrected after that.
def get_pseudocode(self, *args) ‑> strvec_t const &
get_pseudocode(self) -> strvec_t
Get pointer to decompilation output: the pseudocode. This function generates pseudocode if not done yet.
def get_stkoff_delta(self, *args) ‑> sval_t
get_stkoff_delta(self) -> 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.
return: the delta to apply. example: ida_stkoff = v.location.stkoff() -
f->get_stkoff_delta()
def get_user_cmt(self, *args) ‑> char const *
get_user_cmt(self, loc, rt) -> char const *
Retrieve a user defined comment.
loc: (C++: const treeloc_t &) ctree location
rt: (C++: cmt_retrieval_type_t) should already retrieved comments retrieved again?
return: pointer to the comment string or nullptr
def get_user_iflags(self, *args) ‑> int32
get_user_iflags(self, loc) -> int32
Retrieve citem iflags.
loc: (C++: const citem_locator_t &) citem locator
return: ctree item iflags bits or 0
def get_user_union_selection(self, *args) ‑> bool
get_user_union_selection(self, ea, path) -> bool
Retrieve a user defined union field selection.
ea: (C++: ea_t) address
path: (C++: intvec_t *) out: path describing the union selection.
return: pointer to the path or nullptr
def get_warnings(self, *args) ‑> hexwarns_t &
get_warnings(self) -> hexwarns_t
Get information about decompilation warnings.
return: reference to the vector of warnings
def has_orphan_cmts(self, *args) ‑> bool
has_orphan_cmts(self) -> bool
Check if there are orphan comments.
def locked(self, *args) ‑> bool
locked(self) -> bool
def print_dcl(self, *args) ‑> void
print_dcl(self)
Print function prototype.
def print_func(self, *args) ‑> void
print_func(self, vp)
Print function text.
vp: (C++: vc_printer_t &) printer helper class to receive the generated text.
def refresh_func_ctext(self, *args) ‑> void
refresh_func_ctext(self)
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(self)
Remove unused labels. This function checks what labels are really used by the function and removes the unused ones. You must call it after deleting a goto statement.
def save_user_cmts(self, *args) ‑> void
save_user_cmts(self)
Save user-defined comments into the database.
def save_user_iflags(self, *args) ‑> void
save_user_iflags(self)
Save user-defined iflags into the database.
def save_user_labels(self, *args) ‑> void
save_user_labels(self)
Save user-defined labels into the database.
def save_user_numforms(self, *args) ‑> void
save_user_numforms(self)
Save user-defined number formats into the database.
def save_user_unions(self, *args) ‑> void
save_user_unions(self)
Save user-defined union field selections into the database.
def set_user_cmt(self, *args) ‑> void
set_user_cmt(self, loc, cmt)
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.
loc: (C++: const treeloc_t &) ctree location
cmt: (C++: const char *) new comment. if empty or nullptr, then an existing comment is
deleted.
def set_user_iflags(self, *args) ‑> void
set_user_iflags(self, loc, iflags)
Set citem iflags.
loc: (C++: const citem_locator_t &) citem locator
iflags: (C++: int32) new iflags
def set_user_union_selection(self, *args) ‑> void
set_user_union_selection(self, ea, path)
Set a union field selection. The save_user_unions() function must be called after calling this function.
ea: (C++: ea_t) address
path: (C++: const intvec_t &) in: path describing the union selection.
def verify(self, *args) ‑> void
verify(self, aul, even_without_debugger)
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.
aul: (C++: allow_unused_labels_t) Are unused labels acceptable?
even_without_debugger: (C++: bool) if false and there is no debugger, the
verification will be skipped
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
argidx
var arguments
var body
body
var boundaries
var eamap
var entry_ea
entry_ea
var hdrlines
hdrlines
var lvars
var maturity
maturity
var mba
mba
var numforms
numforms
var pseudocode
var refcnt
refcnt
var statebits
statebits
var treeitems
treeitems
var type
var user_cmts
user_cmts
var user_iflags
user_iflags
var user_labels
user_labels
var user_unions
user_unions
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) -> (int, int), bool
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
Target label number.

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: chain_visitor_t &
gca: 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
__init__(self, t, off, w=1, v=-1) -> 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
combination Chain properties bits
var varnum
allocated variable index (-1 - not allocated yet)
var width
size of the value in bytes

Methods

def append_list(self, *args) ‑> void
append_list(self, mba, list)
Append the contents of the chain to the specified list of locations.
mba: (C++: const mba_t *) mba_t const *
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: chain_t const &
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: chain_t const &
def set_inited(self, *args) ‑> void
set_inited(self, b)
b: bool
def set_overlapped(self, *args) ‑> void
set_overlapped(self, b)
b: bool
def set_replaced(self, *args) ‑> void
set_replaced(self, b)
b: bool
def set_term(self, *args) ‑> void
set_term(self, b)
b: bool
def set_value(self, *args) ‑> void
set_value(self, r)
r: chain_t const &

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
parent of the current chain

Methods

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

Ancestors

Instance variables

var ielse
Else-branch of the if-statement. May be nullptr.
var ithen
Then-branch of the if-statement.

Methods

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

Inherited members

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

Subclasses

Methods

def at(self, index)
def back(self)
def begin(self, *args) ‑> cinsn_list_t_iterator
begin(self) -> cinsn_list_t_iterator
def clear(self, *args) ‑> void
clear(self)
def empty(self, *args) ‑> bool
empty(self) -> bool
def end(self, *args) ‑> cinsn_list_t_iterator
end(self) -> cinsn_list_t_iterator
def erase(self, *args) ‑> void
erase(self, p)
p: cinsn_list_t_iterator
def find(self, item)
def front(self)
def index(self, item)
def insert(self, *args) ‑> cinsn_list_t_iterator
insert(self, i, v)
i: size_t
v: cinsn_t const &
insert(self, p, x) -> cinsn_list_t_iterator
p: cinsn_list_t_iterator
x: cinsn_t const &
def pop_back(self, *args) ‑> void
pop_back(self)
def pop_front(self, *args) ‑> void
pop_front(self)
def push_back(self, *args) ‑> cinsn_t &
push_back(self, x)
x: cinsn_t const &
push_back(self) -> cinsn_t
def push_front(self, *args) ‑> void
push_front(self, x)
x: cinsn_t const &
def rbegin(self, *args) ‑> qlist< cinsn_t >::const_reverse_iterator
rbegin(self) -> qlist< cinsn_t >::reverse_iterator
rbegin(self) -> qlist< cinsn_t >::const_reverse_iterator
def remove(self, *args) ‑> bool
remove(self, v) -> bool
v: cinsn_t const &
def rend(self, *args) ‑> qlist< cinsn_t >::const_reverse_iterator
rend(self) -> qlist< cinsn_t >::reverse_iterator
rend(self) -> qlist< cinsn_t >::const_reverse_iterator
def size(self, *args) ‑> size_t
size(self) -> size_t
def swap(self, *args) ‑> void
swap(self, x)
x: qlist< cinsn_t > &
class cinsn_list_t_iterator (*args)
Proxy of C++ cinsn_list_t_iterator class.
__init__(self) -> cinsn_list_t_iterator

Instance variables

var cur
cur

Methods

def next(self, *args) ‑> void
__next__(self)
class cinsn_t (*args)
Proxy of C++ cinsn_t class.
__init__(self) -> cinsn_t
__init__(self, r) -> 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
details of asm-statement
var cblock
details of block-statement
var cdo
details of do-statement
var cexpr
details of expression-statement
var cfor
details of for-statement
var cgoto
details of goto-statement
var cif
details of if-statement
var creturn
details of return-statement
var cswitch
details of switch-statement
var cwhile
details of while-statement
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: cinsn_t const &
def cleanup(self, *args) ‑> void
cleanup(self)
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_breaks(self, breaks) -> 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.
breaks: (C++: cinsnptrvec_t *) pointer to the variable where the vector of all found free break
statements is returned. This argument can be nullptr.
return: true if some free break statements have been found
def collect_free_continues(self, *args) ‑> bool
collect_free_continues(self, continues) -> 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.
continues: (C++: cinsnptrvec_t *) pointer to the variable where the vector of all found free
continue statements is returned. This argument can be nullptr.
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
contains_free_break(self) -> bool
Check if the statement has free break statements.
def contains_free_continue(self, *args) ‑> bool
contains_free_continue(self) -> bool
Check if the statement has free continue statements.
def contains_insn(self, *args) ‑> bool
contains_insn(self, type, times=1) -> bool
Check if the statement contains a statement of the specified type.
type: (C++: ctype_t) statement opcode to look for
times: (C++: int) how many times TYPE should be present
return: true if the statement has at least TIMES children with opcode == TYPE
def create_if(self, *args) ‑> cif_t &
create_if(self, cnd) -> cif_t
Create a new if-statement. The current statement must be a block. The new statement will be appended to it.
cnd: (C++: cexpr_t *) if condition. It will be deleted after being copied.
def dstr(self, *args) ‑> char const *
dstr(self) -> char const *
def is_epilog(self)
def is_ordinary_flow(self, *args) ‑> bool
is_ordinary_flow(self) -> bool
Check if the statement passes execution to the next statement.
return: false if the statement breaks the control flow (like goto, return, etc)
def new_insn(self, *args) ‑> cinsn_t &
new_insn(self, insn_ea) -> cinsn_t
Create a new statement. The current statement must be a block. The new statement will be appended to it.
insn_ea: (C++: ea_t) statement address
def print1(self, *args) ‑> void
print1(self, func)
Print the statement into one line. Currently this function is not available.
func: (C++: const cfunc_t *) parent function. This argument is used to find out the referenced
variable names.
def swap(self, *args) ‑> void
swap(self, r)
r: cinsn_t &
def zero(self, *args) ‑> void
zero(self)
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
__init__(self, x) -> 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 &
push_back(self) -> cinsn_t *&
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 &
push_back(self) -> cinsn_t *&
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
__init__(self, s) -> citem_cmt_t
s: char const *

Instance variables

var used
the comment has been retrieved?

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 address
var op
citem operation

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, o=cot_empty) -> citem_t
o: enum ctype_t

Subclasses

Instance variables

var cexpr
cexpr
var cinsn
cinsn
var ea
address that corresponds to the item. may be BADADDR
var index
an index in cfunc_t::treeitems. meaningful only after print_func()
var label_num
label number. -1 means no label. items of the expression types (cot_...) should not have labels at the final maturity level, but at the intermediate levels any ctree item may have a label. Labels must be unique. Usually they correspond to the basic block numbers.
var meminfo
var obj_id : PyObject *
_obj_id(self) -> PyObject *
var op : ctype_t
item type
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
contains_expr(self, e) -> bool
Does the item contain an expression?
e: (C++: const cexpr_t *) cexpr_t const *
def contains_label(self, *args) ‑> bool
contains_label(self) -> bool
Does the item contain a label?
def find_closest_addr(self, *args) ‑> citem_t *
find_closest_addr(self, _ea) -> citem_t
_ea: ea_t
def find_parent_of(self, *args) ‑> citem_t *
find_parent_of(self, sitem) -> citem_t
sitem: citem_t const *
find_parent_of(self, item) -> citem_t
item: citem_t const *
def is_expr(self, *args) ‑> bool
is_expr(self) -> bool
Is an expression?
def print1(self, *args) ‑> void
print1(self, func)
Print item into one line.
func: (C++: const cfunc_t *) parent function. This argument is used to find out the referenced
variable names.
return: length of the generated text.
def replace_by(self, o)
def swap(self, *args) ‑> void
swap(self, r)
Swap two citem_t.
r: (C++: citem_t &)
class cloop_t (*args)
Proxy of C++ cloop_t class.
__init__(self, b=None) -> cloop_t
b: cinsn_t *
__init__(self, r) -> cloop_t
r: cloop_t const &

Ancestors

Subclasses

Instance variables

var body
body

Methods

def assign(self, *args) ‑> cloop_t &
assign(self, r) -> cloop_t
r: cloop_t const &
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
how to represent it

Methods

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

Instance variables

var ignore_micro
ignore_micro
var ii
ii
var insn
insn
var mb
mb
var mba
mba

Methods

def analyze_prolog(self, *args) ‑> merror_t
analyze_prolog(self, fc, reachable) -> merror_t
Analyze prolog/epilog of the function to decompile. If prolog is found, allocate and fill 'mba->pi' structure.
fc: (C++: const class qflow_chart_t &) flow chart
reachable: (C++: const class bitset_t &) bitmap of reachable blocks
return: error code
def emit(self, *args) ‑> minsn_t *
emit(self, code, width, l, r, d, offsize) -> minsn_t
Emit one microinstruction. This variant accepts pointers to operands. It is more difficult to use but permits to create virtually any instruction. Operands may be nullptr when it makes sense.
code: (C++: mcode_t) enum mcode_t
width: int
l: (C++: const mop_t *) uval_t
r: (C++: const mop_t *) uval_t
d: (C++: const mop_t *) uval_t
offsize: int
emit(self, code, l, r, d) -> minsn_t
code: enum mcode_t
l: mop_t const *
r: mop_t const *
d: mop_t const *
def emit_micro_mvm(self, *args) ‑> minsn_t *
emit_micro_mvm(self, code, dtype, l, r, d, offsize) -> minsn_t
Emit one microinstruction. This variant takes a data type not a size.
code: (C++: mcode_t) enum 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
gen_micro(self) -> merror_t
Generate microcode for one instruction. The instruction is in INSN
return: MERR_OK - all ok MERR_BLOCK - all ok, need to switch to new block
MERR_BADBLK - delete current block and continue other error codes are fatal
def load_effective_address(self, *args) ‑> mreg_t
load_effective_address(self, n, flags=0) -> mreg_t
Generate microcode to calculate the address of a memory operand.
n: (C++: int) - number of INSN operand
flags: (C++: int) - reserved for future use
return: register containing the operand address. mr_none - failed (not a memory
operand)
def load_operand(self, *args) ‑> mreg_t
load_operand(self, opnum, flags=0) -> mreg_t
Generate microcode to load one operand.
opnum: (C++: int) number of INSN operand
flags: (C++: int) reserved for future use
return: register containing the operand.
def microgen_completed(self, *args) ‑> void
microgen_completed(self)
This method is called when the microcode generation is done.
def prepare_gen_micro(self, *args) ‑> merror_t
prepare_gen_micro(self) -> 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
return: MERR_OK - all ok other error codes are fatal
def store_operand(self, *args) ‑> bool
store_operand(self, n, mop, flags=0, outins=None) -> 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)
n: (C++: int) - number of target INSN operand
mop: (C++: const mop_t &) - operand to be stored
flags: (C++: int) - reserved for future use
outins: (C++: minsn_t **) - (OUT) the last generated instruction
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
Switch cases: values and instructions.
var mvnf
Maximal switch value and number format.

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
Line number.
var x
x coordinate of the cursor within the window
var y
y coordinate of the cursor within the window

Methods

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

Instance variables

var value
value

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
Item type.
var e
var f
var i
var it
var l
var loc
loc

Methods

def dstr(self, *args) ‑> char const *
dstr(self) -> char const *
def get_ea(self, *args) ‑> ea_t
get_ea(self) -> ea_t
Get address of the current item. Each ctree item has an address.
return: BADADDR if failed
def get_edm(self, *args) ‑> int
get_edm(self, parent) -> int
Get type of an enum member. If the current item is a symbolic constant, this function will return information about it.
parent: (C++: tinfo_t *) pointer to buffer for the enum type.
return: member index or -1 if failed
def get_label_num(self, *args) ‑> int
get_label_num(self, gln_flags) -> int
Get label number of the current item.
gln_flags: (C++: int) Combination of get_label_num control bits
return: -1 if failed or no label
def get_lvar(self, *args) ‑> lvar_t *
get_lvar(self) -> lvar_t
Get pointer to local variable. If the current item is a local variable, this function will return pointer to its definition.
return: nullptr if failed
def get_memptr(self, *args) ‑> member_t *
get_memptr(self, p_sptr=None) -> member_t *
Get pointer to structure member. If the current item is a structure field, this function will return pointer to its definition.
p_sptr: (C++: struc_t **) pointer to the variable where the pointer to the parent structure
is returned. This parameter can be nullptr.
return: nullptr if failed OBSOLETE FUNCTION, do not use!
def get_udm(self, *args) ‑> int
get_udm(self, udm=None, parent=None, p_offset=None) -> int
Get type of a structure field. If the current item is a structure/union field, this function will return information about it.
udm: (C++: udm_t *) pointer to buffer for the udt member info.
parent: (C++: tinfo_t *) pointer to buffer for the struct/union type.
p_offset: (C++: uint64 *) pointer to the offset in bits inside udt.
return: member index or -1 if failed Both output parameters can be nullptr.
def is_citem(self, *args) ‑> bool
is_citem(self) -> 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
__init__(self, x) -> 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 &
push_back(self) -> citem_t *&
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 &
push_back(self) -> citem_t *&
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 get_block(self, *args) ‑> cblock_t *
get_block(self) -> cblock_t
Get pointer to the parent block of the currently visited item. This function should be called only when the parent is a block.
def recalc_parent_types(self, *args) ‑> bool
recalc_parent_types(self) -> bool
Recalculate type of parent nodes. 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 the traversal must be stopped because the information about parent nodes is stale.
return: false-ok to continue the traversal, true-must stop.

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 property bits
var parents
Vector of parents of the current item.

Methods

def apply_to(self, *args) ‑> int
apply_to(self, item, parent) -> int
Traverse ctree. The traversal will start at the specified item and continue until of one the visit_...() functions return a non-zero value.
item: (C++: citem_t *) root of the ctree to traverse
parent: (C++: citem_t *) parent of the specified item. can be specified as nullptr.
return: 0 or a non-zero value returned by a visit_...() function
def apply_to_exprs(self, *args) ‑> int
apply_to_exprs(self, item, parent) -> 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.
item: (C++: citem_t *) root of the ctree to traverse
parent: (C++: citem_t *) parent of the specified item. can be specified as nullptr.
return: 0 or a non-zero value returned by a visit_...() function
def clr_prune(self, *args) ‑> void
clr_prune(self)
Do not prune children. This is an internal function, no need to call it.
def clr_restart(self, *args) ‑> void
clr_restart(self)
Do not restart. This is an internal function, no need to call it.
def is_postorder(self, *args) ‑> bool
is_postorder(self) -> bool
Should the leave...() functions be called?
def leave_expr(self, *args) ‑> int
leave_expr(self, arg0) -> 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.
arg0: cexpr_t *
return: 0 to continue the traversal, nonzero to stop.
def leave_insn(self, *args) ‑> int
leave_insn(self, arg0) -> 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.
arg0: cinsn_t *
return: 0 to continue the traversal, nonzero to stop.
def maintain_parents(self, *args) ‑> bool
maintain_parents(self) -> bool
Should the parent information by maintained?
def must_prune(self, *args) ‑> bool
must_prune(self) -> bool
Should the traversal skip the children of the current item?
def must_restart(self, *args) ‑> bool
must_restart(self) -> bool
Should the traversal restart?
def only_insns(self, *args) ‑> bool
only_insns(self) -> bool
Should all expressions be automatically pruned?
def parent_expr(self, *args) ‑> cexpr_t *
parent_expr(self) -> cexpr_t
Get parent of the current item as an expression.
def parent_insn(self, *args) ‑> cinsn_t *
parent_insn(self) -> cinsn_t
Get parent of the current item as a statement.
def prune_now(self, *args) ‑> void
prune_now(self)
Prune children. This function may be called by a visitor() to skip all children of the current item.
def set_restart(self, *args) ‑> void
set_restart(self)
Restart the travesal. Meaningful only in apply_to_exprs()
def visit_expr(self, *args) ‑> int
visit_expr(self, arg0) -> 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.
arg0: cexpr_t *
return: 0 to continue the traversal, nonzero to stop.
def visit_insn(self, *args) ‑> int
visit_insn(self, arg0) -> 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.
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
x
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 long long 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
Internal representation of the number.
var nbytes
Original size of the constant in bytes.

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
flags
var name
register or stkvar name
var regnum
if register, the register id
var size
operand size
var stkoff
if stkvar, stack offset

Methods

def append_to_list(self, *args) ‑> bool
append_to_list(self, list, mba) -> bool
Append operand info to LIST. This function converts IDA register number or stack offset to a decompiler list.
list: (C++: mlist_t *) list to append to
mba: (C++: const mba_t *) microcode object
def cvt_to_ivl(self, *args) ‑> vivl_t
cvt_to_ivl(self) -> 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
acquire(self)
Lock the chains.
def for_all_chains(self, *args) ‑> int
for_all_chains(self, cv, gca_flags) -> int
Visit all chains
cv: (C++: chain_visitor_t &) chain visitor
gca_flags: (C++: int) combination of GCA_ bits
def is_locked(self, *args) ‑> bool
is_locked(self) -> 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
release(self)
Unlock the chains.
def swap(self, *args) ‑> void
swap(self, r)
r: graph_chains_t &

Inherited members

class hexrays_failure_t (*args)
Proxy of C++ hexrays_failure_t class.
__init__(self) -> hexrays_failure_t
__init__(self, c, ea, buf=None) -> 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
Microcode error codes
var errea
associated address
var str
string information

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
Address where the warning occurred.
var id
Warning id.
var text
Fully formatted text of the warning.

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
__init__(self, x) -> 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 &
push_back(self) -> hexwarn_t
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
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
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 &
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 &
push_back(self) -> hexwarn_t
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
The entry address of the decompiled function.
var end
BADADDR-decompile function; otherwise end of the range.

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 &
push_back(self) -> history_item_t
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

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=0, _size=0) -> 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: 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: ivl_t const &
def includes(self, *args) ‑> bool
includes(self, ivl) -> bool
ivl: ivl_t const &
def intersect(self, *args) ‑> void
intersect(self, r)
r: ivl_t const &
def overlap(self, *args) ‑> bool
overlap(self, ivl) -> bool
ivl: ivl_t const &

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
var part
part
var whole
whole
class ivlset_t (*args)
Proxy of C++ ivlset_t class.
__init__(self) -> ivlset_t
__init__(self, ivl) -> ivlset_t
ivl: ivl_t const &

Ancestors

Methods

def add(self, *args) ‑> bool
add(self, ivl) -> bool
ivl: ivl_t const &
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: ivlset_t const &
mask: ivl_t const &
def compare(self, *args) ‑> int
compare(self, r) -> int
r: ivlset_t const &
def contains(self, *args) ‑> bool
contains(self, off) -> bool
off: 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: ivl_t const &
strict: bool
has_common(self, ivs) -> bool
ivs: ivlset_t const &
def includes(self, *args) ‑> bool
includes(self, ivs) -> bool
ivs: ivlset_t const &
def intersect(self, *args) ‑> bool
intersect(self, ivs) -> bool
ivs: ivlset_t const &
def sub(self, *args) ‑> bool
sub(self, ivl) -> bool
ivl: ivl_t const &
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
__init__(self, loc, ea) -> lvar_locator_t
loc: vdloc_t const &
ea: ea_t

Subclasses

Instance variables

var defea
Definition address. Usually, this is the address of the instruction that initializes the variable. In some cases it can be a fictional address.
var location
Variable location.

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: lvar_locator_t const &
def get_reg1(self, *args) ‑> mreg_t
get_reg1(self) -> mreg_t
Get the register number of the variable.
def get_reg2(self, *args) ‑> mreg_t
get_reg2(self) -> mreg_t
Get the number of the second register (works only for ALOC_REG2 lvars)
def get_scattered(self, *args) ‑> scattered_aloc_t &
get_scattered(self) -> scattered_aloc_t
def get_stkoff(self, *args) ‑> sval_t
get_stkoff(self) -> sval_t
Get offset of the varialbe in the stack frame.
return: a non-negative value for stack variables. The value is an offset from
the bottom of the stack frame in terms of vd-offsets. negative values mean error (not a stack variable)
def is_reg1(self, *args) ‑> bool
is_reg1(self) -> bool
Is variable located on one register?
def is_reg2(self, *args) ‑> bool
is_reg2(self) -> bool
Is variable located on two registers?
def is_reg_var(self, *args) ‑> bool
is_reg_var(self) -> bool
Is variable located on register(s)?
def is_scattered(self, *args) ‑> bool
is_scattered(self) -> bool
Is variable scattered?
def is_stk_var(self, *args) ‑> bool
is_stk_var(self) -> 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
x
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
index into mba->vars
var mba
Pointer to the parent mba_t object. Since we need to access the 'mba->vars' array in order to retrieve the referenced variable, we keep a pointer to mba_t here. Note: this means this class and consequently mop_t, minsn_t, mblock_t are specific to a mba_t object and cannot migrate between them. fortunately this is not something we need to do. second, lvar_ref_t's appear only after MMAT_LVARS.
var off
offset from the beginning of the variable

Methods

def compare(self, *args) ‑> int
compare(self, r) -> int
r: lvar_ref_t const &
def swap(self, *args) ‑> void
swap(self, r)
r: lvar_ref_t &
def var(self, *args) ‑> lvar_t &
var(self) -> 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
Comment.
var flags
saved user lvar info property bits
var ll
Variable locator.
var name
Name.
var size
Type size (if not initialized then -1)
var type
Type.

Methods

def clear_keep(self, *args) ‑> void
clear_keep(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_split_lvar(self, *args) ‑> void
clr_split_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_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_split_lvar(self, *args) ‑> bool
is_split_lvar(self) -> bool
def is_unused_lvar(self, *args) ‑> bool
is_unused_lvar(self) -> bool
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_split_lvar(self, *args) ‑> void
set_split_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
__init__(self, x) -> 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 &
push_back(self) -> lvar_saved_info_t
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
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
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 &
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 &
push_back(self) -> lvar_saved_info_t
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
__init__(self, loc, ea) -> lvar_locator_t
loc: vdloc_t const &
ea: ea_t

Ancestors

Instance variables

var cmt
variable comment string
var defblk
first block defining the variable. 0 for args, -1 if unknown
var divisor
max known divisor of the variable
var has_nice_name : bool
has_nice_name(self) -> bool
Does the variable have a nice name?
var has_user_info : bool
has_user_info(self) -> bool
Has any user-defined information?
var has_user_name : bool
has_user_name(self) -> bool
Has user-defined name?
var has_user_type : bool
has_user_type(self) -> bool
Has user-defined type?
var is_arg_var : bool
is_arg_var(self) -> bool
Is the function argument?
var is_fake_var : bool
is_fake_var(self) -> bool
Is fake return variable?
var is_floating_var : bool
is_floating_var(self) -> bool
Used by a fpu insn?
var is_mapdst_var : bool
is_mapdst_var(self) -> bool
Other variable(s) map to this var?
var is_overlapped_var : bool
is_overlapped_var(self) -> bool
Is overlapped variable?
var is_result_var : bool
is_result_var(self) -> bool
Is the function result?
var is_spoiled_var : bool
is_spoiled_var(self) -> bool
Is spoiled var? (meaningful only during lvar allocation)
var is_unknown_width : bool
is_unknown_width(self) -> bool
Do we know the width of the variable?
var mreg_done : bool
mreg_done(self) -> bool
Have corresponding microregs been replaced by references to this variable?
var name
variable name. use mba_t::set_nice_lvar_name() and mba_t::set_user_lvar_name() to modify it
var tif
variable type
var typed : bool
typed(self) -> bool
Has the variable a type?
var used : bool
used(self) -> bool
Is the variable used in the code?
var width
variable size in bytes

Methods

def accepts_type(self, *args) ‑> bool
accepts_type(self, t, may_change_thisarg=False) -> bool
Check if the variable accept the specified type. Some types are forbidden (void, function types, wrong arrays, etc)
t: (C++: const tinfo_t &) tinfo_t const &
may_change_thisarg: (C++: bool)
def append_list(self, *args) ‑> void
append_list(self, mba, lst, pad_if_scattered=False)
Append local variable to mlist.
mba: (C++: const mba_t *) ptr to the current mba_t
lst: (C++: mlist_t *) list to append to
pad_if_scattered: (C++: bool) if true, append padding bytes in case of scattered lvar
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_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_shared(self, *args) ‑> void
clr_shared(self)
def clr_split_var(self, *args) ‑> void
clr_split_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
has_common(self, v) -> bool
Do variables overlap?
v: (C++: const lvar_t &) lvar_t const &
def has_common_bit(self, *args) ‑> bool
has_common_bit(self, loc, width2) -> bool
Does the variable overlap with the specified location?
loc: (C++: const vdloc_t &) vdloc_t const &
width2: (C++: asize_t)
def has_regname(self, *args) ‑> bool
has_regname(self) -> bool
Has a register name? (like _RAX)
def in_asm(self, *args) ‑> bool
in_asm(self) -> bool
Is variable used in an instruction translated into __asm?
def is_aliasable(self, *args) ‑> bool
is_aliasable(self, mba) -> bool
Is the variable aliasable?
mba: (C++: const mba_t *) ptr to the current mba_t Aliasable variables may be modified
indirectly (through a pointer)
def is_automapped(self, *args) ‑> bool
is_automapped(self) -> bool
Was the variable automatically mapped to another variable?
def is_decl_unused(self, *args) ‑> bool
is_decl_unused(self) -> bool
Was declared as __unused by the user? See CVAR_UNUSED.
def is_dummy_arg(self, *args) ‑> bool
is_dummy_arg(self) -> bool
Is a dummy argument (added to fill a hole in the argument list)
def is_noptr_var(self, *args) ‑> bool
is_noptr_var(self) -> bool
Variable type should not be a pointer.
def is_notarg(self, *args) ‑> bool
is_notarg(self) -> bool
Is a local variable? (local variable cannot be an input argument)
def is_shared(self, *args) ‑> bool
is_shared(self) -> bool
Is lvar mapped to several chains.
def is_split_var(self, *args) ‑> bool
is_split_var(self) -> bool
Is a split variable?
def is_thisarg(self, *args) ‑> bool
is_thisarg(self) -> bool
Is 'this' argument of a C++ member function?
def is_used_byref(self, *args) ‑> bool
is_used_byref(self) -> 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_lvar_type(self, t)
Set final variable type.
t: (C++: const tinfo_t &) tinfo_t const &
def set_floating_var(self, *args) ‑> void
set_floating_var(self)
def set_lvar_type(self, *args) ‑> bool
set_lvar_type(self, t, may_fail=False) -> 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.
t: (C++: const tinfo_t &) new type
may_fail: (C++: bool) if false and type is bad, interr
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_shared(self, *args) ‑> void
set_shared(self)
def set_split_var(self, *args) ‑> void
set_split_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
set_width(self, w, svw_flags=0) -> 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().
w: (C++: int) new width
svw_flags: (C++: int) combination of SVW_... bits
return: success
def type(self, *args) ‑> tinfo_t &
type(self) -> tinfo_t

Inherited members

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

Instance variables

var lmaps
Local variable mapping (used for merging variables)
var lvvec
User-specified names, types, comments for lvars. Variables without user- specified info are not present in this vector.
var stkoff_delta
Delta to add to IDA stack offset to calculate Hex-Rays stack offsets. Should be set by the caller before calling save_user_lvar_settings();
var ulv_flags
Various flags. Possible values are from lvar_uservec_t property bits.

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_info(self, vloc) -> lvar_saved_info_t
find saved user settings for given var
vloc: (C++: const lvar_locator_t &) lvar_locator_t const &
def keep_info(self, *args) ‑> void
keep_info(self, v)
Preserve user settings for given var.
v: (C++: const lvar_t &) lvar_t const &
def swap(self, *args) ‑> void
swap(self, r)
r: 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(self, ll) -> lvar_t
Find variable at the specified location.
ll: (C++: const lvar_locator_t &) variable location
return: pointer to variable or nullptr
def find_input_lvar(self, *args) ‑> int
find_input_lvar(self, argloc, _size) -> int
Find input variable at the specified location.
argloc: (C++: const vdloc_t &) variable location
_size: (C++: int) variable size
return: -1 if failed, otherwise the index into the variables vector.
def find_lvar(self, *args) ‑> int
find_lvar(self, location, width, defblk=-1) -> int
Find variable at the specified location.
location: (C++: const vdloc_t &) variable location
width: (C++: int) variable size
defblk: (C++: int) definition block of the lvar. -1 means any block
return: -1 if failed, otherwise the index into the variables vector.
def find_stkvar(self, *args) ‑> int
find_stkvar(self, spoff, width) -> int
Find stack variable at the specified location.
spoff: (C++: sval_t) offset from the minimal sp
width: (C++: int) variable size
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
fii
var rii
rii

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: mba_ranges_t const &
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
function to decompile. if not null, then function mode.
var ranges
snippet mode: ranges to decompile. function mode: list of outlined ranges

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
Deserialize a byte sequence into mbl array.
bytes: (C++: const uchar *) pointer to the beginning of the byte sequence.
return: new mbl array

Instance variables

var aliased_args
Aliased stkarg locations.
var aliased_memory
aliased_memory+restricted_memory=ALLMEM
var aliased_vars
Aliased stkvar locations.
var argidx
input arguments (indexes into 'vars')
var blocks
double linked list of blocks
var cc
calling convention
var consumed_argregs
registers converted into stack arguments, should not be used as arguments
var deprecated_idb_node
netnode with additional decompiler info. deprecated, do not use it anymore. it may get stale after undo.
var entry_ea
entry_ea
var error_ea
during microcode generation holds ins.ea
var error_strarg
error_strarg
var final_type
is the function type final? (specified by the user)
var first_epilog_ea
first_epilog_ea
var fpd
frame pointer delta
var frregs
size of saved registers range in the stack frame
var frsize
size of local stkvars range in the stack frame
var fti_flags
FTI_... constants for the current function.
var fullsize
Full stack size including incoming args.
var gotoff_stkvars
stkvars that hold .got offsets. considered to be unaliasable
var idb_node
var idb_spoiled
MBA_SPLINFO && final_type: info in ida format.
var idb_type
function type as retrieved from the database
var inargoff
offset of the first stack argument; after fix_scattered_movs() INARGOFF may be less than STACKSIZE
var label
name of the function or pattern (colored)
var last_prolog_ea
last_prolog_ea
var maturity
current maturity level
var mbr
mbr
var minargref
The lowest stack argument location whose address was taken This location and locations above it can be aliased It controls locations >= inargoff-shadow_args
var minstkref
The lowest stack location whose address was taken.
var minstkref_ea
address with lowest minstkref (for debugging)
var natural
natural order of blocks
var nodel_memory
global dead elimination may not delete references to this area
var notes
notes
var npurged
-1 - unknown
var occurred_warns
occurred_warns
var pfn_flags
copy of func_t::flags
var qty
number of basic blocks
var reqmat
required maturity level
var restricted_memory
restricted_memory
var retsize
size of return address in the stack frame
var retvaridx
index of variable holding the return value -1 means none
var shadow_args
size of shadow argument area
var spd_adjust
If sp>0, the max positive sp value.
var spoiled_list
MBA_SPLINFO && !final_type: info in vd format.
var stacksize
The maximal size of the function stack including bytes allocated for outgoing call arguments (up to retaddr)
var std_ivls
we treat memory as consisting of 6 parts see memreg_index_t
var tmpstk_size
size of the temporary stack part (which dynamically changes with push/pops)
var vars
local variables

Methods

def alloc_fict_ea(self, *args) ‑> ea_t
alloc_fict_ea(self, real_ea) -> 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 LDM
  • another 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.
real_ea: (C++: ea_t) real instruction address (BADADDR is ok too)
return: a unique fictional address
def alloc_kreg(self, *args) ‑> mreg_t
alloc_kreg(self, size, check_size=True) -> mreg_t
Allocate a kernel register.
size: (C++: size_t) size of the register in bytes
check_size: (C++: bool) if true, only the sizes that correspond to a size of a basic
type will be accepted.
return: allocated register. mr_none means failure.
def alloc_lvars(self, *args) ‑> void
alloc_lvars(self)
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(self, acflags) -> int
Analyze calls and determine calling conventions.
acflags: (C++: int) permitted actions that are necessary for successful detection of
calling conventions. See Bits for analyze_calls()
return: number of calls. -1 means error.
def arg(self, *args) ‑> lvar_t const &
arg(self, n) -> lvar_t
n: 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_graph(self) -> 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.
return: error code
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: int
def clr_mba_flags2(self, *args) ‑> void
clr_mba_flags2(self, f)
f: int
def code16_bit_removed(self, *args) ‑> bool
code16_bit_removed(self) -> bool
def combine_blocks(self, *args) ‑> bool
combine_blocks(self) -> bool
Combine blocks. This function merges blocks constituting linear flow. It calls remove_empty_and_unreachable_blocks() as well.
return: true if changed any blocks
def common_stkvars_stkargs(self, *args) ‑> bool
common_stkvars_stkargs(self) -> bool
def copy_block(self, *args) ‑> mblock_t *
copy_block(self, blk, new_serial, cpblk_flags=3) -> 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.
blk: (C++: mblock_t *) block to copy
new_serial: (C++: int) position of the copied block
cpblk_flags: (C++: int) combination of Batch decompilation bits... bits
return: pointer to the new copy
def create_helper_call(self, *args) ‑> minsn_t *
create_helper_call(self, ea, helper, rettype=None, callargs=None, out=None) -> minsn_t
Create a call of a helper function.
ea: (C++: ea_t) The desired address of the instruction
helper: (C++: const char *) The helper name
rettype: (C++: const tinfo_t *) The return type (nullptr or empty type means 'void')
callargs: (C++: const mcallargs_t *) The helper arguments (nullptr-no arguments)
out: (C++: const mop_t *) The operand where the call result should be stored. If this argument
is not nullptr, "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
return: pointer to the created instruction or nullptr 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(self)
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: bool
title: char const *
def find_mop(self, *args) ‑> mop_t *
find_mop(self, ctx, ea, is_dest, list) -> 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.
ctx: (C++: op_parent_info_t *) context information for the result
ea: (C++: ea_t) desired address of the operand. BADADDR means to accept any address.
is_dest: (C++: bool) search for destination operand? this argument may be ignored if
the exact match could not be found
list: (C++: const mlist_t &) list of locations the correspond to the operand
return: pointer to the operand or nullptr.
def for_all_insns(self, *args) ‑> int
for_all_insns(self, mv) -> int
Visit all instructions. This function visits all instruction and subinstructions.
mv: (C++: minsn_visitor_t &) instruction visitor
return: non-zero value returned by mv.visit_mop() or zero
def for_all_ops(self, *args) ‑> int
for_all_ops(self, mv) -> int
Visit all operands of all instructions.
mv: (C++: mop_visitor_t &) operand visitor
return: non-zero value returned by mv.visit_mop() or zero
def for_all_topinsns(self, *args) ‑> int
for_all_topinsns(self, mv) -> int
Visit all top level instructions.
mv: (C++: minsn_visitor_t &) instruction visitor
return: non-zero value returned by mv.visit_mop() or zero
def free_kreg(self, *args) ‑> void
free_kreg(self, reg, size)
Free a kernel register. If wrong arguments are passed, this function will generate an internal error.
reg: (C++: mreg_t) a previously allocated kernel register
size: (C++: size_t) size of the register in bytes
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_func_output_lists(self, *args) ‑> void
get_func_output_lists(self, return_regs, spoiled, type, call_ea=BADADDR, tail_call=False)
Prepare the lists of registers & memory that are defined/killed by a function
return_regs: (C++: mlist_t *) defined regs to return (eax,edx)
spoiled: (C++: mlist_t *) spoiled regs (flags,ecx,mem)
type: (C++: const tinfo_t &) the function type
call_ea: (C++: ea_t) the call insn address (if known)
tail_call: (C++: bool) is it the tail call?
def get_graph(self, *args) ‑> mbl_graph_t *
get_graph(self) -> 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: lvar_t const &
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_mblock(self, n) -> mblock_t
n: 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_std_region(self, idx) -> ivl_t
Get information about various memory regions. We map the stack frame to the global memory, to some unused range.
idx: (C++: memreg_index_t) enum 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_outlines(self, *args) ‑> bool
has_outlines(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: argloc_t const &
width: int
def insert_block(self, *args) ‑> mblock_t *
insert_block(self, bblk) -> 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.
bblk: (C++: int) the new block will be inserted before BBLK
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: lvar_t const &
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
map_fict_ea(self, fict_ea) -> ea_t
Resolve a fictional address. This function provides a reverse of the mapping made by alloc_fict_ea().
fict_ea: (C++: ea_t) fictional definition address
return: the real instruction address
def mark_chains_dirty(self, *args) ‑> void
mark_chains_dirty(self)
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_global(self) -> 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.
return: error code
def optimize_local(self, *args) ‑> int
optimize_local(self, locopt_bits) -> int
Optimize each basic block locally
locopt_bits: (C++: int) combination of Bits for optimize_local() bits
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 prop_complex(self, *args) ‑> bool
prop_complex(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
remove_block(self, blk) -> bool
Delete a block.
blk: (C++: mblock_t *) block to delete
return: true if at least one of the other blocks became empty or unreachable
def remove_empty_and_unreachable_blocks(self, *args) ‑> bool
remove_empty_and_unreachable_blocks(self) -> 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
save_snapshot(self, description)
Create and save microcode snapshot.
description: (C++: const char *) char const *
def saverest_done(self, *args) ‑> bool
saverest_done(self) -> bool
def serialize(self, *args) ‑> void
serialize(self)
Serialize mbl array into a sequence of bytes.
def set_lvar_name(self, *args) ‑> bool
set_lvar_name(self, v, name, flagbits) -> bool
v: lvar_t &
name: char const *
flagbits: int
def set_maturity(self, *args) ‑> bool
set_maturity(self, mat) -> bool
Set maturity level.
mat: (C++: mba_maturity_t) new maturity level
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: int
def set_mba_flags2(self, *args) ‑> void
set_mba_flags2(self, f)
f: int
def set_nice_lvar_name(self, *args) ‑> bool
set_nice_lvar_name(self, v, name) -> bool
v: lvar_t &
name: char const *
def set_user_lvar_name(self, *args) ‑> bool
set_user_lvar_name(self, v, name) -> bool
v: lvar_t &
name: char const *
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: sval_t
def stkoff_vd2ida(self, *args) ‑> sval_t
stkoff_vd2ida(self, off) -> sval_t
off: 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: vdloc_t const &
width: int
spd: sval_t
vd2idaloc(self, loc, width) -> argloc_t
loc: vdloc_t const &
width: int
def verify(self, *args) ‑> void
verify(self, always)
Verify microcode consistency.
always: (C++: bool) 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. If the microcode is inconsistent, this function will generate an internal error. We provide the source code of this function in the plugins/hexrays_sdk/verifier directory for your reference.
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
Deserialize a byte sequence into mbl array.
bytes: (C++: const uchar *) pointer to the beginning of the byte sequence.
return: new mbl array

Instance variables

var aliased_args
Aliased stkarg locations.
var aliased_memory
aliased_memory+restricted_memory=ALLMEM
var aliased_vars
Aliased stkvar locations.
var argidx
input arguments (indexes into 'vars')
var blocks
double linked list of blocks
var cc
calling convention
var consumed_argregs
registers converted into stack arguments, should not be used as arguments
var deprecated_idb_node
netnode with additional decompiler info. deprecated, do not use it anymore. it may get stale after undo.
var entry_ea
entry_ea
var error_ea
during microcode generation holds ins.ea
var error_strarg
error_strarg
var final_type
is the function type final? (specified by the user)
var first_epilog_ea
first_epilog_ea
var fpd
frame pointer delta
var frregs
size of saved registers range in the stack frame
var frsize
size of local stkvars range in the stack frame
var fti_flags
FTI_... constants for the current function.
var fullsize
Full stack size including incoming args.
var gotoff_stkvars
stkvars that hold .got offsets. considered to be unaliasable
var idb_node
var idb_spoiled
MBA_SPLINFO && final_type: info in ida format.
var idb_type
function type as retrieved from the database
var inargoff
offset of the first stack argument; after fix_scattered_movs() INARGOFF may be less than STACKSIZE
var label
name of the function or pattern (colored)
var last_prolog_ea
last_prolog_ea
var maturity
current maturity level
var mbr
mbr
var minargref
The lowest stack argument location whose address was taken This location and locations above it can be aliased It controls locations >= inargoff-shadow_args
var minstkref
The lowest stack location whose address was taken.
var minstkref_ea
address with lowest minstkref (for debugging)
var natural
natural order of blocks
var nodel_memory
global dead elimination may not delete references to this area
var notes
notes
var npurged
-1 - unknown
var occurred_warns
occurred_warns
var pfn_flags
copy of func_t::flags
var qty
number of basic blocks
var reqmat
required maturity level
var restricted_memory
restricted_memory
var retsize
size of return address in the stack frame
var retvaridx
index of variable holding the return value -1 means none
var shadow_args
size of shadow argument area
var spd_adjust
If sp>0, the max positive sp value.
var spoiled_list
MBA_SPLINFO && !final_type: info in vd format.
var stacksize
The maximal size of the function stack including bytes allocated for outgoing call arguments (up to retaddr)
var std_ivls
we treat memory as consisting of 6 parts see memreg_index_t
var tmpstk_size
size of the temporary stack part (which dynamically changes with push/pops)
var vars
local variables

Methods

def alloc_fict_ea(self, *args) ‑> ea_t
alloc_fict_ea(self, real_ea) -> 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 LDM
  • another 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.
real_ea: (C++: ea_t) real instruction address (BADADDR is ok too)
return: a unique fictional address
def alloc_kreg(self, *args) ‑> mreg_t
alloc_kreg(self, size, check_size=True) -> mreg_t
Allocate a kernel register.
size: (C++: size_t) size of the register in bytes
check_size: (C++: bool) if true, only the sizes that correspond to a size of a basic
type will be accepted.
return: allocated register. mr_none means failure.
def alloc_lvars(self, *args) ‑> void
alloc_lvars(self)
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(self, acflags) -> int
Analyze calls and determine calling conventions.
acflags: (C++: int) permitted actions that are necessary for successful detection of
calling conventions. See Bits for analyze_calls()
return: number of calls. -1 means error.
def arg(self, *args) ‑> lvar_t const &
arg(self, n) -> lvar_t
n: 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_graph(self) -> 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.
return: error code
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: int
def clr_mba_flags2(self, *args) ‑> void
clr_mba_flags2(self, f)
f: int
def code16_bit_removed(self, *args) ‑> bool
code16_bit_removed(self) -> bool
def combine_blocks(self, *args) ‑> bool
combine_blocks(self) -> bool
Combine blocks. This function merges blocks constituting linear flow. It calls remove_empty_and_unreachable_blocks() as well.
return: true if changed any blocks
def common_stkvars_stkargs(self, *args) ‑> bool
common_stkvars_stkargs(self) -> bool
def copy_block(self, *args) ‑> mblock_t *
copy_block(self, blk, new_serial, cpblk_flags=3) -> 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.
blk: (C++: mblock_t *) block to copy
new_serial: (C++: int) position of the copied block
cpblk_flags: (C++: int) combination of Batch decompilation bits... bits
return: pointer to the new copy
def create_helper_call(self, *args) ‑> minsn_t *
create_helper_call(self, ea, helper, rettype=None, callargs=None, out=None) -> minsn_t
Create a call of a helper function.
ea: (C++: ea_t) The desired address of the instruction
helper: (C++: const char *) The helper name
rettype: (C++: const tinfo_t *) The return type (nullptr or empty type means 'void')
callargs: (C++: const mcallargs_t *) The helper arguments (nullptr-no arguments)
out: (C++: const mop_t *) The operand where the call result should be stored. If this argument
is not nullptr, "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
return: pointer to the created instruction or nullptr 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(self)
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: bool
title: char const *
def find_mop(self, *args) ‑> mop_t *
find_mop(self, ctx, ea, is_dest, list) -> 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.
ctx: (C++: op_parent_info_t *) context information for the result
ea: (C++: ea_t) desired address of the operand. BADADDR means to accept any address.
is_dest: (C++: bool) search for destination operand? this argument may be ignored if
the exact match could not be found
list: (C++: const mlist_t &) list of locations the correspond to the operand
return: pointer to the operand or nullptr.
def for_all_insns(self, *args) ‑> int
for_all_insns(self, mv) -> int
Visit all instructions. This function visits all instruction and subinstructions.
mv: (C++: minsn_visitor_t &) instruction visitor
return: non-zero value returned by mv.visit_mop() or zero
def for_all_ops(self, *args) ‑> int
for_all_ops(self, mv) -> int
Visit all operands of all instructions.
mv: (C++: mop_visitor_t &) operand visitor
return: non-zero value returned by mv.visit_mop() or zero
def for_all_topinsns(self, *args) ‑> int
for_all_topinsns(self, mv) -> int
Visit all top level instructions.
mv: (C++: minsn_visitor_t &) instruction visitor
return: non-zero value returned by mv.visit_mop() or zero
def free_kreg(self, *args) ‑> void
free_kreg(self, reg, size)
Free a kernel register. If wrong arguments are passed, this function will generate an internal error.
reg: (C++: mreg_t) a previously allocated kernel register
size: (C++: size_t) size of the register in bytes
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_func_output_lists(self, *args) ‑> void
get_func_output_lists(self, return_regs, spoiled, type, call_ea=BADADDR, tail_call=False)
Prepare the lists of registers & memory that are defined/killed by a function
return_regs: (C++: mlist_t *) defined regs to return (eax,edx)
spoiled: (C++: mlist_t *) spoiled regs (flags,ecx,mem)
type: (C++: const tinfo_t &) the function type
call_ea: (C++: ea_t) the call insn address (if known)
tail_call: (C++: bool) is it the tail call?
def get_graph(self, *args) ‑> mbl_graph_t *
get_graph(self) -> 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: lvar_t const &
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_mblock(self, n) -> mblock_t
n: 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_std_region(self, idx) -> ivl_t
Get information about various memory regions. We map the stack frame to the global memory, to some unused range.
idx: (C++: memreg_index_t) enum 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_outlines(self, *args) ‑> bool
has_outlines(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: argloc_t const &
width: int
def insert_block(self, *args) ‑> mblock_t *
insert_block(self, bblk) -> 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.
bblk: (C++: int) the new block will be inserted before BBLK
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: lvar_t const &
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
map_fict_ea(self, fict_ea) -> ea_t
Resolve a fictional address. This function provides a reverse of the mapping made by alloc_fict_ea().
fict_ea: (C++: ea_t) fictional definition address
return: the real instruction address
def mark_chains_dirty(self, *args) ‑> void
mark_chains_dirty(self)
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_global(self) -> 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.
return: error code
def optimize_local(self, *args) ‑> int
optimize_local(self, locopt_bits) -> int
Optimize each basic block locally
locopt_bits: (C++: int) combination of Bits for optimize_local() bits
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 prop_complex(self, *args) ‑> bool
prop_complex(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
remove_block(self, blk) -> bool
Delete a block.
blk: (C++: mblock_t *) block to delete
return: true if at least one of the other blocks became empty or unreachable
def remove_empty_and_unreachable_blocks(self, *args) ‑> bool
remove_empty_and_unreachable_blocks(self) -> 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
save_snapshot(self, description)
Create and save microcode snapshot.
description: (C++: const char *) char const *
def saverest_done(self, *args) ‑> bool
saverest_done(self) -> bool
def serialize(self, *args) ‑> void
serialize(self)
Serialize mbl array into a sequence of bytes.
def set_lvar_name(self, *args) ‑> bool
set_lvar_name(self, v, name, flagbits) -> bool
v: lvar_t &
name: char const *
flagbits: int
def set_maturity(self, *args) ‑> bool
set_maturity(self, mat) -> bool
Set maturity level.
mat: (C++: mba_maturity_t) new maturity level
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: int
def set_mba_flags2(self, *args) ‑> void
set_mba_flags2(self, f)
f: int
def set_nice_lvar_name(self, *args) ‑> bool
set_nice_lvar_name(self, v, name) -> bool
v: lvar_t &
name: char const *
def set_user_lvar_name(self, *args) ‑> bool
set_user_lvar_name(self, v, name) -> bool
v: lvar_t &
name: char const *
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: sval_t
def stkoff_vd2ida(self, *args) ‑> sval_t
stkoff_vd2ida(self, off) -> sval_t
off: 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: vdloc_t const &
width: int
spd: sval_t
vd2idaloc(self, loc, width) -> argloc_t
loc: vdloc_t const &
width: int
def verify(self, *args) ‑> void
verify(self, always)
Verify microcode consistency.
always: (C++: bool) 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. If the microcode is inconsistent, this function will generate an internal error. We provide the source code of this function in the plugins/hexrays_sdk/verifier directory for your reference.
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_du(self, gctype) -> graph_chains_t
Get def-use chains.
gctype: (C++: gctype_t) enum gctype_t
def get_mblock(self, *args) ‑> mblock_t *
get_mblock(self, n) -> mblock_t
n: int
def get_ud(self, *args) ‑> graph_chains_t *
get_ud(self, gctype) -> graph_chains_t
Get use-def chains.
gctype: (C++: gctype_t) enum gctype_t
def is_du_chain_dirty(self, *args) ‑> bool
is_du_chain_dirty(self, gctype) -> bool
Is the def-use chain of the specified kind dirty?
gctype: (C++: gctype_t) enum gctype_t
def is_redefined_globally(self, *args) ‑> bool
is_redefined_globally(self, list, b1, b2, m1, m2, maymust=MAY_ACCESS) -> bool
Is LIST redefined in the graph?
list: (C++: const mlist_t &) mlist_t const &
b1: (C++: int)
b2: (C++: int)
m1: (C++: const minsn_t *) minsn_t const *
m2: (C++: const minsn_t *) minsn_t const *
maymust: (C++: maymust_t)
def is_ud_chain_dirty(self, *args) ‑> bool
is_ud_chain_dirty(self, gctype) -> bool
Is the use-def chain of the specified kind dirty?
gctype: (C++: gctype_t) enum gctype_t
def is_used_globally(self, *args) ‑> bool
is_used_globally(self, list, b1, b2, m1, m2, maymust=MAY_ACCESS) -> bool
Is LIST used in the graph?
list: (C++: const mlist_t &) mlist_t const &
b1: (C++: int)
b2: (C++: int)
m1: (C++: const minsn_t *) minsn_t const *
m2: (C++: const minsn_t *) minsn_t const *
maymust: (C++: maymust_t)

Inherited members

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

Instance variables

var dead_at_start
data that is dead at the block entry
var dnu
data that is defined but not used in the block
var end
end address note: we cannot rely on start/end addresses very much because instructions are propagated between blocks
var flags
combination of Basic block properties bits
var head
pointer to the first instruction of the block
var maxbsp
maximal sp value in the block (0...stacksize)
var maybdef
data that may be defined by the block
var maybuse
data that may be used by the block
var mba
the parent micro block array
var minbargref
the same for arguments
var minbstkref
lowest stack location accessible with indirect addressing (offset from the stack bottom) initially it is 0 (not computed)
var mustbdef
data that must be defined by the block
var mustbuse
data that must be used by the block
var nextb
next block in the doubly linked list
var predset
control flow graph: list of our predecessors use npred() and pred() to access it
var prevb
previous block in the doubly linked list
var serial
block number
var start
start address
var succset
control flow graph: list of our successors use nsucc() and succ() to access it
var tail
pointer to the last instruction of the block
var type
block type (BLT_NONE - not computed yet)

Methods

def append_def_list(self, *args) ‑> void
append_def_list(self, list, op, maymust)
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.
list: (C++: mlist_t *) ptr to the output buffer. we will append to it.
op: (C++: const mop_t &) operand to calculate the def list of
maymust: (C++: maymust_t) should we calculate 'may-def' or 'must-def' list? see maymust_t
for more details.
def append_use_list(self, *args) ‑> void
append_use_list(self, list, op, maymust, mask=bitrange_t(0, USHRT_MAX)) 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.
list: (C++: mlist_t *) ptr to the output buffer. we will append to it.
op: (C++: const mop_t &) operand to calculate the use list of
maymust: (C++: maymust_t) should we calculate 'may-use' or 'must-use' list? see maymust_t
for more details.
mask: (C++: bitrange_t) 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.
def build_def_list(self, *args) ‑> mlist_t
build_def_list(self, ins, maymust) -> 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.
ins: (C++: const minsn_t &) instruction to calculate the def list of
maymust: (C++: maymust_t) should we calculate 'may-def' or 'must-def' list? see maymust_t
for more details.
return: the calculated def-list
def build_lists(self, *args) ‑> int
build_lists(self, kill_deads) -> int
Build def-use lists and eliminate deads.
kill_deads: (C++: bool) do delete dead instructions?
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(self, ins, maymust) -> 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.
ins: (C++: const minsn_t &) instruction to calculate the use list of
maymust: (C++: maymust_t) should we calculate 'may-use' or 'must-use' list? see maymust_t
for more details.
return: the calculated use-list
def dump(self, *args) ‑> void
dump(self)
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: char const *
def empty(self, *args) ‑> bool
empty(self) -> bool
def find_access(self, *args) ‑> minsn_t *
find_access(self, op, parent, mend, fdflags) -> minsn_t
Find the instruction that accesses the specified operand. This function search inside one block.
op: (C++: const mop_t &) operand to search for
parent: (C++: minsn_t **) ptr to ptr to a top level instruction. denotes the beginning of
the search range.
mend: (C++: const minsn_t *) end instruction of the range (must be a top level insn) mend is
excluded from the range. it can be specified as nullptr. parent and mend must belong to the same block.
fdflags: (C++: int) combination of bits for mblock_t::find_access bits
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. nullptr means 'not found'.
def find_def(self, *args) ‑> minsn_t *
find_def(self, op, p_i1, i2, fdflags) -> minsn_t
op: mop_t const &
p_i1: minsn_t **
i2: minsn_t const *
fdflags: int
def find_first_use(self, *args) ‑> minsn_t *
find_first_use(self, list, i1, i2, maymust=MAY_ACCESS) -> minsn_t
list: mlist_t *
i1: minsn_t *
i2: minsn_t const *
maymust: maymust_t
def find_redefinition(self, *args) ‑> minsn_t *
find_redefinition(self, list, i1, i2, maymust=MAY_ACCESS) -> minsn_t
list: mlist_t const &
i1: minsn_t *
i2: minsn_t const *
maymust: maymust_t
def find_use(self, *args) ‑> minsn_t *
find_use(self, op, p_i1, i2, fdflags) -> minsn_t
op: mop_t const &
p_i1: minsn_t **
i2: minsn_t const *
fdflags: int
def for_all_insns(self, *args) ‑> int
for_all_insns(self, mv) -> int
Visit all instructions. This function visits subinstructions too.
mv: (C++: minsn_visitor_t &) instruction visitor
return: zero or the value returned by mv.visit_insn() See also
mba_t::for_all_topinsns()
def for_all_ops(self, *args) ‑> int
for_all_ops(self, mv) -> int
Visit all operands. This function visit subinstruction operands too.
mv: (C++: mop_visitor_t &) operand visitor
return: zero or the value returned by mv.visit_mop()
def for_all_uses(self, *args) ‑> int
for_all_uses(self, list, i1, i2, mmv) -> int
Visit all operands that use LIST.
list: (C++: mlist_t *) ptr to the list of locations. it may be modified: parts that get
redefined by the instructions in [i1,i2) will be deleted.
i1: (C++: minsn_t *) starting instruction. must be a top level insn.
i2: (C++: minsn_t *) ending instruction (excluded). must be a top level insn.
mmv: (C++: mlist_mop_visitor_t &) operand visitor
return: zero or the value returned by mmv.visit_mop()
def get_reginsn_qty(self, *args) ‑> size_t
get_reginsn_qty(self) -> size_t
Calculate number of regular instructions in the block. Assertions are skipped by this function.
return: Number of non-assertion instructions in the block.
def get_valranges(self, *args) ‑> bool
get_valranges(self, res, vivl, vrflags) -> bool
Find possible values for an instruction.
res: (C++: valrng_t *) set of value ranges
vivl: (C++: const vivl_t &) what to search for
vrflags: (C++: int) combination of bits for get_valranges bits
get_valranges(self, res, vivl, m, vrflags) -> bool
res: valrng_t *
vivl: vivl_t const &
m: minsn_t const *
vrflags: int
def insert_into_block(self, *args) ‑> minsn_t *
insert_into_block(self, nm, om) -> minsn_t
Insert instruction into the doubly linked list
nm: (C++: minsn_t *) new instruction
om: (C++: minsn_t *) existing instruction, part of the doubly linked list if nullptr, then
the instruction will be inserted at the beginning of the list NM will be inserted immediately after OM
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_redefined(self, list, i1, i2, maymust=MAY_ACCESS) -> bool
Is the list redefined by the specified instructions?
list: (C++: const mlist_t &) list of locations to check.
i1: (C++: const minsn_t *) starting instruction of the range (must be a top level insn)
i2: (C++: const minsn_t *) end instruction of the range (must be a top level insn) i2 is
excluded from the range. it can be specified as nullptr. i1 and i2 must belong to the same block.
maymust: (C++: maymust_t) should we search in 'may-access' or 'must-access' mode?
def is_rhs_redefined(self, *args) ‑> bool
is_rhs_redefined(self, ins, i1, i2) -> bool
Is the right hand side of the instruction redefined the insn range? "right hand side" corresponds to the source operands of the instruction.
ins: (C++: const minsn_t *) instruction to consider
i1: (C++: const minsn_t *) starting instruction of the range (must be a top level insn)
i2: (C++: const minsn_t *) end instruction of the range (must be a top level insn) i2 is
excluded from the range. it can be specified as nullptr. i1 and i2 must belong to the same block.
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_used(self, list, i1, i2, maymust=MAY_ACCESS) -> bool
Is the list used by the specified instruction range?
list: (C++: mlist_t *) list of locations. LIST may be modified by the function: redefined
locations will be removed from it.
i1: (C++: const minsn_t *) starting instruction of the range (must be a top level insn)
i2: (C++: const minsn_t *) end instruction of the range (must be a top level insn) i2 is
excluded from the range. it can be specified as nullptr. i1 and i2 must belong to the same block.
maymust: (C++: maymust_t) should we search in 'may-access' or 'must-access' mode?
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
make_nop(self, m)
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.
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
npred(self) -> int
Get number of block predecessors.
def nsucc(self, *args) ‑> int
nsucc(self) -> int
Get number of block successors.
def optimize_block(self, *args) ‑> int
optimize_block(self) -> 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.
return: number of changes made to the block
def optimize_insn(self, *args) ‑> int
optimize_insn(self, m, optflags=0x0002|0x0004) -> int
Optimize one instruction in the context of the block.
m: (C++: minsn_t *) pointer to a top level instruction
optflags: (C++: int) combination of optimization flags bits
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
optimize_useless_jump(self) -> 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).
return: number of changes made to the block
def pred(self, *args) ‑> int
pred(self, n) -> int
n: int
def preds(self)
Iterates the list of predecessor blocks
def remove_from_block(self, *args) ‑> minsn_t *
remove_from_block(self, m) -> minsn_t
Remove instruction from the doubly linked list
m: (C++: minsn_t *) instruction to remove The removed instruction is not deleted, the
caller gets its ownership
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: int
def succs(self)
Iterates the list of successor blocks
class mcallarg_t (*args)
Proxy of C++ mcallarg_t class.
__init__(self) -> mcallarg_t
__init__(self, rarg) -> mcallarg_t
rarg: mop_t const &

Ancestors

Instance variables

var argloc
ida argloc
var ea
address where the argument was initialized. BADADDR means unknown.
var flags
FAI_...
var name
formal argument name
var type
formal argument type

Methods

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

Inherited members

class mcallargs_t (*args)
Proxy of C++ qvector< mcallarg_t &