Module `ida_hexrays`

IDA Plugin SDK API wrapper: hexrays

Global variables

var ACFL_BLKOPT: perform interblock transformations
var ACFL_GLBDEL: perform dead code eliminition
var ACFL_GLBPROP: perform global propagation
var ACFL_GUESS: may guess calling conventions
var ACFL_LOCOPT: perform local propagation (requires ACFL_BLKOPT)
var ALLOW_UNUSED_LABELS: ALLOW_UNUSED_LABELS = 1
var ANCHOR_BLKCMT: block comment (for ctree items)
var ANCHOR_CITEM: c-tree item
var ANCHOR_INDEX: ANCHOR_INDEX = 536870911
var ANCHOR_ITP: item type preciser
var ANCHOR_LVAR: declaration of local variable
var ANCHOR_MASK: ANCHOR_MASK = -1073741824
var ANY_FPSIZE: ANY_FPSIZE = 256
var ANY_REGSIZE: ANY_REGSIZE = 128
var BLT_0WAY: BLT_0WAY = 2
var BLT_1WAY: BLT_1WAY = 3
var BLT_2WAY: BLT_2WAY = 4
var BLT_NONE: BLT_NONE = 0
var BLT_NWAY: BLT_NWAY = 5
var BLT_STOP: BLT_STOP = 1
var BLT_XTRN: BLT_XTRN = 6
var CALC_CURLY_BRACES: CALC_CURLY_BRACES = 0
var CALL_SPOILS_ONLY_ARGS: CALL_SPOILS_ONLY_ARGS = 16384
var CFL_FINAL: call type is final, should not be changed
var CFL_HELPER: created from a decompiler helper function
var CFL_NORET: call does not return
var CFS_BOUNDS: 'eamap' and 'boundaries' are ready
var CFS_LOCKED: cfunc is temporarily locked
var CFS_LVARS_HIDDEN: local variable definitions are collapsed
var CFS_TEXT: 'sv' is ready (and hdrlines)
var CHF_FAKE: fake chain created by widen_chains()
var CHF_INITED: is chain initialized? (valid only after lvar allocation)
var CHF_OVER: overlapped chain
var CHF_PASSTHRU: pass-thru chain, must use the input variable to the block
var CHF_REPLACED: chain operands have been replaced?
var CHF_TERM: terminating chain; the variable does not survive across the block
var CIT_COLLAPSED: display element in collapsed form
var CMAT_BUILT: CMAT_BUILT = 1
var CMAT_CASTED: CMAT_CASTED = 7
var CMAT_CPA: CMAT_CPA = 5
var CMAT_FINAL: CMAT_FINAL = 8
var CMAT_NICE: CMAT_NICE = 3
var CMAT_TRANS1: CMAT_TRANS1 = 2
var CMAT_TRANS2: CMAT_TRANS2 = 4
var CMAT_TRANS3: CMAT_TRANS3 = 6
var CMAT_ZERO: CMAT_ZERO = 0
var CMP_A: CMP_A = 4
var CMP_AE: CMP_AE = 2
var CMP_B: CMP_B = 3
var CMP_BE: CMP_BE = 5
var CMP_GE: CMP_GE = 7
var CMP_GT: CMP_GT = 6
var CMP_LE: CMP_LE = 9
var CMP_LT: CMP_LT = 8
var CMP_NZ: CMP_NZ = 0
var CMP_Z: CMP_Z = 1
var CMT_ALL: CMT_ALL = 31
var CMT_BLOCK1: CMT_BLOCK1 = 2
var CMT_BLOCK2: CMT_BLOCK2 = 4
var CMT_FUNC: CMT_FUNC = 16
var CMT_LVAR: CMT_LVAR = 8
var CMT_NONE: CMT_NONE = 0
var CMT_TAIL: CMT_TAIL = 1
var CPBLK_FAST: do not update minbstkref and minbargref
var CPBLK_MINREF: update minbstkref and minbargref
var CPBLK_OPTJMP: del the jump insn at the end of the block if it becomes useless
var CV_FAST: do not maintain parent information
var CV_INSNS: visit only statements, prune all expressions do not use before the final ctree maturity because expressions may contain statements at intermediate stages (see cot_insn). Otherwise you risk missing statements embedded into expressions.
var CV_PARENTS: maintain parent information
var CV_POST: call the leave...() functions
var CV_PRUNE: this bit is set by visit...() to prune the walk
var CV_RESTART: restart enumeration at the top expr (apply_to_exprs)
var DECOMP_ALL_BLKS: generate microcode for unreachable blocks
var DECOMP_NO_CACHE: do not use decompilation cache
var DECOMP_NO_FRAME: do not use function frame info (only snippet mode)
var DECOMP_NO_HIDE: do not close display waitbox. see close_hexrays_waitboxes()
var DECOMP_NO_WAIT: do not display waitbox
var DECOMP_NO_XREFS: do not update global xrefs cache
var DECOMP_WARNINGS: display warnings in the output window
var EQ_CMPDEST: compare instruction destinations
var EQ_IGNCODE: ignore instruction opcodes
var EQ_IGNSIZE: ignore source operand sizes
var EQ_OPTINSN: optimize mop_d operands
var EXCLUDE_PASS_REGS: EXCLUDE_PASS_REGS = 128
var EXCLUDE_VOLATILE: EXCLUDE_VOLATILE = 1024
var EXFL_ALL: all currently defined bits
var EXFL_ALONE: standalone helper
var EXFL_CPADONE: pointer arithmetic correction done
var EXFL_CSTR: string literal
var EXFL_FPOP: floating point operation
var EXFL_JUMPOUT: jump out-of-function
var EXFL_LVALUE: expression is lvalue even if it doesn't look like it
var EXFL_PARTIAL: type of the expression is considered partial
var EXFL_UNDEF: expression uses undefined value
var EXFL_VFTABLE: is ptr to vftable (used for cot_memptr, cot_memref)
var FCI_DEAD: some return registers were determined dead
var FCI_EXPLOCS: all arglocs are specified explicitly
var FCI_FINAL: call type is final, should not be changed
var FCI_HASCALL: A function is an synthetic helper combined from several instructions and at least one of them was a call to a real functions
var FCI_HASFMT: A variadic function with recognized printf- or scanf-style format string
var FCI_NORET: call does not return
var FCI_NOSIDE: call does not have side effects
var FCI_PROP: call has been propagated
var FCI_PURE: pure function
var FCI_SPLOK: spoiled/visible_memory lists have been optimized. for some functions we can reduce them as soon as information about the arguments becomes available. in order not to try optimize them again we use this bit.
var FD_BACKWARD: search direction
var FD_DEF: look for definition
var FD_DIRTY: ignore possible implicit definitions by function calls and indirect memory access
var FD_FORWARD: search direction
var FD_USE: look for use
var FORBID_UNUSED_LABELS: FORBID_UNUSED_LABELS = 0
var FULL_XDSU: FULL_XDSU = 256
var FUNC_NAME_CONTAINING_RECORD: FUNC_NAME_CONTAINING_RECORD = 'CONTAINING_RECORD'
var FUNC_NAME_EMPTY: FUNC_NAME_EMPTY = '$empty'
var FUNC_NAME_MEMCPY: FUNC_NAME_MEMCPY = 'memcpy'
var FUNC_NAME_MEMSET: FUNC_NAME_MEMSET = 'memset'
var FUNC_NAME_MEMSET32: FUNC_NAME_MEMSET32 = 'memset32'
var FUNC_NAME_MEMSET64: FUNC_NAME_MEMSET64 = 'memset64'
var FUNC_NAME_PRESENT: FUNC_NAME_PRESENT = '$present'
var FUNC_NAME_STRCAT: FUNC_NAME_STRCAT = 'strcat'
var FUNC_NAME_STRCPY: FUNC_NAME_STRCPY = 'strcpy'
var FUNC_NAME_STRLEN: FUNC_NAME_STRLEN = 'strlen'
var FUNC_NAME_TAIL: FUNC_NAME_TAIL = 'tail'
var FUNC_NAME_VA_ARG: FUNC_NAME_VA_ARG = 'va_arg'
var FUNC_NAME_WCSCAT: FUNC_NAME_WCSCAT = 'wcscat'
var FUNC_NAME_WCSCPY: FUNC_NAME_WCSCPY = 'wcscpy'
var FUNC_NAME_WCSLEN: FUNC_NAME_WCSLEN = 'wcslen'
var FUNC_NAME_WMEMCPY: FUNC_NAME_WMEMCPY = 'wmemcpy'
var FUNC_NAME_WMEMSET: FUNC_NAME_WMEMSET = 'wmemset'
var GCA_ALLOC: enumerate only allocated chains
var GCA_EMPTY: include empty chains
var GCA_NALLOC: enumerate only non-allocated chains
var GCA_OFIRST: consider only chains of the first block
var GCA_OLAST: consider only chains of the last block
var GCA_SPEC: include chains for special registers
var GCO_DEF: is destination operand?
var GCO_REG: is register? otherwise a stack variable
var GCO_STK: a stack variable
var GCO_USE: is source operand?
var GC_ASR: GC_ASR = 1
var GC_DIRTY_ALL: GC_DIRTY_ALL = 63
var GC_END: GC_END = 3
var GC_REGS_AND_STKVARS: GC_REGS_AND_STKVARS = 0
var GC_XDSU: GC_XDSU = 2
var GLN_ALL: get both
var GLN_CURRENT: get label of the current item
var GLN_GOTO_TARGET: get goto target
var GUESSED_DATA: GUESSED_DATA = 3
var GUESSED_FUNC: GUESSED_FUNC = 2
var GUESSED_NONE: GUESSED_NONE = 0
var GUESSED_WEAK: GUESSED_WEAK = 1
var HEXRAYS_API_MAGIC: HEXRAYS_API_MAGIC = 62699504545038339
var INCLUDE_DEAD_RETREGS: INCLUDE_DEAD_RETREGS = 4096
var INCLUDE_RESTRICTED: INCLUDE_RESTRICTED = 8192
var INCLUDE_SPOILED_REGS: INCLUDE_SPOILED_REGS = 64
var INCLUDE_UNUSED_SRC: INCLUDE_UNUSED_SRC = 2048
var IPROP_ASSERT: assertion: usually mov #val, op. assertions are used to help the optimizer. assertions are ignored when generating ctree
var IPROP_CLNPOP: the purpose of the instruction is to clean stack (e.g. "pop ecx" is often used for that)
var IPROP_COMBINED: insn has been modified because of a partial reference
var IPROP_DONT_COMB: may not combine this instruction with others
var IPROP_DONT_PROP: may not propagate
var IPROP_EXTSTX: this is m_ext propagated into m_stx
var IPROP_FARCALL: call of a far function using push cs/call sequence
var IPROP_FPINSN: floating point insn
var IPROP_IGNLOWSRC: low part of the instruction source operand has been created artificially (this bit is used only for 'and x, 80...')
var IPROP_INV_JX: inverted conditional jump
var IPROP_MBARRIER: this instruction acts as a memory barrier (instructions accessing memory may not be reordered past it)
var IPROP_MULTI_MOV: bits that can be set by plugins:

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

Functions

def accepts_small_udts(*args) ‑> bool: Is the operator allowed on small structure or union?

accepts_small_udts(op) -> bool
op (C++: ctype_t)
def accepts_udts(*args) ‑> bool: accepts_udts(op) -> bool
op (C++: ctype_t)
def arglocs_overlap(*args) ‑> bool: Do two arglocs overlap?

arglocs_overlap(loc1, w1, loc2, w2) -> bool
loc1 (C++: const vdloc_t &)

w1 (C++: size_t)

loc2 (C++: const vdloc_t &)

w2 (C++: size_t)
def asgop(*args) ‑> ctype_t: Convert plain operator into assignment operator. For example, cot_add returns cot_asgadd.

asgop(cop) -> ctype_t
cop (C++: ctype_t)
def asgop_revert(*args) ‑> ctype_t: Convert assignment operator into plain operator. For example, cot_asgadd returns cot_add

asgop_revert(cop) -> ctype_t
cop (C++: ctype_t)

return: cot_empty is the input operator is not an assignment
operator.
def block_chains_begin(*args) ‑> block_chains_iterator_t: Get iterator pointing to the beginning of 'block_chains_t' .

block_chains_begin(set) -> block_chains_iterator_t
set (C++: const block_chains_t *)
def block_chains_clear(*args) ‑> void: Clear 'block_chains_t' .

block_chains_clear(set)
set (C++: block_chains_t *)
def block_chains_end(*args) ‑> block_chains_iterator_t: Get iterator pointing to the end of 'block_chains_t' .

block_chains_end(set) -> block_chains_iterator_t
set (C++: const block_chains_t *)
def block_chains_erase(*args) ‑> void: Erase current element from 'block_chains_t' .

block_chains_erase(set, p)
set (C++: block_chains_t *)

p (C++: block_chains_iterator_t)
def block_chains_find(*args) ‑> block_chains_iterator_t: Find the specified key in set 'block_chains_t' .

block_chains_find(set, val) -> block_chains_iterator_t
set (C++: const block_chains_t *)

val (C++: const chain_t &)
def block_chains_free(*args) ‑> void: Delete 'block_chains_t' instance.

block_chains_free(set)
set (C++: block_chains_t *)
def block_chains_get(*args) ‑> chain_t &: Get reference to the current set value.

block_chains_get(p) -> chain_t
p (C++: block_chains_iterator_t)
def block_chains_insert(*args) ‑> block_chains_iterator_t: Insert new ( 'chain_t' ) into set 'block_chains_t' .

block_chains_insert(set, val) -> block_chains_iterator_t
set (C++: block_chains_t *)

val (C++: const chain_t &)
def block_chains_new(*args) ‑> block_chains_t *: Create a new 'block_chains_t' instance.
def block_chains_next(*args) ‑> block_chains_iterator_t: Move to the next element.

block_chains_next(p) -> block_chains_iterator_t
p (C++: block_chains_iterator_t)
def block_chains_prev(*args) ‑> block_chains_iterator_t: Move to the previous element.

block_chains_prev(p) -> block_chains_iterator_t
p (C++: block_chains_iterator_t)
def block_chains_size(*args) ‑> size_t: Get size of 'block_chains_t' .

block_chains_size(set) -> size_t
set (C++: block_chains_t *)
def boundaries_begin(*args) ‑> boundaries_iterator_t: Get iterator pointing to the beginning of boundaries_t.

boundaries_begin(map) -> boundaries_iterator_t
map (C++: const boundaries_t *)
def boundaries_clear(*args) ‑> void: Clear boundaries_t.

boundaries_clear(map)
map (C++: boundaries_t *)
def boundaries_end(*args) ‑> boundaries_iterator_t: Get iterator pointing to the end of boundaries_t.

boundaries_end(map) -> boundaries_iterator_t
map (C++: const boundaries_t *)
def boundaries_erase(*args) ‑> void: Erase current element from boundaries_t.

boundaries_erase(map, p)
map (C++: boundaries_t *)

p (C++: boundaries_iterator_t)
def boundaries_find(*args) ‑> boundaries_iterator_t: Find the specified key in boundaries_t.

boundaries_find(map, key) -> boundaries_iterator_t
map (C++: const boundaries_t *)

key (C++: const cinsn_t *&)
def boundaries_first(*args) ‑> cinsn_t *const &: Get reference to the current map key.

boundaries_first(p) -> cinsn_t
p (C++: boundaries_iterator_t)
def boundaries_free(*args) ‑> void: Delete boundaries_t instance.

boundaries_free(map)
map (C++: boundaries_t *)
def boundaries_insert(*args) ‑> boundaries_iterator_t: Insert new ( 'cinsn_t' *, 'rangeset_t' ) pair into boundaries_t.

boundaries_insert(map, key, val) -> boundaries_iterator_t
map (C++: boundaries_t *)

key (C++: const cinsn_t *&)

val (C++: const rangeset_t &)
def boundaries_new(*args) ‑> boundaries_t *: Create a new boundaries_t instance.
def boundaries_next(*args) ‑> boundaries_iterator_t: Move to the next element.

boundaries_next(p) -> boundaries_iterator_t
p (C++: boundaries_iterator_t)
def boundaries_prev(*args) ‑> boundaries_iterator_t: Move to the previous element.

boundaries_prev(p) -> boundaries_iterator_t
p (C++: boundaries_iterator_t)
def boundaries_second(*args) ‑> rangeset_t &: Get reference to the current map value.

boundaries_second(p) -> rangeset_t
p (C++: boundaries_iterator_t)
def boundaries_size(*args) ‑> size_t: Get size of boundaries_t.

boundaries_size(map) -> size_t
map (C++: boundaries_t *)
def call_helper(rettype, args, *rest)
def cexpr_operands(self): return a dictionary with the operands of a cexpr_t.
def cfunc_type(self): Get the function's return type tinfo_t object.
def checkout_hexrays_license(*args) ‑> bool: Check out a floating decompiler license. This function will display a dialog box if the license is not available. For non-floating licenses this function is effectively no-op. It is not necessary to call this function before decompiling. If the license was not checked out, the decompiler will automatically do it. This function can be used to check out a license in advance and ensure that a license is available.

checkout_hexrays_license(silent) -> bool
silent: silently fail if the license cannot be checked out.
(C++: bool)

return: false if failed
def cinsn_details(self): return the details pointer for the cinsn_t object depending on the value of its op member. this is one of the cblock_t, cif_t, etc. objects.
def cinsn_t_insn_is_epilog(*args) ‑> bool: cinsn_t_insn_is_epilog(insn) -> bool
insn: cinsn_t const *
def citem_to_specific_type(self): cast the citem_t object to its more specific type, either cexpr_t or cinsn_t.
def clear_cached_cfuncs(*args) ‑> void: Flush all cached decompilation results.
def close_hexrays_waitbox(*args) ‑> void: Close the waitbox displayed by the decompiler. Useful if DECOMP_NO_HIDE was used during decompilation.
def close_pseudocode(*args) ‑> bool: Close pseudocode window.

close_pseudocode(f) -> bool
f: pointer to window (C++: TWidget *)

return: false if failed
def convert_to_user_call(*args) ‑> merror_t: try to generate user-defined call for an instruction

convert_to_user_call(udc, cdg) -> merror_t
udc (C++: const udcall_t &)

cdg (C++: codegen_t &)

return: Microcode error codes code: MERR_OK - user-defined call
generated else - error (MERR_INSN == inacceptable udc.tif)
def create_cfunc(*args) ‑> cfuncptr_t: Create a new 'cfunc_t' object.

create_cfunc(mba) -> cfuncptr_t
mba: microcode object. After creating the cfunc object it takes
the ownership of MBA. (C++: mba_t *)
def create_field_name(*args) ‑> qstring: create_field_name(type, offset=BADADDR) -> qstring
type (C++: const tinfo_t &)

offset (C++: uval_t)
def create_helper(*args)
def create_typedef(*args) ‑> tinfo_t: Create a reference to a named type.

create_typedef(name) -> tinfo_t
name: type name (C++: const char *)

return: type which refers to the specified ordinal. For example, if n
is 1, the type info which refers to ordinal type 1 is created.

create_typedef(n) -> tinfo_t
n: int

return: type which refers to the specified ordinal. For example, if n
is 1, the type info which refers to ordinal type 1 is created.
def debug_hexrays_ctree(*args) ‑> void: debug_hexrays_ctree(level, msg)
level: int msg: char const *
def decompile(ea, hf=None, flags=0)
def decompile_func(*args) ‑> cfuncptr_t: Decompile a function. Multiple decompilations of the same function return the same object.

decompile_func(pfn, hf, decomp_flags=0) -> cfuncptr_t
pfn: pointer to function to decompile (C++: func_t *)

hf: extended error information (if failed) (C++:
hexrays_failure_t *)

decomp_flags: bitwise combination of decompile() flags ...
bits (C++: int)

return: pointer to the decompilation result (a reference counted
pointer). NULL if failed.
def decompile_many(*args) ‑> bool: Batch decompilation. Decompile all or the specified functions

decompile_many(outfile, funcaddrs, flags) -> bool
outfile: name of the output file (C++: const char *)

funcaddrs: list of functions to decompile. If NULL or empty,
then decompile all nonlib functions (C++: const eavec_t *)

flags: Batch decompilation bits (C++: int)

return: true if no internal error occurred and the user has not
cancelled decompilation
def dereference(e, ptrsize, is_float=False)
def dstr(*args) ‑> char const *: Print the specified type info. This function can be used from a debugger by typing "tif->dstr()"

dstr(tif) -> char const *
tif (C++: const tinfo_t *)
def dummy_ptrtype(*args) ‑> tinfo_t: Generate a dummy pointer type

dummy_ptrtype(ptrsize, isfp) -> tinfo_t
ptrsize: size of pointed object (C++: int)

isfp: is floating point object? (C++: bool)
def eamap_begin(*args) ‑> eamap_iterator_t: Get iterator pointing to the beginning of eamap_t.

eamap_begin(map) -> eamap_iterator_t
map (C++: const eamap_t *)
def eamap_clear(*args) ‑> void: Clear eamap_t.

eamap_clear(map)
map (C++: eamap_t *)
def eamap_end(*args) ‑> eamap_iterator_t: Get iterator pointing to the end of eamap_t.

eamap_end(map) -> eamap_iterator_t
map (C++: const eamap_t *)
def eamap_erase(*args) ‑> void: Erase current element from eamap_t.

eamap_erase(map, p)
map (C++: eamap_t *)

p (C++: eamap_iterator_t)
def eamap_find(*args) ‑> eamap_iterator_t: Find the specified key in eamap_t.

eamap_find(map, key) -> eamap_iterator_t
map (C++: const eamap_t *)

key (C++: const ea_t &)
def eamap_first(*args) ‑> ea_t const &: Get reference to the current map key.

eamap_first(p) -> ea_t const &
p (C++: eamap_iterator_t)
def eamap_free(*args) ‑> void: Delete eamap_t instance.

eamap_free(map)
map (C++: eamap_t *)
def eamap_insert(*args) ‑> eamap_iterator_t: Insert new (ea_t, cinsnptrvec_t) pair into eamap_t.

eamap_insert(map, key, val) -> eamap_iterator_t
map (C++: eamap_t *)

key (C++: const ea_t &)

val (C++: const cinsnptrvec_t &)
def eamap_new(*args) ‑> eamap_t *: Create a new eamap_t instance.
def eamap_next(*args) ‑> eamap_iterator_t: Move to the next element.

eamap_next(p) -> eamap_iterator_t
p (C++: eamap_iterator_t)
def eamap_prev(*args) ‑> eamap_iterator_t: Move to the previous element.

eamap_prev(p) -> eamap_iterator_t
p (C++: eamap_iterator_t)
def eamap_second(*args) ‑> cinsnptrvec_t &: Get reference to the current map value.

eamap_second(p) -> cinsnptrvec_t
p (C++: eamap_iterator_t)
def eamap_size(*args) ‑> size_t: Get size of eamap_t.

eamap_size(map) -> size_t
map (C++: eamap_t *)
def gen_microcode(*args) ‑> mba_t *: Generate microcode of an arbitrary code snippet

gen_microcode(mbr, hf, retlist=None, decomp_flags=0, reqmat=MMAT_GLBOPT3) -> mba_t
mbr: snippet ranges (C++: const mba_ranges_t &)

hf: extended error information (if failed) (C++:
hexrays_failure_t *)

retlist: list of registers the snippet returns (C++: const
mlist_t *)

decomp_flags: bitwise combination of decompile() flags ...
bits (C++: int)

reqmat: required microcode maturity (C++: mba_maturity_t)

return: pointer to the microcode, NULL if failed.
def get_ctype_name(*args) ‑> char const *: get_ctype_name(op) -> char const *
op (C++: ctype_t)
def get_current_operand(*args) ‑> bool: Get the instruction operand under the cursor. This function determines the operand that is under the cursor in the active disassembly listing. If the operand refers to a register or stack variable, it returns true.

get_current_operand(out) -> bool
out (C++: gco_info_t *)
def get_float_type(*args) ‑> tinfo_t: Get a type of a floating point value with the specified width

get_float_type(width) -> tinfo_t
width: width of the desired type (C++: int)

return: type info object
def get_hexrays_version(*args) ‑> char const *: Get decompiler version. The returned string is of the form <major>.<minor>.<revision>.<build-date>
def get_int_type_by_width_and_sign(*args) ‑> tinfo_t: Create a type info by width and sign. Returns a simple type (examples: int, short) with the given width and sign.

get_int_type_by_width_and_sign(srcwidth, sign) -> tinfo_t
srcwidth: size of the type in bytes (C++: int)

sign: sign of the type (C++: type_sign_t)
def get_member_type(*args) ‑> bool: Get type of a structure field. This function performs validity checks of the field type. Wrong types are rejected.

get_member_type(mptr, type) -> bool
mptr: structure field (C++: const member_t *)

type: pointer to the variable where the type is returned. This
parameter can be NULL. (C++: tinfo_t *)

return: false if failed
def get_merror_desc(*args) ‑> qstring *: Get textual description of an error code

get_merror_desc(code, mba) -> str
code: Microcode error codes (C++: merror_t)

mba: the microcode array (C++: mba_t *)

return: the error address
def get_mreg_name(*args) ‑> qstring *: Get the microregister name.

get_mreg_name(reg, width, ud=None) -> str
reg (C++: mreg_t)

width: size of microregister in bytes. may be bigger than the
real register size. (C++: int)

ud: reserved, must be nullptr (C++: void *)

return: width of the printed register. this value may be less than
the WIDTH argument.
def get_op_signness(*args) ‑> type_sign_t: Get operator sign. Meaningful for sign-dependent operators, like cot_sdiv.

get_op_signness(op) -> type_sign_t
op (C++: ctype_t)
def get_signed_mcode(*args) ‑> mcode_t: get_signed_mcode(code) -> mcode_t
code (C++: mcode_t)
def get_temp_regs(*args) ‑> mlist_t const &: Get list of temporary registers. Tempregs are temporary registers that are used during code generation. They do not map to regular processor registers. They are used only to store temporary values during execution of one instruction. Tempregs may not be used to pass a value from one block to another. In other words, at the end of a block all tempregs must be dead.
def get_type(*args) ‑> bool: Get a global type. Global types are types of addressable objects and struct/union/enum types

get_type(id, tif, guess) -> bool
id: address or id of the object (C++: uval_t)

tif: buffer for the answer (C++: tinfo_t *)

guess: what kind of types to consider (C++: type_source_t)

return: success
def get_unk_type(*args) ‑> tinfo_t: Create a partial type info by width. Returns a partially defined type (examples: _DWORD, _BYTE) with the given width.

get_unk_type(size) -> tinfo_t
size: size of the type in bytes (C++: int)
def get_unsigned_mcode(*args) ‑> mcode_t: get_unsigned_mcode(code) -> mcode_t
code (C++: mcode_t)
def get_widget_vdui(*args) ‑> vdui_t *: Get the 'vdui_t' instance associated to the TWidget

get_widget_vdui(f) -> vdui_t
f: pointer to window (C++: TWidget *)

return: a vdui_t *, or NULL
def getb_reginsn(*args) ‑> minsn_t *: Skip assertions backward.

getb_reginsn(ins) -> minsn_t
ins (C++: const minsn_t *)
def getf_reginsn(*args) ‑> minsn_t *: Skip assertions forward.

getf_reginsn(ins) -> minsn_t
ins (C++: const minsn_t *)
def has_cached_cfunc(*args) ‑> bool: Do we have a cached decompilation result for 'ea'?

has_cached_cfunc(ea) -> bool
ea (C++: ea_t)
def has_mcode_seloff(*args) ‑> bool: has_mcode_seloff(op) -> bool
op (C++: mcode_t)
def hexrays_alloc(*args) ‑> void *: hexrays_alloc(size) -> void *
size (C++: size_t)
def hexrays_free(*args) ‑> void: hexrays_free(ptr)
ptr (C++: void *)
def init_hexrays_plugin(*args) ‑> bool: Check that your plugin is compatible with hex-rays decompiler. This function must be called before calling any other decompiler function.

init_hexrays_plugin(flags=0) -> bool
flags: reserved, must be 0 (C++: int)

return: true if the decompiler exists and is compatible with your
plugin
def install_hexrays_callback(callback): Deprecated. Please use Hexrays_Hooks instead
def install_microcode_filter(*args) ‑> bool: register/unregister non-standard microcode generator

install_microcode_filter(filter, install=True) -> bool
filter: - microcode generator object (C++: microcode_filter_t
*)

install: - TRUE - register the object, FALSE - unregister (C++:
bool)

return: success
def is_additive(*args) ‑> bool: Is additive operator?

is_additive(op) -> bool
op (C++: ctype_t)
def is_allowed_on_small_struni(*args) ‑> bool: Is the operator allowed on small structure or union?

accepts_small_udts(op) -> bool
op (C++: ctype_t)
def is_assignment(*args) ‑> bool: Is assignment operator?

is_assignment(op) -> bool
op (C++: ctype_t)
def is_binary(*args) ‑> bool: Is binary operator?

is_binary(op) -> bool
op (C++: ctype_t)
def is_bitop(*args) ‑> bool: Is bit related operator?

is_bitop(op) -> bool
op (C++: ctype_t)
def is_bool_type(*args) ‑> bool: Is a boolean type?

is_bool_type(type) -> bool
type (C++: const tinfo_t &)

return: true if the type is a boolean type
def is_break_consumer(*args) ‑> bool: Does a break statement influence the specified statement code?

is_break_consumer(op) -> bool
op (C++: ctype_t)
def is_commutative(*args) ‑> bool: Is commutative operator?

is_commutative(op) -> bool
op (C++: ctype_t)
def is_inplace_def(*args) ‑> bool: Is struct/union/enum definition (not declaration)?

is_inplace_def(type) -> bool
type (C++: const tinfo_t &)
def is_kreg(*args) ‑> bool: Is a kernel register? Kernel registers are temporary registers that can be used freely. They may be used to store values that cross instruction or basic block boundaries. Kernel registers do not map to regular processor registers. See also 'mba_t::alloc_kreg()'

is_kreg(r) -> bool
r (C++: mreg_t)
def is_logical(*args) ‑> bool: Is logical operator?

is_logical(op) -> bool
op (C++: ctype_t)
def is_loop(*args) ‑> bool: Is loop statement code?

is_loop(op) -> bool
op (C++: ctype_t)
def is_lvalue(*args) ‑> bool: Is Lvalue operator?

is_lvalue(op) -> bool
op (C++: ctype_t)
def is_may_access(*args) ‑> bool: is_may_access(maymust) -> bool
maymust (C++: maymust_t)
def is_mcode_addsub(*args) ‑> bool: is_mcode_addsub(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_call(*args) ‑> bool: is_mcode_call(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_commutative(*args) ‑> bool: is_mcode_commutative(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_convertible_to_jmp(*args) ‑> bool: is_mcode_convertible_to_jmp(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_convertible_to_set(*args) ‑> bool: is_mcode_convertible_to_set(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_divmod(*args) ‑> bool: is_mcode_divmod(op) -> bool
op (C++: mcode_t)
def is_mcode_fpu(*args) ‑> bool: is_mcode_fpu(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_j1(*args) ‑> bool: is_mcode_j1(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_jcond(*args) ‑> bool: is_mcode_jcond(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_propagatable(*args) ‑> bool: May opcode be propagated? Such opcodes can be used in sub-instructions (nested instructions) There is a handful of non-propagatable opcodes, like jumps, ret, nop, etc All other regular opcodes are propagatable and may appear in a nested instruction.

is_mcode_propagatable(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_set(*args) ‑> bool: is_mcode_set(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_set1(*args) ‑> bool: is_mcode_set1(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_shift(*args) ‑> bool: is_mcode_shift(mcode) -> bool
mcode (C++: mcode_t)
def is_mcode_xdsu(*args) ‑> bool: is_mcode_xdsu(mcode) -> bool
mcode (C++: mcode_t)
def is_multiplicative(*args) ‑> bool: Is multiplicative operator?

is_multiplicative(op) -> bool
op (C++: ctype_t)
def is_nonbool_type(*args) ‑> bool: Is definitely a non-boolean type?

is_nonbool_type(type) -> bool
type (C++: const tinfo_t &)

return: true if the type is a non-boolean type (non bool and well
defined)
def is_paf(*args) ‑> bool: Is a pointer, array, or function type?

is_paf(t) -> bool
t (C++: type_t)
def is_prepost(*args) ‑> bool: Is pre/post increment/decrement operator?

is_prepost(op) -> bool
op (C++: ctype_t)
def is_ptr_or_array(*args) ‑> bool: Is a pointer or array type?

is_ptr_or_array(t) -> bool
t (C++: type_t)
def is_relational(*args) ‑> bool: Is comparison operator?

is_relational(op) -> bool
op (C++: ctype_t)
def is_signed_mcode(*args) ‑> bool: is_signed_mcode(code) -> bool
code (C++: mcode_t)
def is_small_struni(*args) ‑> bool: Is a small structure or union?

is_small_udt(tif) -> bool
tif (C++: const tinfo_t &)

return: true if the type is a small UDT (user defined type). Small
UDTs fit into a register (or pair or registers) as a rule.
def is_small_udt(*args) ‑> bool: Is a small structure or union?

is_small_udt(tif) -> bool
tif (C++: const tinfo_t &)

return: true if the type is a small UDT (user defined type). Small
UDTs fit into a register (or pair or registers) as a rule.
def is_type_correct(*args) ‑> bool: Verify a type string.

is_type_correct(ptr) -> bool
ptr (C++: const type_t *)

return: true if type string is correct
def is_unary(*args) ‑> bool: Is unary operator?

is_unary(op) -> bool
op (C++: ctype_t)
def is_unsigned_mcode(*args) ‑> bool: is_unsigned_mcode(code) -> bool
code (C++: mcode_t)
def jcnd2set(*args) ‑> mcode_t: jcnd2set(code) -> mcode_t
code (C++: mcode_t)
def lexcompare(*args) ‑> int: lexcompare(a, b) -> int
a: mop_t const & b: mop_t const &
def lnot(e)
def locate_lvar(*args) ‑> bool: Find a variable by name.

locate_lvar(out, func_ea, varname) -> bool
out: output buffer for the variable locator (C++:
lvar_locator_t *)

func_ea: function start address (C++: ea_t)

varname: variable name (C++: const char *)

return: success Since VARNAME is not always enough to find the
variable, it may decompile the function.
def lvar_mapping_begin(*args) ‑> lvar_mapping_iterator_t: Get iterator pointing to the beginning of lvar_mapping_t.

lvar_mapping_begin(map) -> lvar_mapping_iterator_t
map (C++: const lvar_mapping_t *)
def lvar_mapping_clear(*args) ‑> void: Clear lvar_mapping_t.

lvar_mapping_clear(map)
map (C++: lvar_mapping_t *)
def lvar_mapping_end(*args) ‑> lvar_mapping_iterator_t: Get iterator pointing to the end of lvar_mapping_t.

lvar_mapping_end(map) -> lvar_mapping_iterator_t
map (C++: const lvar_mapping_t *)
def lvar_mapping_erase(*args) ‑> void: Erase current element from lvar_mapping_t.

lvar_mapping_erase(map, p)
map (C++: lvar_mapping_t *)

p (C++: lvar_mapping_iterator_t)
def lvar_mapping_find(*args) ‑> lvar_mapping_iterator_t: Find the specified key in lvar_mapping_t.

lvar_mapping_find(map, key) -> lvar_mapping_iterator_t
map (C++: const lvar_mapping_t *)

key (C++: const lvar_locator_t &)
def lvar_mapping_first(*args) ‑> lvar_locator_t const &: Get reference to the current map key.

lvar_mapping_first(p) -> lvar_locator_t
p (C++: lvar_mapping_iterator_t)
def lvar_mapping_free(*args) ‑> void: Delete lvar_mapping_t instance.

lvar_mapping_free(map)
map (C++: lvar_mapping_t *)
def lvar_mapping_insert(*args) ‑> lvar_mapping_iterator_t: Insert new ( 'lvar_locator_t' , 'lvar_locator_t' ) pair into lvar_mapping_t.

lvar_mapping_insert(map, key, val) -> lvar_mapping_iterator_t
map (C++: lvar_mapping_t *)

key (C++: const lvar_locator_t &)

val (C++: const lvar_locator_t &)
def lvar_mapping_new(*args) ‑> lvar_mapping_t *: Create a new lvar_mapping_t instance.
def lvar_mapping_next(*args) ‑> lvar_mapping_iterator_t: Move to the next element.

lvar_mapping_next(p) -> lvar_mapping_iterator_t
p (C++: lvar_mapping_iterator_t)
def lvar_mapping_prev(*args) ‑> lvar_mapping_iterator_t: Move to the previous element.

lvar_mapping_prev(p) -> lvar_mapping_iterator_t
p (C++: lvar_mapping_iterator_t)
def lvar_mapping_second(*args) ‑> lvar_locator_t &: Get reference to the current map value.

lvar_mapping_second(p) -> lvar_locator_t
p (C++: lvar_mapping_iterator_t)
def lvar_mapping_size(*args) ‑> size_t: Get size of lvar_mapping_t.

lvar_mapping_size(map) -> size_t
map (C++: lvar_mapping_t *)
def make_num(*args)
def make_pointer(*args) ‑> tinfo_t: Create a pointer type. This function performs the following conversion: "type" -> "type*"

make_pointer(type) -> tinfo_t
type: object type. (C++: const tinfo_t &)

return: "type*". for example, if 'char' is passed as the argument,
def make_ref(e)
def mark_cfunc_dirty(*args) ‑> bool: Flush the cached decompilation results. Erases a cache entry for the specified function.

mark_cfunc_dirty(ea, close_views=False) -> bool
ea: function to erase from the cache (C++: ea_t)

close_views: close pseudocode windows that show the function
(C++: bool)

return: if a cache entry existed.
def mba_t_deserialize(*args) ‑> mba_t *: mba_t_deserialize(bytes) -> mba_t
bytes: uchar const *
def mcode_modifies_d(*args) ‑> bool: mcode_modifies_d(mcode) -> bool
mcode (C++: mcode_t)
def modify_user_lvar_info(*args) ‑> bool: Modify saved local variable settings of one variable.

modify_user_lvar_info(func_ea, mli_flags, info) -> bool
func_ea: function start address (C++: ea_t)

mli_flags: bits that specify which attrs defined by INFO are to
be set (C++: uint)

info: local variable info attrs (C++: const lvar_saved_info_t
&)

return: true if modified, false if invalid MLI_FLAGS passed
def modify_user_lvars(*args) ‑> bool: Modify saved local variable settings.

modify_user_lvars(entry_ea, mlv) -> bool
entry_ea: function start address (C++: ea_t)

mlv: local variable modifier (C++: user_lvar_modifier_t &)

return: true if modified variables
def mreg2reg(*args) ‑> int: Map a microregister to a processor register.

mreg2reg(reg, width) -> int
reg: microregister number (C++: mreg_t)

width: size of microregister in bytes (C++: int)

return: processor register id or -1
def must_mcode_close_block(*args) ‑> bool: Must an instruction with the given opcode be the last one in a block? Such opcodes are called closing opcodes.

must_mcode_close_block(mcode, including_calls) -> bool
mcode: instruction opcode (C++: mcode_t)

including_calls: should m_call/m_icall be considered as the
closing opcodes? If this function returns true, the opcode cannot appear in the middle of a block. Calls are a special case: unknown calls (is_unknown_call) are considered as closing opcodes. (C++: bool)
def negate_mcode_relation(*args) ‑> mcode_t: negate_mcode_relation(code) -> mcode_t
code (C++: mcode_t)
def negated_relation(*args) ‑> ctype_t: Negate a comparison operator. For example, cot_sge becomes cot_slt.

negated_relation(op) -> ctype_t
op (C++: ctype_t)
def new_block()
def op_uses_x(*args) ‑> bool: Does operator use the 'x' field of 'cexpr_t' ?

op_uses_x(op) -> bool
op (C++: ctype_t)
def op_uses_y(*args) ‑> bool: Does operator use the 'y' field of 'cexpr_t' ?

op_uses_y(op) -> bool
op (C++: ctype_t)
def op_uses_z(*args) ‑> bool: Does operator use the 'z' field of 'cexpr_t' ?

op_uses_z(op) -> bool
op (C++: ctype_t)
def open_pseudocode(*args) ‑> vdui_t *: Open pseudocode window. The specified function is decompiled and the pseudocode window is opened.

open_pseudocode(ea, flags) -> vdui_t
ea: function to decompile (C++: ea_t)

flags: a combination of OPF_ flags (C++: int)

return: false if failed
def parse_user_call(*args) ‑> bool: Convert function type declaration into internal structure

parse_user_call(udc, decl, silent) -> bool
udc: - pointer to output structure (C++: udcall_t *)

decl: - function type declaration (C++: const char *)

silent: - if TRUE: do not show warning in case of incorrect
type (C++: bool)

return: success
def partial_type_num(*args) ‑> int: Calculate number of partial subtypes.

partial_type_num(type) -> int
type (C++: const tinfo_t &)

return: number of partial subtypes. The bigger is this number, the
uglier is the type.
def print_vdloc(*args) ‑> qstring *: Print vdloc. Since vdloc does not always carry the size info, we pass it as NBYTES..

print_vdloc(loc, nbytes)
loc (C++: const vdloc_t &)

nbytes (C++: int)
def property_op_to_typename(self)
def qswap(*args) ‑> void: qswap(a, b)
a: cinsn_t & b: cinsn_t &
def reg2mreg(*args) ‑> mreg_t: Map a processor register to a microregister.

reg2mreg(reg) -> mreg_t
reg: processor register number (C++: int)

return: microregister register id or mr_none
def remitem(*args) ‑> void: remitem(e)
e (C++: const citem_t *)
def remove_hexrays_callback(callback): Deprecated. Please use Hexrays_Hooks instead
def rename_lvar(*args) ‑> bool: Rename a local variable.

rename_lvar(func_ea, oldname, newname) -> bool
func_ea: function start address (C++: ea_t)

oldname: old name of the variable (C++: const char *)

newname: new name of the variable (C++: const char *)

return: success This is a convenience function. For bulk renaming
consider using modify_user_lvars.
def restore_user_cmts(*args) ‑> user_cmts_t *: Restore user defined comments from the database.

restore_user_cmts(func_ea) -> user_cmts_t
func_ea: the entry address of the function (C++: ea_t)

return: collection of user defined comments. The returned object must
be deleted by the caller using delete_user_cmts()
def restore_user_defined_calls(*args) ‑> bool: Restore user defined function calls from the database.

restore_user_defined_calls(udcalls, func_ea) -> bool
udcalls: ptr to output buffer (C++: udcall_map_t *)

func_ea: entry address of the function (C++: ea_t)

return: success
def restore_user_iflags(*args) ‑> user_iflags_t *: Restore user defined citem iflags from the database.

restore_user_iflags(func_ea) -> user_iflags_t
func_ea: the entry address of the function (C++: ea_t)

return: collection of user defined iflags. The returned object must
be deleted by the caller using delete_user_iflags()
def restore_user_labels(*args) ‑> user_labels_t *: Restore user defined labels from the database.

restore_user_labels(func_ea) -> user_labels_t
func_ea: the entry address of the function, ignored if FUNC !=
NULL (C++: ea_t)

return: collection of user defined labels. The returned object must
be deleted by the caller using delete_user_labels()
def restore_user_labels2(*args) ‑> user_labels_t *: restore_user_labels2(func_ea, func=None) -> user_labels_t
func_ea (C++: ea_t)

func (C++: const cfunc_t *)
def restore_user_lvar_settings(*args) ‑> bool: Restore user defined local variable settings in the database.

restore_user_lvar_settings(lvinf, func_ea) -> bool
lvinf: ptr to output buffer (C++: lvar_uservec_t *)

func_ea: entry address of the function (C++: ea_t)

return: success
def restore_user_numforms(*args) ‑> user_numforms_t *: Restore user defined number formats from the database.

restore_user_numforms(func_ea) -> user_numforms_t
func_ea: the entry address of the function (C++: ea_t)

return: collection of user defined number formats. The returned
object must be deleted by the caller using

delete_user_numforms()
def restore_user_unions(*args) ‑> user_unions_t *: Restore user defined union field selections from the database.

restore_user_unions(func_ea) -> user_unions_t
func_ea: the entry address of the function (C++: ea_t)

return: collection of union field selections The returned object must
be deleted by the caller using delete_user_unions()
def save_user_cmts(*args) ‑> void: Save user defined comments into the database.

save_user_cmts(func_ea, user_cmts)
func_ea: the entry address of the function (C++: ea_t)

user_cmts: collection of user defined comments (C++: const
user_cmts_t *)
def save_user_defined_calls(*args) ‑> void: Save user defined local function calls into the database.

save_user_defined_calls(func_ea, udcalls)
func_ea: entry address of the function (C++: ea_t)

udcalls: user-specified info about user defined function calls
(C++: const udcall_map_t &)
def save_user_iflags(*args) ‑> void: Save user defined citem iflags into the database.

save_user_iflags(func_ea, iflags)
func_ea: the entry address of the function (C++: ea_t)

iflags: collection of user defined citem iflags (C++: const
user_iflags_t *)
def save_user_labels(*args) ‑> void: Save user defined labels into the database.

save_user_labels(func_ea, user_labels)
func_ea: the entry address of the function, ignored if FUNC !=
NULL (C++: ea_t)

user_labels: collection of user defined labels (C++: const
user_labels_t *)
def save_user_labels2(*args) ‑> void: save_user_labels2(func_ea, user_labels, func=None)
func_ea (C++: ea_t)

user_labels (C++: const user_labels_t *)

func (C++: const cfunc_t *)
def save_user_lvar_settings(*args) ‑> void: Save user defined local variable settings into the database.

save_user_lvar_settings(func_ea, lvinf)
func_ea: entry address of the function (C++: ea_t)

lvinf: user-specified info about local variables (C++: const
lvar_uservec_t &)
def save_user_numforms(*args) ‑> void: Save user defined number formats into the database.

save_user_numforms(func_ea, numforms)
func_ea: the entry address of the function (C++: ea_t)

numforms: collection of user defined comments (C++: const
user_numforms_t *)
def save_user_unions(*args) ‑> void: Save user defined union field selections into the database.

save_user_unions(func_ea, unions)
func_ea: the entry address of the function (C++: ea_t)

unions: collection of union field selections (C++: const
user_unions_t *)
def select_udt_by_offset(*args) ‑> int: Select UDT

select_udt_by_offset(udts, ops, applicator) -> int
udts: list of UDT tinfo_t for the selection, if NULL or empty
then UDTs from the "Local types" will be used (C++: const qvector < tinfo_t > *)

ops: operands (C++: const ui_stroff_ops_t &)

applicator (C++: ui_stroff_applicator_t &)
def send_database(*args) ‑> void: Send the database to Hex-Rays. This function sends the current database to the Hex-Rays server. The database is sent in the compressed form over an encrypted (SSL) connection.

send_database(err, silent)
err: failure description object. Empty hexrays_failure_t
object can be used if error information is not available. (C++: const hexrays_failure_t &)

silent: if false, a dialog box will be displayed before sending
the database. (C++: bool)
def set2jcnd(*args) ‑> mcode_t: set2jcnd(code) -> mcode_t
code (C++: mcode_t)
def set_type(*args) ‑> bool: Set a global type.

set_type(id, tif, source, force=False) -> bool
id: address or id of the object (C++: uval_t)

tif: new type info (C++: const tinfo_t &)

source: where the type comes from (C++: type_source_t)

force: true means to set the type as is, false means to merge
the new type with the possibly existing old type info. (C++: bool)

return: success
def swap_mcode_relation(*args) ‑> mcode_t: swap_mcode_relation(code) -> mcode_t
code (C++: mcode_t)
def swapped_relation(*args) ‑> ctype_t: Swap a comparison operator. For example, cot_sge becomes cot_sle.

swapped_relation(op) -> ctype_t
op (C++: ctype_t)
def term_hexrays_plugin(*args) ‑> void: Stop working with hex-rays decompiler.
def udcall_map_begin(*args) ‑> udcall_map_iterator_t: Get iterator pointing to the beginning of udcall_map_t.

udcall_map_begin(map) -> udcall_map_iterator_t
map (C++: const udcall_map_t *)
def udcall_map_clear(*args) ‑> void: Clear udcall_map_t.

udcall_map_clear(map)
map (C++: udcall_map_t *)
def udcall_map_end(*args) ‑> udcall_map_iterator_t: Get iterator pointing to the end of udcall_map_t.

udcall_map_end(map) -> udcall_map_iterator_t
map (C++: const udcall_map_t *)
def udcall_map_erase(*args) ‑> void: Erase current element from udcall_map_t.

udcall_map_erase(map, p)
map (C++: udcall_map_t *)

p (C++: udcall_map_iterator_t)
def udcall_map_find(*args) ‑> udcall_map_iterator_t: Find the specified key in udcall_map_t.

udcall_map_find(map, key) -> udcall_map_iterator_t
map (C++: const udcall_map_t *)

key (C++: const ea_t &)
def udcall_map_first(*args) ‑> ea_t const &: Get reference to the current map key.

udcall_map_first(p) -> ea_t const &
p (C++: udcall_map_iterator_t)
def udcall_map_free(*args) ‑> void: Delete udcall_map_t instance.

udcall_map_free(map)
map (C++: udcall_map_t *)
def udcall_map_insert(*args) ‑> udcall_map_iterator_t: Insert new (ea_t, 'udcall_t' ) pair into udcall_map_t.

udcall_map_insert(map, key, val) -> udcall_map_iterator_t
map (C++: udcall_map_t *)

key (C++: const ea_t &)

val (C++: const udcall_t &)
def udcall_map_new(*args) ‑> udcall_map_t *: Create a new udcall_map_t instance.
def udcall_map_next(*args) ‑> udcall_map_iterator_t: Move to the next element.

udcall_map_next(p) -> udcall_map_iterator_t
p (C++: udcall_map_iterator_t)
def udcall_map_prev(*args) ‑> udcall_map_iterator_t: Move to the previous element.

udcall_map_prev(p) -> udcall_map_iterator_t
p (C++: udcall_map_iterator_t)
def udcall_map_second(*args) ‑> udcall_t &: Get reference to the current map value.

udcall_map_second(p) -> udcall_t
p (C++: udcall_map_iterator_t)
def udcall_map_size(*args) ‑> size_t: Get size of udcall_map_t.

udcall_map_size(map) -> size_t
map (C++: udcall_map_t *)
def user_cmts_begin(*args) ‑> user_cmts_iterator_t: Get iterator pointing to the beginning of user_cmts_t.

user_cmts_begin(map) -> user_cmts_iterator_t
map (C++: const user_cmts_t *)
def user_cmts_clear(*args) ‑> void: Clear user_cmts_t.

user_cmts_clear(map)
map (C++: user_cmts_t *)
def user_cmts_end(*args) ‑> user_cmts_iterator_t: Get iterator pointing to the end of user_cmts_t.

user_cmts_end(map) -> user_cmts_iterator_t
map (C++: const user_cmts_t *)
def user_cmts_erase(*args) ‑> void: Erase current element from user_cmts_t.

user_cmts_erase(map, p)
map (C++: user_cmts_t *)

p (C++: user_cmts_iterator_t)
def user_cmts_find(*args) ‑> user_cmts_iterator_t: Find the specified key in user_cmts_t.

user_cmts_find(map, key) -> user_cmts_iterator_t
map (C++: const user_cmts_t *)

key (C++: const treeloc_t &)
def user_cmts_first(*args) ‑> treeloc_t const &: Get reference to the current map key.

user_cmts_first(p) -> treeloc_t
p (C++: user_cmts_iterator_t)
def user_cmts_free(*args) ‑> void: Delete user_cmts_t instance.

user_cmts_free(map)
map (C++: user_cmts_t *)
def user_cmts_insert(*args) ‑> user_cmts_iterator_t: Insert new ( 'treeloc_t' , 'citem_cmt_t' ) pair into user_cmts_t.

user_cmts_insert(map, key, val) -> user_cmts_iterator_t
map (C++: user_cmts_t *)

key (C++: const treeloc_t &)

val (C++: const citem_cmt_t &)
def user_cmts_new(*args) ‑> user_cmts_t *: Create a new user_cmts_t instance.
def user_cmts_next(*args) ‑> user_cmts_iterator_t: Move to the next element.

user_cmts_next(p) -> user_cmts_iterator_t
p (C++: user_cmts_iterator_t)
def user_cmts_prev(*args) ‑> user_cmts_iterator_t: Move to the previous element.

user_cmts_prev(p) -> user_cmts_iterator_t
p (C++: user_cmts_iterator_t)
def user_cmts_second(*args) ‑> citem_cmt_t &: Get reference to the current map value.

user_cmts_second(p) -> citem_cmt_t
p (C++: user_cmts_iterator_t)
def user_cmts_size(*args) ‑> size_t: Get size of user_cmts_t.

user_cmts_size(map) -> size_t
map (C++: user_cmts_t *)
def user_iflags_begin(*args) ‑> user_iflags_iterator_t: Get iterator pointing to the beginning of user_iflags_t.

user_iflags_begin(map) -> user_iflags_iterator_t
map (C++: const user_iflags_t *)
def user_iflags_clear(*args) ‑> void: Clear user_iflags_t.

user_iflags_clear(map)
map (C++: user_iflags_t *)
def user_iflags_end(*args) ‑> user_iflags_iterator_t: Get iterator pointing to the end of user_iflags_t.

user_iflags_end(map) -> user_iflags_iterator_t
map (C++: const user_iflags_t *)
def user_iflags_erase(*args) ‑> void: Erase current element from user_iflags_t.

user_iflags_erase(map, p)
map (C++: user_iflags_t *)

p (C++: user_iflags_iterator_t)
def user_iflags_find(*args) ‑> user_iflags_iterator_t: Find the specified key in user_iflags_t.

user_iflags_find(map, key) -> user_iflags_iterator_t
map (C++: const user_iflags_t *)

key (C++: const citem_locator_t &)
def user_iflags_first(*args) ‑> citem_locator_t const &: Get reference to the current map key.

user_iflags_first(p) -> citem_locator_t
p (C++: user_iflags_iterator_t)
def user_iflags_free(*args) ‑> void: Delete user_iflags_t instance.

user_iflags_free(map)
map (C++: user_iflags_t *)
def user_iflags_insert(*args) ‑> user_iflags_iterator_t: Insert new ( 'citem_locator_t' , int32) pair into user_iflags_t.

user_iflags_insert(map, key, val) -> user_iflags_iterator_t
map (C++: user_iflags_t *)

key (C++: const citem_locator_t &)

val (C++: const int32 &)
def user_iflags_new(*args) ‑> user_iflags_t *: Create a new user_iflags_t instance.
def user_iflags_next(*args) ‑> user_iflags_iterator_t: Move to the next element.

user_iflags_next(p) -> user_iflags_iterator_t
p (C++: user_iflags_iterator_t)
def user_iflags_prev(*args) ‑> user_iflags_iterator_t: Move to the previous element.

user_iflags_prev(p) -> user_iflags_iterator_t
p (C++: user_iflags_iterator_t)
def user_iflags_second(*args) ‑> int32 const &: Get reference to the current map value.

user_iflags_second(p) -> int32 const &
p (C++: user_iflags_iterator_t)
def user_iflags_size(*args) ‑> size_t: Get size of user_iflags_t.

user_iflags_size(map) -> size_t
map (C++: user_iflags_t *)
def user_labels_begin(*args) ‑> user_labels_iterator_t: Get iterator pointing to the beginning of user_labels_t.

user_labels_begin(map) -> user_labels_iterator_t
map (C++: const user_labels_t *)
def user_labels_clear(*args) ‑> void: Clear user_labels_t.

user_labels_clear(map)
map (C++: user_labels_t *)
def user_labels_end(*args) ‑> user_labels_iterator_t: Get iterator pointing to the end of user_labels_t.

user_labels_end(map) -> user_labels_iterator_t
map (C++: const user_labels_t *)
def user_labels_erase(*args) ‑> void: Erase current element from user_labels_t.

user_labels_erase(map, p)
map (C++: user_labels_t *)

p (C++: user_labels_iterator_t)
def user_labels_find(*args) ‑> user_labels_iterator_t: Find the specified key in user_labels_t.

user_labels_find(map, key) -> user_labels_iterator_t
map (C++: const user_labels_t *)

key (C++: const int &)
def user_labels_first(*args) ‑> int const &: Get reference to the current map key.

user_labels_first(p) -> int const &
p (C++: user_labels_iterator_t)
def user_labels_free(*args) ‑> void: Delete user_labels_t instance.

user_labels_free(map)
map (C++: user_labels_t *)
def user_labels_insert(*args) ‑> user_labels_iterator_t: Insert new (int, qstring) pair into user_labels_t.

user_labels_insert(map, key, val) -> user_labels_iterator_t
map (C++: user_labels_t *)

key (C++: const int &)

val (C++: const qstring &)
def user_labels_new(*args) ‑> user_labels_t *: Create a new user_labels_t instance.
def user_labels_next(*args) ‑> user_labels_iterator_t: Move to the next element.

user_labels_next(p) -> user_labels_iterator_t
p (C++: user_labels_iterator_t)
def user_labels_prev(*args) ‑> user_labels_iterator_t: Move to the previous element.

user_labels_prev(p) -> user_labels_iterator_t
p (C++: user_labels_iterator_t)
def user_labels_second(*args) ‑> qstring &: Get reference to the current map value.

user_labels_second(p) -> qstring &
p (C++: user_labels_iterator_t)
def user_labels_size(*args) ‑> size_t: Get size of user_labels_t.

user_labels_size(map) -> size_t
map (C++: user_labels_t *)
def user_numforms_begin(*args) ‑> user_numforms_iterator_t: Get iterator pointing to the beginning of user_numforms_t.

user_numforms_begin(map) -> user_numforms_iterator_t
map (C++: const user_numforms_t *)
def user_numforms_clear(*args) ‑> void: Clear user_numforms_t.

user_numforms_clear(map)
map (C++: user_numforms_t *)
def user_numforms_end(*args) ‑> user_numforms_iterator_t: Get iterator pointing to the end of user_numforms_t.

user_numforms_end(map) -> user_numforms_iterator_t
map (C++: const user_numforms_t *)
def user_numforms_erase(*args) ‑> void: Erase current element from user_numforms_t.

user_numforms_erase(map, p)
map (C++: user_numforms_t *)

p (C++: user_numforms_iterator_t)
def user_numforms_find(*args) ‑> user_numforms_iterator_t: Find the specified key in user_numforms_t.

user_numforms_find(map, key) -> user_numforms_iterator_t
map (C++: const user_numforms_t *)

key (C++: const operand_locator_t &)
def user_numforms_first(*args) ‑> operand_locator_t const &: Get reference to the current map key.

user_numforms_first(p) -> operand_locator_t
p (C++: user_numforms_iterator_t)
def user_numforms_free(*args) ‑> void: Delete user_numforms_t instance.

user_numforms_free(map)
map (C++: user_numforms_t *)
def user_numforms_insert(*args) ‑> user_numforms_iterator_t: Insert new ( 'operand_locator_t' , 'number_format_t' ) pair into user_numforms_t.

user_numforms_insert(map, key, val) -> user_numforms_iterator_t
map (C++: user_numforms_t *)

key (C++: const operand_locator_t &)

val (C++: const number_format_t &)
def user_numforms_new(*args) ‑> user_numforms_t *: Create a new user_numforms_t instance.
def user_numforms_next(*args) ‑> user_numforms_iterator_t: Move to the next element.

user_numforms_next(p) -> user_numforms_iterator_t
p (C++: user_numforms_iterator_t)
def user_numforms_prev(*args) ‑> user_numforms_iterator_t: Move to the previous element.

user_numforms_prev(p) -> user_numforms_iterator_t
p (C++: user_numforms_iterator_t)
def user_numforms_second(*args) ‑> number_format_t &: Get reference to the current map value.

user_numforms_second(p) -> number_format_t
p (C++: user_numforms_iterator_t)
def user_numforms_size(*args) ‑> size_t: Get size of user_numforms_t.

user_numforms_size(map) -> size_t
map (C++: user_numforms_t *)
def user_unions_begin(*args) ‑> user_unions_iterator_t: Get iterator pointing to the beginning of user_unions_t.

user_unions_begin(map) -> user_unions_iterator_t
map (C++: const user_unions_t *)
def user_unions_clear(*args) ‑> void: Clear user_unions_t.

user_unions_clear(map)
map (C++: user_unions_t *)
def user_unions_end(*args) ‑> user_unions_iterator_t: Get iterator pointing to the end of user_unions_t.

user_unions_end(map) -> user_unions_iterator_t
map (C++: const user_unions_t *)
def user_unions_erase(*args) ‑> void: Erase current element from user_unions_t.

user_unions_erase(map, p)
map (C++: user_unions_t *)

p (C++: user_unions_iterator_t)
def user_unions_find(*args) ‑> user_unions_iterator_t: Find the specified key in user_unions_t.

user_unions_find(map, key) -> user_unions_iterator_t
map (C++: const user_unions_t *)

key (C++: const ea_t &)
def user_unions_first(*args) ‑> ea_t const &: Get reference to the current map key.

user_unions_first(p) -> ea_t const &
p (C++: user_unions_iterator_t)
def user_unions_free(*args) ‑> void: Delete user_unions_t instance.

user_unions_free(map)
map (C++: user_unions_t *)
def user_unions_insert(*args) ‑> user_unions_iterator_t: Insert new (ea_t, intvec_t) pair into user_unions_t.

user_unions_insert(map, key, val) -> user_unions_iterator_t
map (C++: user_unions_t *)

key (C++: const ea_t &)

val (C++: const intvec_t &)
def user_unions_new(*args) ‑> user_unions_t *: Create a new user_unions_t instance.
def user_unions_next(*args) ‑> user_unions_iterator_t: Move to the next element.

user_unions_next(p) -> user_unions_iterator_t
p (C++: user_unions_iterator_t)
def user_unions_prev(*args) ‑> user_unions_iterator_t: Move to the previous element.

user_unions_prev(p) -> user_unions_iterator_t
p (C++: user_unions_iterator_t)
def user_unions_second(*args) ‑> intvec_t &: Get reference to the current map value.

user_unions_second(p) -> intvec_t
p (C++: user_unions_iterator_t)
def user_unions_size(*args) ‑> size_t: Get size of user_unions_t.

user_unions_size(map) -> size_t
map (C++: user_unions_t *)

Classes

class DecompilationFailure (info)

Raised on a decompilation error.

The associated hexrays_failure_t object is stored in the 'info' member of this exception.

Ancestors

builtins.Exception
builtins.BaseException

class Hexrays_Hooks (*args)

Proxy of C++ Hexrays_Hooks class.

__init__(self, _flags=0) -> Hexrays_Hooks

_flags: uint32

Subclasses

ida_hexrays.__cbhooks_t

Methods

def build_callinfo(self, *args) ‑> int: Analyzing a call instruction.

build_callinfo(self, blk, type, callinfo) -> int
blk: blk->tail is the call. (C++: mblock_t *)

type: buffer for the output type. (C++: tinfo_t *)

callinfo: prepared callinfo. Should return: 1 if the function
type has been determined. The plugin should either specify the function type, either allocate and return a new mcallinfo_t object. (C++: mcallinfo_t **)
def close_pseudocode(self, *args) ‑> int: Pseudocode view is being closed.

close_pseudocode(self, vu) -> int
vu (C++: vdui_t *)
def cmt_changed(self, *args) ‑> int: Comment got changed.

cmt_changed(self, cfunc, loc, cmt) -> int
cfunc (C++: cfunc_t *)

loc (C++: const treeloc_t *)

cmt (C++: const char *)
def combine(self, *args) ‑> int: Trying to combine instructions of basic block.

combine(self, blk, insn) -> int
blk (C++: mblock_t *)

insn: Should return: 1 if combined the current instruction with
a preceding one (C++: minsn_t *)
def create_hint(self, *args) ‑> PyObject *: Create a hint for the current item. 'ui_get_custom_viewer_hint'

create_hint(self, vu) -> PyObject *
vu (C++: vdui_t *)

retval: 0 - continue collecting hints with other subscribers

retval: 1 - stop collecting hints
def curpos(self, *args) ‑> int: Current cursor position has been changed. (for example, by left- clicking or using keyboard)

curpos(self, vu) -> int
vu (C++: vdui_t *)
def double_click(self, *args) ‑> int: Mouse double click.

double_click(self, vu, shift_state) -> int
vu (C++: vdui_t *)

shift_state: Should return: 1 if the event has been handled
(C++: int)
def flowchart(self, *args) ‑> int: Flowchart has been generated.

flowchart(self, fc) -> int
fc (C++: qflow_chart_t *)
def func_printed(self, *args) ‑> int: Function text has been generated. Plugins may modify the text in 'cfunc_t::sv' . The text uses regular color codes (see 'lines.hpp' ) COLOR_ADDR is used to store pointers to ctree elements.

func_printed(self, cfunc) -> int
cfunc (C++: cfunc_t *)
def glbopt(self, *args) ‑> int: Global optimization has been finished. If microcode is modified, MERR_LOOP must be returned. It will cause a complete restart of the optimization.

glbopt(self, mba) -> int
mba: return Microcode error codes code (C++: mba_t *)
def hook(self, *args) ‑> bool: hook(self) -> bool
def interr(self, *args) ‑> int: Internal error has occurred.

interr(self, errcode) -> int
errcode (C++: int )
def keyboard(self, *args) ‑> int: Keyboard has been hit.

keyboard(self, vu, key_code, shift_state) -> int
vu (C++: vdui_t *)

key_code: VK_... (C++: int)

shift_state: Should return: 1 if the event has been handled
(C++: int)
def locopt(self, *args) ‑> int: Basic block level optimization has been finished.

locopt(self, mba) -> int
mba: return Microcode error codes code (C++: mba_t *)
def lvar_cmt_changed(self, *args) ‑> int: Local variable comment got changed.

lvar_cmt_changed(self, vu, v, cmt) -> int
vu (C++: vdui_t *)

v (C++: lvar_t *)

cmt: Please note that it is possible to read/write user
settings for lvars directly from the idb. (C++: const char *)
def lvar_mapping_changed(self, *args) ‑> int: Local variable mapping got changed.

lvar_mapping_changed(self, vu, frm, to) -> int
vu (C++: vdui_t *)

frm (C++: lvar_t *)

to: Please note that it is possible to read/write user settings
for lvars directly from the idb. (C++: lvar_t *)
def lvar_name_changed(self, *args) ‑> int: Local variable got renamed.

lvar_name_changed(self, vu, v, name, is_user_name) -> int
vu (C++: vdui_t *)

v (C++: lvar_t *)

name (C++: const char *)

is_user_name: Please note that it is possible to read/write
user settings for lvars directly from the idb. (C++: bool)
def lvar_type_changed(self, *args) ‑> int: Local variable type got changed.

lvar_type_changed(self, vu, v, tinfo) -> int
vu (C++: vdui_t *)

v (C++: lvar_t *)

tinfo: Please note that it is possible to read/write user
settings for lvars directly from the idb. (C++: const tinfo_t *)
def maturity(self, *args) ‑> int: Ctree maturity level is being changed.

maturity(self, cfunc, new_maturity) -> int
cfunc (C++: cfunc_t *)

new_maturity (C++: ctree_maturity_t)
def microcode(self, *args) ‑> int: Microcode has been generated.

microcode(self, mba) -> int
mba: return Microcode error codes code (C++: mba_t *)
def open_pseudocode(self, *args) ‑> int: New pseudocode view has been opened.

open_pseudocode(self, vu) -> int
vu (C++: vdui_t *)
def populating_popup(self, *args) ‑> int: Populating popup menu. We can add menu items now.

populating_popup(self, widget, popup_handle, vu) -> int
widget (C++: TWidget *)

popup_handle (C++: TPopupMenu *)

vu (C++: vdui_t *)
def prealloc(self, *args) ‑> int: Local variables: preallocation step begins.

prealloc(self, mba) -> int
mba: This event may occur several times. Should return: 1 if
modified microcode Negative values are Microcode error codes error codes (C++: mba_t *)
def preoptimized(self, *args) ‑> int: Microcode has been preoptimized.

preoptimized(self, mba) -> int
mba: return Microcode error codes code (C++: mba_t *)
def print_func(self, *args) ‑> int: Printing ctree and generating text.

print_func(self, cfunc, vp) -> int
cfunc (C++: cfunc_t *)

vp: Returns: 1 if text has been generated by the plugin It is
forbidden to modify ctree at this event. (C++: vc_printer_t *)
def prolog(self, *args) ‑> int: Prolog analysis has been finished.

prolog(self, mba, fc, reachable_blocks, decomp_flags) -> int
mba (C++: mba_t *)

fc (C++: qflow_chart_t *)

reachable_blocks (C++: bitset_t *)

decomp_flags: return Microcode error codes code (C++: int)
def refresh_pseudocode(self, *args) ‑> int: Existing pseudocode text has been refreshed. Adding/removing pseudocode lines is forbidden in this event.

refresh_pseudocode(self, vu) -> int
vu: See also hxe_text_ready, which happens earlier (C++:
vdui_t *)
def resolve_stkaddrs(self, *args) ‑> int: The optimizer is about to resolve stack addresses.

resolve_stkaddrs(self, mba) -> int
mba (C++: mba_t *)
def right_click(self, *args) ‑> int: Mouse right click. Use hxe_populating_popup instead, in case you want to add items in the popup menu.

right_click(self, vu) -> int
vu (C++: vdui_t *)
def stkpnts(self, *args) ‑> int: SP change points have been calculated.

stkpnts(self, mba, _sps) -> int
mba (C++: mba_t *) _sps: stkpnts_t *
def structural(self, *args) ‑> int: Structural analysis has been finished.

structural(self, ct) -> int
ct (C++: control_graph_t *)
def switch_pseudocode(self, *args) ‑> int: Existing pseudocode view has been reloaded with a new function. Its text has not been refreshed yet, only cfunc and mba pointers are ready.

switch_pseudocode(self, vu) -> int
vu (C++: vdui_t *)
def text_ready(self, *args) ‑> int: Decompiled text is ready.

text_ready(self, vu) -> int
vu: This event can be used to modify the output text (sv).
Obsolete. Please use hxe_func_printed instead. (C++: vdui_t *)
def unhook(self, *args) ‑> bool: unhook(self) -> bool

class array_of_bitsets (*args)

Proxy of C++ qvector< bitset_t > class.

__init__(self) -> array_of_bitsets

x: qvector< bitset_t > const &

Methods

def add_unique(self, *args) ‑> bool: add_unique(self, x) -> bool
x: bitset_t const &
def at(self, *args) ‑> bitset_t const &: at(self, _idx) -> bitset_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< bitset_t >::const_iterator: begin(self) -> bitset_t

begin(self) -> bitset_t
def capacity(self, *args) ‑> size_t: capacity(self) -> size_t
def clear(self, *args) ‑> void: clear(self)
def empty(self, *args) ‑> bool: empty(self) -> bool
def end(self, *args) ‑> qvector< bitset_t >::const_iterator: end(self) -> bitset_t

end(self) -> bitset_t
def erase(self, *args) ‑> qvector< bitset_t >::iterator: erase(self, it) -> bitset_t
it: qvector< bitset_t >::iterator

erase(self, first, last) -> bitset_t
first: qvector< bitset_t >::iterator last: qvector< bitset_t >::iterator
def extract(self, *args) ‑> bitset_t *: extract(self) -> bitset_t
def find(self, *args) ‑> qvector< bitset_t >::const_iterator: find(self, x) -> bitset_t
x: bitset_t const &

find(self, x) -> bitset_t
x: bitset_t const &
def front(self)
def grow(self, *args) ‑> void: grow(self, x=bitset_t())
x: bitset_t const &
def has(self, *args) ‑> bool: has(self, x) -> bool
x: bitset_t const &
def inject(self, *args) ‑> void: inject(self, s, len)
s: bitset_t * len: size_t
def insert(self, *args) ‑> qvector< bitset_t >::iterator: insert(self, it, x) -> bitset_t
it: qvector< bitset_t >::iterator x: bitset_t const &
def pop_back(self, *args) ‑> void: pop_back(self)
def push_back(self, *args) ‑> bitset_t &: push_back(self, x)
x: bitset_t const &
def qclear(self, *args) ‑> void: qclear(self)
def reserve(self, *args) ‑> void: reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void: resize(self, _newsize, x)
_newsize: size_t x: bitset_t const &

resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t: size(self) -> size_t
def swap(self, *args) ‑> void: swap(self, r)
r: qvector< bitset_t > &
def truncate(self, *args) ‑> void: truncate(self)

class array_of_ivlsets (*args)

Proxy of C++ qvector< ivlset_t > class.

__init__(self) -> array_of_ivlsets

x: qvector< ivlset_t > const &

Methods

def add_unique(self, *args) ‑> bool: add_unique(self, x) -> bool
x: ivlset_t const &
def at(self, *args) ‑> ivlset_t const &: at(self, _idx) -> ivlset_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< ivlset_t >::const_iterator: begin(self) -> ivlset_t

begin(self) -> ivlset_t
def capacity(self, *args) ‑> size_t: capacity(self) -> size_t
def clear(self, *args) ‑> void: clear(self)
def empty(self, *args) ‑> bool: empty(self) -> bool
def end(self, *args) ‑> qvector< ivlset_t >::const_iterator: end(self) -> ivlset_t

end(self) -> ivlset_t
def erase(self, *args) ‑> qvector< ivlset_t >::iterator: erase(self, it) -> ivlset_t
it: qvector< ivlset_t >::iterator

erase(self, first, last) -> ivlset_t
first: qvector< ivlset_t >::iterator last: qvector< ivlset_t >::iterator
def extract(self, *args) ‑> ivlset_t *: extract(self) -> ivlset_t
def find(self, *args) ‑> qvector< ivlset_t >::const_iterator: find(self, x) -> ivlset_t
x: ivlset_t const &

find(self, x) -> ivlset_t
x: ivlset_t const &
def front(self)
def grow(self, *args) ‑> void: grow(self, x=ivlset_t())
x: ivlset_t const &
def has(self, *args) ‑> bool: has(self, x) -> bool
x: ivlset_t const &
def inject(self, *args) ‑> void: inject(self, s, len)
s: ivlset_t * len: size_t
def insert(self, *args) ‑> qvector< ivlset_t >::iterator: insert(self, it, x) -> ivlset_t
it: qvector< ivlset_t >::iterator x: ivlset_t const &
def pop_back(self, *args) ‑> void: pop_back(self)
def push_back(self, *args) ‑> ivlset_t &: push_back(self, x)
x: ivlset_t const &
def qclear(self, *args) ‑> void: qclear(self)
def reserve(self, *args) ‑> void: reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void: resize(self, _newsize, x)
_newsize: size_t x: ivlset_t const &

resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t: size(self) -> size_t
def swap(self, *args) ‑> void: swap(self, r)
r: qvector< ivlset_t > &
def truncate(self, *args) ‑> void: truncate(self)

class bit_bound_t (*args)

Proxy of C++ bit_bound_t class.

__init__(self, n=0, s=0) -> bit_bound_t

n: int s: int

Instance variables

var nbits: bit_bound_t_nbits_get(self) -> int16
var sbits: bit_bound_t_sbits_get(self) -> int16

class bitset_t (*args)

Proxy of C++ bitset_t class.

__init__(self) -> bitset_t

m: bitset_t const &

Subclasses

rlist_t

Methods

def add(self, *args) ‑> bool: add(self, bit) -> bool
bit (C++: int)

add(self, bit, width) -> bool
bit (C++: int) width: int

add(self, ml) -> bool
ml: bitset_t const &
def back(self, *args) ‑> int: back(self) -> int
def begin(self, *args) ‑> bitset_t::iterator: begin(self) -> iterator
def clear(self, *args) ‑> void: clear(self)
def compare(self, *args) ‑> int: compare(self, r) -> int
r: bitset_t const &
def copy(self, *args) ‑> bitset_t &: copy(self, m) -> bitset_t
m (C++: const bitset_t &)
def count(self, *args) ‑> int: count(self) -> int
bit: int
def cut_at(self, *args) ‑> bool: cut_at(self, maxbit) -> bool
maxbit (C++: int)
def dstr(self, *args) ‑> char const *: dstr(self) -> char const *
def empty(self, *args) ‑> bool: empty(self) -> bool
def end(self, *args) ‑> bitset_t::iterator: end(self) -> iterator
def fill_with_ones(self, *args) ‑> void: fill_with_ones(self, maxbit)
maxbit (C++: int)
def front(self, *args) ‑> int: front(self) -> int
def has(self, *args) ‑> bool: has(self, bit) -> bool
bit (C++: int)
def has_all(self, *args) ‑> bool: has_all(self, bit, width) -> bool
bit (C++: int)

width (C++: int)
def has_any(self, *args) ‑> bool: has_any(self, bit, width) -> bool
bit (C++: int)

width (C++: int)
def has_common(self, *args) ‑> bool: has_common(self, ml) -> bool
ml (C++: const bitset_t &)
def inc(self, *args) ‑> void: inc(self, p, n=1)
p (C++: iterator &)

n (C++: int)
def includes(self, *args) ‑> bool: includes(self, ml) -> bool
ml (C++: const bitset_t &)
def intersect(self, *args) ‑> bool: intersect(self, ml) -> bool
ml (C++: const bitset_t &)
def is_subset_of(self, *args) ‑> bool: is_subset_of(self, ml) -> bool
ml (C++: const bitset_t &)
def itat(self, *args) ‑> bitset_t::iterator: itat(self, n) -> iterator
n (C++: int)
def itv(self, *args) ‑> int: itv(self, it) -> int
it: bitset_t::const_iterator
def last(self, *args) ‑> int: last(self) -> int
def shift_down(self, *args) ‑> void: shift_down(self, shift)
shift (C++: int)
def sub(self, *args) ‑> bool: sub(self, bit) -> bool
bit (C++: int)

sub(self, bit, width) -> bool
bit (C++: int) width: int

sub(self, ml) -> bool
ml: bitset_t const &
def swap(self, *args) ‑> void: swap(self, r)
r (C++: bitset_t &)

class block_chains_iterator_t (*args)

Proxy of C++ block_chains_iterator_t class.

__init__(self) -> block_chains_iterator_t

Instance variables

var x: block_chains_iterator_t_x_get(self) -> iterator_word

class block_chains_t (*args)

Proxy of C++ block_chains_t class.

__init__(self) -> block_chains_t

Methods

def dstr(self, *args) ‑> char const *: dstr(self) -> char const *
def get_chain(self, *args) ‑> chain_t *: Get chain for the specified value offset.

get_chain(self, k, width=1) -> chain_t
k: value offset (register number or stack offset) (C++: const
voff_t &)

width: size of value in bytes (C++: int)

get_chain(self, k, width=1) -> chain_t
k: value offset (register number or stack offset) (C++: const
voff_t &)

width: size of value in bytes (C++: int)

get_chain(self, ch) -> chain_t
ch: chain_t const &

get_chain(self, ch) -> chain_t
ch: chain_t const &
def get_reg_chain(self, *args) ‑> chain_t *: Get chain for the specified register

get_reg_chain(self, reg, width=1) -> chain_t
reg: register number (C++: mreg_t)

width: size of register in bytes (C++: int)

get_reg_chain(self, reg, width=1) -> chain_t
reg: register number (C++: mreg_t)

width: size of register in bytes (C++: int)
def get_stk_chain(self, *args) ‑> chain_t *: Get chain for the specified stack offset

get_stk_chain(self, off, width=1) -> chain_t
off: stack offset (C++: sval_t)

width: size of stack value in bytes (C++: int)

get_stk_chain(self, off, width=1) -> chain_t
off: stack offset (C++: sval_t)

width: size of stack value in bytes (C++: int)

class block_chains_vec_t (*args)

Proxy of C++ qvector< block_chains_t > class.

__init__(self) -> block_chains_vec_t

x: qvector< block_chains_t > const &

Subclasses

graph_chains_t

Methods

def at(self, *args) ‑> block_chains_t const &: at(self, _idx) -> block_chains_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< block_chains_t >::const_iterator: begin(self) -> block_chains_t

begin(self) -> block_chains_t
def capacity(self, *args) ‑> size_t: capacity(self) -> size_t
def clear(self, *args) ‑> void: clear(self)
def empty(self, *args) ‑> bool: empty(self) -> bool
def end(self, *args) ‑> qvector< block_chains_t >::const_iterator: end(self) -> block_chains_t

end(self) -> block_chains_t
def erase(self, *args) ‑> qvector< block_chains_t >::iterator: erase(self, it) -> block_chains_t
it: qvector< block_chains_t >::iterator

erase(self, first, last) -> block_chains_t
first: qvector< block_chains_t >::iterator last: qvector< block_chains_t >::iterator
def extract(self, *args) ‑> block_chains_t *: extract(self) -> block_chains_t
def front(self)
def grow(self, *args) ‑> void: grow(self, x=block_chains_t())
x: block_chains_t const &
def inject(self, *args) ‑> void: inject(self, s, len)
s: block_chains_t * len: size_t
def insert(self, *args) ‑> qvector< block_chains_t >::iterator: insert(self, it, x) -> block_chains_t
it: qvector< block_chains_t >::iterator x: block_chains_t const &
def pop_back(self, *args) ‑> void: pop_back(self)
def push_back(self, *args) ‑> block_chains_t &: push_back(self, x)
x: block_chains_t const &
def qclear(self, *args) ‑> void: qclear(self)
def reserve(self, *args) ‑> void: reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void: resize(self, _newsize, x)
_newsize: size_t x: block_chains_t const &

resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t: size(self) -> size_t
def swap(self, *args) ‑> void: swap(self, r)
r: qvector< block_chains_t > &
def truncate(self, *args) ‑> void: truncate(self)

class boundaries_iterator_t (*args)

Proxy of C++ boundaries_iterator_t class.

__init__(self) -> boundaries_iterator_t

Instance variables

var x: boundaries_iterator_t_x_get(self) -> iterator_word

class boundaries_t (*args)

Proxy of C++ std::map< cinsn_t *,rangeset_t > class.

__init__(self) -> boundaries_t

Class variables

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

Methods

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

class carg_t (*args)

Proxy of C++ carg_t class.

__init__(self) -> carg_t

Instance variables

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

Methods

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

Inherited members

cexpr_t:
- assign
- calc_type
- cexpr
- cinsn
- cleanup
- contains_comma
- contains_comma_or_insn_or_label
- contains_expr
- contains_insn
- contains_insn_or_label
- contains_label
- contains_operator
- cpadone
- ea
- equal_effect
- exflags
- find_closest_addr
- find_num_op
- find_op
- find_parent_of
- get_1num_op
- get_const_value
- get_high_nbit_bound
- get_low_nbit_bound
- get_ptr_or_array
- get_type_sign
- get_v
- has_side_effects
- index
- is_call_arg_of
- is_call_object_of
- is_child_of
- is_const_value
- is_cstr
- is_expr
- is_fpop
- is_jumpout
- is_negative_const
- is_nice_cond
- is_nice_expr
- is_non_negative_const
- is_non_zero_const
- is_odd_lvalue
- is_type_signed
- is_type_unsigned
- is_undef_val
- is_vftable
- is_zero_const
- label_num
- maybe_ptr
- numval
- obj_id
- op
- operands
- print1
- put_number
- requires_lvalue
- set_cpadone
- set_v
- set_vftable
- swap
- theother
- to_specific_type
- type

class carglist_t (*args)

Proxy of C++ carglist_t class.

__init__(self) -> carglist_t

ftype: tinfo_t const & fl: int

Ancestors

qvector_carg_t

Instance variables

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

Methods

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

Inherited members

qvector_carg_t:
- add_unique
- append
- at
- begin
- capacity
- clear
- empty
- end
- erase
- extract
- find
- grow
- has
- inject
- insert
- pop_back
- push_back
- qclear
- reserve
- resize
- size
- swap
- truncate

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

uintvec_t

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

uintvec_t:
- add_unique
- append
- at
- begin
- capacity
- clear
- empty
- end
- erase
- extract
- find
- has
- inject
- insert
- pop_back
- push_back
- qclear
- reserve
- resize
- size
- swap
- truncate

class cblock_t (*args)

Proxy of C++ cblock_t class.

__init__(self) -> cblock_t

Ancestors

qlist_cinsn_t

Methods

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

Inherited members

qlist_cinsn_t:
- begin
- clear
- empty
- end
- erase
- insert
- pop_back
- pop_front
- push_back
- push_front
- rbegin
- remove
- rend
- size
- swap

class ccase_t (*args)

Proxy of C++ ccase_t class.

__init__(self) -> ccase_t

Ancestors

cinsn_t
citem_t

Instance variables

var values: ccase_t_values_get(self) -> ulonglongvec_t

Methods

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

Inherited members

cinsn_t:
- assign
- cinsn
- cleanup
- collect_free_breaks
- collect_free_continues
- contains_expr
- contains_free_break
- contains_free_continue
- contains_insn
- contains_label
- create_if
- details
- ea
- find_closest_addr
- find_parent_of
- index
- insn_is_epilog
- is_expr
- is_ordinary_flow
- label_num
- new_insn
- obj_id
- op
- print1
- swap
- to_specific_type
- zero
citem_t:
- cexpr

class ccases_t (*args)

Proxy of C++ ccases_t class.

__init__(self) -> ccases_t

Ancestors

qvector_ccase_t

Methods

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

Inherited members

qvector_ccase_t:
- add_unique
- append
- at
- begin
- capacity
- clear
- empty
- end
- erase
- extract
- find
- grow
- has
- inject
- insert
- pop_back
- push_back
- qclear
- reserve
- resize
- size
- swap
- truncate

class cdg_insn_iterator_t (*args)

Proxy of C++ cdg_insn_iterator_t class.

__init__(self, mba_) -> cdg_insn_iterator_t

mba_: mba_t const *

__init__(self, r) -> cdg_insn_iterator_t

r: cdg_insn_iterator_t const &

Instance variables

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

Methods

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

class cdo_t (*args)

Proxy of C++ cdo_t class.

__init__(self) -> cdo_t

Ancestors

cloop_t
ceinsn_t

Methods

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

Inherited members

cloop_t:
- assign
- body
- cleanup
- expr

class ceinsn_t (*args)

Proxy of C++ ceinsn_t class.

__init__(self) -> ceinsn_t

Subclasses

cif_t
cloop_t
creturn_t
cswitch_t

Instance variables

var expr: ceinsn_t_expr_get(self) -> cexpr_t

class cexpr_t (*args)

Proxy of C++ cexpr_t class.

__init__(self) -> cexpr_t

cop: enum ctype_t _x: cexpr_t *

__init__(self, cop, _x, _y) -> cexpr_t

cop: enum ctype_t _x: cexpr_t * _y: cexpr_t *

__init__(self, cop, _x, _y, _z) -> cexpr_t

cop: enum ctype_t _x: cexpr_t * _y: cexpr_t * _z: cexpr_t *

__init__(self, r) -> cexpr_t

r: cexpr_t const &

Ancestors

citem_t

Subclasses

carg_t

Class variables

var op_to_typename

Instance variables

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

Methods

def assign(self, *args) ‑> cexpr_t &: assign(self, r) -> cexpr_t
r (C++: const cexpr_t &)
def calc_type(self, *args) ‑> void: Calculate the type of the expression. Use this function to calculate the expression type when a new expression is built

calc_type(self, recursive)
recursive: if true, types of all children expression will be
calculated before calculating our type (C++: bool)
def cleanup(self, *args) ‑> void: Cleanup the expression. This function properly deletes all children and sets the item type to cot_empty.
def compare(self, *args) ‑> int: compare(self, r) -> int
r: cexpr_t const &
def contains_comma(self, *args) ‑> bool: Does the expression contain a comma operator?

contains_comma(self, times=1) -> bool
times (C++: int)
def contains_comma_or_insn_or_label(self, *args) ‑> bool: Does the expression contain a comma operator or an embedded statement operator or a label?

contains_comma_or_insn_or_label(self, maxcommas=1) -> bool
maxcommas (C++: int)
def contains_insn(self, *args) ‑> bool: Does the expression contain an embedded statement operator?

contains_insn(self, times=1) -> bool
times (C++: int)
def contains_insn_or_label(self, *args) ‑> bool: Does the expression contain an embedded statement operator or a label?
def contains_operator(self, *args) ‑> bool: Check if the expression contains the specified operator.

contains_operator(self, needed_op, times=1) -> bool
needed_op: operator code to search for (C++: ctype_t)

times: how many times the operator code should be present (C++:
int)

return: true if the expression has at least TIMES children with
NEEDED_OP
def cpadone(self, *args) ‑> bool: Pointer arithmetic correction done for this expression?
def equal_effect(self, *args) ‑> bool: Compare two expressions. This function tries to compare two expressions in an 'intelligent' manner. For example, it knows about commutitive operators and can ignore useless casts.

equal_effect(self, r) -> bool
r: the expression to compare against the current expression
(C++: const cexpr_t &)

return: true expressions can be considered equal
def find_num_op(self, *args) ‑> cexpr_t *: Find the operand with a numeric value.
def find_op(self, *args) ‑> cexpr_t *: Find the child with the specified operator.

find_op(self, _op) -> cexpr_t
_op (C++: ctype_t)

find_op(self, _op) -> cexpr_t
_op (C++: ctype_t)
def get_1num_op(self, *args) ‑> bool: Get pointers to operands. at last one operand should be a number o1 will be pointer to the number

get_1num_op(self, o1, o2) -> bool
o1 (C++: cexpr_t **)

o2 (C++: cexpr_t **)
def get_const_value(self, *args) ‑> bool: Get expression value.
def get_high_nbit_bound(self, *args) ‑> bit_bound_t: Get max number of bits that can really be used by the expression. For example, x % 16 can yield only 4 non-zero bits, higher bits are zero
def get_low_nbit_bound(self, *args) ‑> int: Get min number of bits that are certainly required to represent the expression. For example, constant 16 always uses 5 bits: 10000.
def get_ptr_or_array(self, *args) ‑> cexpr_t *: Find pointer or array child.
def get_type_sign(self, *args) ‑> type_sign_t: Get expression sign.
def get_v(self, *args) ‑> var_ref_t *: get_v(self) -> var_ref_t
def has_side_effects(self, *args) ‑> bool: Check if the expression has side effects. Calls, pre/post inc/dec, and assignments have side effects.
def is_call_arg_of(self, *args) ‑> bool: Is call argument?

is_call_arg_of(self, parent) -> bool
parent (C++: const citem_t *)

return: true if our expression is a call argument of the specified
parent expression.
def is_call_object_of(self, *args) ‑> bool: Is call object?

is_call_object_of(self, parent) -> bool
parent (C++: const citem_t *)

return: true if our expression is the call object of the specified
parent expression.
def is_child_of(self, *args) ‑> bool: Verify if the specified item is our parent.

is_child_of(self, parent) -> bool
parent: possible parent item (C++: const citem_t *)

return: true if the specified item is our parent
def is_const_value(self, *args) ‑> bool: Check if the expression is a number with the specified value.

is_const_value(self, _v) -> bool
_v (C++: uint64)
def is_cstr(self, *args) ‑> bool: is_cstr(self) -> bool
def is_fpop(self, *args) ‑> bool: is_fpop(self) -> bool
def is_jumpout(self, *args) ‑> bool: is_jumpout(self) -> bool
def is_negative_const(self, *args) ‑> bool: Check if the expression is a negative number.
def is_nice_cond(self, *args) ‑> bool: Is nice condition?. Nice condition is a nice expression of the boolean type.
def is_nice_expr(self, *args) ‑> bool: Is nice expression? Nice expressions do not contain comma operators, embedded statements, or labels.
def is_non_negative_const(self, *args) ‑> bool: Check if the expression is a non-negative number.
def is_non_zero_const(self, *args) ‑> bool: Check if the expression is a non-zero number.
def is_odd_lvalue(self, *args) ‑> bool: is_odd_lvalue(self) -> bool
def is_type_signed(self, *args) ‑> bool: Is expression signed?
def is_type_unsigned(self, *args) ‑> bool: Is expression unsigned?
def is_undef_val(self, *args) ‑> bool: is_undef_val(self) -> bool
def is_vftable(self, *args) ‑> bool: is_vftable(self) -> bool
def is_zero_const(self, *args) ‑> bool: Check if the expression is a zero.
def maybe_ptr(self, *args) ‑> bool: May the expression be a pointer?
def numval(self, *args) ‑> uint64: Get numeric value of the expression. This function can be called only on cot_num expressions!
def print1(self, *args) ‑> void: Print expression into one line.

print1(self, func)
func: parent function. This argument is used to find out the
referenced variable names. (C++: const cfunc_t *)
def put_number(self, *args) ‑> void: Assign a number to the expression.

put_number(self, func, value, nbytes, sign=no_sign)
func: current function (C++: cfunc_t *)

value: number value (C++: uint64)

nbytes: size of the number in bytes (C++: int)

sign: number sign (C++: type_sign_t)
def requires_lvalue(self, *args) ‑> bool: Check if the expression requires an lvalue.

requires_lvalue(self, child) -> bool
child: The function will check if this child of our expression
must be an lvalue. (C++: const cexpr_t *)

return: true if child must be an lvalue.
def set_cpadone(self, *args) ‑> void: set_cpadone(self)
def set_v(self, *args) ‑> void: set_v(self, v)
v: var_ref_t const *
def set_vftable(self, *args) ‑> void: set_vftable(self)
def swap(self, *args) ‑> void: swap(self, r)
r (C++: cexpr_t &)
def theother(self, *args) ‑> cexpr_t *: Get the other operand. This function returns the other operand (not the specified one) for binary expressions.

theother(self, what) -> cexpr_t
what (C++: const cexpr_t *)

theother(self, what) -> cexpr_t
what (C++: const cexpr_t *)

Inherited members

citem_t:
- cexpr
- cinsn
- contains_expr
- contains_label
- ea
- find_closest_addr
- find_parent_of
- index
- is_expr
- label_num
- obj_id
- op
- to_specific_type

class cfor_t (*args)

Proxy of C++ cfor_t class.

__init__(self) -> cfor_t

Ancestors

cloop_t
ceinsn_t

Instance variables

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

Methods

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

Inherited members

cloop_t:
- assign
- body
- cleanup
- expr

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

ctree_parentee_t
ctree_visitor_t

Instance variables

var func: cfunc_parentee_t_func_get(self) -> cfunc_t

Methods

def calc_rvalue_type(self, *args) ‑> bool: Calculate rvalue type. This function tries to determine the type of the specified item based on its context. For example, if the current expression is the right side of an assignment operator, the type of its left side will be returned. This function can be used to determine the 'best' type of the specified expression.

calc_rvalue_type(self, target, e) -> bool
target: 'best' type of the expression will be returned here
(C++: tinfo_t *)

e: expression to determine the desired type (C++: const
cexpr_t *)

return: false if failed

Inherited members

ctree_parentee_t:
- apply_to
- apply_to_exprs
- clr_prune
- clr_restart
- cv_flags
- is_postorder
- leave_expr
- leave_insn
- maintain_parents
- must_prune
- must_restart
- only_insns
- parent_expr
- parent_insn
- parents
- prune_now
- recalc_parent_types
- set_restart
- visit_expr
- visit_insn

class cfunc_t (*args, **kwargs)

Proxy of C++ cfunc_t class.

Instance variables

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

Methods

def build_c_tree(self, *args) ‑> void: Generate the function body. This function (re)generates the function body from the underlying microcode.
def del_orphan_cmts(self, *args) ‑> int: Delete all orphan comments. The 'save_user_cmts()' function must be called after this call.
def find_item_coords(self, *args) ‑> PyObject *: find_item_coords(self, item, px, py) -> bool
item (C++: const citem_t *)

px (C++: int *)

py (C++: int *)

find_item_coords(self, item) -> PyObject *
item (C++: const citem_t *)
def find_label(self, *args) ‑> citem_t *: Find the label.

find_label(self, label) -> citem_t
label (C++: int)

return: pointer to the ctree item with the specified label number.
def gather_derefs(self, *args) ‑> bool: gather_derefs(self, ci, udm=None) -> bool
ci (C++: const ctree_item_t &)

udm (C++: udt_type_data_t *)
def get_boundaries(self, *args) ‑> boundaries_t &: Get pointer to map of instruction boundaries. This function initializes the boundary map if not done yet.
def get_eamap(self, *args) ‑> eamap_t &: Get pointer to ea->insn map. This function initializes eamap if not done yet.
def get_func_type(self, *args) ‑> bool: Get the function type.

get_func_type(self, type) -> bool
type: variable where the function type is returned (C++:
tinfo_t *)

return: false if failure
def get_line_item(self, *args) ‑> bool: Get ctree item for the specified cursor position. 'vdui_t::get_current_item()'

get_line_item(self, line, x, is_ctree_line, phead, pitem, ptail) -> bool
line: line of decompilation text (element of sv ) (C++: const
char *)

x: x cursor coordinate in the line (C++: int)

is_ctree_line: does the line belong to statement area? (if not,
it is assumed to belong to the declaration area) (C++: bool)

phead: ptr to the first item on the line (used to attach block
comments). May be NULL (C++: ctree_item_t *)

pitem: ptr to the current item. May be NULL (C++: ctree_item_t
*)

ptail: ptr to the last item on the line (used to attach
indented comments). May be NULL (C++: ctree_item_t *)

return: false if failed to get the current item
def get_lvars(self, *args) ‑> lvars_t *: Get vector of local variables.
def get_pseudocode(self, *args) ‑> strvec_t const &: Get pointer to decompilation output: the pseudocode. This function generates pseudocode if not done yet.
def get_stkoff_delta(self, *args) ‑> sval_t: Get stack offset delta. The local variable stack offsets retrieved by v.location.stkoff() should be adjusted before being used as stack frame offsets in IDA.
def get_user_cmt(self, *args) ‑> char const *: Retrieve a user defined comment.

get_user_cmt(self, loc, rt) -> char const *
loc: ctree location (C++: const treeloc_t &)

rt: should already retrieved comments retrieved again? (C++:
cmt_retrieval_type_t)

return: pointer to the comment string or NULL
def get_user_iflags(self, *args) ‑> int32: Retrieve citem iflags.

get_user_iflags(self, loc) -> int32
loc: citem locator (C++: const citem_locator_t &)

return: ctree item iflags bits or 0
def get_user_union_selection(self, *args) ‑> bool: Retrieve a user defined union field selection.

get_user_union_selection(self, ea, path) -> bool
ea: address (C++: ea_t)

path: out: path describing the union selection. (C++: intvec_t
*)

return: pointer to the path or NULL
def get_warnings(self, *args) ‑> hexwarns_t &: Get information about decompilation warnings.
def has_orphan_cmts(self, *args) ‑> bool: Check if there are orphan comments.
def locked(self, *args) ‑> bool: locked(self) -> bool
def print_dcl(self, *args) ‑> void: Print function prototype.
def print_func(self, *args) ‑> void: Print function text.

print_func(self, vp)
vp: printer helper class to receive the generated text. (C++:
vc_printer_t &)
def refresh_func_ctext(self, *args) ‑> void: Refresh ctext after a ctree modification. This function informs the decompiler that ctree ( 'body' ) have been modified and ctext ( 'sv' ) does not correspond to it anymore. It also refreshes the pseudocode windows if there is any.
def release(self, *args) ‑> void: release(self)
def remove_unused_labels(self, *args) ‑> void: Remove unused labels. This function check what labels are really used by the function and removes the unused ones.
def save_user_cmts(self, *args) ‑> void: Save user-defined comments into the database.
def save_user_iflags(self, *args) ‑> void: Save user-defined iflags into the database.
def save_user_labels(self, *args) ‑> void: Save user-defined labels into the database.
def save_user_numforms(self, *args) ‑> void: Save user-defined number formats into the database.
def save_user_unions(self, *args) ‑> void: Save user-defined union field selections into the database.
def set_user_cmt(self, *args) ‑> void: Set a user defined comment. This function stores the specified comment in the 'cfunc_t' structure. The 'save_user_cmts()' function must be called after it.

set_user_cmt(self, loc, cmt)
loc: ctree location (C++: const treeloc_t &)

cmt: new comment. if empty or NULL, then an existing comment is
deleted. (C++: const char *)
def set_user_iflags(self, *args) ‑> void: Set citem iflags.

set_user_iflags(self, loc, iflags)
loc: citem locator (C++: const citem_locator_t &)

iflags: new iflags (C++: int32)
def set_user_union_selection(self, *args) ‑> void: Set a union field selection. The 'save_user_unions()' function must be called after calling this function.

set_user_union_selection(self, ea, path)
ea: address (C++: ea_t)

path: in: path describing the union selection. (C++: const
intvec_t &)
def verify(self, *args) ‑> void: Verify the ctree. This function verifies the ctree. If the ctree is malformed, an internal error is generated. Use it to verify the ctree after your modifications.

verify(self, aul, even_without_debugger)
aul: Are unused labels acceptable? (C++: allow_unused_labels_t)

even_without_debugger: if false and there is no debugger, the
verification will be skipped (C++: bool)

class cfuncptr_t (*args)

Proxy of C++ qrefcnt_t< cfunc_t > class.

__init__(self, p) -> cfuncptr_t

p: cfunc_t *

__init__(self, r) -> cfuncptr_t

r: qrefcnt_t< cfunc_t > const &

Instance variables

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

Methods

def build_c_tree(self, *args) ‑> void: build_c_tree(self)
def del_orphan_cmts(self, *args) ‑> int: del_orphan_cmts(self) -> int
def find_item_coords(self, *args) ‑> PyObject *: find_item_coords(self, item, px, py) -> bool
item: citem_t const * px: int * py: int *

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

class cgoto_t (*args)

Proxy of C++ cgoto_t class.

__init__(self) -> cgoto_t

Instance variables

var label_num: cgoto_t_label_num_get(self) -> int

Methods

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

class chain_keeper_t (*args)

Proxy of C++ chain_keeper_t class.

__init__(self, _gc) -> chain_keeper_t

_gc: graph_chains_t *

Methods

def back(self, *args) ‑> block_chains_t &: back(self) -> block_chains_t
def for_all_chains(self, *args) ‑> int: for_all_chains(self, cv, gca) -> int
cv (C++: chain_visitor_t &)

gca (C++: int)
def front(self, *args) ‑> block_chains_t &: front(self) -> block_chains_t

class chain_t (*args)

Proxy of C++ chain_t class.

__init__(self) -> chain_t

t: mopt_t off: sval_t w: int v: int

__init__(self, _k, w=1) -> chain_t

_k: voff_t const & w: int

Ancestors

intvec_t

Instance variables

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

Methods

def append_list(self, *args) ‑> void: Append the contents of the chain to the specified list of locations.

append_list(self, mba, list)
mba (C++: const mba_t *)

list (C++: mlist_t *)
def clear_varnum(self, *args) ‑> void: clear_varnum(self)
def dstr(self, *args) ‑> char const *: dstr(self) -> char const *
def endoff(self, *args) ‑> voff_t const: endoff(self) -> voff_t
def get_reg(self, *args) ‑> mreg_t: get_reg(self) -> mreg_t
def get_stkoff(self, *args) ‑> sval_t: get_stkoff(self) -> sval_t
def includes(self, *args) ‑> bool: includes(self, r) -> bool
r (C++: const chain_t &)
def is_fake(self, *args) ‑> bool: is_fake(self) -> bool
def is_inited(self, *args) ‑> bool: is_inited(self) -> bool
def is_overlapped(self, *args) ‑> bool: is_overlapped(self) -> bool
def is_passreg(self, *args) ‑> bool: is_passreg(self) -> bool
def is_reg(self, *args) ‑> bool: is_reg(self) -> bool
def is_replaced(self, *args) ‑> bool: is_replaced(self) -> bool
def is_stkoff(self, *args) ‑> bool: is_stkoff(self) -> bool
def is_term(self, *args) ‑> bool: is_term(self) -> bool
def key(self, *args) ‑> voff_t const &: key(self) -> voff_t
def overlap(self, *args) ‑> bool: overlap(self, r) -> bool
r (C++: const chain_t &)
def set_inited(self, *args) ‑> void: set_inited(self, b)
b (C++: bool)
def set_overlapped(self, *args) ‑> void: set_overlapped(self, b)
b (C++: bool)
def set_replaced(self, *args) ‑> void: set_replaced(self, b)
b (C++: bool)
def set_term(self, *args) ‑> void: set_term(self, b)
b (C++: bool)
def set_value(self, *args) ‑> void: set_value(self, r)
r (C++: const chain_t &)

Inherited members

intvec_t:
- add_unique
- append
- at
- begin
- capacity
- clear
- empty
- end
- erase
- extract
- find
- has
- inject
- insert
- pop_back
- push_back
- qclear
- reserve
- resize
- size
- swap
- truncate

class chain_visitor_t (*args)

Proxy of C++ chain_visitor_t class.

__init__(self) -> chain_visitor_t

self: PyObject *

Instance variables

var parent: chain_visitor_t_parent_get(self) -> block_chains_t

Methods

def visit_chain(self, *args) ‑> int: visit_chain(self, nblock, ch) -> int
nblock (C++: int)

ch (C++: chain_t &)

class cif_t (*args)

Proxy of C++ cif_t class.

__init__(self) -> cif_t

r: cif_t const &

Ancestors

ceinsn_t

Instance variables

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

Methods

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

Inherited members

ceinsn_t:
- expr

class cinsn_t (*args)

Proxy of C++ cinsn_t class.

__init__(self) -> cinsn_t

r: cinsn_t const &

Ancestors

citem_t

Subclasses

ccase_t

Class variables

var op_to_typename

Static methods

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

Instance variables

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

Methods

def assign(self, *args) ‑> cinsn_t &: assign(self, r) -> cinsn_t
r (C++: const cinsn_t &)
def cleanup(self, *args) ‑> void: Cleanup the statement. This function properly deletes all children and sets the item type to cit_empty.
def collect_free_breaks(self, *args) ‑> bool: Collect free 'break' statements. This function finds all free 'break' statements within the current statement. A 'break' statement is free if it does not have a loop or switch parent that that is also within the current statement.

collect_free_breaks(self, breaks) -> bool
breaks: pointer to the variable where the vector of all found
free break statements is returned. This argument can be NULL. (C++: cinsnptrvec_t *)

return: true if some free break statements have been found
def collect_free_continues(self, *args) ‑> bool: Collect free 'continue' statements. This function finds all free 'continue' statements within the current statement. A 'continue' statement is free if it does not have a loop parent that that is also within the current statement.

collect_free_continues(self, continues) -> bool
continues: pointer to the variable where the vector of all
found free continue statements is returned. This argument can be NULL. (C++: cinsnptrvec_t *)

return: true if some free continue statements have been found
def compare(self, *args) ‑> int: compare(self, r) -> int
r: cinsn_t const &
def contains_free_break(self, *args) ‑> bool: Check if the statement has free 'break' statements.
def contains_free_continue(self, *args) ‑> bool: Check if the statement has free 'continue' statements.
def contains_insn(self, *args) ‑> bool: Check if the statement contains a statement of the specified type.

contains_insn(self, type, times=1) -> bool
type: statement opcode to look for (C++: ctype_t)

times: how many times TYPE should be present (C++: int)

return: true if the statement has at least TIMES children with opcode
== TYPE
def create_if(self, *args) ‑> cif_t &: Create a new if-statement. The current statement must be a block. The new statement will be appended to it.

create_if(self, cnd) -> cif_t
cnd: if condition. It will be deleted after being copied. (C++:
cexpr_t *)
def is_epilog(self)
def is_ordinary_flow(self, *args) ‑> bool: Check if the statement passes execution to the next statement.
def new_insn(self, *args) ‑> cinsn_t &: Create a new statement. The current statement must be a block. The new statement will be appended to it.

new_insn(self, insn_ea) -> cinsn_t
insn_ea: statement address (C++: ea_t)
def print1(self, *args) ‑> void: Print the statement into one line. Currently this function is not available.

print1(self, func)
func: parent function. This argument is used to find out the
referenced variable names. (C++: const cfunc_t *)
def swap(self, *args) ‑> void: swap(self, r)
r (C++: cinsn_t &)
def zero(self, *args) ‑> void: Overwrite with zeroes without cleaning memory or deleting children.

Inherited members

citem_t:
- cexpr
- cinsn
- contains_expr
- contains_label
- ea
- find_closest_addr
- find_parent_of
- index
- is_expr
- label_num
- obj_id
- op
- to_specific_type

class cinsnptrvec_t (*args)

Proxy of C++ qvector< cinsn_t * > class.

__init__(self) -> cinsnptrvec_t

x: qvector< cinsn_t * > const &

Methods

def add_unique(self, *args) ‑> bool: add_unique(self, x) -> bool
x: cinsn_t *const &
def append(self, *args) ‑> cinsn_t *&: push_back(self, x)
x: cinsn_t *const &
def at(self, *args) ‑> cinsn_t *const &: __getitem__(self, i) -> cinsn_t
i: size_t
def back(self)
def begin(self, *args) ‑> qvector< cinsn_t * >::const_iterator: begin(self) -> qvector< cinsn_t * >::iterator

begin(self) -> qvector< cinsn_t * >::const_iterator
def capacity(self, *args) ‑> size_t: capacity(self) -> size_t
def clear(self, *args) ‑> void: clear(self)
def empty(self, *args) ‑> bool: empty(self) -> bool
def end(self, *args) ‑> qvector< cinsn_t * >::const_iterator: end(self) -> qvector< cinsn_t * >::iterator

end(self) -> qvector< cinsn_t * >::const_iterator
def erase(self, *args) ‑> qvector< cinsn_t * >::iterator: erase(self, it) -> qvector< cinsn_t * >::iterator
it: qvector< cinsn_t * >::iterator

erase(self, first, last) -> qvector< cinsn_t * >::iterator
first: qvector< cinsn_t * >::iterator last: qvector< cinsn_t * >::iterator
def extract(self, *args) ‑> cinsn_t **: extract(self) -> cinsn_t **
def find(self, *args) ‑> qvector< cinsn_t * >::const_iterator: find(self, x) -> qvector< cinsn_t * >::iterator
x: cinsn_t *const &

find(self, x) -> qvector< cinsn_t * >::const_iterator
x: cinsn_t *const &
def front(self)
def has(self, *args) ‑> bool: has(self, x) -> bool
x: cinsn_t *const &
def inject(self, *args) ‑> void: inject(self, s, len)
s: cinsn_t ** len: size_t
def insert(self, *args) ‑> qvector< cinsn_t * >::iterator: insert(self, it, x) -> qvector< cinsn_t * >::iterator
it: qvector< cinsn_t * >::iterator x: cinsn_t *const &
def pop_back(self, *args) ‑> void: pop_back(self)
def push_back(self, *args) ‑> cinsn_t *&: push_back(self, x)
x: cinsn_t *const &
def qclear(self, *args) ‑> void: qclear(self)
def reserve(self, *args) ‑> void: reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void: resize(self, _newsize, x)
_newsize: size_t x: cinsn_t *const &

resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t: size(self) -> size_t
def swap(self, *args) ‑> void: swap(self, r)
r: qvector< cinsn_t * > &
def truncate(self, *args) ‑> void: truncate(self)

class citem_cmt_t (*args)

Proxy of C++ citem_cmt_t class.

__init__(self) -> citem_cmt_t

s: char const *

Instance variables

var used: citem_cmt_t_used_get(self) -> bool

Methods

def c_str(self, *args) ‑> char const *: c_str(self) -> char const *

class citem_locator_t (*args)

Proxy of C++ citem_locator_t class.

__init__(self, _ea, _op) -> citem_locator_t

_ea: ea_t _op: enum ctype_t

__init__(self, i) -> citem_locator_t

i: citem_t const *

Instance variables

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

Methods

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

class citem_t (*args)

Proxy of C++ citem_t class.

__init__(self) -> citem_t

o: enum ctype_t

Subclasses

cexpr_t
cinsn_t

Instance variables

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

Methods

def contains_expr(self, *args) ‑> bool: Does the item contain an expression?

contains_expr(self, e) -> bool
e (C++: const cexpr_t *)
def contains_label(self, *args) ‑> bool: Does the item contain a label?
def find_closest_addr(self, *args) ‑> citem_t *: find_closest_addr(self, _ea) -> citem_t
_ea (C++: ea_t)
def find_parent_of(self, *args) ‑> citem_t *: Find parent of the specified item.

find_parent_of(self, sitem) -> citem_t
sitem: Item to find the parent of. The search will be performed
among the children of the item pointed by this . (C++: const citem_t *)

return: NULL if not found

find_parent_of(self, item) -> citem_t
item: citem_t const *

return: NULL if not found
def is_expr(self, *args) ‑> bool: Is an expression?
def print1(self, *args) ‑> void: Print item into one line.

print1(self, func)
func: parent function. This argument is used to find out the
referenced variable names. (C++: const cfunc_t *)

return: length of the generated text.
def replace_by(self, o)
def swap(self, *args) ‑> void: Swap two 'citem_t' .

swap(self, r)
r (C++: citem_t &)

class cloop_t (*args)

Proxy of C++ cloop_t class.

__init__(self) -> cloop_t

b: cinsn_t *

__init__(self, r) -> cloop_t

r: cloop_t const &

Ancestors

ceinsn_t

Subclasses

cdo_t
cfor_t
cwhile_t

Instance variables

var body: cloop_t_body_get(self) -> cinsn_t

Methods

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

Inherited members

ceinsn_t:
- expr

class cnumber_t (*args)

Proxy of C++ cnumber_t class.

__init__(self, _opnum=0) -> cnumber_t

_opnum: int

Instance variables

var nf: cnumber_t_nf_get(self) -> number_format_t

Methods

def assign(self, *args) ‑> void: Assign new value

assign(self, v, nbytes, sign)
v: new value (C++: uint64)

nbytes: size of the new value in bytes (C++: int)

sign: sign of the value (C++: type_sign_t)
def compare(self, *args) ‑> int: compare(self, r) -> int
r: cnumber_t const &
def value(self, *args) ‑> uint64: Get value. This function will properly extend the number sign to 64bits depending on the type sign.

value(self, type) -> uint64
type (C++: const tinfo_t &)

class codegen_t (*args, **kwargs)

Proxy of C++ codegen_t class.

Instance variables

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

Methods

def analyze_prolog(self, *args) ‑> merror_t: Analyze prolog/epilog of the function to decompile. If prolog is found, allocate and fill 'mba->pi' structure.

analyze_prolog(self, fc, reachable) -> merror_t
fc: flow chart (C++: const class qflow_chart_t &)

reachable: bitmap of reachable blocks (C++: const class
bitset_t &)

return: error code
def emit(self, *args) ‑> minsn_t *: Emit one microinstruction. The L, R, D arguments usually mean the register number. However, they depend on CODE. For example:for m_goto and m_jcnd L is the target addressfor m_ldc L is the constant value to load

emit(self, code, width, l, r, d, offsize) -> minsn_t
code (C++: mcode_t)

width (C++: int)

l (C++: uval_t)

r (C++: uval_t)

d (C++: uval_t)

offsize (C++: int)

return: created microinstruction. can be NULL if the instruction got
immediately optimized away.

emit(self, code, l, r, d) -> minsn_t
code (C++: mcode_t)

l (C++: uval_t)

r (C++: uval_t)

d (C++: uval_t)

return: created microinstruction. can be NULL if the instruction got
immediately optimized away.
def emit_micro_mvm(self, *args) ‑> minsn_t *: Emit one microinstruction. This variant takes a data type not a size.

emit_micro_mvm(self, code, dtype, l, r, d, offsize) -> minsn_t
code (C++: mcode_t)

dtype (C++: op_dtype_t)

l (C++: uval_t)

r (C++: uval_t)

d (C++: uval_t)

offsize (C++: int)
def gen_micro(self, *args) ‑> merror_t: Generate microcode for one instruction. The instruction is in INSN
def load_effective_address(self, *args) ‑> mreg_t: Generate microcode to calculate the address of a memory operand.

load_effective_address(self, n, flags=0) -> mreg_t
n: - number of INSN operand (C++: int)

flags: - reserved for future use (C++: int)

return: register containing the operand address. mr_none - failed
(not a memory operand)
def load_operand(self, *args) ‑> mreg_t: Generate microcode to load one operand.

load_operand(self, opnum, flags=0) -> mreg_t
opnum (C++: int)

flags: - reserved for future use (C++: int)

return: register containing the operand.
def microgen_completed(self, *args) ‑> void: This method is called when the microcode generation is done.
def prepare_gen_micro(self, *args) ‑> merror_t: Setup internal data to handle new instruction. This method should be called before calling 'gen_micro()' . Usually 'gen_micro()' is called by the decompiler. You have to call this function explicitly only if you yourself call 'gen_micro()' . The instruction is in INSN
def store_operand(self, *args) ‑> bool: Generate microcode to store an operand. In case of success an arbitrary number of instructions can be generated (and even no instruction if the source and target are the same)

store_operand(self, n, mop, flags=0, outins=None) -> bool
n: - number of target INSN operand (C++: int)

mop: - operand to be stored (C++: const mop_t &)

flags: - reserved for future use (C++: int)

outins: - (OUT) the last generated instruction (C++: minsn_t
**)

return: success

class creturn_t (*args)

Proxy of C++ creturn_t class.

__init__(self) -> creturn_t

Ancestors

ceinsn_t

Methods

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

Inherited members

ceinsn_t:
- expr

class cswitch_t (*args)

Proxy of C++ cswitch_t class.

__init__(self) -> cswitch_t

Ancestors

ceinsn_t

Instance variables

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

Methods

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

Inherited members

ceinsn_t:
- expr

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

history_item_t

Instance variables

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

Methods

def compare(self, *args) ‑> int: compare(self, r) -> int
r: ctext_position_t const &
def in_ctree(self, *args) ‑> bool: Is the cursor in the variable/type declaration area?

in_ctree(self, hdrlines) -> bool
hdrlines: Number of lines of the declaration area (C++: int)

class ctree_anchor_t (*args)

Proxy of C++ ctree_anchor_t class.

__init__(self) -> ctree_anchor_t

Instance variables

var value: ctree_anchor_t_value_get(self) -> uval_t

Methods

def get_index(self, *args) ‑> int: get_index(self) -> int
def get_itp(self, *args) ‑> item_preciser_t: get_itp(self) -> item_preciser_t
def is_blkcmt_anchor(self, *args) ‑> bool: is_blkcmt_anchor(self) -> bool
def is_citem_anchor(self, *args) ‑> bool: is_citem_anchor(self) -> bool
def is_itp_anchor(self, *args) ‑> bool: is_itp_anchor(self) -> bool
def is_lvar_anchor(self, *args) ‑> bool: is_lvar_anchor(self) -> bool
def is_valid_anchor(self, *args) ‑> bool: is_valid_anchor(self) -> bool

class ctree_item_t (*args)

Proxy of C++ ctree_item_t class.

__init__(self) -> ctree_item_t

Instance variables

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

Methods

def get_ea(self, *args) ‑> ea_t: Get address of the current item. Each ctree item has an address.
def get_label_num(self, *args) ‑> int: Get label number of the current item.

get_label_num(self, gln_flags) -> int
gln_flags: Combination of get_label_num control bits (C++:
int)

return: -1 if failed or no label
def get_lvar(self, *args) ‑> lvar_t *: Get pointer to local variable. If the current item is a local variable, this function will return pointer to its definition.
def get_memptr(self, *args) ‑> member_t *: Get pointer to structure member. If the current item is a structure field, this function will return pointer to its definition.

get_memptr(self, p_sptr=None) -> member_t *
p_sptr: pointer to the variable where the pointer to the parent
structure is returned. This parameter can be NULL. (C++: struc_t **)

return: NULL if failed
def is_citem(self, *args) ‑> bool: Is the current item is a ctree item?

class ctree_items_t (*args)

Proxy of C++ qvector< citem_t * > class.

__init__(self) -> ctree_items_t

x: qvector< citem_t * > const &

Methods

def add_unique(self, *args) ‑> bool: add_unique(self, x) -> bool
x: citem_t *const &
def append(self, *args) ‑> citem_t *&: push_back(self, x)
x: citem_t *const &
def at(self, *args) ‑> citem_t *const &: __getitem__(self, i) -> citem_t
i: size_t
def back(self)
def begin(self, *args) ‑> qvector< citem_t * >::const_iterator: begin(self) -> qvector< citem_t * >::iterator

begin(self) -> qvector< citem_t * >::const_iterator
def capacity(self, *args) ‑> size_t: capacity(self) -> size_t
def clear(self, *args) ‑> void: clear(self)
def empty(self, *args) ‑> bool: empty(self) -> bool
def end(self, *args) ‑> qvector< citem_t * >::const_iterator: end(self) -> qvector< citem_t * >::iterator

end(self) -> qvector< citem_t * >::const_iterator
def erase(self, *args) ‑> qvector< citem_t * >::iterator: erase(self, it) -> qvector< citem_t * >::iterator
it: qvector< citem_t * >::iterator

erase(self, first, last) -> qvector< citem_t * >::iterator
first: qvector< citem_t * >::iterator last: qvector< citem_t * >::iterator
def extract(self, *args) ‑> citem_t **: extract(self) -> citem_t **
def find(self, *args) ‑> qvector< citem_t * >::const_iterator: find(self, x) -> qvector< citem_t * >::iterator
x: citem_t *const &

find(self, x) -> qvector< citem_t * >::const_iterator
x: citem_t *const &
def front(self)
def has(self, *args) ‑> bool: has(self, x) -> bool
x: citem_t *const &
def inject(self, *args) ‑> void: inject(self, s, len)
s: citem_t ** len: size_t
def insert(self, *args) ‑> qvector< citem_t * >::iterator: insert(self, it, x) -> qvector< citem_t * >::iterator
it: qvector< citem_t * >::iterator x: citem_t *const &
def pop_back(self, *args) ‑> void: pop_back(self)
def push_back(self, *args) ‑> citem_t *&: push_back(self, x)
x: citem_t *const &
def qclear(self, *args) ‑> void: qclear(self)
def reserve(self, *args) ‑> void: reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void: resize(self, _newsize, x)
_newsize: size_t x: citem_t *const &

resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t: size(self) -> size_t
def swap(self, *args) ‑> void: swap(self, r)
r: qvector< citem_t * > &
def truncate(self, *args) ‑> void: truncate(self)

class ctree_parentee_t (*args)

Proxy of C++ ctree_parentee_t class.

__init__(self, post=False) -> ctree_parentee_t

post: bool

Ancestors

ctree_visitor_t

Subclasses

cfunc_parentee_t

Methods

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

Inherited members

ctree_visitor_t:
- apply_to
- apply_to_exprs
- clr_prune
- clr_restart
- cv_flags
- is_postorder
- leave_expr
- leave_insn
- maintain_parents
- must_prune
- must_restart
- only_insns
- parent_expr
- parent_insn
- parents
- prune_now
- set_restart
- visit_expr
- visit_insn

class ctree_visitor_t (*args)

Proxy of C++ ctree_visitor_t class.

__init__(self, _flags) -> ctree_visitor_t

_flags: int

Subclasses

ctree_parentee_t

Instance variables

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

Methods

def apply_to(self, *args) ‑> int: Traverse ctree. The traversal will start at the specified item and continue until of one the visit_...() functions return a non-zero value.

apply_to(self, item, parent) -> int
item: root of the ctree to traverse (C++: citem_t *)

parent: parent of the specified item. can be specified as NULL.
(C++: citem_t *)

return: 0 or a non-zero value returned by a visit_...() function
def apply_to_exprs(self, *args) ‑> int: Traverse only expressions. The traversal will start at the specified item and continue until of one the visit_...() functions return a non- zero value.

apply_to_exprs(self, item, parent) -> int
item: root of the ctree to traverse (C++: citem_t *)

parent: parent of the specified item. can be specified as NULL.
(C++: citem_t *)

return: 0 or a non-zero value returned by a visit_...() function
def clr_prune(self, *args) ‑> void: Do not prune children. This is an internal function, no need to call it.
def clr_restart(self, *args) ‑> void: Do not restart. This is an internal function, no need to call it.
def is_postorder(self, *args) ‑> bool: Should the leave...() functions be called?
def leave_expr(self, *args) ‑> int: Visit an expression after having visited its children This is a visitor function which should be overridden by a derived class to do some useful work. This visitor performs post-order traserval, i.e. an item is visited after its children.

leave_expr(self, arg0) -> int
arg0: cexpr_t *

return: 0 to continue the traversal, nonzero to stop.
def leave_insn(self, *args) ‑> int: Visit a statement after having visited its children This is a visitor function which should be overridden by a derived class to do some useful work. This visitor performs post-order traserval, i.e. an item is visited after its children.

leave_insn(self, arg0) -> int
arg0: cinsn_t *

return: 0 to continue the traversal, nonzero to stop.
def maintain_parents(self, *args) ‑> bool: Should the parent information by maintained?
def must_prune(self, *args) ‑> bool: Should the traversal skip the children of the current item?
def must_restart(self, *args) ‑> bool: Should the traversal restart?
def only_insns(self, *args) ‑> bool: Should all expressions be automatically pruned?
def parent_expr(self, *args) ‑> cexpr_t *: Get parent of the current item as an expression.
def parent_insn(self, *args) ‑> cinsn_t *: Get parent of the current item as a statement.
def prune_now(self, *args) ‑> void: Prune children. This function may be called by a visitor() to skip all children of the current item.
def set_restart(self, *args) ‑> void: Restart the travesal. Meaningful only in 'apply_to_exprs()'
def visit_expr(self, *args) ‑> int: Visit an expression. This is a visitor function which should be overridden by a derived class to do some useful work. This visitor performs pre-order traserval, i.e. an item is visited before its children.

visit_expr(self, arg0) -> int
arg0: cexpr_t *

return: 0 to continue the traversal, nonzero to stop.
def visit_insn(self, *args) ‑> int: Visit a statement. This is a visitor function which should be overridden by a derived class to do some useful work. This visitor performs pre-order traserval, i.e. an item is visited before its children.

visit_insn(self, arg0) -> int
arg0: cinsn_t *

return: 0 to continue the traversal, nonzero to stop.

class cwhile_t (*args)

Proxy of C++ cwhile_t class.

__init__(self) -> cwhile_t

Ancestors

cloop_t
ceinsn_t

Methods

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

Inherited members

cloop_t:
- assign
- body
- cleanup
- expr

class eamap_iterator_t (*args)

Proxy of C++ eamap_iterator_t class.

__init__(self) -> eamap_iterator_t

Instance variables

var x: eamap_iterator_t_x_get(self) -> iterator_word

class eamap_t (*args)

Proxy of C++ std::map< ea_t,cinsnptrvec_t > class.

__init__(self) -> eamap_t

Class variables

var keytype: int([x]) -> integer

int(x, base=10) -> integer
Convert a number or string to an integer, or return 0 if no arguments are given. If x is a number, return x.__int__(). For floating point numbers, this truncates towards zero.

If x is not a number or if base is given, then x must be a string, bytes, or bytearray instance representing an integer literal in the given base. The literal can be preceded by '+' or '-' and be surrounded by whitespace. The base defaults to 10. Valid bases are 0 and 2-36. Base 0 means to interpret the base from the string as an integer literal. >>> int('0b100', base=0) 4
var valuetype: Proxy of C++ qvector< cinsn_t * > class.

Methods

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

class fnumber_t (*args)

Proxy of C++ fnumber_t class.

__init__(self) -> fnumber_t

Instance variables

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

Methods

def compare(self, *args) ‑> int: compare(self, r) -> int
r: fnumber_t const &
def dereference_const_uint16(self, *args) ‑> uint16 const *: dereference_const_uint16(self) -> uint16 const *
def dereference_uint16(self, *args) ‑> uint16 *: dereference_uint16(self) -> uint16 *

class gco_info_t (*args)

Proxy of C++ gco_info_t class.

__init__(self) -> gco_info_t

Instance variables

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

Methods

def append_to_list(self, *args) ‑> bool: Append operand info to LIST. This function converts IDA register number or stack offset to a decompiler list.

append_to_list(self, list, mba) -> bool
list: list to append to (C++: mlist_t *)

mba: microcode object (C++: const mba_t *)
def cvt_to_ivl(self, *args) ‑> vivl_t: Convert operand info to VIVL. The returned VIVL can be used, for example, in a call of get_valranges().
def is_def(self, *args) ‑> bool: is_def(self) -> bool
def is_reg(self, *args) ‑> bool: is_reg(self) -> bool
def is_use(self, *args) ‑> bool: is_use(self) -> bool

class graph_chains_t (*args)

Proxy of C++ graph_chains_t class.

__init__(self) -> graph_chains_t

Ancestors

block_chains_vec_t

Methods

def acquire(self, *args) ‑> void: Lock the chains.
def for_all_chains(self, *args) ‑> int: Visit all chains

for_all_chains(self, cv, gca_flags) -> int
cv: chain visitor (C++: chain_visitor_t &)

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

Inherited members

block_chains_vec_t:
- at
- begin
- capacity
- clear
- empty
- end
- erase
- extract
- grow
- inject
- insert
- pop_back
- push_back
- qclear
- reserve
- resize
- size
- truncate

class hexrays_failure_t (*args)

Proxy of C++ hexrays_failure_t class.

__init__(self) -> hexrays_failure_t

c: enum merror_t ea: ea_t buf: char const *

__init__(self, c, ea, buf) -> hexrays_failure_t

c: enum merror_t ea: ea_t buf: qstring const &

Instance variables

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

Methods

def desc(self, *args) ‑> qstring: desc(self) -> qstring

class hexwarn_t (*args)

Proxy of C++ hexwarn_t class.

__init__(self) -> hexwarn_t

Instance variables

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

Methods

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

class hexwarns_t (*args)

Proxy of C++ qvector< hexwarn_t > class.

__init__(self) -> hexwarns_t

x: qvector< hexwarn_t > const &

Methods

def add_unique(self, *args) ‑> bool: add_unique(self, x) -> bool
x: hexwarn_t const &
def append(self, *args) ‑> hexwarn_t &: push_back(self, x)
x: hexwarn_t const &
def at(self, *args) ‑> hexwarn_t const &: __getitem__(self, i) -> hexwarn_t
i: size_t
def back(self)
def begin(self, *args) ‑> qvector< hexwarn_t >::const_iterator: begin(self) -> hexwarn_t

begin(self) -> hexwarn_t
def capacity(self, *args) ‑> size_t: capacity(self) -> size_t
def clear(self, *args) ‑> void: clear(self)
def empty(self, *args) ‑> bool: empty(self) -> bool
def end(self, *args) ‑> qvector< hexwarn_t >::const_iterator: end(self) -> hexwarn_t

end(self) -> hexwarn_t
def erase(self, *args) ‑> qvector< hexwarn_t >::iterator: erase(self, it) -> hexwarn_t
it: qvector< hexwarn_t >::iterator

erase(self, first, last) -> hexwarn_t
first: qvector< hexwarn_t >::iterator last: qvector< hexwarn_t >::iterator
def extract(self, *args) ‑> hexwarn_t *: extract(self) -> hexwarn_t
def find(self, *args) ‑> qvector< hexwarn_t >::const_iterator: find(self, x) -> hexwarn_t
x: hexwarn_t const &

find(self, x) -> hexwarn_t
x: hexwarn_t const &
def front(self)
def grow(self, *args) ‑> void: grow(self, x=hexwarn_t())
x: hexwarn_t const &
def has(self, *args) ‑> bool: has(self, x) -> bool
x: hexwarn_t const &
def inject(self, *args) ‑> void: inject(self, s, len)
s: hexwarn_t * len: size_t
def insert(self, *args) ‑> qvector< hexwarn_t >::iterator: insert(self, it, x) -> hexwarn_t
it: qvector< hexwarn_t >::iterator x: hexwarn_t const &
def pop_back(self, *args) ‑> void: pop_back(self)
def push_back(self, *args) ‑> hexwarn_t &: push_back(self, x)
x: hexwarn_t const &
def qclear(self, *args) ‑> void: qclear(self)
def reserve(self, *args) ‑> void: reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void: resize(self, _newsize, x)
_newsize: size_t x: hexwarn_t const &

resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t: size(self) -> size_t
def swap(self, *args) ‑> void: swap(self, r)
r: qvector< hexwarn_t > &
def truncate(self, *args) ‑> void: truncate(self)

class history_item_t (*args)

Proxy of C++ history_item_t class.

__init__(self, _ea=BADADDR, _lnnum=-1, _x=0, _y=0) -> history_item_t

_ea: ea_t _lnnum: int _x: int _y: int

__init__(self, _ea, p) -> history_item_t

_ea: ea_t p: ctext_position_t const &

Ancestors

ctext_position_t

Instance variables

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

Inherited members

ctext_position_t:
- compare
- in_ctree
- lnnum
- x
- y

class history_t (*args)

Proxy of C++ qstack< history_item_t > class.

__init__(self) -> history_t

Ancestors

qvector_history_t

Methods

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

top(self) -> history_item_t

Inherited members

qvector_history_t:
- add_unique
- begin
- capacity
- clear
- empty
- end
- erase
- extract
- find
- grow
- has
- inject
- insert
- pop_back
- push_back
- qclear
- reserve
- resize
- size
- swap
- truncate

class iterator (*args)

Proxy of C++ bitset_t::iterator class.

__init__(self, n=-1) -> iterator

n: int

class ivl_t (*args)

Proxy of C++ ivl_t class.

__init__(self, _off, _size) -> ivl_t

_off: uval_t _size: uval_t

Ancestors

uval_ivl_t

Methods

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

Inherited members

uval_ivl_t:
- end
- last
- off
- size
- valid

class ivl_with_name_t (*args)

Proxy of C++ ivl_with_name_t class.

__init__(self) -> ivl_with_name_t

Instance variables

var ivl: ivl_with_name_t_ivl_get(self) -> ivl_t
var part: ivl_with_name_t_part_get(self) -> char const *
var whole: ivl_with_name_t_whole_get(self) -> char const *

class ivlset_t (*args)

Proxy of C++ ivlset_t class.

__init__(self) -> ivlset_t

ivl: ivl_t const &

Ancestors

uval_ivl_ivlset_t

Methods

def add(self, *args) ‑> bool: add(self, ivl) -> bool
ivl (C++: const ivl_t &)

add(self, ea, size) -> bool
ea: ea_t size: asize_t

add(self, ivs) -> bool
ivs: ivlset_t const &
def addmasked(self, *args) ‑> bool: addmasked(self, ivs, mask) -> bool
ivs (C++: const ivlset_t &)

mask (C++: const ivl_t &)
def compare(self, *args) ‑> int: compare(self, r) -> int
r: ivlset_t const &
def contains(self, *args) ‑> bool: contains(self, off) -> bool
off (C++: uval_t)
def count(self, *args) ‑> asize_t: count(self) -> asize_t
def dstr(self, *args) ‑> char const *: dstr(self) -> char const *
def has_common(self, *args) ‑> bool: has_common(self, ivl, strict=False) -> bool
ivl (C++: const ivl_t &)

strict (C++: bool)

has_common(self, ivs) -> bool
ivs: ivlset_t const &
def includes(self, *args) ‑> bool: includes(self, ivs) -> bool
ivs (C++: const ivlset_t &)
def intersect(self, *args) ‑> bool: intersect(self, ivs) -> bool
ivs (C++: const ivlset_t &)
def sub(self, *args) ‑> bool: sub(self, ivl) -> bool
ivl (C++: const ivl_t &)

sub(self, ea, size) -> bool
ea: ea_t size: asize_t

sub(self, ivs) -> bool
ivs: ivlset_t const &

Inherited members

uval_ivl_ivlset_t:
- all_values
- begin
- clear
- empty
- end
- getivl
- lastivl
- nivls
- qclear
- set_all_values
- single_value
- swap

class lvar_locator_t (*args)

Proxy of C++ lvar_locator_t class.

__init__(self) -> lvar_locator_t

loc: vdloc_t const & ea: ea_t

Subclasses

lvar_t

Instance variables

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

Methods

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

class lvar_mapping_iterator_t (*args)

Proxy of C++ lvar_mapping_iterator_t class.

__init__(self) -> lvar_mapping_iterator_t

Instance variables

var x: lvar_mapping_iterator_t_x_get(self) -> iterator_word

class lvar_mapping_t (*args)

Proxy of C++ std::map< lvar_locator_t,lvar_locator_t > class.

__init__(self) -> lvar_mapping_t

Methods

def at(self, *args) ‑> lvar_locator_t &: at(self, _Keyval) -> lvar_locator_t
_Keyval: lvar_locator_t const &
def size(self, *args) ‑> size_t: size(self) -> size_t

class lvar_ref_t (*args)

Proxy of C++ lvar_ref_t class.

__init__(self, m, i, o=0) -> lvar_ref_t

m: mba_t * i: int o: sval_t

__init__(self, r) -> lvar_ref_t

r: lvar_ref_t const &

Instance variables

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

Methods

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

class lvar_saved_info_t (*args)

Proxy of C++ lvar_saved_info_t class.

__init__(self) -> lvar_saved_info_t

Instance variables

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

Methods

def clear_keep(self, *args) ‑> void: clear_keep(self)
def clr_forced_lvar(self, *args) ‑> void: clr_forced_lvar(self)
def clr_nomap_lvar(self, *args) ‑> void: clr_nomap_lvar(self)
def clr_noptr_lvar(self, *args) ‑> void: clr_noptr_lvar(self)
def clr_unused_lvar(self, *args) ‑> void: clr_unused_lvar(self)
def has_info(self, *args) ‑> bool: has_info(self) -> bool
def is_forced_lvar(self, *args) ‑> bool: is_forced_lvar(self) -> bool
def is_kept(self, *args) ‑> bool: is_kept(self) -> bool
def is_nomap_lvar(self, *args) ‑> bool: is_nomap_lvar(self) -> bool
def is_noptr_lvar(self, *args) ‑> bool: is_noptr_lvar(self) -> bool
def is_unused_lvar(self, *args) ‑> bool: is_unused_lvar(self) -> bool
def set_forced_lvar(self, *args) ‑> void: set_forced_lvar(self)
def set_keep(self, *args) ‑> void: set_keep(self)
def set_nomap_lvar(self, *args) ‑> void: set_nomap_lvar(self)
def set_noptr_lvar(self, *args) ‑> void: set_noptr_lvar(self)
def set_unused_lvar(self, *args) ‑> void: set_unused_lvar(self)

class lvar_saved_infos_t (*args)

Proxy of C++ qvector< lvar_saved_info_t > class.

__init__(self) -> lvar_saved_infos_t

x: qvector< lvar_saved_info_t > const &

Methods

def add_unique(self, *args) ‑> bool: add_unique(self, x) -> bool
x: lvar_saved_info_t const &
def append(self, *args) ‑> lvar_saved_info_t &: push_back(self, x)
x: lvar_saved_info_t const &
def at(self, *args) ‑> lvar_saved_info_t const &: __getitem__(self, i) -> lvar_saved_info_t
i: size_t
def back(self)
def begin(self, *args) ‑> qvector< lvar_saved_info_t >::const_iterator: begin(self) -> lvar_saved_info_t

begin(self) -> lvar_saved_info_t
def capacity(self, *args) ‑> size_t: capacity(self) -> size_t
def clear(self, *args) ‑> void: clear(self)
def empty(self, *args) ‑> bool: empty(self) -> bool
def end(self, *args) ‑> qvector< lvar_saved_info_t >::const_iterator: end(self) -> lvar_saved_info_t

end(self) -> lvar_saved_info_t
def erase(self, *args) ‑> qvector< lvar_saved_info_t >::iterator: erase(self, it) -> lvar_saved_info_t
it: qvector< lvar_saved_info_t >::iterator

erase(self, first, last) -> lvar_saved_info_t
first: qvector< lvar_saved_info_t >::iterator last: qvector< lvar_saved_info_t >::iterator
def extract(self, *args) ‑> lvar_saved_info_t *: extract(self) -> lvar_saved_info_t
def find(self, *args) ‑> qvector< lvar_saved_info_t >::const_iterator: find(self, x) -> lvar_saved_info_t
x: lvar_saved_info_t const &

find(self, x) -> lvar_saved_info_t
x: lvar_saved_info_t const &
def front(self)
def grow(self, *args) ‑> void: grow(self, x=lvar_saved_info_t())
x: lvar_saved_info_t const &
def has(self, *args) ‑> bool: has(self, x) -> bool
x: lvar_saved_info_t const &
def inject(self, *args) ‑> void: inject(self, s, len)
s: lvar_saved_info_t * len: size_t
def insert(self, *args) ‑> qvector< lvar_saved_info_t >::iterator: insert(self, it, x) -> lvar_saved_info_t
it: qvector< lvar_saved_info_t >::iterator x: lvar_saved_info_t const &
def pop_back(self, *args) ‑> void: pop_back(self)
def push_back(self, *args) ‑> lvar_saved_info_t &: push_back(self, x)
x: lvar_saved_info_t const &
def qclear(self, *args) ‑> void: qclear(self)
def reserve(self, *args) ‑> void: reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void: resize(self, _newsize, x)
_newsize: size_t x: lvar_saved_info_t const &

resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t: size(self) -> size_t
def swap(self, *args) ‑> void: swap(self, r)
r: qvector< lvar_saved_info_t > &
def truncate(self, *args) ‑> void: truncate(self)

class lvar_t (*args, **kwargs)

Proxy of C++ lvar_t class.

__init__(self) -> lvar_locator_t

loc: vdloc_t const & ea: ea_t

Ancestors

lvar_locator_t

Instance variables

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

Methods

def accepts_type(self, *args) ‑> bool: Check if the variable accept the specified type. Some types are forbidden (void, function types, wrong arrays, etc)

accepts_type(self, t, may_change_thisarg=False) -> bool
t (C++: const tinfo_t &)

may_change_thisarg (C++: bool)
def append_list(self, *args) ‑> void: Append local variable to mlist.

append_list(self, mba, lst, pad_if_scattered=False)
mba: ptr to the current mba_t (C++: const mba_t *)

lst: list to append to (C++: mlist_t *)

pad_if_scattered (C++: bool)
def clear_used(self, *args) ‑> void: clear_used(self)
def clr_arg_var(self, *args) ‑> void: clr_arg_var(self)
def clr_automapped(self, *args) ‑> void: clr_automapped(self)
def clr_decl_unused(self, *args) ‑> void: clr_decl_unused(self)
def clr_dummy_arg(self, *args) ‑> void: clr_dummy_arg(self)
def clr_fake_var(self, *args) ‑> void: clr_fake_var(self)
def clr_floating_var(self, *args) ‑> void: clr_floating_var(self)
def clr_forced_var(self, *args) ‑> void: clr_forced_var(self)
def clr_mapdst_var(self, *args) ‑> void: clr_mapdst_var(self)
def clr_mreg_done(self, *args) ‑> void: clr_mreg_done(self)
def clr_noptr_var(self, *args) ‑> void: clr_noptr_var(self)
def clr_notarg(self, *args) ‑> void: clr_notarg(self)
def clr_overlapped_var(self, *args) ‑> void: clr_overlapped_var(self)
def clr_spoiled_var(self, *args) ‑> void: clr_spoiled_var(self)
def clr_thisarg(self, *args) ‑> void: clr_thisarg(self)
def clr_unknown_width(self, *args) ‑> void: clr_unknown_width(self)
def clr_used_byref(self, *args) ‑> void: clr_used_byref(self)
def clr_user_info(self, *args) ‑> void: clr_user_info(self)
def clr_user_name(self, *args) ‑> void: clr_user_name(self)
def clr_user_type(self, *args) ‑> void: clr_user_type(self)
def has_common(self, *args) ‑> bool: Do variables overlap?

has_common(self, v) -> bool
v (C++: const lvar_t &)
def has_common_bit(self, *args) ‑> bool: Does the variable overlap with the specified location?

has_common_bit(self, loc, width2) -> bool
loc (C++: const vdloc_t &)

width2 (C++: asize_t)
def has_regname(self, *args) ‑> bool: Has a register name? (like _RAX)
def in_asm(self, *args) ‑> bool: Is variable used in an instruction translated into __asm?
def is_aliasable(self, *args) ‑> bool: Is the variable aliasable?

is_aliasable(self, mba) -> bool
mba: ptr to the current mba_t Aliasable variables may be
modified indirectly (through a pointer) (C++: const mba_t *)
def is_automapped(self, *args) ‑> bool: Was the variable automatically mapped to another variable?
def is_decl_unused(self, *args) ‑> bool: Was declared as __unused by the user? See CVAR_UNUSED.
def is_dummy_arg(self, *args) ‑> bool: Is a dummy argument (added to fill a hole in the argument list)
def is_forced_var(self, *args) ‑> bool: Is a forced variable?
def is_noptr_var(self, *args) ‑> bool: Variable type should not be a pointer.
def is_notarg(self, *args) ‑> bool: Is a local variable? (local variable cannot be an input argument)
def is_thisarg(self, *args) ‑> bool: Is 'this' argument of a C++ member function?
def is_used_byref(self, *args) ‑> bool: Was the address of the variable taken?
def set_arg_var(self, *args) ‑> void: set_arg_var(self)
def set_automapped(self, *args) ‑> void: set_automapped(self)
def set_decl_unused(self, *args) ‑> void: set_decl_unused(self)
def set_dummy_arg(self, *args) ‑> void: set_dummy_arg(self)
def set_fake_var(self, *args) ‑> void: set_fake_var(self)
def set_final_lvar_type(self, *args) ‑> void: Set final variable type.

set_final_lvar_type(self, t)
t (C++: const tinfo_t &)
def set_floating_var(self, *args) ‑> void: set_floating_var(self)
def set_forced_var(self, *args) ‑> void: set_forced_var(self)
def set_lvar_type(self, *args) ‑> bool: Set variable type Note: this function does not modify the idb, only the lvar instance in the memory. For permanent changes see modify_user_lvars() Also, the variable type is not considered as final by the decompiler and may be modified later by the type derivation. In some cases set_final_var_type() may work better, but it does not do persistent changes to the database neither.

set_lvar_type(self, t, may_fail=False) -> bool
t: new type (C++: const tinfo_t &)

may_fail: if false and type is bad, interr (C++: bool)

return: success
def set_mapdst_var(self, *args) ‑> void: set_mapdst_var(self)
def set_mreg_done(self, *args) ‑> void: set_mreg_done(self)
def set_non_typed(self, *args) ‑> void: set_non_typed(self)
def set_noptr_var(self, *args) ‑> void: set_noptr_var(self)
def set_notarg(self, *args) ‑> void: set_notarg(self)
def set_overlapped_var(self, *args) ‑> void: set_overlapped_var(self)
def set_spoiled_var(self, *args) ‑> void: set_spoiled_var(self)
def set_thisarg(self, *args) ‑> void: set_thisarg(self)
def set_typed(self, *args) ‑> void: set_typed(self)
def set_unknown_width(self, *args) ‑> void: set_unknown_width(self)
def set_used(self, *args) ‑> void: set_used(self)
def set_used_byref(self, *args) ‑> void: set_used_byref(self)
def set_user_name(self, *args) ‑> void: set_user_name(self)
def set_user_type(self, *args) ‑> void: set_user_type(self)
def set_width(self, *args) ‑> bool: Change the variable width. We call the variable size 'width', it is represents the number of bytes. This function may change the variable type using 'set_lvar_type()' .

set_width(self, w, svw_flags=0) -> bool
w: new width (C++: int)

svw_flags: combination of SVW_... bits (C++: int)

return: success
def type(self, *args) ‑> tinfo_t &: Get variable type.

Inherited members

lvar_locator_t:
- compare
- defea
- get_reg1
- get_reg2
- get_scattered
- get_stkoff
- is_reg1
- is_reg2
- is_reg_var
- is_scattered
- is_stk_var
- location

class lvar_uservec_t (*args)

Proxy of C++ lvar_uservec_t class.

__init__(self) -> lvar_uservec_t

Instance variables

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

Methods

def clear(self, *args) ‑> void: clear(self)
def empty(self, *args) ‑> bool: empty(self) -> bool
def find_info(self, *args) ‑> lvar_saved_info_t *: find saved user settings for given var

find_info(self, vloc) -> lvar_saved_info_t
vloc (C++: const lvar_locator_t &)
def keep_info(self, *args) ‑> void: Preserve user settings for given var.

keep_info(self, v)
v (C++: const lvar_t &)
def swap(self, *args) ‑> void: swap(self, r)
r (C++: lvar_uservec_t &)

class lvars_t (*args)

Proxy of C++ lvars_t class.

__init__(self) -> lvars_t

Ancestors

qvector_lvar_t

Methods

def find(self, *args) ‑> lvar_t *: Find variable at the specified location.

find(self, ll) -> lvar_t
ll: variable location (C++: const lvar_locator_t &)

return: pointer to variable or NULL
def find_input_lvar(self, *args) ‑> int: Find input variable at the specified location.

find_input_lvar(self, argloc, _size) -> int
argloc: variable location (C++: const vdloc_t &)

_size: variable size (C++: int)

return: -1 if failed, otherwise the index into the variables vector.
def find_lvar(self, *args) ‑> int: Find variable at the specified location.

find_lvar(self, location, width, defblk=-1) -> int
location: variable location (C++: const vdloc_t &)

width: variable size (C++: int)

defblk: definition block of the lvar. -1 means any block (C++:
int)

return: -1 if failed, otherwise the index into the variables vector.
def find_stkvar(self, *args) ‑> int: Find stack variable at the specified location.

find_stkvar(self, spoff, width) -> int
spoff: offset from the minimal sp (C++: sval_t)

width: variable size (C++: int)

return: -1 if failed, otherwise the index into the variables vector.

Inherited members

qvector_lvar_t:
- add_unique
- append
- at
- begin
- capacity
- clear
- empty
- end
- erase
- extract
- grow
- has
- inject
- insert
- pop_back
- push_back
- qclear
- reserve
- resize
- size
- swap
- truncate

class mba_range_iterator_t (*args)

Proxy of C++ mba_range_iterator_t class.

__init__(self) -> mba_range_iterator_t

Instance variables

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

Methods

def chunk(self, *args) ‑> range_t const &: chunk(self) -> range_t
def is_snippet(self, *args) ‑> bool: is_snippet(self) -> bool
def next(self, *args) ‑> bool: next(self) -> bool
def set(self, *args) ‑> bool: set(self, mbr) -> bool
mbr (C++: const mba_ranges_t &)

class mba_ranges_t (*args)

Proxy of C++ mba_ranges_t class.

__init__(self, _pfn=None) -> mba_ranges_t

_pfn: func_t *

__init__(self, r) -> mba_ranges_t

r: rangevec_t const &

Instance variables

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

Methods

def clear(self, *args) ‑> void: clear(self)
def empty(self, *args) ‑> bool: empty(self) -> bool
def is_fragmented(self, *args) ‑> bool: is_fragmented(self) -> bool
def is_snippet(self, *args) ‑> bool: is_snippet(self) -> bool
def start(self, *args) ‑> ea_t: start(self) -> ea_t

class mba_t (*args, **kwargs)

Proxy of C++ mba_t class.

Static methods

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

Instance variables

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

Methods

def alloc_fict_ea(self, *args) ‑> ea_t: Allocate a fictional address. This function can be used to allocate a new unique address for a new instruction, if re-using any existing address leads to conflicts. For example, if the last instruction of the function modifies R0 and falls through to the next function, it will be a tail call: LDM R0!, {R4,R7} end of the function start of another function In this case R0 generates two different lvars at the same address:one modified by LDManother that represents the return value from the tail call Another example: a third-party plugin makes a copy of an instruction. This may lead to the generation of two variables at the same address. Example 3: fictional addresses can be used for new instructions created while modifying the microcode. This function can be used to allocate a new unique address for a new instruction or a variable. The fictional address is selected from an unallocated address range.

alloc_fict_ea(self, real_ea) -> ea_t
real_ea (C++: ea_t)

return: a unique fictional address
def alloc_kreg(self, *args) ‑> mreg_t: Allocate a kernel register.

alloc_kreg(self, size, check_size=True) -> mreg_t
size: size of the register in bytes (C++: size_t)

check_size: if true, only the sizes that correspond to a size
of a basic type will be accepted. (C++: bool)

return: allocated register. mr_none means failure.
def alloc_lvars(self, *args) ‑> void: Allocate local variables. Must be called only immediately after 'optimize_global()' , with no modifications to the microcode. Converts registers, stack variables, and similar operands into mop_l. This call will not fail because all necessary checks were performed in 'optimize_global()' . After this call the microcode reaches its final state.
def analyze_calls(self, *args) ‑> int: Analyze calls and determine calling conventions.

analyze_calls(self, acflags) -> int
acflags: permitted actions that are necessary for successful
detection of calling conventions. See Bits for analyze_calls() (C++: int)

return: number of calls. -1 means error.
def arg(self, *args) ‑> lvar_t const &: Get input argument of the decompiled function.

arg(self, n) -> lvar_t
n: argument number (0..nargs-1) (C++: int)

arg(self, n) -> lvar_t
n: argument number (0..nargs-1) (C++: int)
def argbase(self, *args) ‑> sval_t: argbase(self) -> sval_t
def argidx_ok(self, *args) ‑> bool: argidx_ok(self) -> bool
def argidx_sorted(self, *args) ‑> bool: argidx_sorted(self) -> bool
def bad_call_sp_detected(self, *args) ‑> bool: bad_call_sp_detected(self) -> bool
def build_graph(self, *args) ‑> merror_t: Build control flow graph. This function may be called only once. It calculates the type of each basic block and the adjacency list. 'optimize_local()' calls this function if necessary. You need to call this function only before MMAT_LOCOPT.
def calc_shins_flags(self, *args) ‑> int: calc_shins_flags(self) -> int
def callinfo_built(self, *args) ‑> bool: callinfo_built(self) -> bool
def chain_varnums_ok(self, *args) ‑> bool: chain_varnums_ok(self) -> bool
def clr_cdtr(self, *args) ‑> void: clr_cdtr(self)
def clr_mba_flags(self, *args) ‑> void: clr_mba_flags(self, f)
f (C++: int)
def clr_mba_flags2(self, *args) ‑> void: clr_mba_flags2(self, f)
f (C++: int)
def code16_bit_removed(self, *args) ‑> bool: code16_bit_removed(self) -> bool
def combine_blocks(self, *args) ‑> bool: Combine blocks. This function merges blocks constituting linear flow. It calls 'remove_empty_and_unreachable_blocks()' as well.
def common_stkvars_stkargs(self, *args) ‑> bool: common_stkvars_stkargs(self) -> bool
def copy_block(self, *args) ‑> mblock_t *: Make a copy of a block. This function makes a simple copy of the block. It does not fix the predecessor and successor lists, they must be fixed if necessary.

copy_block(self, blk, new_serial, cpblk_flags=3) -> mblock_t
blk: block to copy (C++: mblock_t *)

new_serial: position of the copied block (C++: int)

cpblk_flags: combination of Batch decompilation bits ... bits
(C++: int)

return: pointer to the new copy
def create_helper_call(self, *args) ‑> minsn_t *: Create a call of a helper function.

create_helper_call(self, ea, helper, rettype=None, callargs=None, out=None) -> minsn_t
ea: The desired address of the instruction (C++: ea_t)

helper: The helper name (C++: const char *)

rettype: The return type (NULL or empty type means 'void')
(C++: const tinfo_t *)

callargs: The helper arguments (NULL-no arguments) (C++: const
mcallargs_t *)

out: The operand where the call result should be stored. If
this argument is not NULL, "mov helper_call(), out" will be generated. Otherwise "call helper()" will be generated. Note: the size of this operand must be equal to the RETTYPE size (C++: const mop_t *)

return: pointer to the created instruction or NULL if error
def deleted_pairs(self, *args) ‑> bool: deleted_pairs(self) -> bool
def display_numaddrs(self, *args) ‑> bool: display_numaddrs(self) -> bool
def display_valnums(self, *args) ‑> bool: display_valnums(self) -> bool
def dump(self, *args) ‑> void: Dump microcode to a file. The file will be created in the directory pointed by IDA_DUMPDIR envvar. Dump will be created only if IDA is run under debugger.
def dump_mba(self, *args) ‑> void: dump_mba(self, _verify, title)
_verify (C++: bool)

title (C++: const char *)
def find_mop(self, *args) ‑> mop_t *: Find an operand in the microcode. This function tries to find the operand that matches LIST. Any operand that overlaps with LIST is considered as a match.

find_mop(self, ctx, ea, is_dest, list) -> mop_t
ctx: context information for the result (C++: op_parent_info_t
*)

ea: desired address of the operand (C++: ea_t)

is_dest: search for destination operand? this argument may be
ignored if the exact match could not be found (C++: bool)

list: list of locations the correspond to the operand (C++:
const mlist_t &)

return: pointer to the operand or NULL.
def for_all_insns(self, *args) ‑> int: Visit all instructions. This function visits all instruction and subinstructions.

for_all_insns(self, mv) -> int
mv: instruction visitor (C++: minsn_visitor_t &)

return: non-zero value returned by mv.visit_mop() or zero
def for_all_ops(self, *args) ‑> int: Visit all operands of all instructions.

for_all_ops(self, mv) -> int
mv: operand visitor (C++: mop_visitor_t &)

return: non-zero value returned by mv.visit_mop() or zero
def for_all_topinsns(self, *args) ‑> int: Visit all top level instructions.

for_all_topinsns(self, mv) -> int
mv: instruction visitor (C++: minsn_visitor_t &)

return: non-zero value returned by mv.visit_mop() or zero
def free_kreg(self, *args) ‑> void: Free a kernel register. If wrong arguments are passed, this function will generate an internal error.

free_kreg(self, reg, size)
reg: a previously allocated kernel register (C++: mreg_t)

size: size of the register in bytes (C++: size_t)
def generated_asserts(self, *args) ‑> bool: generated_asserts(self) -> bool
def get_args_region(self, *args) ‑> ivl_t const &: get_args_region(self) -> ivl_t
def get_curfunc(self, *args) ‑> func_t *: get_curfunc(self) -> func_t *
def get_graph(self, *args) ‑> mbl_graph_t *: Get control graph. Call 'build_graph()' if you need the graph before MMAT_LOCOPT.
def get_ida_argloc(self, *args) ‑> argloc_t: get_ida_argloc(self, v) -> argloc_t
v (C++: const lvar_t &)
def get_lvars_region(self, *args) ‑> ivl_t const &: get_lvars_region(self) -> ivl_t
def get_mba_flags(self, *args) ‑> int: get_mba_flags(self) -> int
def get_mba_flags2(self, *args) ‑> int: get_mba_flags2(self) -> int
def get_mblock(self, *args) ‑> mblock_t *: Get basic block by its serial number.

get_mblock(self, n) -> mblock_t
n (C++: int)

get_mblock(self, n) -> mblock_t
n (C++: int)
def get_shadow_region(self, *args) ‑> ivl_t const &: get_shadow_region(self) -> ivl_t
def get_stack_region(self, *args) ‑> ivl_t: get_stack_region(self) -> ivl_t
def get_std_region(self, *args) ‑> ivl_t const &: Get information about various memory regions. We map the stack frame to the global memory, to some unused range.

get_std_region(self, idx) -> ivl_t
idx (C++: memreg_index_t)
def graph_insns(self, *args) ‑> bool: graph_insns(self) -> bool
def has_bad_sp(self, *args) ‑> bool: has_bad_sp(self) -> bool
def has_over_chains(self, *args) ‑> bool: has_over_chains(self) -> bool
def has_passregs(self, *args) ‑> bool: has_passregs(self) -> bool
def has_stack_retval(self, *args) ‑> bool: has_stack_retval(self) -> bool
def idaloc2vd(self, *args) ‑> vdloc_t: idaloc2vd(self, loc, width) -> vdloc_t
loc (C++: const argloc_t &)

width (C++: int)
def insert_block(self, *args) ‑> mblock_t *: Insert a block in the middle of the mbl array. The very first block of microcode must be empty, it is the entry block. The very last block of microcode must be BLT_STOP, it is the exit block. Therefore inserting a new block before the entry point or after the exit block is not a good idea.

insert_block(self, bblk) -> mblock_t
bblk: the new block will be inserted before BBLK (C++: int)

return: ptr to the new block
def is_cdtr(self, *args) ‑> bool: is_cdtr(self) -> bool
def is_ctr(self, *args) ‑> bool: is_ctr(self) -> bool
def is_dtr(self, *args) ‑> bool: is_dtr(self) -> bool
def is_pattern(self, *args) ‑> bool: is_pattern(self) -> bool
def is_snippet(self, *args) ‑> bool: is_snippet(self) -> bool
def is_stkarg(self, *args) ‑> bool: is_stkarg(self, v) -> bool
v (C++: const lvar_t &)
def is_thunk(self, *args) ‑> bool: is_thunk(self) -> bool
def loaded_gdl(self, *args) ‑> bool: loaded_gdl(self) -> bool
def lvar_names_ok(self, *args) ‑> bool: lvar_names_ok(self) -> bool
def lvars_allocated(self, *args) ‑> bool: lvars_allocated(self) -> bool
def lvars_renamed(self, *args) ‑> bool: lvars_renamed(self) -> bool
def map_fict_ea(self, *args) ‑> ea_t: Resolve a fictional address. This function provides a reverse of the mapping made by 'alloc_fict_ea()' .

map_fict_ea(self, fict_ea) -> ea_t
fict_ea: fictional definition address (C++: ea_t)

return: the real instruction address
def mark_chains_dirty(self, *args) ‑> void: Mark the microcode use-def chains dirty. Call this function is any inter-block data dependencies got changed because of your modifications to the microcode. Failing to do so may cause an internal error.
def may_refine_rettype(self, *args) ‑> bool: may_refine_rettype(self) -> bool
def optimize_global(self, *args) ‑> merror_t: Optimize microcode globally. This function applies various optimization methods until we reach the fixed point. After that it preallocates lvars unless reqmat forbids it.
def optimize_local(self, *args) ‑> int: Optimize each basic block locally

optimize_local(self, locopt_bits) -> int
locopt_bits: combination of Bits for optimize_local() bits
(C++: int)

return: number of changes. 0 means nothing changed This function is
called by the decompiler, usually there is no need to call it explicitly.
def optimized(self, *args) ‑> bool: optimized(self) -> bool
def precise_defeas(self, *args) ‑> bool: precise_defeas(self) -> bool
def propagated_asserts(self, *args) ‑> bool: propagated_asserts(self) -> bool
def really_alloc(self, *args) ‑> bool: really_alloc(self) -> bool
def regargs_is_not_aligned(self, *args) ‑> bool: regargs_is_not_aligned(self) -> bool
def remove_block(self, *args) ‑> bool: Delete a block.

remove_block(self, blk) -> bool
blk: block to delete (C++: mblock_t *)

return: true if at least one of the other blocks became empty or
unreachable
def remove_empty_and_unreachable_blocks(self, *args) ‑> bool: Delete all empty and unreachable blocks. Blocks marked with MBL_KEEP won't be deleted.
def returns_fpval(self, *args) ‑> bool: returns_fpval(self) -> bool
def rtype_refined(self, *args) ‑> bool: rtype_refined(self) -> bool
def save_snapshot(self, *args) ‑> void: Create and save microcode snapshot.

save_snapshot(self, description)
description (C++: const char *)
def saverest_done(self, *args) ‑> bool: saverest_done(self) -> bool
def serialize(self, *args) ‑> void: Serialize mbl array into a sequence of bytes.
def set_maturity(self, *args) ‑> bool: Set maturity level.

set_maturity(self, mat) -> bool
mat (C++: mba_maturity_t)

return: true if it is time to stop analysis Plugins may use this
function to skip some parts of the analysis. The maturity level cannot be decreased.
def set_mba_flags(self, *args) ‑> void: set_mba_flags(self, f)
f (C++: int)
def set_mba_flags2(self, *args) ‑> void: set_mba_flags2(self, f)
f (C++: int)
def short_display(self, *args) ‑> bool: short_display(self) -> bool
def should_beautify(self, *args) ‑> bool: should_beautify(self) -> bool
def show_reduction(self, *args) ‑> bool: show_reduction(self) -> bool
def stkoff_ida2vd(self, *args) ‑> sval_t: stkoff_ida2vd(self, off) -> sval_t
off (C++: sval_t)
def stkoff_vd2ida(self, *args) ‑> sval_t: stkoff_vd2ida(self, off) -> sval_t
off (C++: sval_t)
def term(self, *args) ‑> void: term(self)
def use_frame(self, *args) ‑> bool: use_frame(self) -> bool
def use_wingraph32(self, *args) ‑> bool: use_wingraph32(self) -> bool
def valranges_done(self, *args) ‑> bool: valranges_done(self) -> bool
def vd2idaloc(self, *args) ‑> argloc_t: vd2idaloc(self, loc, width, spd) -> argloc_t
loc (C++: const vdloc_t &)

width (C++: int) spd: sval_t

vd2idaloc(self, loc, width) -> argloc_t
loc (C++: const vdloc_t &)

width (C++: int)
def verify(self, *args) ‑> void: Verify microcode consistency.

verify(self, always)
always: if false, the check will be performed only if ida runs
under debugger If any inconsistency is discovered, an internal error will be generated. We strongly recommend you to call this function before returing control to the decompiler from your callbacks, in the case if you modified the microcode. (C++: bool)
def write_to_const_detected(self, *args) ‑> bool: write_to_const_detected(self) -> bool

class mbl_array_t (*args, **kwargs)

Proxy of C++ mba_t class.

Static methods

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

Instance variables

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

Methods

def alloc_fict_ea(self, *args) ‑> ea_t: Allocate a fictional address. This function can be used to allocate a new unique address for a new instruction, if re-using any existing address leads to conflicts. For example, if the last instruction of the function modifies R0 and falls through to the next function, it will be a tail call: LDM R0!, {R4,R7} end of the function start of another function In this case R0 generates two different lvars at the same address:one modified by LDManother that represents the return value from the tail call Another example: a third-party plugin makes a copy of an instruction. This may lead to the generation of two variables at the same address. Example 3: fictional addresses can be used for new instructions created while modifying the microcode. This function can be used to allocate a new unique address for a new instruction or a variable. The fictional address is selected from an unallocated address range.

alloc_fict_ea(self, real_ea) -> ea_t
real_ea (C++: ea_t)

return: a unique fictional address
def alloc_kreg(self, *args) ‑> mreg_t: Allocate a kernel register.

alloc_kreg(self, size, check_size=True) -> mreg_t
size: size of the register in bytes (C++: size_t)

check_size: if true, only the sizes that correspond to a size
of a basic type will be accepted. (C++: bool)

return: allocated register. mr_none means failure.
def alloc_lvars(self, *args) ‑> void: Allocate local variables. Must be called only immediately after 'optimize_global()' , with no modifications to the microcode. Converts registers, stack variables, and similar operands into mop_l. This call will not fail because all necessary checks were performed in 'optimize_global()' . After this call the microcode reaches its final state.
def analyze_calls(self, *args) ‑> int: Analyze calls and determine calling conventions.

analyze_calls(self, acflags) -> int
acflags: permitted actions that are necessary for successful
detection of calling conventions. See Bits for analyze_calls() (C++: int)

return: number of calls. -1 means error.
def arg(self, *args) ‑> lvar_t const &: Get input argument of the decompiled function.

arg(self, n) -> lvar_t
n: argument number (0..nargs-1) (C++: int)

arg(self, n) -> lvar_t
n: argument number (0..nargs-1) (C++: int)
def argbase(self, *args) ‑> sval_t: argbase(self) -> sval_t
def argidx_ok(self, *args) ‑> bool: argidx_ok(self) -> bool
def argidx_sorted(self, *args) ‑> bool: argidx_sorted(self) -> bool
def bad_call_sp_detected(self, *args) ‑> bool: bad_call_sp_detected(self) -> bool
def build_graph(self, *args) ‑> merror_t: Build control flow graph. This function may be called only once. It calculates the type of each basic block and the adjacency list. 'optimize_local()' calls this function if necessary. You need to call this function only before MMAT_LOCOPT.
def calc_shins_flags(self, *args) ‑> int: calc_shins_flags(self) -> int
def callinfo_built(self, *args) ‑> bool: callinfo_built(self) -> bool
def chain_varnums_ok(self, *args) ‑> bool: chain_varnums_ok(self) -> bool
def clr_cdtr(self, *args) ‑> void: clr_cdtr(self)
def clr_mba_flags(self, *args) ‑> void: clr_mba_flags(self, f)
f (C++: int)
def clr_mba_flags2(self, *args) ‑> void: clr_mba_flags2(self, f)
f (C++: int)
def code16_bit_removed(self, *args) ‑> bool: code16_bit_removed(self) -> bool
def combine_blocks(self, *args) ‑> bool: Combine blocks. This function merges blocks constituting linear flow. It calls 'remove_empty_and_unreachable_blocks()' as well.
def common_stkvars_stkargs(self, *args) ‑> bool: common_stkvars_stkargs(self) -> bool
def copy_block(self, *args) ‑> mblock_t *: Make a copy of a block. This function makes a simple copy of the block. It does not fix the predecessor and successor lists, they must be fixed if necessary.

copy_block(self, blk, new_serial, cpblk_flags=3) -> mblock_t
blk: block to copy (C++: mblock_t *)

new_serial: position of the copied block (C++: int)

cpblk_flags: combination of Batch decompilation bits ... bits
(C++: int)

return: pointer to the new copy
def create_helper_call(self, *args) ‑> minsn_t *: Create a call of a helper function.

create_helper_call(self, ea, helper, rettype=None, callargs=None, out=None) -> minsn_t
ea: The desired address of the instruction (C++: ea_t)

helper: The helper name (C++: const char *)

rettype: The return type (NULL or empty type means 'void')
(C++: const tinfo_t *)

callargs: The helper arguments (NULL-no arguments) (C++: const
mcallargs_t *)

out: The operand where the call result should be stored. If
this argument is not NULL, "mov helper_call(), out" will be generated. Otherwise "call helper()" will be generated. Note: the size of this operand must be equal to the RETTYPE size (C++: const mop_t *)

return: pointer to the created instruction or NULL if error
def deleted_pairs(self, *args) ‑> bool: deleted_pairs(self) -> bool
def display_numaddrs(self, *args) ‑> bool: display_numaddrs(self) -> bool
def display_valnums(self, *args) ‑> bool: display_valnums(self) -> bool
def dump(self, *args) ‑> void: Dump microcode to a file. The file will be created in the directory pointed by IDA_DUMPDIR envvar. Dump will be created only if IDA is run under debugger.
def dump_mba(self, *args) ‑> void: dump_mba(self, _verify, title)
_verify (C++: bool)

title (C++: const char *)
def find_mop(self, *args) ‑> mop_t *: Find an operand in the microcode. This function tries to find the operand that matches LIST. Any operand that overlaps with LIST is considered as a match.

find_mop(self, ctx, ea, is_dest, list) -> mop_t
ctx: context information for the result (C++: op_parent_info_t
*)

ea: desired address of the operand (C++: ea_t)

is_dest: search for destination operand? this argument may be
ignored if the exact match could not be found (C++: bool)

list: list of locations the correspond to the operand (C++:
const mlist_t &)

return: pointer to the operand or NULL.
def for_all_insns(self, *args) ‑> int: Visit all instructions. This function visits all instruction and subinstructions.

for_all_insns(self, mv) -> int
mv: instruction visitor (C++: minsn_visitor_t &)

return: non-zero value returned by mv.visit_mop() or zero
def for_all_ops(self, *args) ‑> int: Visit all operands of all instructions.

for_all_ops(self, mv) -> int
mv: operand visitor (C++: mop_visitor_t &)

return: non-zero value returned by mv.visit_mop() or zero
def for_all_topinsns(self, *args) ‑> int: Visit all top level instructions.

for_all_topinsns(self, mv) -> int
mv: instruction visitor (C++: minsn_visitor_t &)

return: non-zero value returned by mv.visit_mop() or zero
def free_kreg(self, *args) ‑> void: Free a kernel register. If wrong arguments are passed, this function will generate an internal error.

free_kreg(self, reg, size)
reg: a previously allocated kernel register (C++: mreg_t)

size: size of the register in bytes (C++: size_t)
def generated_asserts(self, *args) ‑> bool: generated_asserts(self) -> bool
def get_args_region(self, *args) ‑> ivl_t const &: get_args_region(self) -> ivl_t
def get_curfunc(self, *args) ‑> func_t *: get_curfunc(self) -> func_t *
def get_graph(self, *args) ‑> mbl_graph_t *: Get control graph. Call 'build_graph()' if you need the graph before MMAT_LOCOPT.
def get_ida_argloc(self, *args) ‑> argloc_t: get_ida_argloc(self, v) -> argloc_t
v (C++: const lvar_t &)
def get_lvars_region(self, *args) ‑> ivl_t const &: get_lvars_region(self) -> ivl_t
def get_mba_flags(self, *args) ‑> int: get_mba_flags(self) -> int
def get_mba_flags2(self, *args) ‑> int: get_mba_flags2(self) -> int
def get_mblock(self, *args) ‑> mblock_t *: Get basic block by its serial number.

get_mblock(self, n) -> mblock_t
n (C++: int)

get_mblock(self, n) -> mblock_t
n (C++: int)
def get_shadow_region(self, *args) ‑> ivl_t const &: get_shadow_region(self) -> ivl_t
def get_stack_region(self, *args) ‑> ivl_t: get_stack_region(self) -> ivl_t
def get_std_region(self, *args) ‑> ivl_t const &: Get information about various memory regions. We map the stack frame to the global memory, to some unused range.

get_std_region(self, idx) -> ivl_t
idx (C++: memreg_index_t)
def graph_insns(self, *args) ‑> bool: graph_insns(self) -> bool
def has_bad_sp(self, *args) ‑> bool: has_bad_sp(self) -> bool
def has_over_chains(self, *args) ‑> bool: has_over_chains(self) -> bool
def has_passregs(self, *args) ‑> bool: has_passregs(self) -> bool
def has_stack_retval(self, *args) ‑> bool: has_stack_retval(self) -> bool
def idaloc2vd(self, *args) ‑> vdloc_t: idaloc2vd(self, loc, width) -> vdloc_t
loc (C++: const argloc_t &)

width (C++: int)
def insert_block(self, *args) ‑> mblock_t *: Insert a block in the middle of the mbl array. The very first block of microcode must be empty, it is the entry block. The very last block of microcode must be BLT_STOP, it is the exit block. Therefore inserting a new block before the entry point or after the exit block is not a good idea.

insert_block(self, bblk) -> mblock_t
bblk: the new block will be inserted before BBLK (C++: int)

return: ptr to the new block
def is_cdtr(self, *args) ‑> bool: is_cdtr(self) -> bool
def is_ctr(self, *args) ‑> bool: is_ctr(self) -> bool
def is_dtr(self, *args) ‑> bool: is_dtr(self) -> bool
def is_pattern(self, *args) ‑> bool: is_pattern(self) -> bool
def is_snippet(self, *args) ‑> bool: is_snippet(self) -> bool
def is_stkarg(self, *args) ‑> bool: is_stkarg(self, v) -> bool
v (C++: const lvar_t &)
def is_thunk(self, *args) ‑> bool: is_thunk(self) -> bool
def loaded_gdl(self, *args) ‑> bool: loaded_gdl(self) -> bool
def lvar_names_ok(self, *args) ‑> bool: lvar_names_ok(self) -> bool
def lvars_allocated(self, *args) ‑> bool: lvars_allocated(self) -> bool
def lvars_renamed(self, *args) ‑> bool: lvars_renamed(self) -> bool
def map_fict_ea(self, *args) ‑> ea_t: Resolve a fictional address. This function provides a reverse of the mapping made by 'alloc_fict_ea()' .

map_fict_ea(self, fict_ea) -> ea_t
fict_ea: fictional definition address (C++: ea_t)

return: the real instruction address
def mark_chains_dirty(self, *args) ‑> void: Mark the microcode use-def chains dirty. Call this function is any inter-block data dependencies got changed because of your modifications to the microcode. Failing to do so may cause an internal error.
def may_refine_rettype(self, *args) ‑> bool: may_refine_rettype(self) -> bool
def optimize_global(self, *args) ‑> merror_t: Optimize microcode globally. This function applies various optimization methods until we reach the fixed point. After that it preallocates lvars unless reqmat forbids it.
def optimize_local(self, *args) ‑> int: Optimize each basic block locally

optimize_local(self, locopt_bits) -> int
locopt_bits: combination of Bits for optimize_local() bits
(C++: int)

return: number of changes. 0 means nothing changed This function is
called by the decompiler, usually there is no need to call it explicitly.
def optimized(self, *args) ‑> bool: optimized(self) -> bool
def precise_defeas(self, *args) ‑> bool: precise_defeas(self) -> bool
def propagated_asserts(self, *args) ‑> bool: propagated_asserts(self) -> bool
def really_alloc(self, *args) ‑> bool: really_alloc(self) -> bool
def regargs_is_not_aligned(self, *args) ‑> bool: regargs_is_not_aligned(self) -> bool
def remove_block(self, *args) ‑> bool: Delete a block.

remove_block(self, blk) -> bool
blk: block to delete (C++: mblock_t *)

return: true if at least one of the other blocks became empty or
unreachable
def remove_empty_and_unreachable_blocks(self, *args) ‑> bool: Delete all empty and unreachable blocks. Blocks marked with MBL_KEEP won't be deleted.
def returns_fpval(self, *args) ‑> bool: returns_fpval(self) -> bool
def rtype_refined(self, *args) ‑> bool: rtype_refined(self) -> bool
def save_snapshot(self, *args) ‑> void: Create and save microcode snapshot.

save_snapshot(self, description)
description (C++: const char *)
def saverest_done(self, *args) ‑> bool: saverest_done(self) -> bool
def serialize(self, *args) ‑> void: Serialize mbl array into a sequence of bytes.
def set_maturity(self, *args) ‑> bool: Set maturity level.

set_maturity(self, mat) -> bool
mat (C++: mba_maturity_t)

return: true if it is time to stop analysis Plugins may use this
function to skip some parts of the analysis. The maturity level cannot be decreased.
def set_mba_flags(self, *args) ‑> void: set_mba_flags(self, f)
f (C++: int)
def set_mba_flags2(self, *args) ‑> void: set_mba_flags2(self, f)
f (C++: int)
def short_display(self, *args) ‑> bool: short_display(self) -> bool
def should_beautify(self, *args) ‑> bool: should_beautify(self) -> bool
def show_reduction(self, *args) ‑> bool: show_reduction(self) -> bool
def stkoff_ida2vd(self, *args) ‑> sval_t: stkoff_ida2vd(self, off) -> sval_t
off (C++: sval_t)
def stkoff_vd2ida(self, *args) ‑> sval_t: stkoff_vd2ida(self, off) -> sval_t
off (C++: sval_t)
def term(self, *args) ‑> void: term(self)
def use_frame(self, *args) ‑> bool: use_frame(self) -> bool
def use_wingraph32(self, *args) ‑> bool: use_wingraph32(self) -> bool
def valranges_done(self, *args) ‑> bool: valranges_done(self) -> bool
def vd2idaloc(self, *args) ‑> argloc_t: vd2idaloc(self, loc, width, spd) -> argloc_t
loc (C++: const vdloc_t &)

width (C++: int) spd: sval_t

vd2idaloc(self, loc, width) -> argloc_t
loc (C++: const vdloc_t &)

width (C++: int)
def verify(self, *args) ‑> void: Verify microcode consistency.

verify(self, always)
always: if false, the check will be performed only if ida runs
under debugger If any inconsistency is discovered, an internal error will be generated. We strongly recommend you to call this function before returing control to the decompiler from your callbacks, in the case if you modified the microcode. (C++: bool)
def write_to_const_detected(self, *args) ‑> bool: write_to_const_detected(self) -> bool

class mbl_graph_t (*args, **kwargs)

Proxy of C++ mbl_graph_t class.

__init__(self) -> gdl_graph_t

self: PyObject *

Ancestors

Methods

def get_chain_stamp(self, *args) ‑> int: get_chain_stamp(self) -> int
def get_du(self, *args) ‑> graph_chains_t *: Get def-use chains.

get_du(self, gctype) -> graph_chains_t
gctype (C++: gctype_t)
def get_mblock(self, *args) ‑> mblock_t *: get_mblock(self, n) -> mblock_t
n (C++: int)
def get_ud(self, *args) ‑> graph_chains_t *: Get use-def chains.

get_ud(self, gctype) -> graph_chains_t
gctype (C++: gctype_t)
def is_du_chain_dirty(self, *args) ‑> bool: Is the def-use chain of the specified kind dirty?

is_du_chain_dirty(self, gctype) -> bool
gctype (C++: gctype_t)
def is_redefined_globally(self, *args) ‑> bool: Is LIST redefined in the graph?

is_redefined_globally(self, list, b1, b2, m1, m2, maymust=MAY_ACCESS) -> bool
list (C++: const mlist_t &)

b1 (C++: int)

b2 (C++: int)

m1 (C++: const minsn_t *)

m2 (C++: const minsn_t *)

maymust (C++: maymust_t)
def is_ud_chain_dirty(self, *args) ‑> bool: Is the use-def chain of the specified kind dirty?

is_ud_chain_dirty(self, gctype) -> bool
gctype (C++: gctype_t)
def is_used_globally(self, *args) ‑> bool: Is LIST used in the graph?

is_used_globally(self, list, b1, b2, m1, m2, maymust=MAY_ACCESS) -> bool
list (C++: const mlist_t &)

b1 (C++: int)

b2 (C++: int)

m1 (C++: const minsn_t *)

m2 (C++: const minsn_t *)

maymust (C++: maymust_t)

Inherited members

simple_graph_t:
- begin
- colored_gdl_edges
- edge
- empty
- end
- entry
- exists
- exit
- front
- get_edge_color
- get_node_color
- get_node_label
- nedge
- node_qty
- npred
- nsucc
- pred
- print_edge
- print_graph_attributes
- print_node
- print_node_attributes
- size
- succ
- title

class mblock_t (*args, **kwargs)

Proxy of C++ mblock_t class.

Instance variables

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

Methods

def append_def_list(self, *args) ‑> void: Append def-list of an operand. This function calculates list of locations that may or must be modified by the operand and appends it to LIST.

append_def_list(self, list, op, maymust)
list: ptr to the output buffer. we will append to it. (C++:
mlist_t *)

op: operand to calculate the def list of (C++: const mop_t &)

maymust: should we calculate 'may-def' or 'must-def' list? see
maymust_t for more details. (C++: maymust_t)
def append_use_list(self, *args) ‑> void: Append use-list of an operand. This function calculates list of locations that may or must be used by the operand and appends it to LIST.

append_use_list(self, list, op, maymust, mask=bitrange_t(0, USHRT_MAX))
list: ptr to the output buffer. we will append to it. (C++:
mlist_t *)

op: operand to calculate the use list of (C++: const mop_t &)

maymust: should we calculate 'may-use' or 'must-use' list? see
maymust_t for more details. (C++: maymust_t)

mask: if only part of the operand should be considered, a
bitmask can be used to specify which part. example: op=AX,mask=0xFF means that we will consider only AL. (C++: bitrange_t)
def build_def_list(self, *args) ‑> mlist_t: Build def-list of an instruction. This function calculates list of locations that may or must be modified by the instruction. Examples: "stx ebx.4, ds.2, eax.4", may-list: all aliasable memory "stx ebx.4, ds.2, eax.4", must-list: empty Since STX uses EAX for indirect access, it may modify any aliasable memory. On the other hand, we cannot tell for sure which memory cells will be modified, this is why the must- list is empty.

build_def_list(self, ins, maymust) -> mlist_t
ins: instruction to calculate the def list of (C++: const
minsn_t &)

maymust: should we calculate 'may-def' or 'must-def' list? see
maymust_t for more details. (C++: maymust_t)

return: the calculated def-list
def build_lists(self, *args) ‑> int: Build def-use lists and eliminate deads.

build_lists(self, kill_deads) -> int
kill_deads: do delete dead instructions? (C++: bool)

return: the number of eliminated instructions Better mblock_t::call
make_lists_ready() rather than this function.
def build_use_list(self, *args) ‑> mlist_t: Build use-list of an instruction. This function calculates list of locations that may or must be used by the instruction. Examples: "ldx ds.2, eax.4, ebx.4", may-list: all aliasable memory "ldx ds.2, eax.4, ebx.4", must-list: empty Since LDX uses EAX for indirect access, it may access any aliasable memory. On the other hand, we cannot tell for sure which memory cells will be accessed, this is why the must-list is empty.

build_use_list(self, ins, maymust) -> mlist_t
ins: instruction to calculate the use list of (C++: const
minsn_t &)

maymust: should we calculate 'may-use' or 'must-use' list? see
maymust_t for more details. (C++: maymust_t)

return: the calculated use-list
def dump(self, *args) ‑> void: Dump block info. This function is useful for debugging, see 'mba_t::dump' for info
def dump_block(self, *args) ‑> void: dump_block(self, title)
title (C++: const char *)
def empty(self, *args) ‑> bool: empty(self) -> bool
def find_access(self, *args) ‑> minsn_t *: Find the instruction that accesses the specified operand. This function search inside one block.

find_access(self, op, parent, mend, fdflags) -> minsn_t
op: operand to search for (C++: const mop_t &)

parent (C++: minsn_t **)

mend (C++: const minsn_t *)

fdflags (C++: int)

return: the instruction that accesses the operand. this instruction
may be a sub-instruction. to find out the top level instruction, check out *p_i1. NULL means 'not found'.
def find_def(self, *args) ‑> minsn_t *: find_def(self, op, p_i1, i2, fdflags) -> minsn_t
op (C++: const mop_t &)

p_i1 (C++: minsn_t **)

i2 (C++: const minsn_t *)

fdflags (C++: int)
def find_first_use(self, *args) ‑> minsn_t *: Find the first insn that uses the specified list in the insn range.

find_first_use(self, list, i1, i2, maymust=MAY_ACCESS) -> minsn_t
list: list of locations. LIST may be modified by the function:
redefined locations will be removed from it. (C++: mlist_t *)

i1: starting instruction of the range (must be a top level
insn) (C++: const minsn_t *)

i2: end instruction of the range (must be a top level insn) i2
is excluded from the range. it can be specified as NULL. i1 and i2 must belong to the same block. (C++: const minsn_t *)

maymust: should we search in 'may-access' or 'must-access'
mode? (C++: maymust_t)

return: pointer to such instruction or NULL. Upon return LIST will
contain only locations not redefined by insns [i1..result]
def find_redefinition(self, *args) ‑> minsn_t *: Find the first insn that redefines any part of the list in the insn range.

find_redefinition(self, list, i1, i2, maymust=MAY_ACCESS) -> minsn_t
list: list of locations to check. (C++: const mlist_t &)

i1: starting instruction of the range (must be a top level
insn) (C++: const minsn_t *)

i2: end instruction of the range (must be a top level insn) i2
is excluded from the range. it can be specified as NULL. i1 and i2 must belong to the same block. (C++: const minsn_t *)

maymust: should we search in 'may-access' or 'must-access'
mode? (C++: maymust_t)

return: pointer to such instruction or NULL.
def find_use(self, *args) ‑> minsn_t *: find_use(self, op, p_i1, i2, fdflags) -> minsn_t
op (C++: const mop_t &)

p_i1 (C++: minsn_t **)

i2 (C++: const minsn_t *)

fdflags (C++: int)
def for_all_insns(self, *args) ‑> int: Visit all instructions. This function visits subinstructions too.

for_all_insns(self, mv) -> int
mv: instruction visitor (C++: minsn_visitor_t &)

return: zero or the value returned by mv.visit_insn() See also
mba_t::for_all_topinsns()
def for_all_ops(self, *args) ‑> int: Visit all operands. This function visit subinstruction operands too.

for_all_ops(self, mv) -> int
mv: operand visitor (C++: mop_visitor_t &)

return: zero or the value returned by mv.visit_mop()
def for_all_uses(self, *args) ‑> int: Visit all operands that use LIST.

for_all_uses(self, list, i1, i2, mmv) -> int
list: ptr to the list of locations. it may be modified: parts
that get redefined by the instructions in [i1,i2) will be deleted. (C++: mlist_t *)

i1: starting instruction. must be a top level insn. (C++:
minsn_t *)

i2: ending instruction (excluded). must be a top level insn.
(C++: minsn_t *)

mmv: operand visitor (C++: mlist_mop_visitor_t &)

return: zero or the value returned by mmv.visit_mop()
def get_reginsn_qty(self, *args) ‑> size_t: Calculate number of regular instructions in the block. Assertions are skipped by this function.
def get_valranges(self, *args) ‑> bool: Find possible values for a block.

get_valranges(self, res, vivl, vrflags) -> bool
res: set of value ranges (C++: valrng_t *)

vivl: what to search for (C++: const vivl_t &)

vrflags: combination of bits for get_valranges bits (C++:
int)

get_valranges(self, res, vivl, m, vrflags) -> bool
res: set of value ranges (C++: valrng_t *)

vivl: what to search for (C++: const vivl_t &) m: minsn_t const *

vrflags: combination of bits for get_valranges bits (C++:
int)
def insert_into_block(self, *args) ‑> minsn_t *: Insert instruction into the doubly linked list

insert_into_block(self, nm, om) -> minsn_t
nm: new instruction (C++: minsn_t *)

om: existing instruction, part of the doubly linked list if
NULL, then the instruction will be inserted at the beginning of the list NM will be inserted immediately after OM (C++: minsn_t *)

return: pointer to NM
def is_branch(self, *args) ‑> bool: is_branch(self) -> bool
def is_call_block(self, *args) ‑> bool: is_call_block(self) -> bool
def is_nway(self, *args) ‑> bool: is_nway(self) -> bool
def is_redefined(self, *args) ‑> bool: Is the list redefined by the specified instructions?

is_redefined(self, list, i1, i2, maymust=MAY_ACCESS) -> bool
list: list of locations to check. (C++: const mlist_t &)

i1: starting instruction of the range (must be a top level
insn) (C++: const minsn_t *)

i2: end instruction of the range (must be a top level insn) i2
is excluded from the range. it can be specified as NULL. i1 and i2 must belong to the same block. (C++: const minsn_t *)

maymust: should we search in 'may-access' or 'must-access'
mode? (C++: maymust_t)
def is_rhs_redefined(self, *args) ‑> bool: Is the right hand side of the instruction redefined the insn range? "right hand side" corresponds to the source operands of the instruction.

is_rhs_redefined(self, ins, i1, i2) -> bool
ins: instruction to consider (C++: const minsn_t *)

i1: starting instruction of the range (must be a top level
insn) (C++: const minsn_t *)

i2: end instruction of the range (must be a top level insn) i2
is excluded from the range. it can be specified as NULL. i1 and i2 must belong to the same block. (C++: const minsn_t *)
def is_simple_goto_block(self, *args) ‑> bool: is_simple_goto_block(self) -> bool
def is_simple_jcnd_block(self, *args) ‑> bool: is_simple_jcnd_block(self) -> bool
def is_unknown_call(self, *args) ‑> bool: is_unknown_call(self) -> bool
def is_used(self, *args) ‑> bool: Is the list used by the specified instruction range?

is_used(self, list, i1, i2, maymust=MAY_ACCESS) -> bool
list: list of locations. LIST may be modified by the function:
redefined locations will be removed from it. (C++: mlist_t *)

i1: starting instruction of the range (must be a top level
insn) (C++: const minsn_t *)

i2: end instruction of the range (must be a top level insn) i2
is excluded from the range. it can be specified as NULL. i1 and i2 must belong to the same block. (C++: const minsn_t *)

maymust: should we search in 'may-access' or 'must-access'
mode? (C++: maymust_t)
def lists_dirty(self, *args) ‑> bool: lists_dirty(self) -> bool
def lists_ready(self, *args) ‑> bool: lists_ready(self) -> bool
def make_lists_ready(self, *args) ‑> int: make_lists_ready(self) -> int
def make_nop(self, *args) ‑> void: Erase the instruction (convert it to nop) and mark the lists dirty. This is the recommended function to use because it also marks the block use-def lists dirty.

make_nop(self, m)
m (C++: minsn_t *)
def mark_lists_dirty(self, *args) ‑> void: mark_lists_dirty(self)
def needs_propagation(self, *args) ‑> bool: needs_propagation(self) -> bool
def npred(self, *args) ‑> int: Get number of block predecessors.
def nsucc(self, *args) ‑> int: Get number of block successors.
def optimize_block(self, *args) ‑> int: Optimize a basic block. Usually there is no need to call this function explicitly because the decompiler will call it itself if 'optinsn_t::func' or 'optblock_t::func' return non-zero.
def optimize_insn(self, *args) ‑> int: Optimize one instruction in the context of the block.

optimize_insn(self, m, optflags=0x0002|0x0004) -> int
m: pointer to a top level instruction (C++: minsn_t *)

optflags: combination of optimization flags bits (C++: int)

return: number of changes made to the block This function may change
other instructions in the block too. However, it will not destroy top level instructions (it may convert them to nop's). This function performs only intrablock modifications. See also minsn_t::optimize_solo()
def optimize_useless_jump(self, *args) ‑> int: Remove a jump at the end of the block if it is useless. This function preserves any side effects when removing a useless jump. Both conditional and unconditional jumps are handled (and jtbl too). This function deletes useless jumps, not only replaces them with a nop. (please note that \optimize_insn does not handle useless jumps).
def pred(self, *args) ‑> int: pred(self, n) -> int
n (C++: int)
def preds(self): Iterates the list of predecessor blocks
def remove_from_block(self, *args) ‑> minsn_t *: Remove instruction from the doubly linked list

remove_from_block(self, m) -> minsn_t
m: instruction to remove The removed instruction is not
deleted, the caller gets its ownership (C++: minsn_t *)

return: pointer to the next instruction
def request_demote64(self, *args) ‑> void: request_demote64(self)
def request_propagation(self, *args) ‑> void: request_propagation(self)
def succ(self, *args) ‑> int: succ(self, n) -> int
n (C++: int)
def succs(self): Iterates the list of successor blocks

class mcallarg_t (*args)

Proxy of C++ mcallarg_t class.

__init__(self) -> mcallarg_t

rarg: mop_t const &

Ancestors

mop_t

Instance variables

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

Methods

def copy_mop(self, *args) ‑> void: copy_mop(self, op)
op (C++: const mop_t &)
def make_int(self, *args) ‑> void: make_int(self, val, val_ea, opno=0)
val (C++: int)

val_ea (C++: ea_t)

opno (C++: int)
def make_uint(self, *args) ‑> void: make_uint(self, val, val_ea, opno=0)
val (C++: int)

val_ea (C++: ea_t)

opno (C++: int)
def set_regarg(self, *args) ‑> void: set_regarg(self, mr, sz, tif)
mr (C++: mreg_t)

sz (C++: int)

tif (C++: const tinfo_t &)

set_regarg(self, mr, tif)
mr (C++: mreg_t)

tif (C++: const tinfo_t &)

set_regarg(self, mr, dt, sign=type_unsigned)
mr (C++: mreg_t) dt: char sign: type_sign_t

Inherited members

mop_t:
- apply_ld_mcode
- apply_xds
- apply_xdu
- assign
- change_size
- create_from_insn
- create_from_ivlset
- create_from_mlist
- create_from_scattered_vdloc
- create_from_vdloc
- double_size
- dstr
- empty
- equal_mops
- erase
- erase_but_keep_size
- for_all_ops
- for_all_scattered_submops
- get_insn
- get_stkoff
- get_stkvar
- has_side_effects
- is01
- is_arglist
- is_bit_reg
- is_cc
- is_ccflags
- is_constant
- is_equal_to
- is_extended_from
- is_glbaddr
- is_impptr_done
- is_insn
- is_kreg
- is_lowaddr
- is_mob
- is_negative_constant
- is_one
- is_pcval
- is_positive_constant
- is_reg
- is_scattered
- is_sign_extended_from
- is_stkaddr
- is_udt
- is_undef_val
- is_zero
- is_zero_extended_from
- lexcompare
- make_blkref
- make_first_half
- make_fpnum
- make_gvar
- make_helper
- make_high_half
- make_insn
- make_low_half
- make_number
- make_reg
- make_reg_pair
- make_second_half
- make_stkvar
- may_use_aliased_memory
- obj_id
- oprops
- preserve_side_effects
- probably_floating
- set_impptr_done
- set_lowaddr
- set_udt
- set_undef_val
- shift_mop
- signed_value
- size
- swap
- t
- unsigned_value
- update_numop_value
- valnum
- value
- zero

class mcallargs_t (*args)

Proxy of C++ qvector< mcallarg_t > class.

__init__(self) -> mcallargs_t

x: qvector< mcallarg_t > const &

Methods

def add_unique(self, *args) ‑> bool: add_unique(self, x) -> bool
x: mcallarg_t const &
def at(self, *args) ‑> mcallarg_t const &: at(self, _idx) -> mcallarg_t
_idx: size_t
def back(self)
def begin(self, *args) ‑> qvector< mcallarg_t >::const_iterator: begin(self) -> mcallarg_t

begin(self) -> mcallarg_t
def capacity(self, *args) ‑> size_t: capacity(self) -> size_t
def clear(self, *args) ‑> void: clear(self)
def empty(self, *args) ‑> bool: empty(self) -> bool
def end(self, *args) ‑> qvector< mcallarg_t >::const_iterator: end(self) -> mcallarg_t

end(self) -> mcallarg_t
def erase(self, *args) ‑> qvector< mcallarg_t >::iterator: erase(self, it) -> mcallarg_t
it: qvector< mcallarg_t >::iterator

erase(self, first, last) -> mcallarg_t
first: qvector< mcallarg_t >::iterator last: qvector< mcallarg_t >::iterator
def extract(self, *args) ‑> mcallarg_t *: extract(self) -> mcallarg_t
def find(self, *args) ‑> qvector< mcallarg_t >::const_iterator: find(self, x) -> mcallarg_t
x: mcallarg_t const &

find(self, x) -> mcallarg_t
x: mcallarg_t const &
def front(self)
def grow(self, *args) ‑> void: grow(self, x=mcallarg_t())
x: mcallarg_t const &
def has(self, *args) ‑> bool: has(self, x) -> bool
x: mcallarg_t const &
def inject(self, *args) ‑> void: inject(self, s, len)
s: mcallarg_t * len: size_t
def insert(self, *args) ‑> qvector< mcallarg_t >::iterator: insert(self, it, x) -> mcallarg_t
it: qvector< mcallarg_t >::iterator x: mcallarg_t const &
def pop_back(self, *args) ‑> void: pop_back(self)
def push_back(self, *args) ‑> mcallarg_t &: push_back(self, x)
x: mcallarg_t const &
def qclear(self, *args) ‑> void: qclear(self)
def reserve(self, *args) ‑> void: reserve(self, cnt)
cnt: size_t
def resize(self, *args) ‑> void: resize(self, _newsize, x)
_newsize: size_t x: mcallarg_t const &

resize(self, _newsize)
_newsize: size_t
def size(self, *args) ‑> size_t: size(self) -> size_t
def swap(self, *args) ‑> void: swap(self, r)
r: qvector< mcallarg_t > &
def truncate(self, *args) ‑> void: truncate(self)

class mcallinfo_t (*args)

Proxy of C++ mcallinfo_t class.

__init__(self, _callee=BADADDR, _sargs=0) -> mcallinfo_t

_callee: ea_t _sargs: int

Instance variables

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

Methods

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

class mcases_t (*args)

Proxy of C++ mcases_t class.

__init__(self) -> mcases_t

Instance variables

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

Methods

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

class microcode_filter_t (*args)

Proxy of C++ microcode_filter_t class.

__init__(self) -> microcode_filter_t

self: PyObject *

Subclasses

udc_filter_t

Methods

def apply(self, *args) ‑> merror_t: generate microcode for an instruction

apply(self, cdg) -> merror_t
cdg (C++: codegen_t &)

return: MERR_... code: MERR_OK - user-defined call generated, go to
the next instruction MERR_INSN - not generated - the caller should try the standard way else - error
def match(self, *args) ‑> bool: check if the filter object is to be appied

match(self, cdg) -> bool
cdg (C++: codegen_t &)

return: success

class minsn_t (*args)

Proxy of C++ minsn_t class.

__init__(self, _ea) -> minsn_t

_ea: ea_t

__init__(self, m) -> minsn_t

m: minsn_t const &

Instance variables

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

Methods

def clr_assert(self, *args) ‑> void: clr_assert(self)
def clr_combinable(self, *args) ‑> void: clr_combinable(self)
def clr_combined(self, *args) ‑> void: clr_combined(self)
def clr_fpinsn(self, *args) ‑> void: clr_fpinsn(self)
def clr_ignlowsrc(self, *args) ‑> void: clr_ignlowsrc(self)
def clr_multimov(self, *args) ‑> void: clr_multimov(self)
def clr_noret_icall(self, *args) ‑> void: clr_noret_icall(self)
def clr_propagatable(self, *args) ‑> void: clr_propagatable(self)
def clr_tailcall(self, *args) ‑> void: clr_tailcall(self)
def contains_call(self, *args) ‑> bool: Does the instruction contain a call?

contains_call(self, with_helpers=False) -> bool
with_helpers (C++: bool)
def contains_opcode(self, *args) ‑> bool: Does the instruction have the specified opcode? This function searches subinstructions as well.

contains_opcode(self, mcode) -> bool
mcode: opcode to search for. (C++: mcode_t)
def dstr(self, *args) ‑> char const *: Get displayable text without tags in a static buffer.
def equal_insns(self, *args) ‑> bool: Compare instructions. This is the main comparison function for instructions.

equal_insns(self, m, eqflags) -> bool
m: instruction to compare with (C++: const minsn_t &)

eqflags: combination of comparison bits bits (C++: int)
def find_call(self, *args) ‑> minsn_t *: Find a call instruction. Check for the current instruction and its subinstructions.

find_call(self, with_helpers=False) -> minsn_t
with_helpers: consider helper calls as well? (C++: bool)
def find_ins_op(self, *args) ‑> minsn_t *: Find an operand that is a subinsruction with the specified opcode. This function checks only the 'l' and 'r' operands of the current insn.

find_ins_op(self, op=m_nop) -> minsn_t
op: opcode to search for (C++: mcode_t)

return: &l or &r or NULL
def find_num_op(self, *args) ‑> mop_t *: Find a numeric operand of the current instruction. This function checks only the 'l' and 'r' operands of the current insn.
def find_opcode(self, *args) ‑> minsn_t *: Find a (sub)insruction with the specified opcode.

find_opcode(self, mcode) -> minsn_t
mcode: opcode to search for. (C++: mcode_t)

find_opcode(self, mcode) -> minsn_t
mcode: opcode to search for. (C++: mcode_t)
def for_all_insns(self, *args) ‑> int: Visit all instructions. This function visits the instruction itself and all its subinstructions.

for_all_insns(self, mv) -> int
mv: instruction visitor (C++: minsn_visitor_t &)

return: non-zero value returned by mv.visit_mop() or zero
def for_all_ops(self, *args) ‑> int: Visit all instruction operands. This function visits subinstruction operands as well.

for_all_ops(self, mv) -> int
mv: operand visitor (C++: mop_visitor_t &)

return: non-zero value returned by mv.visit_mop() or zero
def get_role(self, *args) ‑> funcrole_t: Get the function role of a call.
def get_split_size(self, *args) ‑> int: get_split_size(self) -> int
def has_side_effects(self, *args) ‑> bool: Does the instruction have a side effect?

has_side_effects(self, include_ldx_and_divs=False) -> bool
include_ldx_and_divs: consider ldx/div/mod as having side
effects? stx is always considered as having side effects. Apart from ldx/std only call may have side effects. (C++: bool)
def is_after(self, *args) ‑> bool: Is the instruction after the specified one?

is_after(self, m) -> bool
m: the instruction to compare against in the list (C++: const
minsn_t *)
def is_alloca(self, *args) ‑> bool: is_alloca(self) -> bool
def is_assert(self, *args) ‑> bool: is_assert(self) -> bool
def is_between(self, *args) ‑> bool: Is the instruction in the specified range of instructions?

is_between(self, m1, m2) -> bool
m1: beginning of the range in the doubly linked list (C++:
const minsn_t *)

m2: end of the range in the doubly linked list (excluded, may
be NULL) This function assumes that m1 and m2 belong to the same basic block and they are top level instructions. (C++: const minsn_t *)
def is_bswap(self, *args) ‑> bool: is_bswap(self) -> bool
def is_cleaning_pop(self, *args) ‑> bool: is_cleaning_pop(self) -> bool
def is_combinable(self, *args) ‑> bool: is_combinable(self) -> bool
def is_combined(self, *args) ‑> bool: is_combined(self) -> bool
def is_extstx(self, *args) ‑> bool: is_extstx(self) -> bool
def is_farcall(self, *args) ‑> bool: is_farcall(self) -> bool
def is_fpinsn(self, *args) ‑> bool: is_fpinsn(self) -> bool
def is_helper(self, *args) ‑> bool: Is a helper call with the specified name? Helper calls usually have well-known function names (see 'Well known function names' ) but they may have any other name. The decompiler does not assume any special meaning for non-well-known names.

is_helper(self, name) -> bool
name (C++: const char *)
def is_ignlowsrc(self, *args) ‑> bool: is_ignlowsrc(self) -> bool
def is_inverted_jx(self, *args) ‑> bool: is_inverted_jx(self) -> bool
def is_like_move(self, *args) ‑> bool: is_like_move(self) -> bool
def is_mbarrier(self, *args) ‑> bool: is_mbarrier(self) -> bool
def is_memcpy(self, *args) ‑> bool: is_memcpy(self) -> bool
def is_memset(self, *args) ‑> bool: is_memset(self) -> bool
def is_mov(self, *args) ‑> bool: is_mov(self) -> bool
def is_multimov(self, *args) ‑> bool: is_multimov(self) -> bool
def is_noret_call(self, *args) ‑> bool: Is a non-returing call?

is_noret_call(self, flags=0) -> bool
flags (C++: int)
def is_optional(self, *args) ‑> bool: is_optional(self) -> bool
def is_persistent(self, *args) ‑> bool: is_persistent(self) -> bool
def is_propagatable(self, *args) ‑> bool: is_propagatable(self) -> bool
def is_readflags(self, *args) ‑> bool: is_readflags(self) -> bool
def is_tailcall(self, *args) ‑> bool: is_tailcall(self) -> bool
def is_unknown_call(self, *args) ‑> bool: Is an unknown call? Unknown calls are calls without the argument list ( 'mcallinfo_t' ). Usually the argument lists are determined by 'mba_t::analyze_calls()' . Unknown calls exist until the MMAT_CALLS maturity level. See also mblock_t::is_call_block
def is_wild_match(self, *args) ‑> bool: is_wild_match(self) -> bool
def lexcompare(self, *args) ‑> int: lexcompare(self, ri) -> int
ri (C++: const minsn_t &)
def may_use_aliased_memory(self, *args) ‑> bool: Is it possible for the instruction to use aliased memory?
def modifes_d(self, *args) ‑> bool: Does the instruction modify its 'd' operand? Some instructions (e.g. m_stx) do not modify the 'd' operand.
def modifies_pair_mop(self, *args) ‑> bool: modifies_pair_mop(self) -> bool
def optimize_solo(self, *args) ‑> int: Optimize one instruction without context. This function does not have access to the instruction context (the previous and next instructions in the list, the block number, etc). It performs only basic optimizations that are available without this info.

optimize_solo(self, optflags=0) -> int
optflags: combination of optimization flags bits (C++: int)

return: number of changes, 0-unchanged See also
mblock_t::optimize_insn()
def optimize_subtree(self, *args) ‑> int: Optimize instruction in its context. Do not use this function, use mblock_t::optimize()

optimize_subtree(self, blk, top, parent, converted_call, optflags=0x0002) -> int
blk (C++: mblock_t *)

top (C++: minsn_t *)

parent (C++: minsn_t *)

converted_call (C++: ea_t *)

optflags (C++: int)
def replace_by(self, o)
def set_assert(self, *args) ‑> void: set_assert(self)
def set_cleaning_pop(self, *args) ‑> void: set_cleaning_pop(self)
def set_combinable(self, *args) ‑> void: set_combinable(self)
def set_extstx(self, *args) ‑> void: set_extstx(self)
def set_farcall(self, *args) ‑> void: set_farcall(self)
def set_fpinsn(self, *args) ‑> void: set_fpinsn(self)
def set_ignlowsrc(self, *args) ‑> void: set_ignlowsrc(self)
def set_inverted_jx(self, *args) ‑> void: set_inverted_jx(self)
def set_mbarrier(self, *args) ‑> void: set_mbarrier(self)
def set_multimov(self, *args) ‑> void: set_multimov(self)
def set_noret_icall(self, *args) ‑> void: set_noret_icall(self)
def set_optional(self, *args) ‑> void: set_optional(self)
def set_persistent(self, *args) ‑> void: set_persistent(self)
def set_split_size(self, *args) ‑> void: set_split_size(self, s)
s (C++: int)
def set_tailcall(self, *args) ‑> void: set_tailcall(self)
def set_wild_match(self, *args) ‑> void: set_wild_match(self)
def setaddr(self, *args) ‑> void: Change the instruction address. This function modifies subinstructions as well.

setaddr(self, new_ea)
new_ea (C++: ea_t)
def swap(self, *args) ‑> void: Swap two instructions. The prev/next fields are not modified by this function because it would corrupt the doubly linked list.

swap(self, m)
m (C++: minsn_t &)
def was_noret_icall(self, *args) ‑> bool: was_noret_icall(self) -> bool
def was_split(self, *args) ‑> bool: was_split(self) -> bool

class minsn_visitor_t (*args)

Proxy of C++ minsn_visitor_t class.

__init__(self, _mba=None, _blk=None, _topins=None) -> minsn_visitor_t

_mba: mba_t * _blk: mblock_t * _topins: minsn_t *

Ancestors

op_parent_info_t

Methods

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

Inherited members

op_parent_info_t:
- blk
- curins
- mba
- topins

class mlist_mop_visitor_t (*args)

Proxy of C++ mlist_mop_visitor_t class.

__init__(self) -> mlist_mop_visitor_t

self: PyObject *

Instance variables

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

Methods

def visit_mop(self, *args) ‑> int: visit_mop(self, op) -> int
op (C++: mop_t *)

class mlist_t (*args)

Proxy of C++ mlist_t class.

__init__(self) -> mlist_t

ivl: ivl_t const &

__init__(self, r, size) -> mlist_t

r: mreg_t size: int

Instance variables

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

Methods

def add(self, *args) ‑> bool: add(self, r, size) -> bool
r (C++: mreg_t)

size (C++: int)

add(self, r) -> bool
r (C++: mreg_t)

add(self, ivl) -> bool
ivl: ivl_t const &

add(self, lst) -> bool
lst: mlist_t const &
def addmem(self, *args) ‑> bool