Module ida_nalt

Definitions of various information kept in netnodes.

Each address in the program has a corresponding netnode: netnode(ea).

If we have no information about an address, the corresponding netnode is not created. Otherwise we will create a netnode and save information in it. All variable length information (names, comments, offset information, etc) is stored in the netnode.

Don't forget that some information is already stored in the flags (bytes.hpp)

@warning: Many of the functions in this file are very low level (they are marked as low level functions). Use them only if you can't find higher level function to set/get/del information.netnode.

Global variables

var AFL_ALIGNFLOW

the previous insn was created for alignment purposes only

var AFL_BNOT0

the 1st operand is bitwise negated

var AFL_BNOT1

the 2nd operand is bitwise negated

var AFL_COLORED

has user defined instruction color?

var AFL_FIXEDSPD

sp delta value is fixed by analysis. should not be modified by modules

var AFL_HIDDEN

the item is hidden completely

var AFL_HR_DETERMINED

the type is definitely guessed by the decompiler

var AFL_HR_GUESSED_DATA

the data type is guessed by the decompiler

var AFL_HR_GUESSED_FUNC

the function type is guessed by the decompiler

var AFL_IDA_GUESSED

the type is guessed by IDA

var AFL_LIB

item from the standard library. low level flag, is used to set FUNC_LIB of func_t

var AFL_LINNUM

has line number info

var AFL_LNAME

has local name too (FF_NAME should be set)

var AFL_LZERO0

toggle leading zeroes for the 1st operand

var AFL_LZERO1

toggle leading zeroes for the 2nd operand

var AFL_MANUAL

the instruction/data is specified by the user

var AFL_NOBRD

the code/data border is hidden

var AFL_NORET

for imported function pointers: doesn't return. this flag can also be used for any instruction which halts or finishes the program execution

var AFL_NOTCODE

autoanalysis should not create code here

var AFL_NOTPROC

autoanalysis should not create proc here

var AFL_PUBNAM

name is public (inter-file linkage)

var AFL_RETFP

function returns a floating point value

var AFL_SIGN0

code: toggle sign of the 1st operand

var AFL_SIGN1

code: toggle sign of the 2nd operand

var AFL_TERSESTR

terse structure variable display?

var AFL_TI

has typeinfo? (NSUP_TYPEINFO); used only for addresses, not for member_t

var AFL_TI0

has typeinfo for operand 0? (NSUP_OPTYPES)

var AFL_TI1

has typeinfo for operand 1? (NSUP_OPTYPES+1)

var AFL_TILCMT

has type comment? (such a comment may be changed by IDA)

var AFL_TYPE_GUESSED

who guessed the type information?

var AFL_USEMODSP

insn modifes SP and uses the modified value; example: pop [rsp+N]

var AFL_USERSP

user-defined SP value

var AFL_USERTI

the type information is definitive. (comes from the user or type library) if not set see AFL_TYPE_GUESSED

var AFL_WEAKNAM

name is weak

var AFL_ZSTROFF

display struct field name at 0 offset when displaying an offset. example: offset somestruct.field_0 if this flag is clear, then offset somestruct

var AP_ALLOWDUPS

use 'dup' construct

var AP_ARRAY

create as array (this flag is not stored in database)

var AP_IDXBASEMASK

mask for number base of the indexes

var AP_IDXBIN

display indexes in binary

var AP_IDXDEC

display indexes in decimal

var AP_IDXHEX

display indexes in hex

var AP_IDXOCT

display indexes in octal

var AP_INDEX

display array element indexes as comments

var AP_SIGNED

treats numbers as signed

var GOTEA_NODE_NAME

node containing address of .got section

var IDB_DESKTOPS_NODE_NAME

hash indexed by desktop name with dekstop netnode

var IDB_DESKTOPS_TAG

tag to store desktop blob & timestamp

var MAXSTRUCPATH

maximal inclusion depth of unions

var NALT_ABSBASE

absolute segment location

var NALT_AFLAGS

additional flags for an item

var NALT_ALIGN

alignment value if the item is FF_ALIGN (should by equal to power of 2)

var NALT_COLOR

instruction/data background color

var NALT_CREF_FROM

code xref from, idx: source address

var NALT_CREF_TO

code xref to, idx: target address

var NALT_DREF_FROM

data xref from, idx: source address

var NALT_DREF_TO

data xref to, idx: target address

var NALT_ENUM0

enum id for the first operand

var NALT_ENUM1

enum id for the second operand

var NALT_GR_LAYX

group layout ptrs, hash: md5 of 'belongs'

var NALT_LINNUM

source line number

var NALT_PURGE

number of bytes purged from the stack when a function is called indirectly

var NALT_STRTYPE

type of string item

var NALT_STRUCT

struct id

var NALT_SWITCH

switch idiom address (used at jump targets)

var NSUP_ARGEAS

instructions that initialize call arguments

var NSUP_ARRAY

array parameters

var NSUP_CMT

regular comment

var NSUP_CUSTDT

custom data type id

var NSUP_EX_FLAGS

Extended flags.

var NSUP_FOP1

forced operand 1

var NSUP_FOP2

forced operand 2

var NSUP_FOP3

forced operand 3

var NSUP_FOP4

forced operand 4

var NSUP_FOP5

forced operand 5

var NSUP_FOP6

forced operand 6

var NSUP_FOP7

forced operand 7

var NSUP_FOP8

forced operand 8

var NSUP_FRAME

function frame type values NSUP_FRAME..NSUP_FRAME+0x10000 are reserved

var NSUP_FTAILS

function tails or tail referers values NSUP_FTAILS..NSUP_FTAILS+0x1000 are reserved

var NSUP_GROUP

graph group information values NSUP_GROUP..NSUP_GROUP+0x1000 are reserved

var NSUP_GROUPS

SEG_GRP: pack_dd encoded list of selectors.

var NSUP_GR_INFO

group node info: color, ea, text

var NSUP_GR_LAYT

group layouts, idx: layout pointer

var NSUP_JINFO

jump table info

var NSUP_LLABEL

local labels. values NSUP_LLABEL..NSUP_LLABEL+0x1000 are reserved

var NSUP_MANUAL

manual instruction. values NSUP_MANUAL..NSUP_MANUAL+0x1000 are reserved

var NSUP_OMFGRP

OMF: group of segments (not used anymore)

var NSUP_OPTYPES

operand type information. values NSUP_OPTYPES..NSUP_OPTYPES+0x100000 are reserved

var NSUP_OREF0

outer complex reference information for operand 1

var NSUP_OREF1

outer complex reference information for operand 2

var NSUP_OREF2

outer complex reference information for operand 3

var NSUP_OREF3

outer complex reference information for operand 4

var NSUP_OREF4

outer complex reference information for operand 5

var NSUP_OREF5

outer complex reference information for operand 6

var NSUP_OREF6

outer complex reference information for operand 7

var NSUP_OREF7

outer complex reference information for operand 8

var NSUP_ORIGFMD

function metadata before lumina information was applied values NSUP_ORIGFMD..NSUP_ORIGFMD+0x1000 are reserved

var NSUP_POINTS

SP change points blob (see funcs.cpp). values NSUP_POINTS..NSUP_POINTS+0x1000 are reserved

var NSUP_REF0

complex reference information for operand 1

var NSUP_REF1

complex reference information for operand 2

var NSUP_REF2

complex reference information for operand 3

var NSUP_REF3

complex reference information for operand 4

var NSUP_REF4

complex reference information for operand 5

var NSUP_REF5

complex reference information for operand 6

var NSUP_REF6

complex reference information for operand 7

var NSUP_REF7

complex reference information for operand 8

var NSUP_REGARG

register argument type/name descriptions values NSUP_REGARG..NSUP_REGARG+0x1000 are reserved

var NSUP_REGVAR

register variables. values NSUP_REGVAR..NSUP_REGVAR+0x1000 are reserved

var NSUP_REPCMT

repeatable comment

var NSUP_SEGTRANS

segment translations

var NSUP_STROFF0

stroff: struct path for the first operand

var NSUP_STROFF1

stroff: struct path for the second operand

var NSUP_SWITCH

switch information

var NSUP_TYPEINFO

type information. values NSUP_TYPEINFO..NSUP_TYPEINFO+0x1000 are reserved

var NSUP_XREFPOS

saved xref address and type in the xrefs window

var PATCH_TAG

Patch netnode tag.

var REFINFO_CUSTOM

a custom reference. see custom_refinfo_handler_t. the id of the custom refinfo is stored under the REFINFO_TYPE mask.

var REFINFO_NOBASE

don't create the base xref; implies that the base can be any value. nb: base xrefs are created only if the offset base points to the middle of a segment

var REFINFO_NO_ONES

an opval of ~0 will be considered invalid

var REFINFO_NO_ZEROS

an opval of 0 will be considered invalid

var REFINFO_PASTEND

reference past an item; it may point to an nonexistent address; do not destroy alignment dirs

var REFINFO_RVAOFF

based reference (rva); refinfo_t::base will be forced to get_imagebase(); such a reference is displayed with the asm_t::a_rva keyword

var REFINFO_SELFREF

the self-based reference; refinfo_t::base will be forced to the reference address

var REFINFO_SIGNEDOP

the operand value is sign-extended (only supported for REF_OFF8/16/32/64)

var REFINFO_SUBTRACT

the reference value is subtracted from the base value instead of (as usual) being added to it

var REFINFO_TYPE

reference type (reftype_t), or custom reference ID if REFINFO_CUSTOM set

var REF_HIGH16

high 16bits of 32bit offset

var REF_HIGH8

high 8bits of 16bit offset

var REF_LOW16

low 16bits of 32bit offset

var REF_LOW8

low 8bits of 16bit offset

var REF_OFF16

16bit full offset

var REF_OFF32

32bit full offset

var REF_OFF64

64bit full offset

var REF_OFF8

8bit full offset

var RIDX_ABINAME

ABI name (processor specific)

var RIDX_ARCHIVE_PATH

archive file path

var RIDX_C_MACROS

C predefined macros.

var RIDX_DBG_BINPATHS

unused (20 indexes)

var RIDX_DUALOP_GRAPH

Graph text representation options.

var RIDX_DUALOP_TEXT

Text text representation options.

var RIDX_FILE_FORMAT_NAME

file format name for loader modules

var RIDX_GROUPS

segment group information (see init_groups())

var RIDX_H_PATH

C header path.

var RIDX_IDA_VERSION

version of ida which created the database

var RIDX_INCLUDE

assembler include file name

var RIDX_MD5

MD5 of the input file.

var RIDX_NOTEPAD

notepad blob, occupies 1000 indexes (1MB of text)

var RIDX_PROBLEMS

problem lists

var RIDX_SELECTORS

2..63 are for selector_t blob (see init_selectors())

var RIDX_SHA256

SHA256 of the input file.

var RIDX_SMALL_IDC

Instant IDC statements, blob.

var RIDX_SMALL_IDC_OLD

Instant IDC statements (obsolete)

var RIDX_SRCDBG_PATHS

source debug paths, occupies 20 indexes

var RIDX_SRCDBG_UNDESIRED

user-closed source files, occupies 20 indexes

var RIDX_STR_ENCODINGS

a list of encodings for the program strings

var STRENC_DEFAULT

use default encoding for this type (see get_default_encoding_idx())

var STRENC_NONE

force no-conversion encoding

var STRTYPE_C

Zero-terminated 16bit chars.

var STRTYPE_C_16

Zero-terminated 32bit chars.

var STRTYPE_C_32

Pascal-style, one-byte length prefix.

var STRTYPE_LEN2

Pascal-style, 16bit chars, two-byte length prefix.

var STRTYPE_LEN2_16

Pascal-style, 32bit chars, two-byte length prefix.

var STRTYPE_LEN2_32

Pascal-style, four-byte length prefix.

var STRTYPE_LEN4

Pascal-style, 16bit chars, four-byte length prefix.

var STRTYPE_LEN4_16

Pascal-style, 32bit chars, four-byte length prefix.

var STRTYPE_PASCAL

Pascal-style, 16bit chars, one-byte length prefix.

var STRTYPE_PASCAL_16

Pascal-style, 32bit chars, one-byte length prefix.

var STRTYPE_PASCAL_32

Pascal-style, two-byte length prefix.

var STRTYPE_TERMCHR

C-style string.

var SWI_CUSTOM

custom jump table. processor_t::create_switch_xrefs will be called to create code xrefs for the table. Custom jump table must be created by the module (see also SWI_STDTBL)

var SWI_DEFRET

return in the default case (defjump==BADADDR)

var SWI_DEF_IN_TBL

default case is an entry in the jump table. This flag is applicable in 2 cases: * The sparse indirect switch (i.e. a switch with a values table) {jump table size} == {value table size} + 1. The default case entry is the last one in the table (or the first one in the case of an inversed jump table). * The switch with insns in the jump table. The default case entry is before the first entry of the table. See also the find_defjump_from_table() helper function.

var SWI_ELBASE

elbase is present (otherwise the base of the switch segment will be used)

var SWI_HXNOLOWCASE

lowcase value should not be used by the decompiler (internal flag)

var SWI_INDIRECT

value table elements are used as indexes into the jump table (for sparse switches)

var SWI_J32

32-bit jump offsets

var SWI_JMPINSN

jump table entries are insns. For such entries SHIFT has a different meaning. It denotes the number of insns in the entry. For example, 0 - the entry contains the jump to the case, 1 - the entry contains one insn like a 'mov' and jump to the end of case, and so on.

var SWI_JMP_INV

jumptable is inversed. (last entry is for first entry in values table)

var SWI_JSIZE

jump offset expansion bit

var SWI_SELFREL

jump address is relative to the element not to ELBASE

var SWI_SEPARATE

create an array of individual elements (otherwise separate items)

var SWI_SHIFT_MASK

use formula (element<<shift) + elbase to find jump targets

var SWI_SIGNED

jump table entries are signed

var SWI_SPARSE

sparse switch (value table present), otherwise lowcase present

var SWI_STDTBL

custom jump table with standard table formatting. ATM IDA doesn't use SWI_CUSTOM for switches with standard table formatting. So this flag can be considered as obsolete.

var SWI_SUBTRACT

table values are subtracted from the elbase instead of being added

var SWI_USER

user specified switch (starting from version 2)

var SWI_V32

32-bit values in table

var SWI_VERSION

the structure contains the VERSION member

var SWI_VSIZE

value table element size expansion bit

var SWI_VSPLIT

value table is split (only for 32-bit values)

var V695_REF_OFF8

reserved

var V695_REF_VHIGH

obsolete

var V695_REF_VLOW

obsolete

Functions

def add_encoding(encname: char const *)

add_encoding(encname) -> int Add a new encoding (e.g. "UTF-8"). If it's already in the list, return its index.

@param encname: (C++: const char *) the encoding name @return: its index (1-based); -1 means error

def clr__bnot0(ea: ea_t)

clr__bnot0(ea)

@param ea: ea_t

def clr__bnot1(ea: ea_t)

clr__bnot1(ea)

@param ea: ea_t

def clr__invsign0(ea: ea_t)

clr__invsign0(ea)

@param ea: ea_t

def clr__invsign1(ea: ea_t)

clr__invsign1(ea)

@param ea: ea_t

def clr_abits(ea: ea_t, bits: aflags_t)

clr_abits(ea, bits)

@param ea: ea_t @param bits: aflags_t

def clr_align_flow(ea: ea_t)

clr_align_flow(ea)

@param ea: ea_t

def clr_colored_item(ea: ea_t)

clr_colored_item(ea)

@param ea: ea_t

def clr_fixed_spd(ea: ea_t)

clr_fixed_spd(ea)

@param ea: ea_t

def clr_has_lname(ea: ea_t)

clr_has_lname(ea)

@param ea: ea_t

def clr_has_ti(ea: ea_t)

clr_has_ti(ea)

@param ea: ea_t

def clr_has_ti0(ea: ea_t)

clr_has_ti0(ea)

@param ea: ea_t

def clr_has_ti1(ea: ea_t)

clr_has_ti1(ea)

@param ea: ea_t

def clr_libitem(ea: ea_t)

clr_libitem(ea)

@param ea: ea_t

def clr_lzero0(ea: ea_t)

clr_lzero0(ea)

@param ea: ea_t

def clr_lzero1(ea: ea_t)

clr_lzero1(ea)

@param ea: ea_t

def clr_noret(ea: ea_t)

clr_noret(ea)

@param ea: ea_t

def clr_notcode(ea: ea_t)

clr_notcode(ea) Clear not-code mark.

@param ea: (C++: ea_t)

def clr_notproc(ea: ea_t)

clr_notproc(ea)

@param ea: ea_t

def clr_retfp(ea: ea_t)

clr_retfp(ea)

@param ea: ea_t

def clr_terse_struc(ea: ea_t)

clr_terse_struc(ea)

@param ea: ea_t

def clr_tilcmt(ea: ea_t)

clr_tilcmt(ea)

@param ea: ea_t

def clr_usemodsp(ea: ea_t)

clr_usemodsp(ea)

@param ea: ea_t

def clr_usersp(ea: ea_t)

clr_usersp(ea)

@param ea: ea_t

def clr_userti(ea: ea_t)

clr_userti(ea)

@param ea: ea_t

def clr_zstroff(ea: ea_t)

clr_zstroff(ea)

@param ea: ea_t

def dbg_get_input_path()

dbg_get_input_path() -> str Get debugger input file name/path (see LFLG_DBG_NOPATH)

def del_absbase(ea: ea_t)

del_absbase(ea)

@param ea: ea_t

def del_aflags(ea: ea_t)

del_aflags(ea)

@param ea: ea_t

def del_alignment(ea: ea_t)

del_alignment(ea)

@param ea: ea_t

def del_array_parameters(ea: ea_t)

del_array_parameters(ea)

@param ea: ea_t

def del_custom_data_type_ids(ea: ea_t)

del_custom_data_type_ids(ea)

@param ea: ea_t

def del_encoding(idx: int) ‑> bool

del_encoding(idx) -> bool Delete an encoding The encoding is not actually removed because its index may be used in strtype. So the deletion just clears the encoding name. The default encoding cannot be deleted.

@param idx: (C++: int) the encoding index (1-based)

def del_ind_purged(ea: ea_t)

del_ind_purged(ea)

@param ea: ea_t

def del_item_color(ea: ea_t)

del_item_color(ea) -> bool

@param ea: ea_t

def del_op_tinfo(ea: ea_t, n: int)

del_op_tinfo(ea, n)

@param ea: ea_t @param n: int

def del_refinfo(ea: ea_t, n: int)

del_refinfo(ea, n) -> bool

@param ea: ea_t @param n: int

def del_source_linnum(ea: ea_t)

del_source_linnum(ea)

@param ea: ea_t

def del_str_type(ea: ea_t)

del_str_type(ea)

@param ea: ea_t

def del_switch_info(ea: ea_t)

del_switch_info(ea)

@param ea: ea_t

def del_switch_parent(ea: ea_t)

del_switch_parent(ea)

@param ea: ea_t

def del_tinfo(ea: ea_t)

del_tinfo(ea)

@param ea: ea_t

def delete_imports()

delete_imports() Delete all imported modules information.

def ea2node(ea: ea_t)

ea2node(ea) -> nodeidx_t Get netnode for the specified address.

@param ea: (C++: ea_t)

def encoding_from_strtype(strtype: int32)

encoding_from_strtype(strtype) -> char const * Get encoding name for this strtype @retval nullptr: if STRTYPE has an incorrect encoding index @retval empty: string if the encoding was deleted

@param strtype: (C++: int32)

def end_ea2node(ea: ea_t)

end_ea2node(ea) -> nodeidx_t

@param ea: ea_t

def enum_import_names(mod_index: int, py_cb: PyObject *)

enum_import_names(mod_index, py_cb) -> int Enumerate imports from a specific module. Please refer to list_imports.py example.

@param mod_index: The module index @param callback: A callable object that will be invoked with an ea, name (could be None) and ordinal. @return: 1-finished ok, -1 on error, otherwise callback return value (<=0)

def find_custom_refinfo(name: char const *)

find_custom_refinfo(name) -> int Get id of a custom refinfo type.

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

def get_abi_name()

def get_absbase(ea: ea_t)

get_absbase(ea) -> ea_t

@param ea: ea_t

def get_aflags(ea: ea_t)

get_aflags(ea) -> aflags_t

@param ea: ea_t

def get_alignment(ea: ea_t)

get_alignment(ea) -> uint32

@param ea: ea_t

def get_archive_path()

get_archive_path() -> str Get archive file path from which input file was extracted.

def get_array_parameters(out: array_parameters_t, ea: ea_t)

get_array_parameters(out, ea) -> ssize_t

@param out: array_parameters_t * @param ea: ea_t

def get_asm_inc_file()

get_asm_inc_file() -> str Get name of the include file.

def get_custom_data_type_ids(cdis: custom_data_type_ids_t, ea: ea_t)

get_custom_data_type_ids(cdis, ea) -> int

@param cdis: custom_data_type_ids_t * @param ea: ea_t

def get_custom_refinfo(crid: int)

get_custom_refinfo(crid) -> custom_refinfo_handler_t const * Get definition of a registered custom refinfo type.

@param crid: (C++: int)

def get_default_encoding_idx(bpu: int) ‑> int

get_default_encoding_idx(bpu) -> int Get default encoding index for a specific string type.

@param bpu: (C++: int) the amount of bytes per unit (e.g., 1 for ASCII, CP1252, UTF-8…, 2 for UTF-16, 4 for UTF-32) @retval 0: bad BPU argument

def get_elapsed_secs()

get_elapsed_secs() -> size_t Get seconds database stayed open.

def get_encoding_bpu(idx: int) ‑> int

get_encoding_bpu(idx) -> int Get the amount of bytes per unit (e.g., 2 for UTF-16, 4 for UTF-32) for the encoding with the given index.

@param idx: (C++: int) the encoding index (1-based) @return: the number of bytes per units (1/2/4); -1 means error

def get_encoding_bpu_by_name(encname: char const *)

get_encoding_bpu_by_name(encname) -> int Get the amount of bytes per unit for the given encoding

@param encname: (C++: const char *) the encoding name @return: the number of bytes per units (1/2/4); -1 means error

def get_encoding_name(idx: int)

get_encoding_name(idx) -> char const * Get encoding name for specific index (1-based).

@param idx: (C++: int) the encoding index (1-based) @retval nullptr: if IDX is out of bounds @retval empty: string if the encoding was deleted

def get_encoding_qty() ‑> int

get_encoding_qty() -> int Get total number of encodings (counted from 0)

def get_gotea()

get_gotea() -> ea_t

def get_ida_notepad_text()

get_ida_notepad_text() -> str Get notepad text.

def get_idb_ctime()

get_idb_ctime() -> time_t Get database creation timestamp.

def get_idb_nopens()

get_idb_nopens() -> size_t Get number of times the database is opened.

def get_ids_modnode()

get_ids_modnode() -> netnode Get ids modnode.

def get_imagebase()

get_imagebase() -> ea_t Get image base address.

def get_import_module_name(mod_index: int)

get_import_module_name(mod_index) -> str Returns the name of an imported module given its index

@param mod_index: int @return: None or the module name

def get_import_module_qty()

get_import_module_qty() -> uint Get number of import modules.

def get_ind_purged(ea: ea_t)

get_ind_purged(ea) -> ea_t

@param ea: ea_t

def get_initial_ida_version()

get_initial_ida_version() -> str Get version of ida which created the database (string format like "7.5")

def get_initial_idb_version()

get_initial_idb_version() -> ushort Get initial version of the database (numeric format like 700)

def get_initial_version()

get_initial_idb_version() -> ushort Get initial version of the database (numeric format like 700)

def get_input_file_path()

get_input_file_path() -> str Get full path of the input file.

def get_item_color(ea: ea_t)

get_item_color(ea) -> bgcolor_t

@param ea: ea_t

def get_loader_format_name()

get_loader_format_name() -> str Get file format name for loader modules.

def get_op_tinfo(tif: tinfo_t, ea: ea_t, n: int)

get_op_tinfo(tif, ea, n) -> bool

@param tif: tinfo_t * @param ea: ea_t @param n: int

def get_outfile_encoding_idx() ‑> int

get_outfile_encoding_idx() -> int Get the index of the encoding used when producing files @retval 0: the IDB's default 1 byte-per-unit encoding is used

def get_refinfo(ri: refinfo_t, ea: ea_t, n: int)

get_refinfo(ri, ea, n) -> bool

@param ri: refinfo_t * @param ea: ea_t @param n: int

def get_reftype_by_size(size: size_t)

get_reftype_by_size(size) -> reftype_t Get REF_… constant from size Supported sizes: 1,2,4,8,16 For other sizes returns reftype_t(-1)

@param size: (C++: size_t)

def get_root_filename()

get_root_filename() -> str Get file name only of the input file.

def get_source_linnum(ea: ea_t)

get_source_linnum(ea) -> uval_t

@param ea: ea_t

def get_srcdbg_paths()

get_srcdbg_paths() -> str Get source debug paths.

def get_srcdbg_undesired_paths()

get_srcdbg_undesired_paths() -> str Get user-closed source files.

def get_str_encoding_idx(strtype: int32)

get_str_encoding_idx(strtype) -> uchar Get index of the string encoding for this string.

@param strtype: (C++: int32)

def get_str_term1(strtype: int32)

get_str_term1(strtype) -> char

@param strtype: int32

def get_str_term2(strtype: int32)

get_str_term2(strtype) -> char

@param strtype: int32

def get_str_type(ea: ea_t)

get_str_type(ea) -> uint32

@param ea: ea_t

def get_str_type_code(strtype: int32)

get_str_type_code(strtype) -> uchar

@param strtype: int32

def get_str_type_prefix_length(strtype: int32)

get_str_type_prefix_length(strtype) -> size_t

@param strtype: int32

def get_strid(ea: ea_t)

get_strid(ea) -> tid_t

@param ea: ea_t

def get_strtype_bpu(strtype: int32)

get_strtype_bpu(strtype) -> int

@param strtype: int32

def get_switch_info(*args)

def get_switch_parent(ea: ea_t)

get_switch_parent(ea) -> ea_t

@param ea: ea_t

def get_tinfo(tif: tinfo_t, ea: ea_t)

get_tinfo(tif, ea) -> bool

@param tif: tinfo_t * @param ea: ea_t

def getnode(ea: ea_t)

getnode(ea) -> netnode

@param ea: ea_t

def has_aflag_linnum(flags: aflags_t)

has_aflag_linnum(flags) -> bool

@param flags: aflags_t

def has_aflag_lname(flags: aflags_t)

has_aflag_lname(flags) -> bool

@param flags: aflags_t

def has_aflag_ti(flags: aflags_t)

has_aflag_ti(flags) -> bool

@param flags: aflags_t

def has_aflag_ti0(flags: aflags_t)

has_aflag_ti0(flags) -> bool

@param flags: aflags_t

def has_aflag_ti1(flags: aflags_t)

has_aflag_ti1(flags) -> bool

@param flags: aflags_t

def has_lname(ea: ea_t)

has_lname(ea) -> bool

@param ea: ea_t

def has_ti(ea: ea_t)

has_ti(ea) -> bool

@param ea: ea_t

def has_ti0(ea: ea_t)

has_ti0(ea) -> bool

@param ea: ea_t

def has_ti1(ea: ea_t)

has_ti1(ea) -> bool

@param ea: ea_t

def hide_border(ea: ea_t)

hide_border(ea)

@param ea: ea_t

def hide_item(ea: ea_t)

hide_item(ea)

@param ea: ea_t

def is__bnot0(ea: ea_t)

is__bnot0(ea) -> bool

@param ea: ea_t

def is__bnot1(ea: ea_t)

is__bnot1(ea) -> bool

@param ea: ea_t

def is__invsign0(ea: ea_t)

is__invsign0(ea) -> bool

@param ea: ea_t

def is__invsign1(ea: ea_t)

is__invsign1(ea) -> bool

@param ea: ea_t

def is_aflag__bnot0(flags: aflags_t)

is_aflag__bnot0(flags) -> bool

@param flags: aflags_t

def is_aflag__bnot1(flags: aflags_t)

is_aflag__bnot1(flags) -> bool

@param flags: aflags_t

def is_aflag__invsign0(flags: aflags_t)

is_aflag__invsign0(flags) -> bool

@param flags: aflags_t

def is_aflag__invsign1(flags: aflags_t)

is_aflag__invsign1(flags) -> bool

@param flags: aflags_t

def is_aflag_align_flow(flags: aflags_t)

is_aflag_align_flow(flags) -> bool

@param flags: aflags_t

def is_aflag_colored_item(flags: aflags_t)

is_aflag_colored_item(flags) -> bool

@param flags: aflags_t

def is_aflag_data_guessed_by_hexrays(flags: aflags_t)

is_aflag_data_guessed_by_hexrays(flags) -> bool

@param flags: aflags_t

def is_aflag_fixed_spd(flags: aflags_t)

is_aflag_fixed_spd(flags) -> bool

@param flags: aflags_t

def is_aflag_func_guessed_by_hexrays(flags: aflags_t)

is_aflag_func_guessed_by_hexrays(flags) -> bool

@param flags: aflags_t

def is_aflag_hidden_border(flags: aflags_t)

is_aflag_hidden_border(flags) -> bool

@param flags: aflags_t

def is_aflag_hidden_item(flags: aflags_t)

is_aflag_hidden_item(flags) -> bool

@param flags: aflags_t

def is_aflag_libitem(flags: aflags_t)

is_aflag_libitem(flags) -> bool

@param flags: aflags_t

def is_aflag_lzero0(flags: aflags_t)

is_aflag_lzero0(flags) -> bool

@param flags: aflags_t

def is_aflag_lzero1(flags: aflags_t)

is_aflag_lzero1(flags) -> bool

@param flags: aflags_t

def is_aflag_manual_insn(flags: aflags_t)

is_aflag_manual_insn(flags) -> bool

@param flags: aflags_t

def is_aflag_noret(flags: aflags_t)

is_aflag_noret(flags) -> bool

@param flags: aflags_t

def is_aflag_notcode(flags: aflags_t)

is_aflag_notcode(flags) -> bool

@param flags: aflags_t

def is_aflag_notproc(flags: aflags_t)

is_aflag_notproc(flags) -> bool

@param flags: aflags_t

def is_aflag_public_name(flags: aflags_t)

is_aflag_public_name(flags) -> bool

@param flags: aflags_t

def is_aflag_retfp(flags: aflags_t)

is_aflag_retfp(flags) -> bool

@param flags: aflags_t

def is_aflag_terse_struc(flags: aflags_t)

is_aflag_terse_struc(flags) -> bool

@param flags: aflags_t

def is_aflag_tilcmt(flags: aflags_t)

is_aflag_tilcmt(flags) -> bool

@param flags: aflags_t

def is_aflag_type_determined_by_hexrays(flags: aflags_t)

is_aflag_type_determined_by_hexrays(flags) -> bool

@param flags: aflags_t

def is_aflag_type_guessed_by_hexrays(flags: aflags_t)

is_aflag_type_guessed_by_hexrays(flags) -> bool

@param flags: aflags_t

def is_aflag_type_guessed_by_ida(flags: aflags_t)

is_aflag_type_guessed_by_ida(flags) -> bool

@param flags: aflags_t

def is_aflag_usersp(flags: aflags_t)

is_aflag_usersp(flags) -> bool

@param flags: aflags_t

def is_aflag_userti(flags: aflags_t)

is_aflag_userti(flags) -> bool

@param flags: aflags_t

def is_aflag_weak_name(flags: aflags_t)

is_aflag_weak_name(flags) -> bool

@param flags: aflags_t

def is_aflag_zstroff(flags: aflags_t)

is_aflag_zstroff(flags) -> bool

@param flags: aflags_t

def is_align_flow(ea: ea_t)

is_align_flow(ea) -> bool

@param ea: ea_t

def is_colored_item(ea: ea_t)

is_colored_item(ea) -> bool

@param ea: ea_t

def is_data_guessed_by_hexrays(ea: ea_t)

is_data_guessed_by_hexrays(ea) -> bool

@param ea: ea_t

def is_finally_visible_item(ea: ea_t)

is_finally_visible_item(ea) -> bool Is instruction visible?

@param ea: (C++: ea_t)

def is_fixed_spd(ea: ea_t)

is_fixed_spd(ea) -> bool

@param ea: ea_t

def is_func_guessed_by_hexrays(ea: ea_t)

is_func_guessed_by_hexrays(ea) -> bool

@param ea: ea_t

def is_hidden_border(ea: ea_t)

is_hidden_border(ea) -> bool

@param ea: ea_t

def is_hidden_item(ea: ea_t)

is_hidden_item(ea) -> bool

@param ea: ea_t

def is_libitem(ea: ea_t)

is_libitem(ea) -> bool

@param ea: ea_t

def is_lzero0(ea: ea_t)

is_lzero0(ea) -> bool

@param ea: ea_t

def is_lzero1(ea: ea_t)

is_lzero1(ea) -> bool

@param ea: ea_t

def is_noret(ea: ea_t)

is_noret(ea) -> bool

@param ea: ea_t

def is_notcode(ea: ea_t)

is_notcode(ea) -> bool Is the address marked as not-code?

@param ea: (C++: ea_t)

def is_notproc(ea: ea_t)

is_notproc(ea) -> bool

@param ea: ea_t

def is_pascal(strtype: int32)

is_pascal(strtype) -> bool

@param strtype: int32

def is_reftype_target_optional(type: reftype_t)

is_reftype_target_optional(type) -> bool Can the target be calculated using operand value?

@param type: (C++: reftype_t)

def is_retfp(ea: ea_t)

is_retfp(ea) -> bool

@param ea: ea_t

def is_terse_struc(ea: ea_t)

is_terse_struc(ea) -> bool

@param ea: ea_t

def is_tilcmt(ea: ea_t)

is_tilcmt(ea) -> bool

@param ea: ea_t

def is_type_determined_by_hexrays(ea: ea_t)

is_type_determined_by_hexrays(ea) -> bool

@param ea: ea_t

def is_type_guessed_by_hexrays(ea: ea_t)

is_type_guessed_by_hexrays(ea) -> bool

@param ea: ea_t

def is_type_guessed_by_ida(ea: ea_t)

is_type_guessed_by_ida(ea) -> bool

@param ea: ea_t

def is_usersp(ea: ea_t)

is_usersp(ea) -> bool

@param ea: ea_t

def is_userti(ea: ea_t)

is_userti(ea) -> bool

@param ea: ea_t

def is_visible_item(ea: ea_t)

is_visible_item(ea) -> bool Test visibility of item at given ea.

@param ea: (C++: ea_t)

def is_zstroff(ea: ea_t)

is_zstroff(ea) -> bool

@param ea: ea_t

def make_str_type(type_code: uchar, encoding_idx: int, term1: uchar = 0, term2: uchar = 0)

make_str_type(type_code, encoding_idx, term1=0, term2=0) -> int32 Get string type for a string in the given encoding.

@param type_code: (C++: uchar) @param encoding_idx: (C++: int) @param term1: (C++: uchar) @param term2: (C++: uchar)

def node2ea(ndx: nodeidx_t)

node2ea(ndx) -> ea_t

@param ndx: nodeidx_t

def rename_encoding(idx: int, encname: char const *)

rename_encoding(idx, encname) -> bool Change name for an encoding The number of bytes per unit (BPU) of the new encoding must match this number of the existing default encoding. Specifying the empty name simply deletes this encoding.

@param idx: (C++: int) the encoding index (1-based) @param encname: (C++: const char *) the new encoding name

def retrieve_input_file_crc32()

retrieve_input_file_crc32() -> uint32 Get input file crc32 stored in the database. it can be used to check that the input file has not been changed.

def retrieve_input_file_md5()

retrieve_input_file_md5() -> bytes Get input file md5.

def retrieve_input_file_sha256()

retrieve_input_file_sha256() -> bytes Get input file sha256.

def retrieve_input_file_size()

retrieve_input_file_size() -> size_t Get size of input file in bytes.

def set__bnot0(ea: ea_t)

set__bnot0(ea)

@param ea: ea_t

def set__bnot1(ea: ea_t)

set__bnot1(ea)

@param ea: ea_t

def set__invsign0(ea: ea_t)

set__invsign0(ea)

@param ea: ea_t

def set__invsign1(ea: ea_t)

set__invsign1(ea)

@param ea: ea_t

def set_abits(ea: ea_t, bits: aflags_t)

set_abits(ea, bits)

@param ea: ea_t @param bits: aflags_t

def set_absbase(ea: ea_t, x: ea_t)

set_absbase(ea, x)

@param ea: ea_t @param x: ea_t

def set_aflags(ea: ea_t, flags: aflags_t)

set_aflags(ea, flags)

@param ea: ea_t @param flags: aflags_t

def set_align_flow(ea: ea_t)

set_align_flow(ea)

@param ea: ea_t

def set_alignment(ea: ea_t, x: uint32)

set_alignment(ea, x)

@param ea: ea_t @param x: uint32

def set_archive_path(file: char const *)

set_archive_path(file) -> bool Set archive file path from which input file was extracted.

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

def set_array_parameters(ea: ea_t, _in: array_parameters_t)

set_array_parameters(ea, _in)

@param ea: ea_t @param in: array_parameters_t const *

def set_asm_inc_file(file: char const *)

set_asm_inc_file(file) -> bool Set name of the include file.

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

def set_colored_item(ea: ea_t)

set_colored_item(ea)

@param ea: ea_t

def set_custom_data_type_ids(ea: ea_t, cdis: custom_data_type_ids_t)

set_custom_data_type_ids(ea, cdis)

@param ea: ea_t @param cdis: custom_data_type_ids_t const *

def set_data_guessed_by_hexrays(ea: ea_t)

set_data_guessed_by_hexrays(ea)

@param ea: ea_t

def set_default_encoding_idx(bpu: int, idx: int) ‑> bool

set_default_encoding_idx(bpu, idx) -> bool Set default encoding for a string type

@param bpu: (C++: int) the amount of bytes per unit @param idx: (C++: int) the encoding index. It cannot be 0

def set_fixed_spd(ea: ea_t)

set_fixed_spd(ea)

@param ea: ea_t

def set_func_guessed_by_hexrays(ea: ea_t)

set_func_guessed_by_hexrays(ea)

@param ea: ea_t

def set_gotea(gotea: ea_t)

set_gotea(gotea)

@param gotea: ea_t

def set_has_lname(ea: ea_t)

set_has_lname(ea)

@param ea: ea_t

def set_has_ti(ea: ea_t)

set_has_ti(ea)

@param ea: ea_t

def set_has_ti0(ea: ea_t)

set_has_ti0(ea)

@param ea: ea_t

def set_has_ti1(ea: ea_t)

set_has_ti1(ea)

@param ea: ea_t

def set_ida_notepad_text(text: char const *, size: size_t = 0)

set_ida_notepad_text(text, size=0) Set notepad text.

@param text: (C++: const char *) char const * @param size: (C++: size_t)

def set_ids_modnode(id: netnode)

set_ids_modnode(id) Set ids modnode.

@param id: (C++: netnode)

def set_imagebase(base: ea_t)

set_imagebase(base) Set image base address.

@param base: (C++: ea_t)

def set_item_color(ea: ea_t, color: bgcolor_t)

set_item_color(ea, color)

@param ea: ea_t @param color: bgcolor_t

def set_libitem(ea: ea_t)

set_libitem(ea)

@param ea: ea_t

def set_loader_format_name(name: char const *)

set_loader_format_name(name) Set file format name for loader modules.

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

def set_lzero0(ea: ea_t)

set_lzero0(ea)

@param ea: ea_t

def set_lzero1(ea: ea_t)

set_lzero1(ea)

@param ea: ea_t

def set_noret(ea: ea_t)

set_noret(ea)

@param ea: ea_t

def set_notcode(ea: ea_t)

set_notcode(ea) Mark address so that it cannot be converted to instruction.

@param ea: (C++: ea_t)

def set_notproc(ea: ea_t)

set_notproc(ea)

@param ea: ea_t

def set_op_tinfo(ea: ea_t, n: int, tif: tinfo_t)

set_op_tinfo(ea, n, tif) -> bool

@param ea: ea_t @param n: int @param tif: tinfo_t const *

def set_outfile_encoding_idx(idx: int) ‑> bool

set_outfile_encoding_idx(idx) -> bool set encoding to be used when producing files

@param idx: (C++: int) the encoding index IDX can be 0 to use the IDB's default 1-byte-per- unit encoding

def set_refinfo(*args) ‑> bool

set_refinfo(ea, n, type, target=BADADDR, base=0, tdelta=0) -> bool

@param ea: ea_t @param n: int @param type: reftype_t @param target: ea_t @param base: ea_t @param tdelta: adiff_t

def set_refinfo_ex(ea: ea_t, n: int, ri: refinfo_t)

set_refinfo_ex(ea, n, ri) -> bool

@param ea: ea_t @param n: int @param ri: refinfo_t const *

def set_retfp(ea: ea_t)

set_retfp(ea)

@param ea: ea_t

def set_root_filename(file: char const *)

set_root_filename(file) Set full path of the input file.

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

def set_source_linnum(ea: ea_t, lnnum: uval_t)

set_source_linnum(ea, lnnum)

@param ea: ea_t @param lnnum: uval_t

def set_srcdbg_paths(paths: char const *)

set_srcdbg_paths(paths) Set source debug paths.

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

def set_srcdbg_undesired_paths(paths: char const *)

set_srcdbg_undesired_paths(paths) Set user-closed source files.

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

def set_str_encoding_idx(strtype: int32, encoding_idx: int)

set_str_encoding_idx(strtype, encoding_idx) -> int32 Set index of the string encoding in the string type.

@param strtype: (C++: int32) @param encoding_idx: (C++: int)

def set_str_type(ea: ea_t, x: uint32)

set_str_type(ea, x)

@param ea: ea_t @param x: uint32

def set_switch_info(ea: ea_t, _in: switch_info_t)

set_switch_info(ea, _in)

@param ea: ea_t @param in: switch_info_t const &

def set_switch_parent(ea: ea_t, x: ea_t)

set_switch_parent(ea, x)

@param ea: ea_t @param x: ea_t

def set_terse_struc(ea: ea_t)

set_terse_struc(ea)

@param ea: ea_t

def set_tilcmt(ea: ea_t)

set_tilcmt(ea)

@param ea: ea_t

def set_tinfo(ea: ea_t, tif: tinfo_t)

set_tinfo(ea, tif) -> bool

@param ea: ea_t @param tif: tinfo_t const *

def set_type_determined_by_hexrays(ea: ea_t)

set_type_determined_by_hexrays(ea)

@param ea: ea_t

def set_type_guessed_by_ida(ea: ea_t)

set_type_guessed_by_ida(ea)

@param ea: ea_t

def set_usemodsp(ea: ea_t)

set_usemodsp(ea)

@param ea: ea_t

def set_usersp(ea: ea_t)

set_usersp(ea)

@param ea: ea_t

def set_userti(ea: ea_t)

set_userti(ea)

@param ea: ea_t

def set_visible_item(ea: ea_t, visible: bool)

set_visible_item(ea, visible) Change visibility of item at given ea.

@param ea: (C++: ea_t) @param visible: (C++: bool)

def set_zstroff(ea: ea_t)

set_zstroff(ea)

@param ea: ea_t

def switch_info_t__from_ptrval__(ptrval: size_t)

switch_info_t__from_ptrval__(ptrval) -> switch_info_t

@param ptrval: size_t

def unhide_border(ea: ea_t)

unhide_border(ea)

@param ea: ea_t

def unhide_item(ea: ea_t)

unhide_item(ea)

@param ea: ea_t

def upd_abits(ea: ea_t, clr_bits: aflags_t, set_bits: aflags_t)

upd_abits(ea, clr_bits, set_bits)

@param ea: ea_t @param clr_bits: aflags_t @param set_bits: aflags_t

def uses_aflag_modsp(flags: aflags_t)

uses_aflag_modsp(flags) -> bool

@param flags: aflags_t

def uses_modsp(ea: ea_t)

uses_modsp(ea) -> bool

@param ea: ea_t

Classes

class array_parameters_t

Proxy of C++ array_parameters_t class.

init(self, _f=0x00000001, _l=0, _a=-1) -> array_parameters_t

@param _f: int32 @param _l: int32 @param _a: int32

Instance variables

var alignment : int32

-1 - don't align. 0 - align automatically. else item width

var flags : int32

flags

var lineitems : int32

number of items on a line

var thisown

The membership flag

Methods

def is_default(self) ‑> bool

is_default(self) -> bool

class custom_data_type_ids_fids_array (data: short (&)[8])

Proxy of C++ wrapped_array_t< int16,8 > class.

init(self, data) -> custom_data_type_ids_fids_array

@param data: short (&)[8]

Instance variables

var bytes : bytevec_t

_get_bytes(self) -> bytevec_t

var data : short (&)[8]

data

var thisown

The membership flag

class custom_data_type_ids_t

Proxy of C++ custom_data_type_ids_t class.

init(self) -> custom_data_type_ids_t

Instance variables

var dtid : int16

data type id

var fids : wrapped_array_t< int16,8 >

data format ids

var thisown

The membership flag

Methods

def get_dtid(self)

get_dtid(self) -> tid_t

def set(self, tid: tid_t)

set(self, tid)

@param tid: tid_t

class enum_const_t

Proxy of C++ enum_const_t class.

init(self) -> enum_const_t

Instance variables

var serial : uchar

serial

var thisown

The membership flag

var tid : tid_t

tid

class opinfo_t

Proxy of C++ opinfo_t class.

init(self) -> opinfo_t

Instance variables

var cd : custom_data_type_ids_t

for custom data

var ec : enum_const_t

for enums

var path : strpath_t

for stroff

var ri : refinfo_t

for offset members

var strtype : int32

for strings (String type codes)

var thisown

The membership flag

var tid : tid_t

for struct, etc. members

class printop_t

Proxy of C++ printop_t class.

init(self) -> printop_t

Instance variables

var aflags : aflags_t

aflags

var features : uchar

features

var flags : flags64_t

flags

var is_ti_valid : bool

is_ti_initialized(self) -> bool

var suspop : int

suspop

var thisown

The membership flag

var ti : opinfo_t

ti

Methods

def get_ti(self)

get_ti(self) -> opinfo_t

def is_aflags_initialized(self) ‑> bool

is_aflags_initialized(self) -> bool

def is_f64(self) ‑> bool

is_f64(self) -> bool

def is_ti_initialized(self) ‑> bool

is_ti_initialized(self) -> bool

def set_aflags_initialized(self, v: bool = True)

set_aflags_initialized(self, v=True)

@param v: bool

def set_ti_initialized(self, v: bool = True)

set_ti_initialized(self, v=True)

@param v: bool

class refinfo_t

Proxy of C++ refinfo_t class.

init(self) -> refinfo_t

Instance variables

var base : ea_t

base of reference (may be BADADDR)

var flags : uint32

Reference info flags

var target : ea_t

reference target (BADADDR-none)

var tdelta : adiff_t

offset from the target

var thisown

The membership flag

Methods

def init(self, *args)

init(self, reft_and_flags, _base=0, _target=BADADDR, _tdelta=0)

@param reft_and_flags: uint32 @param _base: ea_t @param _target: ea_t @param _tdelta: adiff_t

def is_custom(self) ‑> bool

is_custom(self) -> bool

def is_no_ones(self) ‑> bool

is_no_ones(self) -> bool

def is_no_zeros(self) ‑> bool

is_no_zeros(self) -> bool

def is_pastend(self) ‑> bool

is_pastend(self) -> bool

def is_rvaoff(self) ‑> bool

is_rvaoff(self) -> bool

def is_selfref(self) ‑> bool

is_selfref(self) -> bool

def is_signed(self) ‑> bool

is_signed(self) -> bool

def is_subtract(self) ‑> bool

is_subtract(self) -> bool

def is_target_optional(self) ‑> bool

is_target_optional(self) -> bool < is_reftype_target_optional()

def no_base_xref(self) ‑> bool

no_base_xref(self) -> bool

def set_type(self, rt: reftype_t)

set_type(self, rt)

@param rt: reftype_t

def type(self)

type(self) -> reftype_t

class strpath_ids_array (data: unsigned long long (&)[32])

Proxy of C++ wrapped_array_t< tid_t,32 > class.

init(self, data) -> strpath_ids_array

@param data: unsigned long long (&)[32]

Instance variables

var bytes : bytevec_t

_get_bytes(self) -> bytevec_t

var data : unsigned long long (&)[32]

data

var thisown

The membership flag

class strpath_t

Proxy of C++ strpath_t class.

init(self) -> strpath_t

Instance variables

var delta : adiff_t

delta

var ids : wrapped_array_t< tid_t,32 >

__getIds(self) -> strpath_ids_array

var len : int

len

var thisown

The membership flag

class switch_info_t

Proxy of C++ switch_info_t class.

init(self) -> switch_info_t

Class variables

var SWITCH_INFO_VERSION

Instance variables

var custom : uval_t

information for custom tables (filled and used by modules)

var defjump : ea_t

default jump address (BADADDR if no default case)

var elbase : ea_t

element base

var expr_ea : ea_t

the address before that the switch expression is in REGNUM. If BADADDR, then the first insn marked as IM_SWITCH after STARTEA is used.

var flags : uint32

Switch info flags

var ind_lowcase : sval_t

ind_lowcase

var jcases : int

number of entries in the jump table (SWI_INDIRECT)

var jumps : ea_t

jump table start address

var lowcase : ea_t

the lowest value in cases

var marks : eavec_t

the insns marked as IM_SWITCH. They are used to delete the switch.

var ncases : ushort

number of cases (excluding default)

var regdtype : op_dtype_t

size of the switch expression register as dtype

var regnum : int

the switch expression as a value of the REGNUM register before the instruction at EXPR_EA. -1 means 'unknown'

var startea : ea_t

start of the switch idiom

var thisown

The membership flag

var values : ea_t

values table address (if SWI_SPARSE is set)

Methods

def assign(self, other: switch_info_t)

assign(self, other)

@param other: switch_info_t const &

def clear(self)

clear(self)

def get_jrange_vrange(self, jrange: range_t = None, vrange: range_t = None)

get_jrange_vrange(self, jrange=None, vrange=None) -> bool get separate parts of the switch

@param jrange: (C++: range_t ) @param vrange: (C++: range_t )

def get_jtable_element_size(self) ‑> int

get_jtable_element_size(self) -> int

def get_jtable_size(self) ‑> int

get_jtable_size(self) -> int

def get_lowcase(self)

get_lowcase(self) -> sval_t

def get_shift(self) ‑> int

get_shift(self) -> int See SWI_SHIFT_MASK. possible answers: 0..3.

def get_version(self) ‑> int

get_version(self) -> int

def get_vtable_element_size(self) ‑> int

get_vtable_element_size(self) -> int

def has_default(self) ‑> bool

has_default(self) -> bool

def has_elbase(self) ‑> bool

has_elbase(self) -> bool

def is_custom(self) ‑> bool

is_custom(self) -> bool

def is_indirect(self) ‑> bool

is_indirect(self) -> bool

def is_nolowcase(self) ‑> bool

is_nolowcase(self) -> bool

def is_sparse(self) ‑> bool

is_sparse(self) -> bool

def is_subtract(self) ‑> bool

is_subtract(self) -> bool

def is_user_defined(self) ‑> bool

is_user_defined(self) -> bool

def set_elbase(self, base: ea_t)

set_elbase(self, base)

@param base: ea_t

def set_expr(self, r: int, dt: op_dtype_t)

set_expr(self, r, dt)

@param r: int @param dt: op_dtype_t

def set_jtable_element_size(self, size: int)

set_jtable_element_size(self, size)

@param size: int

def set_jtable_size(self, size: int)

set_jtable_size(self, size)

@param size: int

def set_shift(self, shift: int)

set_shift(self, shift) See SWI_SHIFT_MASK.

@param shift: (C++: int)

def set_vtable_element_size(self, size: int)

set_vtable_element_size(self, size)

@param size: int

def use_std_table(self) ‑> bool

use_std_table(self) -> bool