|
| "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.
|
| |
1.12.0