 |
IDAPython 8.4
|
|
IDAPython 8.4
|
Contains functions that deal with individual byte characteristics. Each byte of the disassembled program is represented by a 32-bit value. We will call this value 'flags'. The structure of the flags is here. You are not allowed to inspect individual bits of flags and modify them directly. Use special functions to inspect and/or modify flags. Flags are kept in a virtual array file (*.id1). Addresses (ea) are all 32-bit (or 64-bit) quantities.
Classes | |
| class | compiled_binpat_t |
| Proxy of C++ compiled_binpat_t class. More... | |
| class | compiled_binpat_vec_t |
| Proxy of C++ qvector< compiled_binpat_t > class. More... | |
| class | data_format_t |
| Proxy of C++ data_format_t class. More... | |
| class | data_type_t |
| Proxy of C++ data_type_t class. More... | |
| class | hidden_range_t |
| Proxy of C++ hidden_range_t class. More... | |
| class | octet_generator_t |
| Proxy of C++ octet_generator_t class. More... | |
Functions | |
| "error_t" | enable_flags (*args) |
| enable_flags(start_ea, end_ea, stt) -> error_t Allocate flags for address range. | |
| "error_t" | disable_flags (*args) |
| disable_flags(start_ea, end_ea) -> error_t Deallocate flags for address range. | |
| "error_t" | change_storage_type (*args) |
| change_storage_type(start_ea, end_ea, stt) -> error_t Change flag storage type for address range. | |
| "ea_t" | next_addr (*args) |
| next_addr(ea) -> ea_t Get next address in the program (i.e. | |
| "ea_t" | prev_addr (*args) |
| prev_addr(ea) -> ea_t Get previous address in the program. | |
| "ea_t" | next_chunk (*args) |
| next_chunk(ea) -> ea_t Get the first address of next contiguous chunk in the program. | |
| "ea_t" | prev_chunk (*args) |
| prev_chunk(ea) -> ea_t Get the last address of previous contiguous chunk in the program. | |
| "ea_t" | chunk_start (*args) |
| chunk_start(ea) -> ea_t Get start of the contiguous address block containing 'ea'. | |
| "asize_t" | chunk_size (*args) |
| chunk_size(ea) -> asize_t Get size of the contiguous address block containing 'ea'. | |
| "ea_t" | find_free_chunk (*args) |
| find_free_chunk(start, size, alignment) -> ea_t Search for a hole in the addressing space of the program. | |
| "ea_t" | next_that (*args) |
| next_that(ea, maxea, testf) -> ea_t Find next address with a flag satisfying the function 'testf'. | |
| "ea_t" | next_unknown (*args) |
| next_unknown(ea, maxea) -> ea_t Similar to next_that(), but will find the next address that is unexplored. | |
| "ea_t" | prev_that (*args) |
| prev_that(ea, minea, testf) -> ea_t Find previous address with a flag satisfying the function 'testf'. | |
| "ea_t" | prev_unknown (*args) |
| prev_unknown(ea, minea) -> ea_t Similar to prev_that(), but will find the previous address that is unexplored. | |
| "ea_t" | prev_head (*args) |
| prev_head(ea, minea) -> ea_t Get start of previous defined item. | |
| "ea_t" | next_head (*args) |
| next_head(ea, maxea) -> ea_t Get start of next defined item. | |
| "ea_t" | prev_not_tail (*args) |
| prev_not_tail(ea) -> ea_t Get address of previous non-tail byte. | |
| "ea_t" | next_not_tail (*args) |
| next_not_tail(ea) -> ea_t Get address of next non-tail byte. | |
| "ea_t" | prev_visea (*args) |
| prev_visea(ea) -> ea_t Get previous visible address. | |
| "ea_t" | next_visea (*args) |
| next_visea(ea) -> ea_t Get next visible address. | |
| "ea_t" | get_item_head (*args) |
| get_item_head(ea) -> ea_t Get the start address of the item at 'ea'. | |
| "ea_t" | get_item_end (*args) |
| get_item_end(ea) -> ea_t Get the end address of the item at 'ea'. | |
| "ea_t" | calc_max_item_end (*args) |
| calc_max_item_end(ea, how=15) -> ea_t Calculate maximal reasonable end address of a new item. | |
| "asize_t" | get_item_size (*args) |
| get_item_size(ea) -> asize_t Get size of item (instruction/data) in bytes. | |
| "bool" | is_mapped (*args) |
| is_mapped(ea) -> bool Is the specified address 'ea' present in the program? | |
| "flags64_t" | get_flags_ex (*args) |
| get_flags_ex(ea, how) -> flags64_t Get flags for the specified address, extended form. | |
| "flags64_t" | get_flags (*args) |
| get_flags(ea) -> flags64_t get flags with FF_IVL & MS_VAL. | |
| "flags64_t" | get_full_flags (*args) |
| get_full_flags(ea) -> flags64_t Get flags value for address 'ea'. | |
| "flags64_t" | get_item_flag (*args) |
| get_item_flag(_from, n, ea, appzero) -> flags64_t Get flag of the item at 'ea' even if it is a tail byte of some array or structure. | |
| "bool" | get_item_refinfo (*args) |
| get_item_refinfo(ri, ea, n) -> bool Get refinfo of the item at 'ea'. | |
| "bool" | has_value (*args) |
| has_value(F) -> bool Do flags contain byte value? | |
| "void" | del_value (*args) |
| del_value(ea) Delete byte value from flags. | |
| "bool" | is_loaded (*args) |
| is_loaded(ea) -> bool Does the specified address have a byte value (is initialized?) | |
| "int" | nbits (*args) |
| nbits(ea) -> int Get number of bits in a byte at the given address. | |
| "int" | bytesize (*args) |
| bytesize(ea) -> int Get number of bytes required to store a byte at the given address. | |
| "uchar" | get_byte (*args) |
| get_byte(ea) -> uchar Get one byte (8-bit) of the program at 'ea'. | |
| "uchar" | get_db_byte (*args) |
| get_db_byte(ea) -> uchar Get one byte (8-bit) of the program at 'ea' from the database. | |
| "ushort" | get_word (*args) |
| get_word(ea) -> ushort Get one word (16-bit) of the program at 'ea'. | |
| "uint32" | get_dword (*args) |
| get_dword(ea) -> uint32 Get one dword (32-bit) of the program at 'ea'. | |
| "uint64" | get_qword (*args) |
| get_qword(ea) -> uint64 Get one qword (64-bit) of the program at 'ea'. | |
| "uint64" | get_wide_byte (*args) |
| get_wide_byte(ea) -> uint64 Get one wide byte of the program at 'ea'. | |
| "uint64" | get_wide_word (*args) |
| get_wide_word(ea) -> uint64 Get one wide word (2 'byte') of the program at 'ea'. | |
| "uint64" | get_wide_dword (*args) |
| get_wide_dword(ea) -> uint64 Get two wide words (4 'bytes') of the program at 'ea'. | |
| "uchar *" | get_octet2 (*args) |
| get_octet2(ogen) -> bool | |
| "uint32" | get_16bit (*args) |
| get_16bit(ea) -> uint32 Get 16bits of the program at 'ea'. | |
| "uint32" | get_32bit (*args) |
| get_32bit(ea) -> uint32 Get not more than 32bits of the program at 'ea'. | |
| "uint64" | get_64bit (*args) |
| get_64bit(ea) -> uint64 Get not more than 64bits of the program at 'ea'. | |
| "bool" | get_data_value (*args) |
| get_data_value(v, ea, size) -> bool Get the value at of the item at 'ea'. | |
| "uint64" | get_original_byte (*args) |
| get_original_byte(ea) -> uint64 Get original byte value (that was before patching). | |
| "uint64" | get_original_word (*args) |
| get_original_word(ea) -> uint64 Get original word value (that was before patching). | |
| "uint64" | get_original_dword (*args) |
| get_original_dword(ea) -> uint64 Get original dword (that was before patching) This function works for wide byte processors too. | |
| "uint64" | get_original_qword (*args) |
| get_original_qword(ea) -> uint64 Get original qword value (that was before patching) This function DOESN'T work for wide byte processors too. | |
| "bool" | put_byte (*args) |
| put_byte(ea, x) -> bool Set value of one byte of the program. | |
| "void" | put_word (*args) |
| put_word(ea, x) Set value of one word of the program. | |
| "void" | put_dword (*args) |
| put_dword(ea, x) Set value of one dword of the program. | |
| "void" | put_qword (*args) |
| put_qword(ea, x) Set value of one qword (8 bytes) of the program. | |
| "bool" | patch_byte (*args) |
| patch_byte(ea, x) -> bool Patch a byte of the program. | |
| "bool" | patch_word (*args) |
| patch_word(ea, x) -> bool Patch a word of the program. | |
| "bool" | patch_dword (*args) |
| patch_dword(ea, x) -> bool Patch a dword of the program. | |
| "bool" | patch_qword (*args) |
| patch_qword(ea, x) -> bool Patch a qword of the program. | |
| "bool" | revert_byte (*args) |
| revert_byte(ea) -> bool Revert patched byte | |
| "void" | add_byte (*args) |
| add_byte(ea, value) Add a value to one byte of the program. | |
| "void" | add_word (*args) |
| add_word(ea, value) Add a value to one word of the program. | |
| "void" | add_dword (*args) |
| add_dword(ea, value) Add a value to one dword of the program. | |
| "void" | add_qword (*args) |
| add_qword(ea, value) Add a value to one qword of the program. | |
| "bool" | get_zero_ranges (*args) |
| get_zero_ranges(zranges, range) -> bool Return set of ranges with zero initialized bytes. | |
| "void" | put_bytes (*args) |
| put_bytes(ea, buf) Modify the specified number of bytes of the program. | |
| "void" | patch_bytes (*args) |
| patch_bytes(ea, buf) Patch the specified number of bytes of the program. | |
| "bool" | is_code (*args) |
| is_code(F) -> bool Does flag denote start of an instruction? | |
| "bool" | f_is_code (*args) |
| f_is_code(F, arg2) -> bool Does flag denote start of an instruction? | |
| "bool" | is_data (*args) |
| is_data(F) -> bool Does flag denote start of data? | |
| "bool" | f_is_data (*args) |
| f_is_data(F, arg2) -> bool Does flag denote start of data? | |
| "bool" | is_tail (*args) |
| is_tail(F) -> bool Does flag denote tail byte? | |
| "bool" | f_is_tail (*args) |
| f_is_tail(F, arg2) -> bool Does flag denote tail byte? | |
| "bool" | is_not_tail (*args) |
| is_not_tail(F) -> bool Does flag denote tail byte? | |
| "bool" | f_is_not_tail (*args) |
| f_is_not_tail(F, arg2) -> bool Does flag denote tail byte? | |
| "bool" | is_unknown (*args) |
| is_unknown(F) -> bool Does flag denote unexplored byte? | |
| "bool" | is_head (*args) |
| is_head(F) -> bool Does flag denote start of instruction OR data? | |
| "bool" | f_is_head (*args) |
| f_is_head(F, arg2) -> bool Does flag denote start of instruction OR data? | |
| "bool" | del_items (*args) |
| del_items(ea, flags=0, nbytes=1, may_destroy=None) -> bool Convert item (instruction/data) to unexplored bytes. | |
| "bool" | is_manual_insn (*args) |
| is_manual_insn(ea) -> bool Is the instruction overridden? | |
| "qstring *" | get_manual_insn (*args) |
| get_manual_insn(ea) -> str Retrieve the user-specified string for the manual instruction. | |
| "void" | set_manual_insn (*args) |
| set_manual_insn(ea, manual_insn) Set manual instruction string. | |
| "bool" | is_flow (*args) |
| is_flow(F) -> bool Does the previous instruction exist and pass execution flow to the current byte? | |
| "bool" | has_extra_cmts (*args) |
| has_extra_cmts(F) -> bool Does the current byte have additional anterior or posterior lines? | |
| "bool" | f_has_extra_cmts (*args) |
| f_has_extra_cmts(f, arg2) -> bool | |
| "bool" | has_cmt (*args) |
| has_cmt(F) -> bool Does the current byte have an indented comment? | |
| "bool" | f_has_cmt (*args) |
| f_has_cmt(f, arg2) -> bool | |
| "bool" | has_xref (*args) |
| has_xref(F) -> bool Does the current byte have cross-references to it? | |
| "bool" | f_has_xref (*args) |
| f_has_xref(f, arg2) -> bool Does the current byte have cross-references to it? | |
| "bool" | has_name (*args) |
| has_name(F) -> bool Does the current byte have non-trivial (non-dummy) name? | |
| "bool" | f_has_name (*args) |
| f_has_name(f, arg2) -> bool Does the current byte have non-trivial (non-dummy) name? | |
| "bool" | has_dummy_name (*args) |
| has_dummy_name(F) -> bool Does the current byte have dummy (auto-generated, with special prefix) name? | |
| "bool" | f_has_dummy_name (*args) |
| f_has_dummy_name(f, arg2) -> bool Does the current byte have dummy (auto-generated, with special prefix) name? | |
| "bool" | has_auto_name (*args) |
| has_auto_name(F) -> bool Does the current byte have auto-generated (no special prefix) name? | |
| "bool" | has_any_name (*args) |
| has_any_name(F) -> bool Does the current byte have any name? | |
| "bool" | has_user_name (*args) |
| has_user_name(F) -> bool Does the current byte have user-specified name? | |
| "bool" | f_has_user_name (*args) |
| f_has_user_name(F, arg2) -> bool Does the current byte have user-specified name? | |
| "bool" | is_invsign (*args) |
| is_invsign(ea, F, n) -> bool Should sign of n-th operand inverted during output?. | |
| "bool" | toggle_sign (*args) |
| toggle_sign(ea, n) -> bool Toggle sign of n-th operand. | |
| "bool" | is_bnot (*args) |
| is_bnot(ea, F, n) -> bool Should we negate the operand?. | |
| "bool" | toggle_bnot (*args) |
| toggle_bnot(ea, n) -> bool Toggle binary negation of operand. | |
| "bool" | is_lzero (*args) |
| is_lzero(ea, n) -> bool Display leading zeroes? Display leading zeroes in operands. | |
| "bool" | set_lzero (*args) |
| set_lzero(ea, n) -> bool Set toggle lzero bit. | |
| "bool" | clr_lzero (*args) |
| clr_lzero(ea, n) -> bool Clear toggle lzero bit. | |
| "bool" | toggle_lzero (*args) |
| toggle_lzero(ea, n) -> bool Toggle lzero bit. | |
| "bool" | leading_zero_important (*args) |
| leading_zero_important(ea, n) -> bool Check if leading zeroes are important. | |
| "int" | get_operand_type_shift (*args) |
get_operand_type_shift(n) -> int Get the shift in flags64_t for the nibble representing operand n's type | |
| "flags64_t" | get_operand_flag (*args) |
get_operand_flag(typebits, n) -> flags64_t Place operand n's type flag in the right nibble of a 64-bit flags set. | |
| "bool" | is_flag_for_operand (*args) |
is_flag_for_operand(F, typebits, n) -> bool Check that the 64-bit flags set has the expected type for operand n. | |
| "bool" | is_defarg0 (*args) |
| is_defarg0(F) -> bool Is the first operand defined? Initially operand has no defined representation. | |
| "bool" | is_defarg1 (*args) |
| is_defarg1(F) -> bool Is the second operand defined? Initially operand has no defined representation. | |
| "bool" | is_off0 (*args) |
| is_off0(F) -> bool Is the first operand offset? (example: push offset xxx) | |
| "bool" | is_off1 (*args) |
| is_off1(F) -> bool Is the second operand offset? (example: mov ax, offset xxx) | |
| "bool" | is_char0 (*args) |
| is_char0(F) -> bool Is the first operand character constant? (example: push 'a') | |
| "bool" | is_char1 (*args) |
| is_char1(F) -> bool Is the second operand character constant? (example: mov al, 'a') | |
| "bool" | is_seg0 (*args) |
| is_seg0(F) -> bool Is the first operand segment selector? (example: push seg seg001) | |
| "bool" | is_seg1 (*args) |
| is_seg1(F) -> bool Is the second operand segment selector? (example: mov dx, seg dseg) | |
| "bool" | is_enum0 (*args) |
| is_enum0(F) -> bool Is the first operand a symbolic constant (enum member)? | |
| "bool" | is_enum1 (*args) |
| is_enum1(F) -> bool Is the second operand a symbolic constant (enum member)? | |
| "bool" | is_stroff0 (*args) |
| is_stroff0(F) -> bool Is the first operand an offset within a struct? | |
| "bool" | is_stroff1 (*args) |
| is_stroff1(F) -> bool Is the second operand an offset within a struct? | |
| "bool" | is_stkvar0 (*args) |
| is_stkvar0(F) -> bool Is the first operand a stack variable? | |
| "bool" | is_stkvar1 (*args) |
| is_stkvar1(F) -> bool Is the second operand a stack variable? | |
| "bool" | is_float0 (*args) |
| is_float0(F) -> bool Is the first operand a floating point number? | |
| "bool" | is_float1 (*args) |
| is_float1(F) -> bool Is the second operand a floating point number? | |
| "bool" | is_custfmt0 (*args) |
| is_custfmt0(F) -> bool Does the first operand use a custom data representation? | |
| "bool" | is_custfmt1 (*args) |
| is_custfmt1(F) -> bool Does the second operand use a custom data representation? | |
| "bool" | is_numop0 (*args) |
| is_numop0(F) -> bool Is the first operand a number (i.e. | |
| "bool" | is_numop1 (*args) |
| is_numop1(F) -> bool Is the second operand a number (i.e. | |
| "flags64_t" | get_optype_flags0 (*args) |
| get_optype_flags0(F) -> flags64_t Get flags for first operand. | |
| "flags64_t" | get_optype_flags1 (*args) |
| get_optype_flags1(F) -> flags64_t Get flags for second operand. | |
| "bool" | is_defarg (*args) |
| is_defarg(F, n) -> bool is defined? | |
| "bool" | is_off (*args) |
| is_off(F, n) -> bool is offset? | |
| "bool" | is_char (*args) |
| is_char(F, n) -> bool is character constant? | |
| "bool" | is_seg (*args) |
| is_seg(F, n) -> bool is segment? | |
| "bool" | is_enum (*args) |
| is_enum(F, n) -> bool is enum? | |
| "bool" | is_manual (*args) |
| is_manual(F, n) -> bool is forced operand? (use is_forced_operand()) | |
| "bool" | is_stroff (*args) |
| is_stroff(F, n) -> bool is struct offset? | |
| "bool" | is_stkvar (*args) |
| is_stkvar(F, n) -> bool is stack variable? | |
| "bool" | is_fltnum (*args) |
| is_fltnum(F, n) -> bool is floating point number? | |
| "bool" | is_custfmt (*args) |
| is_custfmt(F, n) -> bool is custom data format? | |
| "bool" | is_numop (*args) |
| is_numop(F, n) -> bool is number (bin, oct, dec, hex)? | |
| "bool" | is_suspop (*args) |
| is_suspop(ea, F, n) -> bool is suspicious operand? | |
| "bool" | op_adds_xrefs (*args) |
| op_adds_xrefs(F, n) -> bool Should processor module create xrefs from the operand?. | |
| "bool" | set_op_type (*args) |
| set_op_type(ea, type, n) -> bool (internal function) change representation of operand(s). | |
| "bool" | op_seg (*args) |
| op_seg(ea, n) -> bool Set operand representation to be 'segment'. | |
| "bool" | op_enum (*args) |
| op_enum(ea, n, id, serial=0) -> bool Set operand representation to be 'enum_t'. | |
| "uchar *" | get_enum_id (*args) |
| get_enum_id(ea, n) -> enum_t Get enum id of 'enum' operand. | |
| "bool" | op_based_stroff (*args) |
| op_based_stroff(insn, n, opval, base) -> bool Set operand representation to be 'struct offset' if the operand likely points to a structure member. | |
| "int" | get_stroff_path (*args) |
| get_stroff_path(path, delta, ea, n) -> int Get struct path of operand. | |
| "bool" | op_stkvar (*args) |
| op_stkvar(ea, n) -> bool Set operand representation to be 'stack variable'. | |
| "bool" | set_forced_operand (*args) |
| set_forced_operand(ea, n, op) -> bool Set forced operand. | |
| "qstring *" | get_forced_operand (*args) |
| get_forced_operand(ea, n) -> str Get forced operand. | |
| "bool" | is_forced_operand (*args) |
| is_forced_operand(ea, n) -> bool Is operand manually defined?. | |
| "flags64_t" | combine_flags (*args) |
| combine_flags(F) -> flags64_t | |
| "flags64_t" | char_flag (*args) |
| char_flag() -> flags64_t see FF_opbits | |
| "flags64_t" | off_flag (*args) |
| off_flag() -> flags64_t see FF_opbits | |
| "flags64_t" | enum_flag (*args) |
| enum_flag() -> flags64_t see FF_opbits | |
| "flags64_t" | stroff_flag (*args) |
| stroff_flag() -> flags64_t see FF_opbits | |
| "flags64_t" | stkvar_flag (*args) |
| stkvar_flag() -> flags64_t see FF_opbits | |
| "flags64_t" | flt_flag (*args) |
| flt_flag() -> flags64_t see FF_opbits | |
| "flags64_t" | custfmt_flag (*args) |
| custfmt_flag() -> flags64_t see FF_opbits | |
| "flags64_t" | seg_flag (*args) |
| seg_flag() -> flags64_t see FF_opbits | |
| "flags64_t" | num_flag (*args) |
| num_flag() -> flags64_t Get number of default base (bin, oct, dec, hex) | |
| "flags64_t" | hex_flag (*args) |
| hex_flag() -> flags64_t Get number flag of the base, regardless of current processor - better to use num_flag() | |
| "flags64_t" | dec_flag (*args) |
| dec_flag() -> flags64_t Get number flag of the base, regardless of current processor - better to use num_flag() | |
| "flags64_t" | oct_flag (*args) |
| oct_flag() -> flags64_t Get number flag of the base, regardless of current processor - better to use num_flag() | |
| "flags64_t" | bin_flag (*args) |
| bin_flag() -> flags64_t Get number flag of the base, regardless of current processor - better to use num_flag() | |
| "bool" | op_chr (*args) |
| op_chr(ea, n) -> bool set op type to char_flag() | |
| "bool" | op_num (*args) |
| op_num(ea, n) -> bool set op type to num_flag() | |
| "bool" | op_hex (*args) |
| op_hex(ea, n) -> bool set op type to hex_flag() | |
| "bool" | op_dec (*args) |
| op_dec(ea, n) -> bool set op type to dec_flag() | |
| "bool" | op_oct (*args) |
| op_oct(ea, n) -> bool set op type to oct_flag() | |
| "bool" | op_bin (*args) |
| op_bin(ea, n) -> bool set op type to bin_flag() | |
| "bool" | op_flt (*args) |
| op_flt(ea, n) -> bool set op type to flt_flag() | |
| "bool" | op_custfmt (*args) |
| op_custfmt(ea, n, fid) -> bool Set custom data format for operand (fid-custom data format id) | |
| "bool" | clr_op_type (*args) |
| clr_op_type(ea, n) -> bool Remove operand representation information. | |
| "int" | get_default_radix (*args) |
| get_default_radix() -> int Get default base of number for the current processor. | |
| "int" | get_radix (*args) |
| get_radix(F, n) -> int Get radix of the operand, in: flags. | |
| "flags64_t" | code_flag (*args) |
| code_flag() -> flags64_t FF_CODE | |
| "flags64_t" | byte_flag (*args) |
| byte_flag() -> flags64_t Get a flags64_t representing a byte. | |
| "flags64_t" | word_flag (*args) |
| word_flag() -> flags64_t Get a flags64_t representing a word. | |
| "flags64_t" | dword_flag (*args) |
| dword_flag() -> flags64_t Get a flags64_t representing a double word. | |
| "flags64_t" | qword_flag (*args) |
| qword_flag() -> flags64_t Get a flags64_t representing a quad word. | |
| "flags64_t" | oword_flag (*args) |
| oword_flag() -> flags64_t Get a flags64_t representing a octaword. | |
| "flags64_t" | yword_flag (*args) |
| yword_flag() -> flags64_t Get a flags64_t representing a ymm word. | |
| "flags64_t" | zword_flag (*args) |
| zword_flag() -> flags64_t Get a flags64_t representing a zmm word. | |
| "flags64_t" | tbyte_flag (*args) |
| tbyte_flag() -> flags64_t Get a flags64_t representing a tbyte. | |
| "flags64_t" | strlit_flag (*args) |
| strlit_flag() -> flags64_t Get a flags64_t representing a string literal. | |
| "flags64_t" | stru_flag (*args) |
| stru_flag() -> flags64_t Get a flags64_t representing a struct. | |
| "flags64_t" | cust_flag (*args) |
| cust_flag() -> flags64_t Get a flags64_t representing custom type data. | |
| "flags64_t" | align_flag (*args) |
| align_flag() -> flags64_t Get a flags64_t representing an alignment directive. | |
| "flags64_t" | float_flag (*args) |
| float_flag() -> flags64_t Get a flags64_t representing a float. | |
| "flags64_t" | double_flag (*args) |
| double_flag() -> flags64_t Get a flags64_t representing a double. | |
| "flags64_t" | packreal_flag (*args) |
| packreal_flag() -> flags64_t Get a flags64_t representing a packed decimal real. | |
| "bool" | is_byte (*args) |
| is_byte(F) -> bool FF_BYTE | |
| "bool" | is_word (*args) |
| is_word(F) -> bool FF_WORD | |
| "bool" | is_dword (*args) |
| is_dword(F) -> bool FF_DWORD | |
| "bool" | is_qword (*args) |
| is_qword(F) -> bool FF_QWORD | |
| "bool" | is_oword (*args) |
| is_oword(F) -> bool FF_OWORD | |
| "bool" | is_yword (*args) |
| is_yword(F) -> bool FF_YWORD | |
| "bool" | is_zword (*args) |
| is_zword(F) -> bool FF_ZWORD | |
| "bool" | is_tbyte (*args) |
| is_tbyte(F) -> bool FF_TBYTE | |
| "bool" | is_float (*args) |
| is_float(F) -> bool FF_FLOAT | |
| "bool" | is_double (*args) |
| is_double(F) -> bool FF_DOUBLE | |
| "bool" | is_pack_real (*args) |
| is_pack_real(F) -> bool FF_PACKREAL | |
| "bool" | is_strlit (*args) |
| is_strlit(F) -> bool FF_STRLIT | |
| "bool" | is_struct (*args) |
| is_struct(F) -> bool FF_STRUCT | |
| "bool" | is_align (*args) |
| is_align(F) -> bool FF_ALIGN | |
| "bool" | is_custom (*args) |
| is_custom(F) -> bool FF_CUSTOM | |
| "bool" | f_is_byte (*args) |
| f_is_byte(F, arg2) -> bool See is_byte() | |
| "bool" | f_is_word (*args) |
| f_is_word(F, arg2) -> bool See is_word() | |
| "bool" | f_is_dword (*args) |
| f_is_dword(F, arg2) -> bool See is_dword() | |
| "bool" | f_is_qword (*args) |
| f_is_qword(F, arg2) -> bool See is_qword() | |
| "bool" | f_is_oword (*args) |
| f_is_oword(F, arg2) -> bool See is_oword() | |
| "bool" | f_is_yword (*args) |
| f_is_yword(F, arg2) -> bool See is_yword() | |
| "bool" | f_is_tbyte (*args) |
| f_is_tbyte(F, arg2) -> bool See is_tbyte() | |
| "bool" | f_is_float (*args) |
| f_is_float(F, arg2) -> bool See is_float() | |
| "bool" | f_is_double (*args) |
| f_is_double(F, arg2) -> bool See is_double() | |
| "bool" | f_is_pack_real (*args) |
| f_is_pack_real(F, arg2) -> bool See is_pack_real() | |
| "bool" | f_is_strlit (*args) |
| f_is_strlit(F, arg2) -> bool See is_strlit() | |
| "bool" | f_is_struct (*args) |
| f_is_struct(F, arg2) -> bool See is_struct() | |
| "bool" | f_is_align (*args) |
| f_is_align(F, arg2) -> bool See is_align() | |
| "bool" | f_is_custom (*args) |
| f_is_custom(F, arg2) -> bool See is_custom() | |
| "bool" | is_same_data_type (*args) |
| is_same_data_type(F1, F2) -> bool Do the given flags specify the same data type? | |
| "flags64_t" | get_flags_by_size (*args) |
| get_flags_by_size(size) -> flags64_t Get flags from size (in bytes). | |
| "bool" | create_data (*args) |
| create_data(ea, dataflag, size, tid) -> bool Convert to data (byte, word, dword, etc). | |
| "flags64_t" | calc_dflags (*args) |
| calc_dflags(f, force) -> flags64_t | |
| "bool" | create_byte (*args) |
| create_byte(ea, length, force=False) -> bool Convert to byte. | |
| "bool" | create_word (*args) |
| create_word(ea, length, force=False) -> bool Convert to word. | |
| "bool" | create_dword (*args) |
| create_dword(ea, length, force=False) -> bool Convert to dword. | |
| "bool" | create_qword (*args) |
| create_qword(ea, length, force=False) -> bool Convert to quadword. | |
| "bool" | create_oword (*args) |
| create_oword(ea, length, force=False) -> bool Convert to octaword/xmm word. | |
| "bool" | create_yword (*args) |
| create_yword(ea, length, force=False) -> bool Convert to ymm word. | |
| "bool" | create_zword (*args) |
| create_zword(ea, length, force=False) -> bool Convert to zmm word. | |
| "bool" | create_tbyte (*args) |
| create_tbyte(ea, length, force=False) -> bool Convert to tbyte. | |
| "bool" | create_float (*args) |
| create_float(ea, length, force=False) -> bool Convert to float. | |
| "bool" | create_double (*args) |
| create_double(ea, length, force=False) -> bool Convert to double. | |
| "bool" | create_packed_real (*args) |
| create_packed_real(ea, length, force=False) -> bool Convert to packed decimal real. | |
| "bool" | create_struct (*args) |
| create_struct(ea, length, tid, force=False) -> bool Convert to struct. | |
| "bool" | create_custdata (*args) |
| create_custdata(ea, length, dtid, fid, force=False) -> bool Convert to custom data type. | |
| "bool" | create_align (*args) |
| create_align(ea, length, alignment) -> bool Create an alignment item. | |
| "int" | calc_min_align (*args) |
| calc_min_align(length) -> int Calculate the minimal possible alignment exponent. | |
| "int" | calc_max_align (*args) |
| calc_max_align(endea) -> int Calculate the maximal possible alignment exponent. | |
| "int" | calc_def_align (*args) |
| calc_def_align(ea, mina, maxa) -> int Calculate the default alignment exponent. | |
| "bool" | create_16bit_data (*args) |
| create_16bit_data(ea, length) -> bool Convert to 16-bit quantity (take the byte size into account) | |
| "bool" | create_32bit_data (*args) |
| create_32bit_data(ea, length) -> bool Convert to 32-bit quantity (take the byte size into account) | |
| "size_t" | get_max_strlit_length (*args) |
| get_max_strlit_length(ea, strtype, options=0) -> size_t Determine maximum length of string literal. | |
| "bool" | create_strlit (*args) |
| create_strlit(start, len, strtype) -> bool Convert to string literal and give a meaningful name. | |
| "opinfo_t *" | get_opinfo (*args) |
| get_opinfo(buf, ea, n, flags) -> opinfo_t Get additional information about an operand representation. | |
| "bool" | set_opinfo (*args) |
| set_opinfo(ea, n, flag, ti, suppress_events=False) -> bool Set additional information about an operand representation. | |
| "asize_t" | get_data_elsize (*args) |
| get_data_elsize(ea, F, ti=None) -> asize_t Get size of data type specified in flags 'F'. | |
| "asize_t" | get_full_data_elsize (*args) |
| get_full_data_elsize(ea, F, ti=None) -> asize_t Get full size of data type specified in flags 'F'. | |
| "int" | is_varsize_item (*args) |
| is_varsize_item(ea, F, ti=None, itemsize=None) -> int Is the item at 'ea' variable size?. | |
| "asize_t" | get_possible_item_varsize (*args) |
| get_possible_item_varsize(ea, tif) -> asize_t Return the possible size of the item at EA of type TIF if TIF is the variable structure. | |
| "bool" | can_define_item (*args) |
| can_define_item(ea, length, flags) -> bool Can define item (instruction/data) of the specified 'length', starting at 'ea'? | |
| "bool" | has_immd (*args) |
| has_immd(F) -> bool Has immediate value? | |
| "bool" | is_func (*args) |
| is_func(F) -> bool Is function start? | |
| "bool" | set_immd (*args) |
| set_immd(ea) -> bool Set 'has immediate operand' flag. | |
| "data_type_t const *" | get_custom_data_type (*args) |
| get_custom_data_type(dtid) -> data_type_t Get definition of a registered custom data type. | |
| "data_format_t const *" | get_custom_data_format (*args) |
| get_custom_data_format(dfid) -> data_format_t Get definition of a registered custom data format. | |
| "bool" | attach_custom_data_format (*args) |
| attach_custom_data_format(dtid, dfid) -> bool Attach the data format to the data type. | |
| "bool" | detach_custom_data_format (*args) |
| detach_custom_data_format(dtid, dfid) -> bool Detach the data format from the data type. | |
| "bool" | is_attached_custom_data_format (*args) |
| is_attached_custom_data_format(dtid, dfid) -> bool Is the custom data format attached to the custom data type? | |
| "int" | get_custom_data_types (*args) |
| get_custom_data_types(out, min_size=0, max_size=BADADDR) -> int Get list of registered custom data type ids. | |
| "int" | get_custom_data_formats (*args) |
| get_custom_data_formats(out, dtid) -> int Get list of attached custom data formats for the specified data type. | |
| "int" | find_custom_data_type (*args) |
| find_custom_data_type(name) -> int Get id of a custom data type. | |
| "int" | find_custom_data_format (*args) |
| find_custom_data_format(name) -> int Get id of a custom data format. | |
| "bool" | set_cmt (*args) |
| set_cmt(ea, comm, rptble) -> bool Set an indented comment. | |
| "qstring *" | get_cmt (*args) |
| get_cmt(ea, rptble) -> str Get an indented comment. | |
| "bool" | append_cmt (*args) |
| append_cmt(ea, str, rptble) -> bool Append to an indented comment. | |
| "qstring *" | get_predef_insn_cmt (*args) |
| get_predef_insn_cmt(ins) -> str Get predefined comment. | |
| "ea_t" | find_byte (*args) |
| find_byte(sEA, size, value, bin_search_flags) -> ea_t Find forward a byte with the specified value (only 8-bit value from the database). | |
| "ea_t" | find_byter (*args) |
| find_byter(sEA, size, value, bin_search_flags) -> ea_t Find reverse a byte with the specified value (only 8-bit value from the database). | |
| "qstring *" | parse_binpat_str (*args) |
| parse_binpat_str(out, ea, _in, radix, strlits_encoding=0) -> str Convert user-specified binary string to internal representation. | |
| "size_t *" | bin_search3 (*args) |
| bin_search3(start_ea, end_ea, data, flags) -> ea_t Search for a patter in the program. | |
| "ea_t" | next_inited (*args) |
| next_inited(ea, maxea) -> ea_t Find the next initialized address. | |
| "ea_t" | prev_inited (*args) |
| prev_inited(ea, minea) -> ea_t Find the previous initialized address. | |
| "bool" | equal_bytes (*args) |
| equal_bytes(ea, image, mask, len, bin_search_flags) -> bool Compare 'len' bytes of the program starting from 'ea' with 'image'. | |
| "bool" | update_hidden_range (*args) |
| update_hidden_range(ha) -> bool Update hidden range information in the database. | |
| "bool" | add_hidden_range (*args) |
| add_hidden_range(ea1, ea2, description, header, footer, color=bgcolor_t(-1)) -> bool Mark a range of addresses as hidden. | |
| "hidden_range_t *" | get_hidden_range (*args) |
| get_hidden_range(ea) -> hidden_range_t Get pointer to hidden range structure, in: linear address. | |
| "hidden_range_t *" | getn_hidden_range (*args) |
| getn_hidden_range(n) -> hidden_range_t Get pointer to hidden range structure, in: number of hidden range. | |
| "int" | get_hidden_range_qty (*args) |
| get_hidden_range_qty() -> int Get number of hidden ranges. | |
| "int" | get_hidden_range_num (*args) |
| get_hidden_range_num(ea) -> int Get number of a hidden range. | |
| "hidden_range_t *" | get_prev_hidden_range (*args) |
| get_prev_hidden_range(ea) -> hidden_range_t Get pointer to previous hidden range. | |
| "hidden_range_t *" | get_next_hidden_range (*args) |
| get_next_hidden_range(ea) -> hidden_range_t Get pointer to next hidden range. | |
| "hidden_range_t *" | get_first_hidden_range (*args) |
| get_first_hidden_range() -> hidden_range_t Get pointer to the first hidden range. | |
| "hidden_range_t *" | get_last_hidden_range (*args) |
| get_last_hidden_range() -> hidden_range_t Get pointer to the last hidden range. | |
| "bool" | del_hidden_range (*args) |
| del_hidden_range(ea) -> bool Delete hidden range. | |
| "bool" | add_mapping (*args) |
| add_mapping(_from, to, size) -> bool IDA supports memory mapping. | |
| "void" | del_mapping (*args) |
| del_mapping(ea) Delete memory mapping range. | |
| "ea_t" | use_mapping (*args) |
| use_mapping(ea) -> ea_t Translate address according to current mappings. | |
| "size_t" | get_mappings_qty (*args) |
| get_mappings_qty() -> size_t Get number of mappings. | |
| "ea_t *, ea_t *, asize_t *" | get_mapping (*args) |
| get_mapping(n) -> bool Get memory mapping range by its number. | |
| "ea_t" | free_chunk (*args) |
| free_chunk(bottom, size, step) -> ea_t | |
| "int" | visit_patched_bytes (*args) |
| visit_patched_bytes(ea1, ea2, py_callable) -> int Enumerates patched bytes in the given range and invokes a callable | |
| "PyObject *" | get_bytes (*args) |
| get_bytes(ea, size, gmb_flags=0x01) -> bytes or None Get the specified number of bytes of the program. | |
| "PyObject *" | get_bytes_and_mask (*args) |
| get_bytes_and_mask(ea, size, gmb_flags=0x01) -> PyObject * Get the specified number of bytes of the program, and a bitmask specifying what bytes are defined and what bytes are not. | |
| "PyObject *" | get_strlit_contents (*args) |
| get_strlit_contents(ea, py_len, type, flags=0) -> bytes or None Get contents of string literal, as UTF-8-encoded codepoints. | |
| "ea_t" | bin_search (*args) |
| bin_search(start_ea, end_ea, data, flags) -> ea_t Search for a set of bytes in the program | |
| "PyObject *" | print_strlit_type (*args) |
| print_strlit_type(strtype, flags=0) -> (str, str) Get string type information: the string type name (possibly decorated with hotkey markers), and the tooltip. | |
| "PyObject *" | get_octet (*args) |
| get_octet(ea, v, nbit) -> (int, int, int, int) | |
| "PyObject *" | get_8bit (*args) |
| get_8bit(ea, v, nbit) -> PyObject * | |
| "bool" | op_stroff (*args) |
| op_stroff(insn, n, path, path_len, delta) -> bool Set operand representation to be 'struct offset'. | |
| "int" | register_custom_data_type (*args) |
| register_custom_data_type(py_dt) -> int Registers a custom data type. | |
| "bool" | unregister_custom_data_type (*args) |
| unregister_custom_data_type(dtid) -> bool Unregisters a custom data type. | |
| "int" | register_custom_data_format (*args) |
| register_custom_data_format(py_df) -> int Registers a custom data format with a given data type. | |
| "bool" | unregister_custom_data_format (*args) |
| unregister_custom_data_format(dfid) -> bool Unregisters a custom data format | |
| register_data_types_and_formats (formats) | |
| Registers multiple data types and formats at once. | |
| unregister_data_types_and_formats (formats) | |
| As opposed to register_data_types_and_formats(), this function unregisters multiple data types and formats at once. | |
Variables | |
| ITEM_END_FIXUP = _ida_bytes.ITEM_END_FIXUP | |
| ITEM_END_INITED = _ida_bytes.ITEM_END_INITED | |
| ITEM_END_NAME = _ida_bytes.ITEM_END_NAME | |
| ITEM_END_XREF = _ida_bytes.ITEM_END_XREF | |
| ITEM_END_CANCEL = _ida_bytes.ITEM_END_CANCEL | |
| GFE_VALUE = _ida_bytes.GFE_VALUE | |
| GFE_IDB_VALUE = _ida_bytes.GFE_IDB_VALUE | |
| MS_VAL = _ida_bytes.MS_VAL | |
| FF_IVL = _ida_bytes.FF_IVL | |
| GMB_READALL = _ida_bytes.GMB_READALL | |
| GMB_WAITBOX = _ida_bytes.GMB_WAITBOX | |
| MS_CLS = _ida_bytes.MS_CLS | |
| FF_CODE = _ida_bytes.FF_CODE | |
| FF_DATA = _ida_bytes.FF_DATA | |
| FF_TAIL = _ida_bytes.FF_TAIL | |
| FF_UNK = _ida_bytes.FF_UNK | |
| DELIT_SIMPLE = _ida_bytes.DELIT_SIMPLE | |
| DELIT_EXPAND = _ida_bytes.DELIT_EXPAND | |
| DELIT_DELNAMES = _ida_bytes.DELIT_DELNAMES | |
| DELIT_NOTRUNC = _ida_bytes.DELIT_NOTRUNC | |
| DELIT_NOUNAME = _ida_bytes.DELIT_NOUNAME | |
| DELIT_NOCMT = _ida_bytes.DELIT_NOCMT | |
| DELIT_KEEPFUNC = _ida_bytes.DELIT_KEEPFUNC | |
| MS_COMM = _ida_bytes.MS_COMM | |
| FF_COMM = _ida_bytes.FF_COMM | |
| FF_REF = _ida_bytes.FF_REF | |
| FF_LINE = _ida_bytes.FF_LINE | |
| FF_NAME = _ida_bytes.FF_NAME | |
| FF_LABL = _ida_bytes.FF_LABL | |
| FF_FLOW = _ida_bytes.FF_FLOW | |
| FF_SIGN = _ida_bytes.FF_SIGN | |
| FF_BNOT = _ida_bytes.FF_BNOT | |
| FF_UNUSED = _ida_bytes.FF_UNUSED | |
| FF_ANYNAME = _ida_bytes.FF_ANYNAME | |
| MS_N_TYPE = _ida_bytes.MS_N_TYPE | |
| FF_N_VOID = _ida_bytes.FF_N_VOID | |
| FF_N_NUMH = _ida_bytes.FF_N_NUMH | |
| FF_N_NUMD = _ida_bytes.FF_N_NUMD | |
| FF_N_CHAR = _ida_bytes.FF_N_CHAR | |
| FF_N_SEG = _ida_bytes.FF_N_SEG | |
| FF_N_OFF = _ida_bytes.FF_N_OFF | |
| FF_N_NUMB = _ida_bytes.FF_N_NUMB | |
| FF_N_NUMO = _ida_bytes.FF_N_NUMO | |
| FF_N_ENUM = _ida_bytes.FF_N_ENUM | |
| FF_N_FOP = _ida_bytes.FF_N_FOP | |
| FF_N_STRO = _ida_bytes.FF_N_STRO | |
| FF_N_STK = _ida_bytes.FF_N_STK | |
| FF_N_FLT = _ida_bytes.FF_N_FLT | |
| FF_N_CUST = _ida_bytes.FF_N_CUST | |
| OPND_OUTER = _ida_bytes.OPND_OUTER | |
| OPND_MASK = _ida_bytes.OPND_MASK | |
| OPND_ALL = _ida_bytes.OPND_ALL | |
| DT_TYPE = _ida_bytes.DT_TYPE | |
| FF_BYTE = _ida_bytes.FF_BYTE | |
| FF_WORD = _ida_bytes.FF_WORD | |
| FF_DWORD = _ida_bytes.FF_DWORD | |
| FF_QWORD = _ida_bytes.FF_QWORD | |
| FF_TBYTE = _ida_bytes.FF_TBYTE | |
| FF_STRLIT = _ida_bytes.FF_STRLIT | |
| FF_STRUCT = _ida_bytes.FF_STRUCT | |
| FF_OWORD = _ida_bytes.FF_OWORD | |
| FF_FLOAT = _ida_bytes.FF_FLOAT | |
| FF_DOUBLE = _ida_bytes.FF_DOUBLE | |
| FF_PACKREAL = _ida_bytes.FF_PACKREAL | |
| FF_ALIGN = _ida_bytes.FF_ALIGN | |
| FF_CUSTOM = _ida_bytes.FF_CUSTOM | |
| FF_YWORD = _ida_bytes.FF_YWORD | |
| FF_ZWORD = _ida_bytes.FF_ZWORD | |
| ALOPT_IGNHEADS = _ida_bytes.ALOPT_IGNHEADS | |
| ALOPT_IGNPRINT = _ida_bytes.ALOPT_IGNPRINT | |
| ALOPT_IGNCLT = _ida_bytes.ALOPT_IGNCLT | |
| ALOPT_MAX4K = _ida_bytes.ALOPT_MAX4K | |
| ALOPT_ONLYTERM = _ida_bytes.ALOPT_ONLYTERM | |
| ALOPT_APPEND = _ida_bytes.ALOPT_APPEND | |
| STRCONV_ESCAPE = _ida_bytes.STRCONV_ESCAPE | |
| STRCONV_REPLCHAR = _ida_bytes.STRCONV_REPLCHAR | |
| STRCONV_INCLLEN = _ida_bytes.STRCONV_INCLLEN | |
| PSTF_TNORM = _ida_bytes.PSTF_TNORM | |
| PSTF_TBRIEF = _ida_bytes.PSTF_TBRIEF | |
| PSTF_TINLIN = _ida_bytes.PSTF_TINLIN | |
| PSTF_TMASK = _ida_bytes.PSTF_TMASK | |
| PSTF_HOTKEY = _ida_bytes.PSTF_HOTKEY | |
| PSTF_ENC = _ida_bytes.PSTF_ENC | |
| PSTF_ONLY_ENC = _ida_bytes.PSTF_ONLY_ENC | |
| PSTF_ATTRIB = _ida_bytes.PSTF_ATTRIB | |
| MS_CODE = _ida_bytes.MS_CODE | |
| FF_FUNC = _ida_bytes.FF_FUNC | |
| FF_IMMD = _ida_bytes.FF_IMMD | |
| FF_JUMP = _ida_bytes.FF_JUMP | |
| DTP_NODUP = _ida_bytes.DTP_NODUP | |
| PBSENC_DEF1BPU = _ida_bytes.PBSENC_DEF1BPU | |
| PBSENC_ALL = _ida_bytes.PBSENC_ALL | |
| BIN_SEARCH_CASE = _ida_bytes.BIN_SEARCH_CASE | |
| BIN_SEARCH_NOCASE = _ida_bytes.BIN_SEARCH_NOCASE | |
| BIN_SEARCH_NOBREAK = _ida_bytes.BIN_SEARCH_NOBREAK | |
| BIN_SEARCH_INITED = _ida_bytes.BIN_SEARCH_INITED | |
| BIN_SEARCH_NOSHOW = _ida_bytes.BIN_SEARCH_NOSHOW | |
| BIN_SEARCH_FORWARD = _ida_bytes.BIN_SEARCH_FORWARD | |
| BIN_SEARCH_BACKWARD = _ida_bytes.BIN_SEARCH_BACKWARD | |
| BIN_SEARCH_BITMASK = _ida_bytes.BIN_SEARCH_BITMASK | |
| MS_0TYPE = _ida_bytes.MS_0TYPE | |
| FF_0VOID = _ida_bytes.FF_0VOID | |
| FF_0NUMH = _ida_bytes.FF_0NUMH | |
| FF_0NUMD = _ida_bytes.FF_0NUMD | |
| FF_0CHAR = _ida_bytes.FF_0CHAR | |
| FF_0SEG = _ida_bytes.FF_0SEG | |
| FF_0OFF = _ida_bytes.FF_0OFF | |
| FF_0NUMB = _ida_bytes.FF_0NUMB | |
| FF_0NUMO = _ida_bytes.FF_0NUMO | |
| FF_0ENUM = _ida_bytes.FF_0ENUM | |
| FF_0FOP = _ida_bytes.FF_0FOP | |
| FF_0STRO = _ida_bytes.FF_0STRO | |
| FF_0STK = _ida_bytes.FF_0STK | |
| FF_0FLT = _ida_bytes.FF_0FLT | |
| FF_0CUST = _ida_bytes.FF_0CUST | |
| MS_1TYPE = _ida_bytes.MS_1TYPE | |
| FF_1VOID = _ida_bytes.FF_1VOID | |
| FF_1NUMH = _ida_bytes.FF_1NUMH | |
| FF_1NUMD = _ida_bytes.FF_1NUMD | |
| FF_1CHAR = _ida_bytes.FF_1CHAR | |
| FF_1SEG = _ida_bytes.FF_1SEG | |
| FF_1OFF = _ida_bytes.FF_1OFF | |
| FF_1NUMB = _ida_bytes.FF_1NUMB | |
| FF_1NUMO = _ida_bytes.FF_1NUMO | |
| FF_1ENUM = _ida_bytes.FF_1ENUM | |
| FF_1FOP = _ida_bytes.FF_1FOP | |
| FF_1STRO = _ida_bytes.FF_1STRO | |
| FF_1STK = _ida_bytes.FF_1STK | |
| FF_1FLT = _ida_bytes.FF_1FLT | |
| FF_1CUST = _ida_bytes.FF_1CUST | |
| "void" add_byte | ( | * | args | ) |
This function works for wide byte processors too.
| ea | (C++: ea_t) linear address |
| value | (C++: uint32) byte value |
| "void" add_dword | ( | * | args | ) |
This function works for wide byte processors too. This function takes into account order of bytes specified in idainfo::is_be()
| ea | (C++: ea_t) linear address |
| value | (C++: uint64) byte value |
| "bool" add_hidden_range | ( | * | args | ) |
The range will be created in the invisible state with the default color
| ea1 | (C++: ea_t) linear address of start of the address range |
| ea2 | (C++: ea_t) linear address of end of the address range |
| description | (C++: const char *) ,header,footer: range parameters |
| header | (C++: const char *) char const * |
| footer | (C++: const char *) char const * |
| color | (C++: bgcolor_t) the range color |
| "bool" add_mapping | ( | * | args | ) |
References to the addresses from the mapped range use data and meta-data from the mapping range.
| from | (C++: ea_t) start of the mapped range (nonexistent address) |
| to | (C++: ea_t) start of the mapping range (existent address) |
| size | (C++: asize_t) size of the range |
| "void" add_qword | ( | * | args | ) |
This function does not work for wide byte processors. This function takes into account order of bytes specified in idainfo::is_be()
| ea | (C++: ea_t) linear address |
| value | (C++: uint64) byte value |
| "void" add_word | ( | * | args | ) |
This function works for wide byte processors too. This function takes into account order of bytes specified in idainfo::is_be()
| ea | (C++: ea_t) linear address |
| value | (C++: uint64) byte value |
| "flags64_t" align_flag | ( | * | args | ) |
| "bool" append_cmt | ( | * | args | ) |
Creates a new comment if none exists. Appends a newline character and the specified string otherwise.
| ea | (C++: ea_t) linear address |
| str | (C++: const char *) comment string to append |
| rptble | (C++: bool) append to repeatable comment? |
| "bool" attach_custom_data_format | ( | * | args | ) |
| dtid | (C++: int) data type id that can use the data format. 0 means all standard data types. Such data formats can be applied to any data item or instruction operands. For instruction operands, the data_format_t.value_size check is not performed by the kernel. |
| dfid | (C++: int) data format id |
| true | ok |
| false | no such ‘dtid’, or no such ‘dfid’, or the data format has already been attached to the data type |
| "flags64_t" bin_flag | ( | * | args | ) |
| "ea_t" bin_search | ( | * | args | ) |
| start_ea | linear address, start of range to search |
| end_ea | linear address, end of range to search (exclusive) |
| data | the prepared data to search for (see parse_binpat_str()) |
| flags | combination of BIN_SEARCH_* flags |
| start_ea | ea_t |
| end_ea | ea_t |
| image | bytevec_t const & |
| imask | bytevec_t const & |
| step | int |
| flags | int |
| "size_t *" bin_search3 | ( | * | args | ) |
| start_ea | (C++: ea_t) linear address, start of range to search |
| end_ea | (C++: ea_t) linear address, end of range to search (exclusive) |
| data | (C++: const compiled_binpat_vec_t &) the prepared data to search for (see parse_binpat_str()) |
| flags | (C++: int) combination of Search flags |
| "flags64_t" byte_flag | ( | * | args | ) |
| "int" bytesize | ( | * | args | ) |
| ea | (C++: ea_t) |
| "int" calc_def_align | ( | * | args | ) |
| ea | (C++: ea_t) linear address |
| mina | (C++: int) minimal possible alignment exponent. |
| maxa | (C++: int) minimal possible alignment exponent. |
| "flags64_t" calc_dflags | ( | * | args | ) |
| f | flags64_t |
| force | bool |
| "int" calc_max_align | ( | * | args | ) |
| endea | (C++: ea_t) end address of the alignment item. |
| "ea_t" calc_max_item_end | ( | * | args | ) |
This function will limit the item with the current segment bounds.
| ea | (C++: ea_t) linear address |
| how | (C++: int) when to stop the search. A combination of Item end search flags |
| "int" calc_min_align | ( | * | args | ) |
| length | (C++: asize_t) size of the item in bytes. |
| "bool" can_define_item | ( | * | args | ) |
| ea | (C++: ea_t) start of the range for the new item |
| length | (C++: asize_t) length of the new item in bytes |
| flags | (C++: flags64_t) if not 0, then the kernel will ignore the data types specified by the flags and destroy them. For example: 1000 dw 5 1002 db 5 ; undef 1003 db 5 ; undef 1004 dw 5 1006 dd 5 can_define_item(1000, 6, 0) - false because of dw at 1004 can_define_item(1000, 6, word_flag()) - true, word at 1004 is destroyed |
| "error_t" change_storage_type | ( | * | args | ) |
| start_ea | (C++: ea_t) should be lower than end_ea. |
| end_ea | (C++: ea_t) does not belong to the range. |
| stt | (C++: storage_type_t) |
| "flags64_t" char_flag | ( | * | args | ) |
| "asize_t" chunk_size | ( | * | args | ) |
| ea | (C++: ea_t) |
| "ea_t" chunk_start | ( | * | args | ) |
| ea | (C++: ea_t) |
| "bool" clr_lzero | ( | * | args | ) |
This function reset the display of leading zeroes for the specified operand to the default. If the default is not to display leading zeroes, leading zeroes will not be displayed, as vice versa.
| ea | (C++: ea_t) the item (insn/data) address |
| n | (C++: int) the operand number (0-first operand, 1-other operands) |
| "bool" clr_op_type | ( | * | args | ) |
(set operand representation to be 'undefined')
| ea | (C++: ea_t) linear address |
| n | (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands |
| "flags64_t" code_flag | ( | * | args | ) |
| "flags64_t" combine_flags | ( | * | args | ) |
| F | flags64_t |
| "bool" create_16bit_data | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| "bool" create_32bit_data | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| "bool" create_align | ( | * | args | ) |
| ea | (C++: ea_t) linear address |
| length | (C++: asize_t) size of the item in bytes. 0 means to infer from ALIGNMENT |
| alignment | (C++: int) alignment exponent. Example: 3 means align to 8 bytes. 0 means to infer from LENGTH It is forbidden to specify both LENGTH and ALIGNMENT as 0. |
| "bool" create_byte | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| force | (C++: bool) |
| "bool" create_custdata | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| dtid | (C++: int) |
| fid | (C++: int) |
| force | (C++: bool) |
| "bool" create_data | ( | * | args | ) |
This function may be used to create arrays.
| ea | (C++: ea_t) linear address |
| dataflag | (C++: flags64_t) type of data. Value of function byte_flag(), word_flag(), etc. |
| size | (C++: asize_t) size of array in bytes. should be divisible by the size of one item of the specified type. for variable sized items it can be specified as 0, and the kernel will try to calculate the size. |
| tid | (C++: tid_t) type id. If the specified type is a structure, then tid is structure id. Otherwise should be BADNODE. |
| "bool" create_double | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| force | (C++: bool) |
| "bool" create_dword | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| force | (C++: bool) |
| "bool" create_float | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| force | (C++: bool) |
| "bool" create_oword | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| force | (C++: bool) |
| "bool" create_packed_real | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| force | (C++: bool) |
| "bool" create_qword | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| force | (C++: bool) |
| "bool" create_strlit | ( | * | args | ) |
'start' may be higher than 'end', the kernel will swap them in this case
| start | (C++: ea_t) starting address |
| len | (C++: size_t) length of the string in bytes. if 0, then get_max_strlit_length() will be used to determine the length |
| strtype | (C++: int32) string type. one of String type codes |
| "bool" create_struct | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| tid | (C++: tid_t) |
| force | (C++: bool) |
| "bool" create_tbyte | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| force | (C++: bool) |
| "bool" create_word | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| force | (C++: bool) |
| "bool" create_yword | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| force | (C++: bool) |
| "bool" create_zword | ( | * | args | ) |
| ea | (C++: ea_t) |
| length | (C++: asize_t) |
| force | (C++: bool) |
| "flags64_t" cust_flag | ( | * | args | ) |
| "flags64_t" custfmt_flag | ( | * | args | ) |
| "flags64_t" dec_flag | ( | * | args | ) |
| "bool" del_hidden_range | ( | * | args | ) |
| ea | (C++: ea_t) any address in the hidden range |
| "bool" del_items | ( | * | args | ) |
The whole item (including the head and tail bytes) will be destroyed. It is allowed to pass any address in the item to this function
| ea | (C++: ea_t) any address within the first item to delete |
| flags | (C++: int) combination of Unexplored byte conversion flags |
| nbytes | (C++: asize_t) number of bytes in the range to be undefined |
| may_destroy | (C++: may_destroy_cb_t *) optional routine invoked before deleting a head item. If callback returns false then item is not to be deleted and operation fails |
| "void" del_mapping | ( | * | args | ) |
| ea | (C++: ea_t) any address in the mapped range |
| "void" del_value | ( | * | args | ) |
The corresponding byte becomes uninitialized.
| ea | (C++: ea_t) |
| "bool" detach_custom_data_format | ( | * | args | ) |
Unregistering a custom data type detaches all attached data formats, no need to detach them explicitly. You still need unregister them. Unregistering a custom data format detaches it from all attached data types.
| dtid | (C++: int) data type id to detach data format from |
| dfid | (C++: int) data format id to detach |
| true | ok |
| false | no such ‘dtid’, or no such ‘dfid’, or the data format was not attached to the data type |
| "error_t" disable_flags | ( | * | args | ) |
Exit with an error message if not enough disk space (this may occur too).
| start_ea | (C++: ea_t) should be lower than end_ea. |
| end_ea | (C++: ea_t) does not belong to the range. |
| "flags64_t" double_flag | ( | * | args | ) |
| "flags64_t" dword_flag | ( | * | args | ) |
| "error_t" enable_flags | ( | * | args | ) |
This function does not change the storage type of existing ranges. Exit with an error message if not enough disk space.
| start_ea | (C++: ea_t) should be lower than end_ea. |
| end_ea | (C++: ea_t) does not belong to the range. |
| stt | (C++: storage_type_t) |
| "flags64_t" enum_flag | ( | * | args | ) |
| "bool" equal_bytes | ( | * | args | ) |
| ea | (C++: ea_t) linear address |
| image | (C++: const uchar *) bytes to compare with |
| mask | (C++: const uchar *) array of mask bytes, it's length is 'len'. if the flag BIN_SEARCH_BITMASK is passsed, 'bitwise AND' is used to compare. if not; 1 means to perform the comparison of the corresponding byte. 0 means not to perform. if mask == nullptr, then all bytes of 'image' will be compared. if mask == SKIP_FF_MASK then 0xFF bytes will be skipped |
| len | (C++: size_t) length of block to compare in bytes. |
| bin_search_flags | (C++: int) combination of Search flags |
| 1 | equal |
| 0 | not equal |
| "bool" f_has_cmt | ( | * | args | ) |
| f | flags64_t |
| arg2 | void * |
| "bool" f_has_dummy_name | ( | * | args | ) |
| f | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_has_extra_cmts | ( | * | args | ) |
| f | flags64_t |
| arg2 | void * |
| "bool" f_has_name | ( | * | args | ) |
| f | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_has_user_name | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_has_xref | ( | * | args | ) |
| f | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_align | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_byte | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_code | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_custom | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_data | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_double | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_dword | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_float | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_head | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_not_tail | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_oword | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_pack_real | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_qword | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_strlit | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_struct | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_tail | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_tbyte | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_word | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "bool" f_is_yword | ( | * | args | ) |
| F | (C++: flags64_t) |
| arg2 | void * |
| "ea_t" find_byte | ( | * | args | ) |
example: ea=4 size=3 will inspect addresses 4, 5, and 6
| sEA | (C++: ea_t) linear address |
| size | (C++: asize_t) number of bytes to inspect |
| value | (C++: uchar) value to find |
| bin_search_flags | (C++: int) combination of Search flags |
| "ea_t" find_byter | ( | * | args | ) |
example: ea=4 size=3 will inspect addresses 6, 5, and 4
| sEA | (C++: ea_t) the lower address of the search range |
| size | (C++: asize_t) number of bytes to inspect |
| value | (C++: uchar) value to find |
| bin_search_flags | (C++: int) combination of Search flags |
| "int" find_custom_data_format | ( | * | args | ) |
| name | (C++: const char *) name of the custom data format |
| "int" find_custom_data_type | ( | * | args | ) |
| name | (C++: const char *) name of the custom data type |
| "ea_t" find_free_chunk | ( | * | args | ) |
| start | (C++: ea_t) Address to start searching from |
| size | (C++: asize_t) Size of the desired empty range |
| alignment | (C++: asize_t) Alignment bitmask, must be a pow2-1. (for example, 0xF would align the returned range to 16 bytes). |
| "flags64_t" float_flag | ( | * | args | ) |
| "flags64_t" flt_flag | ( | * | args | ) |
| "ea_t" free_chunk | ( | * | args | ) |
| bottom | ea_t |
| size | asize_t |
| step | int32 |
| "uint32" get_16bit | ( | * | args | ) |
| ea | (C++: ea_t) |
| "uint32" get_32bit | ( | * | args | ) |
| ea | (C++: ea_t) |
| "uint64" get_64bit | ( | * | args | ) |
| ea | (C++: ea_t) |
| "PyObject *" get_8bit | ( | * | args | ) |
| ea | ea_t |
| v | uint32 |
| nbit | int |
| "uchar" get_byte | ( | * | args | ) |
This function works only for 8bit byte processors.
| ea | (C++: ea_t) |
| "PyObject *" get_bytes | ( | * | args | ) |
| ea | program address |
| size | number of bytes to return |
| gmb_flags | int |
| "PyObject *" get_bytes_and_mask | ( | * | args | ) |
| ea | program address |
| size | number of bytes to return |
| gmb_flags | int |
| "qstring *" get_cmt | ( | * | args | ) |
| ea | (C++: ea_t) linear address. may point to tail byte, the function will find start of the item |
| rptble | (C++: bool) get repeatable comment? |
| "data_format_t const *" get_custom_data_format | ( | * | args | ) |
| dfid | (C++: int) data format id |
| "int" get_custom_data_formats | ( | * | args | ) |
| out | (C++: intvec_t *) buffer for the output. may be nullptr |
| dtid | (C++: int) data type id |
| "data_type_t const *" get_custom_data_type | ( | * | args | ) |
| dtid | (C++: int) data type id |
| "int" get_custom_data_types | ( | * | args | ) |
| out | (C++: intvec_t *) buffer for the output. may be nullptr |
| min_size | (C++: asize_t) minimum value size |
| max_size | (C++: asize_t) maximum value size |
| "asize_t" get_data_elsize | ( | * | args | ) |
| ea | (C++: ea_t) linear address of the item |
| F | (C++: flags64_t) flags |
| ti | (C++: const opinfo_t *) additional information about the data type. For example, if the current item is a structure instance, then ti->tid is structure id. Otherwise is ignored (may be nullptr). If specified as nullptr, will be automatically retrieved from the database |
| "bool" get_data_value | ( | * | args | ) |
This function works with entities up to sizeof(ea_t) (bytes, word, etc)
| v | (C++: uval_t *) pointer to the result. may be nullptr |
| ea | (C++: ea_t) linear address |
| size | (C++: asize_t) size of data to read. If 0, then the item type at 'ea' will be used |
| "uchar" get_db_byte | ( | * | args | ) |
Works even if the debugger is active. See also get_dbg_byte() to read the process memory directly. This function works only for 8bit byte processors.
| ea | (C++: ea_t) |
| "int" get_default_radix | ( | * | args | ) |
| "uint32" get_dword | ( | * | args | ) |
This function takes into account order of bytes specified in idainfo::is_be() This function works only for 8bit byte processors.
| ea | (C++: ea_t) |
| "uchar *" get_enum_id | ( | * | args | ) |
| ea | (C++: ea_t) linear address |
| n | (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL one of the operands |
| "hidden_range_t *" get_first_hidden_range | ( | * | args | ) |
| "flags64_t" get_flags | ( | * | args | ) |
It is much slower under remote debugging because the kernel needs to read the process memory.
| ea | (C++: ea_t) |
| "flags64_t" get_flags_by_size | ( | * | args | ) |
Supported sizes: 1, 2, 4, 8, 16, 32. For other sizes returns 0
| size | (C++: size_t) |
| "flags64_t" get_flags_ex | ( | * | args | ) |
| ea | (C++: ea_t) |
| how | (C++: int) |
| "qstring *" get_forced_operand | ( | * | args | ) |
| ea | (C++: ea_t) linear address |
| n | (C++: int) 0..UA_MAXOP-1 operand number |
| "asize_t" get_full_data_elsize | ( | * | args | ) |
takes into account processors with wide bytes e.g. returns 2 for a byte element with 16-bit bytes
| ea | (C++: ea_t) |
| F | (C++: flags64_t) |
| ti | (C++: const opinfo_t *) opinfo_t const * |
| "flags64_t" get_full_flags | ( | * | args | ) |
| ea | (C++: ea_t) |
| "hidden_range_t *" get_hidden_range | ( | * | args | ) |
| ea | (C++: ea_t) any address in the hidden range |
| "int" get_hidden_range_num | ( | * | args | ) |
| ea | (C++: ea_t) any address in the hidden range |
| "int" get_hidden_range_qty | ( | * | args | ) |
| "ea_t" get_item_end | ( | * | args | ) |
The returned address doesn't belong to the current item. Unexplored bytes are counted as 1 byte entities.
| ea | (C++: ea_t) |
| "flags64_t" get_item_flag | ( | * | args | ) |
This function is used to get flags of structure members or array elements.
| from | (C++: ea_t) linear address of the instruction which refers to 'ea' |
| n | (C++: int) operand number which refers to 'ea' or OPND_ALL for one of the operands |
| ea | (C++: ea_t) the referenced address |
| appzero | (C++: bool) append a struct field name if the field offset is zero? meaningful only if the name refers to a structure. |
| "ea_t" get_item_head | ( | * | args | ) |
If there is no current item, then 'ea' will be returned (see definition at the end of bytes.hpp source)
| ea | (C++: ea_t) |
| "bool" get_item_refinfo | ( | * | args | ) |
This function works for a regular offset operand as well as for a tail byte of a structure variable (in this case refinfo to corresponding structure member will be returned)
| ri | (C++: refinfo_t *) refinfo holder |
| ea | (C++: ea_t) the item address |
| n | (C++: int) operand number which refers to 'ea' or OPND_ALL for one of the operands |
| "asize_t" get_item_size | ( | * | args | ) |
Unexplored bytes have length of 1 byte. This function returns 0 only for BADADDR.
| ea | (C++: ea_t) |
| "hidden_range_t *" get_last_hidden_range | ( | * | args | ) |
| "qstring *" get_manual_insn | ( | * | args | ) |
| ea | (C++: ea_t) linear address of the instruction or data item |
| "ea_t *, ea_t *, asize_t *" get_mapping | ( | * | args | ) |
| n | (C++: size_t) number of mapping range (0..get_mappings_qty()-1) |
| "size_t" get_mappings_qty | ( | * | args | ) |
| "size_t" get_max_strlit_length | ( | * | args | ) |
If the string literal has a length prefix (e.g., STRTYPE_LEN2 has a two-byte length prefix), the length of that prefix (i.e., 2) will be part of the returned value.
| ea | (C++: ea_t) starting address |
| strtype | (C++: int32) string type. one of String type codes |
| options | (C++: int) combination of string literal length options |
| "hidden_range_t *" get_next_hidden_range | ( | * | args | ) |
| ea | (C++: ea_t) any address in the program |
| "PyObject *" get_octet | ( | * | args | ) |
| ea | ea_t |
| v | uint64 |
| nbit | int |
| "uchar *" get_octet2 | ( | * | args | ) |
| ogen | octet_generator_t * |
| "flags64_t" get_operand_flag | ( | * | args | ) |
| typebits | (C++: uint8) the type bits (one of FF_N_) |
| n | (C++: int) the operand number |
| "int" get_operand_type_shift | ( | * | args | ) |
Note: n must be < UA_MAXOP, and is not checked
| n | (C++: uint32) the operand number |
| "opinfo_t *" get_opinfo | ( | * | args | ) |
| buf | (C++: opinfo_t *) buffer to receive the result. may not be nullptr |
| ea | (C++: ea_t) linear address of item |
| n | (C++: int) number of operand, 0 or 1 |
| flags | (C++: flags64_t) flags of the item |
| "flags64_t" get_optype_flags0 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "flags64_t" get_optype_flags1 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "uint64" get_original_byte | ( | * | args | ) |
This function works for wide byte processors too.
| ea | (C++: ea_t) |
| "uint64" get_original_dword | ( | * | args | ) |
This function takes into account order of bytes specified in idainfo::is_be()
| ea | (C++: ea_t) |
| "uint64" get_original_qword | ( | * | args | ) |
This function takes into account order of bytes specified in idainfo::is_be()
| ea | (C++: ea_t) |
| "uint64" get_original_word | ( | * | args | ) |
This function works for wide byte processors too. This function takes into account order of bytes specified in idainfo::is_be()
| ea | (C++: ea_t) |
| "asize_t" get_possible_item_varsize | ( | * | args | ) |
| ea | (C++: ea_t) the linear address of the item |
| tif | (C++: const tinfo_t &) the item type |
| asize_t(-1) | TIF is not a variable structure |
| "qstring *" get_predef_insn_cmt | ( | * | args | ) |
| ins | (C++: const insn_t &) current instruction information |
| "hidden_range_t *" get_prev_hidden_range | ( | * | args | ) |
| ea | (C++: ea_t) any address in the program |
| "uint64" get_qword | ( | * | args | ) |
This function takes into account order of bytes specified in idainfo::is_be() This function works only for 8bit byte processors.
| ea | (C++: ea_t) |
| "int" get_radix | ( | * | args | ) |
If the operand is not a number, returns get_default_radix()
| F | (C++: flags64_t) flags |
| n | (C++: int) number of operand (0, 1, -1) |
| "PyObject *" get_strlit_contents | ( | * | args | ) |
It works even if the string has not been created in the database yet.
Note that the returned value will be of type 'bytes'; if you want auto-conversion to unicode strings (that is: real Python strings), you should probably be using the idautils.Strings class.
| ea | linear address of the string |
| py_len | length of the string in bytes (including terminating 0) |
| type | type of the string. Represents both the character encoding, and the 'type' of string at the given location. |
| flags | combination of STRCONV_..., to perform output conversion. |
| "int" get_stroff_path | ( | * | args | ) |
| path | (C++: tid_t *) buffer for structure path (strpath). see nalt.hpp for more info. |
| delta | (C++: adiff_t *) struct offset delta |
| ea | (C++: ea_t) linear address |
| n | (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL one of the operands |
| "uint64" get_wide_byte | ( | * | args | ) |
Some processors may access more than 8bit quantity at an address. These processors have 32-bit byte organization from the IDA's point of view.
| ea | (C++: ea_t) |
| "uint64" get_wide_dword | ( | * | args | ) |
Some processors may access more than 8bit quantity at an address. These processors have 32-bit byte organization from the IDA's point of view. This function takes into account order of bytes specified in idainfo::is_be()
| ea | (C++: ea_t) |
| "uint64" get_wide_word | ( | * | args | ) |
Some processors may access more than 8bit quantity at an address. These processors have 32-bit byte organization from the IDA's point of view. This function takes into account order of bytes specified in idainfo::is_be()
| ea | (C++: ea_t) |
| "ushort" get_word | ( | * | args | ) |
This function takes into account order of bytes specified in idainfo::is_be() This function works only for 8bit byte processors.
| ea | (C++: ea_t) |
| "bool" get_zero_ranges | ( | * | args | ) |
The returned set includes only big zero initialized ranges (at least >1KB). Some zero initialized byte ranges may be not included. Only zero bytes that use the sparse storage method (STT_MM) are reported.
| zranges | (C++: rangeset_t *) pointer to the return value. cannot be nullptr |
| range | (C++: const range_t *) the range of addresses to verify. can be nullptr - means all ranges |
| "hidden_range_t *" getn_hidden_range | ( | * | args | ) |
| n | (C++: int) number of hidden range, is in range 0..get_hidden_range_qty()-1 |
| "bool" has_any_name | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" has_auto_name | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" has_cmt | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" has_dummy_name | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" has_extra_cmts | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" has_immd | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" has_name | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" has_user_name | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" has_value | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" has_xref | ( | * | args | ) |
| F | (C++: flags64_t) |
| "flags64_t" hex_flag | ( | * | args | ) |
| "bool" is_align | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_attached_custom_data_format | ( | * | args | ) |
| dtid | (C++: int) data type id |
| dfid | (C++: int) data format id |
| "bool" is_bnot | ( | * | args | ) |
asm_t::a_bnot should be defined in the idp module in order to work with this function
| ea | (C++: ea_t) |
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" is_byte | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_char | ( | * | args | ) |
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" is_char0 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_char1 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_code | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_custfmt | ( | * | args | ) |
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" is_custfmt0 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_custfmt1 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_custom | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_data | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_defarg | ( | * | args | ) |
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" is_defarg0 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_defarg1 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_double | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_dword | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_enum | ( | * | args | ) |
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" is_enum0 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_enum1 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_flag_for_operand | ( | * | args | ) |
| F | (C++: flags64_t) the flags |
| typebits | (C++: uint8) the type bits (one of FF_N_) |
| n | (C++: int) the operand number |
| "bool" is_float | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_float0 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_float1 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_flow | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_fltnum | ( | * | args | ) |
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" is_forced_operand | ( | * | args | ) |
| ea | (C++: ea_t) linear address |
| n | (C++: int) 0..UA_MAXOP-1 operand number |
| "bool" is_func | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_head | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_invsign | ( | * | args | ) |
allowed values of n: 0-first operand, 1-other operands
| ea | (C++: ea_t) |
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" is_loaded | ( | * | args | ) |
| ea | (C++: ea_t) |
| "bool" is_lzero | ( | * | args | ) |
The global switch for the leading zeroes is in idainfo::s_genflags Note: the leading zeroes doesn't work if for the target assembler octal numbers start with 0.
| ea | (C++: ea_t) the item (insn/data) address |
| n | (C++: int) the operand number (0-first operand, 1-other operands) |
| "bool" is_manual | ( | * | args | ) |
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" is_manual_insn | ( | * | args | ) |
| ea | (C++: ea_t) linear address of the instruction or data item |
| "bool" is_mapped | ( | * | args | ) |
| ea | (C++: ea_t) |
| "bool" is_not_tail | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_numop | ( | * | args | ) |
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" is_numop0 | ( | * | args | ) |
binary, octal, decimal or hex?)
| F | (C++: flags64_t) |
| "bool" is_numop1 | ( | * | args | ) |
binary, octal, decimal or hex?)
| F | (C++: flags64_t) |
| "bool" is_off | ( | * | args | ) |
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" is_off0 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_off1 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_oword | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_pack_real | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_qword | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_same_data_type | ( | * | args | ) |
| F1 | (C++: flags64_t) |
| F2 | (C++: flags64_t) |
| "bool" is_seg | ( | * | args | ) |
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" is_seg0 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_seg1 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_stkvar | ( | * | args | ) |
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" is_stkvar0 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_stkvar1 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_strlit | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_stroff | ( | * | args | ) |
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" is_stroff0 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_stroff1 | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_struct | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_suspop | ( | * | args | ) |
| ea | (C++: ea_t) |
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" is_tail | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_tbyte | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_unknown | ( | * | args | ) |
| F | (C++: flags64_t) |
| "int" is_varsize_item | ( | * | args | ) |
| ea | (C++: ea_t) linear address of the item |
| F | (C++: flags64_t) flags |
| ti | (C++: const opinfo_t *) additional information about the data type. For example, if the current item is a structure instance, then ti->tid is structure id. Otherwise is ignored (may be nullptr). If specified as nullptr, will be automatically retrieved from the database |
| itemsize | (C++: asize_t *) if not nullptr and the item is varsize, itemsize will contain the calculated item size (for struct types, the minimal size is returned) |
| 1 | varsize item |
| 0 | fixed item |
| -1 | error (bad data definition) |
| "bool" is_word | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_yword | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" is_zword | ( | * | args | ) |
| F | (C++: flags64_t) |
| "bool" leading_zero_important | ( | * | args | ) |
| ea | (C++: ea_t) |
| n | (C++: int) |
| "int" nbits | ( | * | args | ) |
| ea | (C++: ea_t) |
| "ea_t" next_addr | ( | * | args | ) |
next address which has flags).
| ea | (C++: ea_t) |
| "ea_t" next_chunk | ( | * | args | ) |
| ea | (C++: ea_t) |
| "ea_t" next_head | ( | * | args | ) |
| ea | (C++: ea_t) begin search at this address |
| maxea | (C++: ea_t) not included in the search range |
| "ea_t" next_inited | ( | * | args | ) |
| ea | (C++: ea_t) |
| maxea | (C++: ea_t) |
| "ea_t" next_not_tail | ( | * | args | ) |
| ea | (C++: ea_t) |
| "ea_t" next_that | ( | * | args | ) |
| ea | (C++: ea_t) start searching at this address + 1 |
| maxea | (C++: ea_t) not included in the search range. |
| testf | (C++: testf_t *) test function to find next address |
| "ea_t" next_unknown | ( | * | args | ) |
| ea | (C++: ea_t) |
| maxea | (C++: ea_t) |
| "ea_t" next_visea | ( | * | args | ) |
| ea | (C++: ea_t) |
| "flags64_t" num_flag | ( | * | args | ) |
| "flags64_t" oct_flag | ( | * | args | ) |
| "flags64_t" off_flag | ( | * | args | ) |
| "bool" op_adds_xrefs | ( | * | args | ) |
Currently 'offset' and 'structure offset' operands create xrefs
| F | (C++: flags64_t) |
| n | (C++: int) |
| "bool" op_based_stroff | ( | * | args | ) |
For example, let's there is a structure at 1000 1000 stru_1000 Elf32_Sym <...> the operand #8 will be represented as '#Elf32_Sym.st_size' after the call of 'op_based_stroff(..., 8, 0x1000)' By the way, after the call of 'op_plain_offset(..., 0x1000)' it will be represented as '#(stru_1000.st_size - 0x1000)'
| insn | (C++: const insn_t &) the instruction |
| n | (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands |
| opval | (C++: adiff_t) operand value (usually op_t::value or op_t::addr) |
| base | (C++: ea_t) base reference |
| "bool" op_bin | ( | * | args | ) |
| ea | (C++: ea_t) |
| n | (C++: int) |
| "bool" op_chr | ( | * | args | ) |
| ea | (C++: ea_t) |
| n | (C++: int) |
| "bool" op_custfmt | ( | * | args | ) |
| ea | (C++: ea_t) |
| n | (C++: int) |
| fid | (C++: int) |
| "bool" op_dec | ( | * | args | ) |
| ea | (C++: ea_t) |
| n | (C++: int) |
| "bool" op_enum | ( | * | args | ) |
If applied to unexplored bytes, converts them to 16/32bit word data
| ea | (C++: ea_t) linear address |
| n | (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands |
| id | (C++: enum_t) id of enum |
| serial | (C++: uchar) the serial number of the constant in the enumeration, usually 0. the serial numbers are used if the enumeration contains several constants with the same value |
| "bool" op_flt | ( | * | args | ) |
| ea | (C++: ea_t) |
| n | (C++: int) |
| "bool" op_hex | ( | * | args | ) |
| ea | (C++: ea_t) |
| n | (C++: int) |
| "bool" op_num | ( | * | args | ) |
| ea | (C++: ea_t) |
| n | (C++: int) |
| "bool" op_oct | ( | * | args | ) |
| ea | (C++: ea_t) |
| n | (C++: int) |
| "bool" op_seg | ( | * | args | ) |
If applied to unexplored bytes, converts them to 16/32bit word data
| ea | (C++: ea_t) linear address |
| n | (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands |
| "bool" op_stkvar | ( | * | args | ) |
Should be applied to an instruction within a function. Should be applied after creating a stack var using insn_t::create_stkvar().
| ea | (C++: ea_t) linear address |
| n | (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands |
| "bool" op_stroff | ( | * | args | ) |
| insn | (C++: const insn_t &) the instruction |
| n | (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands |
| path | (C++: const tid_t *) structure path (strpath). see nalt.hpp for more info. |
| path_len | (C++: int) length of the structure path |
| delta | (C++: adiff_t) struct offset delta. usually 0. denotes the difference between the structure base and the pointer into the structure. |
| insn | an ida_ua.insn_t, or an address (C++: const insn_t &) |
| n | int |
| path | qvector< tid_t > const & |
| delta | adiff_t |
| "flags64_t" oword_flag | ( | * | args | ) |
| "flags64_t" packreal_flag | ( | * | args | ) |
| "qstring *" parse_binpat_str | ( | * | args | ) |
The 'in' parameter contains space-separated tokens:
Note that string constants are surrounded with double quotes.
Here are a few examples (assuming base 16): CD 21 - bytes 0xCD, 0x21 21CD - bytes 0xCD, 0x21 (little endian ) or 0x21, 0xCD (big-endian) "Hello", 0 - the null terminated string "Hello" L"Hello" - 'H', 0, 'e', 0, 'l', 0, 'l', 0, 'o', 0 B8 ? ? ? ? 90 - byte 0xB8, 4 bytes with any value, byte 0x90
| out | (C++: compiled_binpat_vec_t *) a vector of compiled binary patterns, for use with bin_search2() |
| ea | (C++: ea_t) linear address to convert for (the conversion depends on the address, because the number of bits in a byte depend on the segment type) |
| in | (C++: const char *) input text string |
| radix | (C++: int) numeric base of numbers (8,10,16) |
| strlits_encoding | (C++: int) the target encoding into which the string literals present in 'in', should be encoded. Can be any from [1, get_encoding_qty()), or the special values PBSENC_* |
| "bool" patch_byte | ( | * | args | ) |
The original value of the byte is saved and can be obtained by get_original_byte(). This function works for wide byte processors too.
| true | the database has been modified, |
| false | the debugger is running and the process' memory has value 'x' at address 'ea', or the debugger is not running, and the IDB has value 'x' at address 'ea already. |
| ea | (C++: ea_t) |
| x | (C++: uint64) |
| "void" patch_bytes | ( | * | args | ) |
Original values of bytes are saved and are available with get_original...() functions. See also put_bytes().
| ea | (C++: ea_t) linear address |
| buf | (C++: const void *) buffer with new values of bytes |
| "bool" patch_dword | ( | * | args | ) |
The original value of the dword is saved and can be obtained by get_original_dword(). This function DOESN'T work for wide byte processors. This function takes into account order of bytes specified in idainfo::is_be()
| true | the database has been modified, |
| false | the debugger is running and the process' memory has value 'x' at address 'ea', or the debugger is not running, and the IDB has value 'x' at address 'ea already. |
| ea | (C++: ea_t) |
| x | (C++: uint64) |
| "bool" patch_qword | ( | * | args | ) |
The original value of the qword is saved and can be obtained by get_original_qword(). This function DOESN'T work for wide byte processors. This function takes into account order of bytes specified in idainfo::is_be()
| true | the database has been modified, |
| false | the debugger is running and the process' memory has value 'x' at address 'ea', or the debugger is not running, and the IDB has value 'x' at address 'ea already. |
| ea | (C++: ea_t) |
| x | (C++: uint64) |
| "bool" patch_word | ( | * | args | ) |
The original value of the word is saved and can be obtained by get_original_word(). This function works for wide byte processors too. This function takes into account order of bytes specified in idainfo::is_be()
| true | the database has been modified, |
| false | the debugger is running and the process' memory has value 'x' at address 'ea', or the debugger is not running, and the IDB has value 'x' at address 'ea already. |
| ea | (C++: ea_t) |
| x | (C++: uint64) |
| "ea_t" prev_addr | ( | * | args | ) |
| ea | (C++: ea_t) |
| "ea_t" prev_chunk | ( | * | args | ) |
| ea | (C++: ea_t) |
| "ea_t" prev_head | ( | * | args | ) |
| ea | (C++: ea_t) begin search at this address |
| minea | (C++: ea_t) included in the search range |
| "ea_t" prev_inited | ( | * | args | ) |
| ea | (C++: ea_t) |
| minea | (C++: ea_t) |
| "ea_t" prev_not_tail | ( | * | args | ) |
| ea | (C++: ea_t) |
| "ea_t" prev_that | ( | * | args | ) |
| ea | (C++: ea_t) start searching from this address - 1. |
| minea | (C++: ea_t) included in the search range. |
| testf | (C++: testf_t *) test function to find previous address |
| "ea_t" prev_unknown | ( | * | args | ) |
| ea | (C++: ea_t) |
| minea | (C++: ea_t) |
| "ea_t" prev_visea | ( | * | args | ) |
| ea | (C++: ea_t) |
| "PyObject *" print_strlit_type | ( | * | args | ) |
| strtype | (C++: int32) the string type |
| flags | (C++: int) or'ed PSTF_* constants |
| "bool" put_byte | ( | * | args | ) |
This function modifies the database. If the debugger is active then the debugged process memory is patched too.
| ea | (C++: ea_t) linear address |
| x | (C++: uint64) byte value |
| "void" put_bytes | ( | * | args | ) |
This function does not save the original values of bytes. See also patch_bytes().
| ea | (C++: ea_t) linear address |
| buf | (C++: const void *) buffer with new values of bytes |
| "void" put_dword | ( | * | args | ) |
This function takes into account order of bytes specified in idainfo::is_be() This function works for wide byte processors too.
| ea | (C++: ea_t) linear address |
| x | (C++: uint64) dword value |
| "void" put_qword | ( | * | args | ) |
This function takes into account order of bytes specified in idainfo::is_be() This function DOESN'T works for wide byte processors.
| ea | (C++: ea_t) linear address |
| x | (C++: uint64) qword value |
| "void" put_word | ( | * | args | ) |
This function takes into account order of bytes specified in idainfo::is_be() This function works for wide byte processors too.
| ea | (C++: ea_t) |
| x | (C++: uint64) |
| "flags64_t" qword_flag | ( | * | args | ) |
| "int" register_custom_data_format | ( | * | args | ) |
| py_df | an instance of data_format_t |
| "int" register_custom_data_type | ( | * | args | ) |
| py_dt | an instance of the data_type_t class |
| register_data_types_and_formats | ( | formats | ) |
To register one type/format at a time use register_custom_data_type/register_custom_data_format
It employs a special table of types and formats described below:
The 'formats' is a list of tuples. If a tuple has one element then it is the format to be registered with dtid=0 If the tuple has more than one element, then tuple[0] is the data type and tuple[1:] are the data formats. For example: many_formats = [ (pascal_data_type(), pascal_data_format()), (simplevm_data_type(), simplevm_data_format()), (makedword_data_format(),), (simplevm_data_format(),) ] The first two tuples describe data types and their associated formats. The last two tuples describe two data formats to be used with built-in data types. The data format may be attached to several data types. The id of the data format is stored in the first data_format_t object. For example: assert many_formats[1][1] != -1 assert many_formats[2][0] != -1 assert many_formats[3][0] == -1
| "bool" revert_byte | ( | * | args | ) |
| true | byte was patched before and reverted now |
| ea | (C++: ea_t) |
| "flags64_t" seg_flag | ( | * | args | ) |
| "bool" set_cmt | ( | * | args | ) |
| ea | (C++: ea_t) linear address |
| comm | (C++: const char *) comment string
|
| rptble | (C++: bool) is repeatable? |
| "bool" set_forced_operand | ( | * | args | ) |
| ea | (C++: ea_t) linear address |
| n | (C++: int) 0..UA_MAXOP-1 operand number |
| op | (C++: const char *) text of operand
|
| "bool" set_immd | ( | * | args | ) |
Returns true if the FF_IMMD bit was not set and now is set
| ea | (C++: ea_t) |
| "bool" set_lzero | ( | * | args | ) |
This function changes the display of leading zeroes for the specified operand. If the default is not to display leading zeroes, this function will display them and vice versa.
| ea | (C++: ea_t) the item (insn/data) address |
| n | (C++: int) the operand number (0-first operand, 1-other operands) |
| "void" set_manual_insn | ( | * | args | ) |
| ea | (C++: ea_t) linear address of the instruction or data item |
| manual_insn | (C++: const char *) "" - delete manual string. nullptr - do nothing |
| "bool" set_op_type | ( | * | args | ) |
| ea | (C++: ea_t) linear address |
| type | (C++: flags64_t) new flag value (should be obtained from char_flag(), num_flag() and similar functions) |
| n | (C++: int) 0..UA_MAXOP-1 operand number, OPND_ALL all operands |
| 1 | ok |
| 0 | failed (applied to a tail byte) |
| "bool" set_opinfo | ( | * | args | ) |
This function is a low level one. Only the kernel should use it.
| ea | (C++: ea_t) linear address of the item |
| n | (C++: int) number of operand, 0 or 1 (see the note below) |
| flag | (C++: flags64_t) flags of the item |
| ti | (C++: const opinfo_t *) additional representation information |
| suppress_events | (C++: bool) do not generate changing_op_type and op_type_changed events |
| "flags64_t" stkvar_flag | ( | * | args | ) |
| "flags64_t" strlit_flag | ( | * | args | ) |
| "flags64_t" stroff_flag | ( | * | args | ) |
| "flags64_t" stru_flag | ( | * | args | ) |
| "flags64_t" tbyte_flag | ( | * | args | ) |
| "bool" toggle_bnot | ( | * | args | ) |
also see is_bnot()
| ea | (C++: ea_t) |
| n | (C++: int) |
| "bool" toggle_lzero | ( | * | args | ) |
| ea | (C++: ea_t) the item (insn/data) address |
| n | (C++: int) the operand number (0-first operand, 1-other operands) |
| "bool" toggle_sign | ( | * | args | ) |
allowed values of n: 0-first operand, 1-other operands
| ea | (C++: ea_t) |
| n | (C++: int) |
| "bool" unregister_custom_data_format | ( | * | args | ) |
| dfid | data format id |
| "bool" unregister_custom_data_type | ( | * | args | ) |
| dtid | the data type id |
| unregister_data_types_and_formats | ( | formats | ) |
| "bool" update_hidden_range | ( | * | args | ) |
You cannot use this function to change the range boundaries
| ha | (C++: const hidden_range_t *) range to update |
| "ea_t" use_mapping | ( | * | args | ) |
| ea | (C++: ea_t) address to translate |
| "int" visit_patched_bytes | ( | * | args | ) |
| ea1 | start address |
| ea2 | end address |
| py_callable | a Python callable with the following prototype: callable(ea, fpos, org_val, patch_val). If the callable returns non-zero then that value will be returned to the caller and the enumeration will be interrupted. |
| "flags64_t" word_flag | ( | * | args | ) |
| "flags64_t" yword_flag | ( | * | args | ) |
| "flags64_t" zword_flag | ( | * | args | ) |
| ALOPT_APPEND = _ida_bytes.ALOPT_APPEND |
| ALOPT_IGNCLT = _ida_bytes.ALOPT_IGNCLT |
| ALOPT_IGNHEADS = _ida_bytes.ALOPT_IGNHEADS |
| ALOPT_IGNPRINT = _ida_bytes.ALOPT_IGNPRINT |
| ALOPT_MAX4K = _ida_bytes.ALOPT_MAX4K |
| ALOPT_ONLYTERM = _ida_bytes.ALOPT_ONLYTERM |
| BIN_SEARCH_BACKWARD = _ida_bytes.BIN_SEARCH_BACKWARD |
| BIN_SEARCH_BITMASK = _ida_bytes.BIN_SEARCH_BITMASK |
| BIN_SEARCH_CASE = _ida_bytes.BIN_SEARCH_CASE |
| BIN_SEARCH_FORWARD = _ida_bytes.BIN_SEARCH_FORWARD |
| BIN_SEARCH_INITED = _ida_bytes.BIN_SEARCH_INITED |
| BIN_SEARCH_NOBREAK = _ida_bytes.BIN_SEARCH_NOBREAK |
| BIN_SEARCH_NOCASE = _ida_bytes.BIN_SEARCH_NOCASE |
| BIN_SEARCH_NOSHOW = _ida_bytes.BIN_SEARCH_NOSHOW |
| DELIT_DELNAMES = _ida_bytes.DELIT_DELNAMES |
| DELIT_EXPAND = _ida_bytes.DELIT_EXPAND |
| DELIT_KEEPFUNC = _ida_bytes.DELIT_KEEPFUNC |
| DELIT_NOCMT = _ida_bytes.DELIT_NOCMT |
| DELIT_NOTRUNC = _ida_bytes.DELIT_NOTRUNC |
| DELIT_NOUNAME = _ida_bytes.DELIT_NOUNAME |
| DELIT_SIMPLE = _ida_bytes.DELIT_SIMPLE |
| DT_TYPE = _ida_bytes.DT_TYPE |
| int DTP_NODUP = _ida_bytes.DTP_NODUP |
| FF_0CHAR = _ida_bytes.FF_0CHAR |
| FF_0CUST = _ida_bytes.FF_0CUST |
| FF_0ENUM = _ida_bytes.FF_0ENUM |
| FF_0FLT = _ida_bytes.FF_0FLT |
| FF_0FOP = _ida_bytes.FF_0FOP |
| FF_0NUMB = _ida_bytes.FF_0NUMB |
| FF_0NUMD = _ida_bytes.FF_0NUMD |
| FF_0NUMH = _ida_bytes.FF_0NUMH |
| FF_0NUMO = _ida_bytes.FF_0NUMO |
| FF_0OFF = _ida_bytes.FF_0OFF |
| FF_0SEG = _ida_bytes.FF_0SEG |
| FF_0STK = _ida_bytes.FF_0STK |
| FF_0STRO = _ida_bytes.FF_0STRO |
| FF_0VOID = _ida_bytes.FF_0VOID |
| FF_1CHAR = _ida_bytes.FF_1CHAR |
| FF_1CUST = _ida_bytes.FF_1CUST |
| FF_1ENUM = _ida_bytes.FF_1ENUM |
| FF_1FLT = _ida_bytes.FF_1FLT |
| FF_1FOP = _ida_bytes.FF_1FOP |
| FF_1NUMB = _ida_bytes.FF_1NUMB |
| FF_1NUMD = _ida_bytes.FF_1NUMD |
| FF_1NUMH = _ida_bytes.FF_1NUMH |
| FF_1NUMO = _ida_bytes.FF_1NUMO |
| FF_1OFF = _ida_bytes.FF_1OFF |
| FF_1SEG = _ida_bytes.FF_1SEG |
| FF_1STK = _ida_bytes.FF_1STK |
| FF_1STRO = _ida_bytes.FF_1STRO |
| FF_1VOID = _ida_bytes.FF_1VOID |
| FF_ALIGN = _ida_bytes.FF_ALIGN |
| FF_ANYNAME = _ida_bytes.FF_ANYNAME |
| FF_BNOT = _ida_bytes.FF_BNOT |
| FF_BYTE = _ida_bytes.FF_BYTE |
| FF_CODE = _ida_bytes.FF_CODE |
| FF_COMM = _ida_bytes.FF_COMM |
| FF_CUSTOM = _ida_bytes.FF_CUSTOM |
| FF_DATA = _ida_bytes.FF_DATA |
| FF_DOUBLE = _ida_bytes.FF_DOUBLE |
| FF_DWORD = _ida_bytes.FF_DWORD |
| FF_FLOAT = _ida_bytes.FF_FLOAT |
| FF_FLOW = _ida_bytes.FF_FLOW |
| FF_FUNC = _ida_bytes.FF_FUNC |
| FF_IMMD = _ida_bytes.FF_IMMD |
| FF_IVL = _ida_bytes.FF_IVL |
| FF_JUMP = _ida_bytes.FF_JUMP |
| FF_LABL = _ida_bytes.FF_LABL |
| FF_LINE = _ida_bytes.FF_LINE |
| FF_N_CHAR = _ida_bytes.FF_N_CHAR |
| FF_N_CUST = _ida_bytes.FF_N_CUST |
| FF_N_ENUM = _ida_bytes.FF_N_ENUM |
| FF_N_FLT = _ida_bytes.FF_N_FLT |
| FF_N_FOP = _ida_bytes.FF_N_FOP |
| FF_N_NUMB = _ida_bytes.FF_N_NUMB |
| FF_N_NUMD = _ida_bytes.FF_N_NUMD |
| FF_N_NUMH = _ida_bytes.FF_N_NUMH |
| FF_N_NUMO = _ida_bytes.FF_N_NUMO |
| FF_N_OFF = _ida_bytes.FF_N_OFF |
| FF_N_SEG = _ida_bytes.FF_N_SEG |
| FF_N_STK = _ida_bytes.FF_N_STK |
| FF_N_STRO = _ida_bytes.FF_N_STRO |
| FF_N_VOID = _ida_bytes.FF_N_VOID |
| FF_NAME = _ida_bytes.FF_NAME |
| FF_OWORD = _ida_bytes.FF_OWORD |
| FF_PACKREAL = _ida_bytes.FF_PACKREAL |
| FF_QWORD = _ida_bytes.FF_QWORD |
| FF_REF = _ida_bytes.FF_REF |
| FF_SIGN = _ida_bytes.FF_SIGN |
| FF_STRLIT = _ida_bytes.FF_STRLIT |
| FF_STRUCT = _ida_bytes.FF_STRUCT |
| FF_TAIL = _ida_bytes.FF_TAIL |
| FF_TBYTE = _ida_bytes.FF_TBYTE |
| FF_UNK = _ida_bytes.FF_UNK |
| FF_UNUSED = _ida_bytes.FF_UNUSED |
| FF_WORD = _ida_bytes.FF_WORD |
| FF_YWORD = _ida_bytes.FF_YWORD |
| FF_ZWORD = _ida_bytes.FF_ZWORD |
| GFE_IDB_VALUE = _ida_bytes.GFE_IDB_VALUE |
| GFE_VALUE = _ida_bytes.GFE_VALUE |
| GMB_READALL = _ida_bytes.GMB_READALL |
| GMB_WAITBOX = _ida_bytes.GMB_WAITBOX |
| ITEM_END_CANCEL = _ida_bytes.ITEM_END_CANCEL |
| ITEM_END_FIXUP = _ida_bytes.ITEM_END_FIXUP |
| ITEM_END_INITED = _ida_bytes.ITEM_END_INITED |
| ITEM_END_NAME = _ida_bytes.ITEM_END_NAME |
| ITEM_END_XREF = _ida_bytes.ITEM_END_XREF |
| MS_0TYPE = _ida_bytes.MS_0TYPE |
| MS_1TYPE = _ida_bytes.MS_1TYPE |
| MS_CLS = _ida_bytes.MS_CLS |
| MS_CODE = _ida_bytes.MS_CODE |
| MS_COMM = _ida_bytes.MS_COMM |
| MS_N_TYPE = _ida_bytes.MS_N_TYPE |
| MS_VAL = _ida_bytes.MS_VAL |
| OPND_ALL = _ida_bytes.OPND_ALL |
| OPND_MASK = _ida_bytes.OPND_MASK |
| OPND_OUTER = _ida_bytes.OPND_OUTER |
| PBSENC_ALL = _ida_bytes.PBSENC_ALL |
| PBSENC_DEF1BPU = _ida_bytes.PBSENC_DEF1BPU |
| PSTF_ATTRIB = _ida_bytes.PSTF_ATTRIB |
| PSTF_ENC = _ida_bytes.PSTF_ENC |
| PSTF_HOTKEY = _ida_bytes.PSTF_HOTKEY |
| PSTF_ONLY_ENC = _ida_bytes.PSTF_ONLY_ENC |
| PSTF_TBRIEF = _ida_bytes.PSTF_TBRIEF |
| PSTF_TINLIN = _ida_bytes.PSTF_TINLIN |
| PSTF_TMASK = _ida_bytes.PSTF_TMASK |
| PSTF_TNORM = _ida_bytes.PSTF_TNORM |
| STRCONV_ESCAPE = _ida_bytes.STRCONV_ESCAPE |
| STRCONV_INCLLEN = _ida_bytes.STRCONV_INCLLEN |
| STRCONV_REPLCHAR = _ida_bytes.STRCONV_REPLCHAR |
1.12.0