IDA SDK

- Main Page
- Header Files
- Classes
- Modules

- File List
- File Members

Classes | Functions | Macros | Typedefs | Variables
bytes.hpp File Reference

## Detailed Description

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
struct | data_type_t
| Information about a data type. More...
struct | data_format_t
| Information about a data format. More...
struct | hidden_area_t
| Hidden areas - address ranges which can be replaced by their descriptions. More...

## Functions
idaman error_t ida_export | enable_flags (ea_t startEA, ea_t endEA, storage_type_t stt)
| Allocate flags for address range. More...
idaman error_t ida_export | disable_flags (ea_t startEA, ea_t endEA)
| Deallocate flags for address range. More...
idaman error_t ida_export | change_storage_type (ea_t startEA, ea_t endEA, storage_type_t stt)
| Change flag storage type for address range. More...
idaman ea_t ida_export | nextaddr (ea_t ea)
| Get next address in the program (i.e. More...
idaman ea_t ida_export | prevaddr (ea_t ea)
| Get previous address in the program. More...
idaman ea_t ida_export | nextchunk (ea_t ea)
| Get the first address of next contiguous chunk in the program. More...
idaman ea_t ida_export | prevchunk (ea_t ea)
| Get the last address of previous contiguous chunk in the program. More...
idaman ea_t ida_export | chunkstart (ea_t ea)
| Get start of the contiguous address block containing 'ea'. More...
idaman asize_t ida_export | chunksize (ea_t ea)
| Get size of the contiguous address block containing 'ea'. More...
idaman ea_t ida_export | freechunk (ea_t bottom, asize_t size, int32 step)
| Search for a hole in the addressing space of the program. More...
idaman ea_t ida_export | nextthat (ea_t ea, ea_t maxea, testf_t *testf, void *ud)
| Find next address with a flag satisfying the function 'testf'. More...
ea_t idaapi | next_unknown (ea_t ea, ea_t maxea)
| Similar to nextthat(), but will find the next address that is unexplored.
idaman ea_t ida_export | prevthat (ea_t ea, ea_t minea, testf_t *testf, void *ud)
| Find previous address with a flag satisfying the function 'testf'. More...
ea_t idaapi | prev_unknown (ea_t ea, ea_t minea)
| Similar to prevthat(), but will find the previous address that is unexplored.
idaman ea_t ida_export | prev_head (ea_t ea, ea_t minea)
| Get start of previous defined item. More...
idaman ea_t ida_export | next_head (ea_t ea, ea_t maxea)
| Get start of next defined item. More...
idaman ea_t ida_export | prev_not_tail (ea_t ea)
| Get address of previous non-tail byte. More...
idaman ea_t ida_export | next_not_tail (ea_t ea)
| Get address of next non-tail byte. More...
ea_t | adjust_visea (ea_t ea)
| Adjust the address and get the nearest visible address. More...
idaman ea_t ida_export | prev_visea (ea_t ea)
| Get previous visible address. More...
idaman ea_t ida_export | next_visea (ea_t ea)
| Get next visible address. More...
bool | is_first_visea (ea_t ea)
| Is an address the first visible address?
bool | is_last_visea (ea_t ea)
| Is an address the last visible address?
bool | is_visible_finally (ea_t ea)
| Is the address visible on the screen (not hidden)?
ea_t idaapi | get_item_head (ea_t ea)
| Get the start address of the item at 'ea'. More...
idaman ea_t ida_export | get_item_end (ea_t ea)
| Get the end address of the item at 'ea'. More...
idaman ea_t ida_export | calc_max_item_end (ea_t ea, int how=15)
| Calculate maximal reasonable end address of a new item. More...
asize_t | get_item_size (ea_t ea)
| Get size of item (instruction/data) in bytes. More...
void | flush_flags (void)
| Flush virtual array to disk.
idaman bool ida_export | isEnabled (ea_t ea)
| Is the specified address 'ea' present in the program?
idaman flags_t ida_export | get_flags_ex (ea_t ea, int how)
| Get flags for the specified address, extended form.
flags_t idaapi | get_flags_novalue (ea_t ea)
| get flags without FF_IVL & MS_VAL. More...
flags_t idaapi | getFlags (ea_t ea)
| Get flags value for address 'ea'. More...
idaman flags_t ida_export | get_item_flag (ea_t from, int n, ea_t ea, bool appzero)
| Get flag of the item at 'ea' even if it is a tail byte of some array or structure. More...
idaman void ida_export | setFlags (ea_t ea, flags_t flags)
| Modify flags value for address 'ea' (ONLY KERNEL MAY USE THIS FUNCTION!). More...
idaman bool ida_export | setFlbits (ea_t EA, flags_t bits)
| Set the specified bits of flags (ONLY KERNEL MAY USE THIS FUNCTION!). More...
idaman bool ida_export | clrFlbits (ea_t EA, flags_t bits)
| Clear the specified bits of flags (ONLY KERNEL MAY USE THIS FUNCTION!). More...
bool idaapi | hasValue (flags_t F)
| Do flags contain byte value?
idaman void ida_export | delValue (ea_t ea)
| Delete byte value from flags. More...
idaman bool ida_export | isLoaded (ea_t ea)
| Does the specified address have a byte value (is initialized?)
idaman int ida_export | nbits (ea_t ea)
| Get number of bits in a byte at the given address. More...
int | bytesize (ea_t ea)
| Get number of bytes required to store a byte at the given address.
idaman uchar ida_export | get_byte (ea_t ea)
| Get one byte (8-bit) of the program at 'ea'. More...
idaman uchar ida_export | get_db_byte (ea_t ea)
| Get one byte (8-bit) of the program at 'ea' from the database. More...
idaman ushort ida_export | get_word (ea_t ea)
| Get one word (16-bit) of the program at 'ea'. More...
idaman uint32 ida_export | get_3byte (ea_t ea)
| Get one 3byte (24-bit) of the program at 'ea'. More...
idaman uint32 ida_export | get_long (ea_t ea)
| Get one dword (32-bit) of the program at 'ea'. More...
idaman uint64 ida_export | get_qword (ea_t ea)
| Get one qword (64-bit) of the program at 'ea'. More...
idaman uint32 ida_export | get_full_byte (ea_t ea)
| Get one wide byte of the program at 'ea'. More...
idaman uint64 ida_export | get_full_word (ea_t ea)
| Get one wide word (2 'byte') of the program at 'ea'. More...
idaman uint64 ida_export | get_full_long (ea_t ea)
| Get two wide words (4 'bytes') of the program at 'ea'. More...
idaman uchar ida_export | get_8bit (ea_t &ea, uint32 &v, int &nbit)
| Get 8 bits of the program at 'ea'. More...
uchar | get_ascii_char (ea_t &ea, uint32 &v, int &nb)
| Like get_8bit(), but takes into account AS2_BYTE1CHAR.
idaman uint32 ida_export | get_16bit (ea_t ea)
| Get 16bits of the program at 'ea'. More...
idaman uint32 ida_export | get_32bit (ea_t ea)
| Get not more than 32bits of the program at 'ea'. More...
idaman uint64 ida_export | get_64bit (ea_t ea)
| Get not more than 64bits of the program at 'ea'. More...
idaman bool ida_export | get_data_value (ea_t ea, uval_t *v, asize_t size)
| Get the value at of the item at 'ea'. More...
idaman int ida_export | visit_patched_bytes (ea_t ea1, ea_t ea2, int(idaapi *cb)(ea_t ea, int32 fpos, uint32 o, uint32 v, void *ud), void *ud=NULL)
| Visit all the patched bytes one byte at a time. More...
idaman uint32 ida_export | get_original_byte (ea_t ea)
| Get original byte value (that was before patching). More...
idaman uint64 ida_export | get_original_word (ea_t ea)
| Get original word value (that was before patching). More...
idaman uint64 ida_export | get_original_long (ea_t ea)
| Get original long value (that was before patching) This function works for wide byte processors too. More...
idaman uint64 ida_export | get_original_qword (ea_t ea)
| Get original qword value (that was before patching) This function DOESN'T work for wide byte processors too. More...
idaman bool ida_export | put_byte (ea_t ea, uint32 x)
| Set value of one byte of the program. More...
idaman void ida_export | put_word (ea_t ea, uint64 x)
| Set value of one word of the program. More...
idaman void ida_export | put_long (ea_t ea, uint64 x)
| Set value of one dword of the program. More...
idaman void ida_export | put_qword (ea_t ea, uint64 x)
| Set value of one qword (8 bytes) of the program. More...
idaman bool ida_export | patch_byte (ea_t ea, uint32 x)
| Patch a byte of the program. More...
idaman bool ida_export | patch_word (ea_t ea, uint64 x)
| Patch a word of the program. More...
idaman bool ida_export | patch_long (ea_t ea, uint64 x)
| Patch a dword of the program. More...
idaman bool ida_export | patch_qword (ea_t ea, uint64 x)
| Patch a qword of the program. More...
idaman void ida_export | add_byte (ea_t ea, uint32 value)
| Add a value to one byte of the program. More...
idaman void ida_export | add_word (ea_t ea, uint64 value)
| Add a value to one word of the program. More...
idaman void ida_export | add_long (ea_t ea, uint64 value)
| Add a value to one dword of the program. More...
idaman void ida_export | add_qword (ea_t ea, uint64 value)
| Add a value to one qword of the program. More...
idaman bool ida_export | get_zero_areas (areaset_t *zareas, const area_t *range)
| Return set of ranges with zero initialized bytes. More...
idaman int ida_export | get_many_bytes_ex (ea_t ea, void *buf, ssize_t size, void *mask)
| Get the specified number of bytes of the program into the buffer. More...
idaman bool ida_export | get_many_bytes (ea_t ea, void *buf, ssize_t size)
| Get the specified number of bytes of the program into the buffer. More...
idaman void ida_export | put_many_bytes (ea_t ea, const void *buf, size_t size)
| Modify the specified number of bytes of the program. More...
idaman void ida_export | patch_many_bytes (ea_t ea, const void *buf, size_t size)
| Patch the specified number of bytes of the program. More...
bool idaapi | isCode (flags_t F)
| Does flag denote start of an instruction?
bool idaapi | f_isCode (flags_t F, void *)
| Does flag denote start of an instruction? More...
bool idaapi | isData (flags_t F)
| Does flag denote start of data?
bool idaapi | f_isData (flags_t F, void *)
| Does flag denote start of data? More...
bool idaapi | isTail (flags_t F)
| Does flag denote tail byte?
bool idaapi | f_isTail (flags_t F, void *)
| Does flag denote tail byte? More...
bool idaapi | isNotTail (flags_t F)
| Does flag denote tail byte? More...
bool idaapi | f_isNotTail (flags_t F, void *)
| Does flag denote tail byte? More...
bool idaapi | isUnknown (flags_t F)
| Does flag denote unexplored byte?
bool idaapi | isHead (flags_t F)
| Does flag denote start of instruction OR data?
bool idaapi | f_isHead (flags_t F, void *)
| Does flag denote start of instruction OR data? More...
idaman bool ida_export | do_unknown (ea_t ea, int flags)
| Convert item (instruction/data) to unexplored bytes. More...
idaman void ida_export | do_unknown_range (ea_t ea, size_t size, int flags)
| Convert range of addresses to unexplored bytes. More...
idaman bool ida_export | is_manual_insn (ea_t ea)
| Is the instruction overridden? More...
idaman char *ida_export | get_manual_insn (ea_t ea, char *buf, size_t bufsize)
| Retrieve the user-specified string for the manual instruction. More...
idaman void ida_export | set_manual_insn (ea_t ea, const char *manual_insn)
| Set manual instruction string. More...
bool idaapi | isFlow (flags_t F)
| Does the previous instruction exist and pass execution flow to the current byte?
bool idaapi | isVar (flags_t F)
| Is the current byte marked as variable?. More...
bool idaapi | hasExtra (flags_t F)
| Does the current byte have additional anterior or posterior lines?
bool idaapi | has_cmt (flags_t F)
| Does the current byte have an indented comment?
bool idaapi | hasRef (flags_t F)
| Does the current byte have cross-references to it?
bool idaapi | f_hasRef (flags_t f, void *)
| Does the current byte have cross-references to it? More...
bool idaapi | has_name (flags_t F)
| Does the current byte have non-trivial (non-dummy) name?
bool idaapi | f_has_name (flags_t f, void *)
| Does the current byte have non-trivial (non-dummy) name? More...
bool idaapi | has_dummy_name (flags_t F)
| Does the current byte have dummy (auto-generated, with special prefix) name?
bool idaapi | f_has_dummy_name (flags_t f, void *)
| Does the current byte have dummy (auto-generated, with special prefix) name? More...
bool idaapi | has_auto_name (flags_t F)
| Does the current byte have auto-generated (no special prefix) name?
bool idaapi | has_any_name (flags_t F)
| Does the current byte have any name?
bool idaapi | has_user_name (flags_t F)
| Does the current byte have user-specified name?
bool idaapi | f_has_user_name (flags_t F, void *)
| Does the current byte have user-specified name? More...
idaman bool ida_export | is_invsign (ea_t ea, flags_t F, int n)
| Should sign of n-th operand inverted during output?. More...
idaman bool ida_export | toggle_sign (ea_t ea, int n)
| Toggle sign of n-th operand. More...
idaman bool ida_export | is_bnot (ea_t ea, flags_t F, int n)
| Should we negate the operand?. More...
idaman bool ida_export | toggle_bnot (ea_t ea, int n)
| Toggle binary negation of operand. also see is_bnot()
idaman bool ida_export | is_lzero (ea_t ea, int n)
| Display leading zeroes in operands. More...
idaman bool ida_export | set_lzero (ea_t ea, int n)
| Set toggle lzero bit.
idaman bool ida_export | clr_lzero (ea_t ea, int n)
| Clear lzero bit.
bool idaapi | toggle_lzero (ea_t ea, int n)
idaman bool ida_export | leading_zero_important (ea_t ea, int n)
| Check if leading zeroes are important.
idaman void ida_export | doVar (ea_t ea, bool isvar=true)
| Set the variableness of an address. More...
bool idaapi | isDefArg0 (flags_t F)
| Is the first operand defined? Initially operand has no defined representation.
bool idaapi | isDefArg1 (flags_t F)
| Is the second operand defined? Initially operand has no defined representation.
bool idaapi | isOff0 (flags_t F)
| Is the first operand offset? (example: push offset xxx)
bool idaapi | isOff1 (flags_t F)
| Is the second operand offset? (example: mov ax, offset xxx)
bool idaapi | isChar0 (flags_t F)
| Is the first operand character constant? (example: push 'a')
bool idaapi | isChar1 (flags_t F)
| Is the second operand character constant? (example: mov al, 'a')
bool idaapi | isSeg0 (flags_t F)
| Is the first operand segment selector? (example: push seg seg001)
bool idaapi | isSeg1 (flags_t F)
| Is the second operand segment selector? (example: mov dx, seg dseg)
bool idaapi | isEnum0 (flags_t F)
| Is the first operand a symbolic constant (enum member)?
bool idaapi | isEnum1 (flags_t F)
| Is the second operand a symbolic constant (enum member)?
bool idaapi | isStroff0 (flags_t F)
| Is the first operand an offset within a struct?
bool idaapi | isStroff1 (flags_t F)
| Is the second operand an offset within a struct?
bool idaapi | isStkvar0 (flags_t F)
| Is the first operand a stack variable?
bool idaapi | isStkvar1 (flags_t F)
| Is the second operand a stack variable?
bool idaapi | isFloat0 (flags_t F)
| Is the first operand a floating point number?
bool idaapi | isFloat1 (flags_t F)
| Is the second operand a floating point number?
bool idaapi | isCustFmt0 (flags_t F)
| Does the first operand use a custom data representation?
bool idaapi | isCustFmt1 (flags_t F)
| Does the second operand use a custom data representation?
idaman bool ida_export | isNum0 (flags_t F)
| Is the first operand a number (i.e. binary,octal,decimal or hex?)
idaman bool ida_export | isNum1 (flags_t F)
| Is the second operand a number (i.e. binary,octal,decimal or hex?)
flags_t | get_optype_flags0 (flags_t F)
| Get flags for first operand.
flags_t | get_optype_flags1 (flags_t F)
| Get flags for second operand.
idaman bool ida_export | isDefArg (flags_t F, int n)
| is defined?
idaman bool ida_export | isOff (flags_t F, int n)
| is offset?
idaman bool ida_export | isChar (flags_t F, int n)
| is character constant?
idaman bool ida_export | isSeg (flags_t F, int n)
| is segment?
idaman bool ida_export | isEnum (flags_t F, int n)
| is enum?
idaman bool ida_export | isFop (flags_t F, int n)
| is forced operand? (use is_forced_operand())
idaman bool ida_export | isStroff (flags_t F, int n)
| is struct offset?
idaman bool ida_export | isStkvar (flags_t F, int n)
| is stack variable?
idaman bool ida_export | isFltnum (flags_t F, int n)
| is floating point number?
idaman bool ida_export | isCustFmt (flags_t F, int n)
| is custom data format?
idaman bool ida_export | isNum (flags_t F, int n)
| is number (bin,oct,dec,hex)?
idaman bool ida_export | isVoid (ea_t ea, flags_t F, int n)
| is 'void' operand?
idaman bool ida_export | op_adds_xrefs (flags_t F, int n)
| Should processor module create xrefs from the operand?. More...
idaman bool ida_export | set_op_type (ea_t ea, flags_t type, int n)
| (internal function) change representation of operand(s). More...
idaman bool ida_export | op_seg (ea_t ea, int n)
| Set operand representation to be 'segment'. More...
idaman bool ida_export | op_enum (ea_t ea, int n, enum_t id, uchar serial)
| Set operand representation to be 'enum_t'. More...
idaman enum_t ida_export | get_enum_id (ea_t ea, int n, uchar *serial)
| Get enum id of 'enum' operand. More...
idaman bool ida_export | op_stroff (ea_t ea, int n, const tid_t *path, int path_len, adiff_t delta)
| Set operand representation to be 'struct offset'. More...
idaman int ida_export | get_stroff_path (ea_t ea, int n, tid_t *path, adiff_t *delta)
| Get struct path of operand. More...
idaman bool ida_export | op_stkvar (ea_t ea, int n)
| Set operand representation to be 'stack variable'. More...
idaman bool ida_export | set_forced_operand (ea_t ea, int n, const char *op)
| Set forced operand. More...
idaman ssize_t ida_export | get_forced_operand (ea_t ea, int n, char *buf, size_t bufsize)
| Get forced operand. More...
idaman bool ida_export | is_forced_operand (ea_t ea, int n)
| Is operand manually defined?. More...
flags_t idaapi | charflag (void)
| see Bits: instruction operand types
flags_t idaapi | offflag (void)
| see Bits: instruction operand types
flags_t idaapi | enumflag (void)
| see Bits: instruction operand types
flags_t idaapi | stroffflag (void)
| see Bits: instruction operand types
flags_t idaapi | stkvarflag (void)
| see Bits: instruction operand types
flags_t idaapi | fltflag (void)
| see Bits: instruction operand types
flags_t idaapi | custfmtflag (void)
| see Bits: instruction operand types
flags_t idaapi | segflag (void)
| see Bits: instruction operand types
idaman flags_t ida_export | numflag (void)
| Get number of default base (bin,oct,dec,hex)
flags_t idaapi | hexflag (void)
| Get number flag of the base, regardless of current processor - better to use numflag()
flags_t idaapi | decflag (void)
| Get number flag of the base, regardless of current processor - better to use numflag() More...
flags_t idaapi | octflag (void)
| Get number flag of the base, regardless of current processor - better to use numflag() More...
flags_t idaapi | binflag (void)
| Get number flag of the base, regardless of current processor - better to use numflag() More...
bool idaapi | op_chr (ea_t ea, int n)
| set op type to charflag()
bool idaapi | op_num (ea_t ea, int n)
| set op type to numflag()
bool idaapi | op_hex (ea_t ea, int n)
| set op type to hexflag()
bool idaapi | op_dec (ea_t ea, int n)
| set op type to decflag()
bool idaapi | op_oct (ea_t ea, int n)
| set op type to octflag()
bool idaapi | op_bin (ea_t ea, int n)
| set op type to binflag()
bool idaapi | op_flt (ea_t ea, int n)
| set op type to fltflag()
idaman bool ida_export | op_custfmt (ea_t ea, int n, int fid)
| Set custom data format for operand (fid-custom data format id)
idaman bool ida_export | noType (ea_t ea, int n)
| Remove operand representation information. More...
idaman int ida_export | getDefaultRadix (void)
| Get default base of number for the current processor. More...
idaman int ida_export | getRadix (flags_t F, int n)
| Get radix of the operand, in: flags. More...
idaman int ida_export | getRadixEA (ea_t ea, int n)
| Get radix of the operand, in: address. More...
flags_t idaapi | codeflag (void)
| FF_CODE
flags_t idaapi | byteflag (void)
| Get a flags_t representing a byte.
flags_t idaapi | wordflag (void)
| Get a flags_t representing a word.
flags_t idaapi | dwrdflag (void)
| Get a flags_t representing a double word.
flags_t idaapi | qwrdflag (void)
| Get a flags_t representing a quad word.
flags_t idaapi | owrdflag (void)
| Get a flags_t representing a octaword.
flags_t idaapi | ywrdflag (void)
| Get a flags_t representing a ymm word.
flags_t idaapi | zwrdflag (void)
| Get a flags_t representing a zmm word.
flags_t idaapi | tbytflag (void)
| Get a flags_t representing a tbyte.
flags_t idaapi | asciflag (void)
| Get a flags_t representing ascii data.
flags_t idaapi | struflag (void)
| Get a flags_t representing a struct.
flags_t idaapi | custflag (void)
| Get a flags_t representing custom type data.
flags_t idaapi | alignflag (void)
| Get a flags_t representing an alignment directive.
flags_t idaapi | floatflag (void)
| Get a flags_t representing a float.
flags_t idaapi | doubleflag (void)
| Get a flags_t representing a double.
flags_t idaapi | tribyteflag (void)
| Get a flags_t representing 3-byte data.
flags_t idaapi | packrealflag (void)
| Get a flags_t representing a packed decimal real.
bool idaapi | isByte (flags_t F)
| FF_BYTE
bool idaapi | isWord (flags_t F)
| FF_WORD
bool idaapi | isDwrd (flags_t F)
| FF_DWRD
bool idaapi | isQwrd (flags_t F)
| FF_QWRD
bool idaapi | isOwrd (flags_t F)
| FF_OWRD
bool idaapi | isYwrd (flags_t F)
| FF_YWRD
bool idaapi | isZwrd (flags_t F)
| FF_ZWRD
bool idaapi | isTbyt (flags_t F)
| FF_TBYT
bool idaapi | isFloat (flags_t F)
| FF_FLOAT
bool idaapi | isDouble (flags_t F)
| FF_DOUBLE
bool idaapi | isPackReal (flags_t F)
| FF_PACKREAL
bool idaapi | isASCII (flags_t F)
| FF_ASCI
bool idaapi | isStruct (flags_t F)
| FF_STRU
bool idaapi | isAlign (flags_t F)
| FF_ALIGN
bool idaapi | is3byte (flags_t F)
| FF_3BYTE
bool idaapi | isCustom (flags_t F)
| FF_CUSTOM
bool idaapi | f_isByte (flags_t F, void *)
| See isByte()
bool idaapi | f_isWord (flags_t F, void *)
| See isWord()
bool idaapi | f_isDwrd (flags_t F, void *)
| See isDwrd()
bool idaapi | f_isQwrd (flags_t F, void *)
| See isQwrd()
bool idaapi | f_isOwrd (flags_t F, void *)
| See isOwrd()
bool idaapi | f_isYwrd (flags_t F, void *)
| See isYwrd()
bool idaapi | f_isTbyt (flags_t F, void *)
| See isTbyt()
bool idaapi | f_isFloat (flags_t F, void *)
| See isFloat()
bool idaapi | f_isDouble (flags_t F, void *)
| See isDouble()
bool idaapi | f_isPackReal (flags_t F, void *)
| See isPackReal()
bool idaapi | f_isASCII (flags_t F, void *)
| See isASCII()
bool idaapi | f_isStruct (flags_t F, void *)
| See isStruct()
bool idaapi | f_isAlign (flags_t F, void *)
| See isAlign()
bool idaapi | f_is3byte (flags_t F, void *)
| See is3byte()
bool idaapi | f_isCustom (flags_t F, void *)
| See isCustom()
bool idaapi | is_same_data_type (flags_t F1, flags_t F2)
| Do the given flags specify the same data type?
idaman flags_t ida_export | get_flags_by_size (size_t size)
| Get flags from size (in bytes). More...
idaman bool ida_export | do_data_ex (ea_t ea, flags_t dataflag, asize_t size, tid_t tid)
| Convert to data (byte,word,dword,etc). More...
bool idaapi | doByte (ea_t ea, asize_t length)
| Convert to byte.
bool idaapi | doWord (ea_t ea, asize_t length)
| Convert to word.
bool idaapi | doDwrd (ea_t ea, asize_t length)
| Convert to dword.
bool idaapi | doQwrd (ea_t ea, asize_t length)
| Convert to quadword.
bool idaapi | doOwrd (ea_t ea, asize_t length)
| Convert to octaword/xmm word.
bool idaapi | doYwrd (ea_t ea, asize_t length)
| Convert to ymm word.
bool idaapi | doZwrd (ea_t ea, asize_t length)
| Convert to zmm word.
bool idaapi | doTbyt (ea_t ea, asize_t length)
| Convert to tbyte.
bool idaapi | doFloat (ea_t ea, asize_t length)
| Convert to float.
bool idaapi | doDouble (ea_t ea, asize_t length)
| Convert to double.
bool idaapi | doPackReal (ea_t ea, asize_t length)
| Convert to packed decimal real.
bool idaapi | doASCI (ea_t ea, asize_t length)
| Convert to ascii.
bool idaapi | do3byte (ea_t ea, asize_t length)
| Convert to 3-byte data.
bool idaapi | doStruct (ea_t ea, asize_t length, tid_t tid)
| Convert to struct.
bool idaapi | doCustomData (ea_t ea, asize_t length, int dtid, int fid)
| Convert to custom data type.
idaman bool ida_export | doAlign (ea_t ea, asize_t length, int alignment)
| Alignment: 0 or 2..32. If it is 0, is will be calculated.
idaman int ida_export | calc_min_align (asize_t length)
| Returns: 1..32.
idaman int ida_export | calc_max_align (ea_t endea)
| Returns: 0..32.
idaman int ida_export | calc_def_align (ea_t ea, int mina, int maxa)
| Calculate default alignment.
idaman bool ida_export | do16bit (ea_t ea, asize_t length)
| Convert to 16-bit quantity (take byte size into account)
idaman bool ida_export | do32bit (ea_t ea, asize_t length)
| Convert to 32-bit quantity (take byte size into account)
idaman size_t ida_export | get_max_ascii_length (ea_t ea, int32 strtype, int options=0)
| Determine maximum length of ascii string. More...
idaman bool ida_export | get_ascii_contents2 (ea_t ea, size_t len, int32 type, void *buf, size_t bufsize, size_t *usedsize=NULL, int flags=ACFOPT_ASCII)
| Get contents of ascii string. More...
idaman bool ida_export | make_ascii_string (ea_t start, size_t len, int32 strtype)
| Convert to ascii string and give a meaningful name. More...
idaman char *ida_export | print_ascii_string_type (char *buf, size_t bufsize, int32 strtype)
| Print the string type name. More...
idaman opinfo_t *ida_export | get_opinfo (ea_t ea, int n, flags_t flags, opinfo_t *buf)
| Get additional information about an operand representation. More...
idaman bool ida_export | set_opinfo (ea_t ea, int n, flags_t flag, const opinfo_t *ti)
| Set additional information about an operand representation. More...
void | del_one_opinfo (ea_t ea, int n, flags_t flag)
| Delete additional information about an operand representation. More...
void | del_opinfo (ea_t ea, flags_t flag)
| See del_one_opinfo()
idaman asize_t ida_export | get_data_elsize (ea_t ea, flags_t F, const opinfo_t *ti=NULL)
| Get size of data type specified in flags 'F'. More...
asize_t | get_full_data_elsize (ea_t ea, flags_t F, const opinfo_t *ti=NULL)
| Get full size of data type specified in flags 'F'. More...
idaman int ida_export | is_varsize_item (ea_t ea, flags_t F, const opinfo_t *ti=NULL, asize_t *itemsize=NULL)
| Is the item at 'ea' variable size?. More...
idaman bool ida_export | can_define_item (ea_t ea, asize_t length, flags_t flags)
| Can define item (instruction/data) of the specified 'length', starting at 'ea'? More...
bool | doCode (ea_t ea, int length)
| Convert to an instruction. More...
bool idaapi | isImmd (flags_t F)
| Has immediate value?
bool idaapi | isFunc (flags_t F)
| Is function start?
idaman bool ida_export | doImmd (ea_t ea)
| Set 'has immediate operand' flag. More...
idaman bool ida_export | noImmd (ea_t ea)
| Clear 'has immediate operand' flag. More...
idaman int ida_export | register_custom_data_type (const data_type_t *dtinfo)
| Register a new data type. More...
idaman bool ida_export | unregister_custom_data_type (int dtid)
| Unregister a data type. More...
idaman int ida_export | register_custom_data_format (int dtid, const data_format_t *dtform)
| Register a new data format. More...
idaman bool ida_export | unregister_custom_data_format (int dtid, int fid)
| Unregister a data format. More...
idaman const data_type_t *ida_export | get_custom_data_type (int dtid)
| Get definition of a registered custom data type. More...
idaman const data_format_t *ida_export | get_custom_data_format (int dtid, int fid)
| Get definition of a registered custom data format. More...
idaman int ida_export | get_custom_data_types (intvec_t *out, asize_t min_size=0, asize_t max_size=BADADDR)
| Get list of registered custom data type ids. More...
idaman int ida_export | get_custom_data_formats (intvec_t *out, int dtid)
| Get list of registered custom data formats for the specified data type. More...
idaman int ida_export | find_custom_data_type (const char *name)
| Get id of a custom data type. More...
idaman int ida_export | find_custom_data_format (const char *name)
| Get id of a custom data format. More...
idaman bool ida_export | set_cmt (ea_t ea, const char *comm, bool rptble)
| Set an indented comment. More...
idaman ssize_t ida_export | get_cmt (ea_t ea, bool rptble, char *buf, size_t bufsize)
| Get an indented comment. More...
char * | get_repeatable_cmt (ea_t ea)
| Get a repeatable comment of any type (indented or function comment). More...
char * | get_any_indented_cmt (ea_t ea, color_t *cmttype)
| Get any indented comment (regular or repeatable indented or function). More...
idaman bool ida_export | append_cmt (ea_t ea, const char *str, bool rptble)
| Append to an indented comment. More...
idaman ea_t ida_export | find_byte (ea_t sEA, asize_t size, uchar value, int bin_search_flags)
| Find forward a byte with the specified value (only 8-bit value from the database). More...
idaman ea_t ida_export | find_byter (ea_t sEA, asize_t size, uchar value, int bin_search_flags)
| Find reverse a byte with the specified value (only 8-bit value from the database). More...
idaman ea_t ida_export | bin_search (ea_t startEA, ea_t endEA, const uchar *image, const uchar *mask, size_t len, int step, int flags)
| Search for a string in the program. More...
ea_t idaapi | next_inited (ea_t ea, ea_t maxea)
| Find the next initialized address.
ea_t idaapi | prev_inited (ea_t ea, ea_t minea)
| Find the previous initialized address.
idaman bool ida_export | equal_bytes (ea_t ea, const uchar *image, const uchar *mask, size_t len, bool sense_case)
| Compare 'len' bytes of the program starting from 'ea' with 'image'. More...
idaman bool ida_export | add_hidden_area (ea_t ea1, ea_t ea2, const char *description, const char *header, const char *footer, bgcolor_t color)
| Mark a range of addresses as hidden. More...
hidden_area_t *idaapi | get_hidden_area (ea_t ea)
| Get pointer to hidden area structure, in: linear address. More...
hidden_area_t *idaapi | getn_hidden_area (int n)
| Get pointer to hidden area structure, in: number of hidden area. More...
int idaapi | get_hidden_area_qty (void)
| Get number of hidden areas.
int idaapi | get_hidden_area_num (ea_t ea)
| Get number of a hidden area. More...
hidden_area_t *idaapi | get_prev_hidden_area (ea_t ea)
| Get pointer to previous hidden area. More...
hidden_area_t *idaapi | get_next_hidden_area (ea_t ea)
| Get pointer to next hidden area. More...
bool idaapi | del_hidden_area (ea_t ea)
| Delete hidden area. More...
ssize_t | get_hex_string (char *buf, size_t bufsize, const uchar *bytes, size_t len)

## Macros
#define | ITEM_END_FIXUP 0x0001
| stop at the first fixup
#define | ITEM_END_INITED 0x0002
| stop when initialization changes More...
#define | ITEM_END_NAME 0x0004
| stop at the first named location
#define | ITEM_END_XREF 0x0008
| stop at the first referenced location
#define | GFE_NOVALUE 0x0001
| get flags without FF_IVL & MS_VAL. More...
#define | MS_VAL 0x000000FFLU
| Mask for byte value.
#define | FF_IVL 0x00000100LU
| Byte has value ?
#define | MS_CLS 0x00000600LU
| Mask for typing.
#define | FF_CODE 0x00000600LU
| Code ?
#define | FF_DATA 0x00000400LU
| Data ?
#define | FF_TAIL 0x00000200LU
| Tail ?
#define | FF_UNK 0x00000000LU
| Unknown ?
#define | DOUNK_SIMPLE 0x0000
| simply undefine the specified item
#define | DOUNK_EXPAND 0x0001
| propagate undefined items; for example More...
#define | DOUNK_DELNAMES 0x0002
| delete any names at the specified More...
#define | DOUNK_NOTRUNC 0x0004
| don't truncate the current function More...
#define | MS_COMM 0x000FF800LU
| Mask of common bits.
#define | FF_COMM 0x00000800LU
| Has comment ?
#define | FF_REF 0x00001000LU
| has references
#define | FF_LINE 0x00002000LU
| Has next or prev lines ?
#define | FF_NAME 0x00004000LU
| Has name ?
#define | FF_LABL 0x00008000LU
| Has dummy name?
#define | FF_FLOW 0x00010000LU
| Exec flow from prev instruction.
#define | FF_SIGN 0x00020000LU
| Inverted sign of operands.
#define | FF_BNOT 0x00040000LU
| Bitwise negation of operands.
#define | FF_VAR 0x00080000LU
| is variable byte?
#define | FF_ANYNAME (FF_LABL|FF_NAME)
#define | MS_0TYPE 0x00F00000LU
| Mask for 1st arg typing.
#define | FF_0VOID 0x00000000LU
| Void (unknown)?
#define | FF_0NUMH 0x00100000LU
| Hexadecimal number?
#define | FF_0NUMD 0x00200000LU
| Decimal number?
#define | FF_0CHAR 0x00300000LU
| Char ('x')?
#define | FF_0SEG 0x00400000LU
| Segment?
#define | FF_0OFF 0x00500000LU
| Offset?
#define | FF_0NUMB 0x00600000LU
| Binary number?
#define | FF_0NUMO 0x00700000LU
| Octal number?
#define | FF_0ENUM 0x00800000LU
| Enumeration?
#define | FF_0FOP 0x00900000LU
| Forced operand?
#define | FF_0STRO 0x00A00000LU
| Struct offset?
#define | FF_0STK 0x00B00000LU
| Stack variable?
#define | FF_0FLT 0x00C00000LU
| Floating point number?
#define | FF_0CUST 0x00D00000LU
| Custom representation?
#define | MS_1TYPE 0x0F000000LU
| Mask for the type of other operands.
#define | FF_1VOID 0x00000000LU
| Void (unknown)?
#define | FF_1NUMH 0x01000000LU
| Hexadecimal number?
#define | FF_1NUMD 0x02000000LU
| Decimal number?
#define | FF_1CHAR 0x03000000LU
| Char ('x')?
#define | FF_1SEG 0x04000000LU
| Segment?
#define | FF_1OFF 0x05000000LU
| Offset?
#define | FF_1NUMB 0x06000000LU
| Binary number?
#define | FF_1NUMO 0x07000000LU
| Octal number?
#define | FF_1ENUM 0x08000000LU
| Enumeration?
#define | FF_1FOP 0x09000000LU
| Forced operand?
#define | FF_1STRO 0x0A000000LU
| Struct offset?
#define | FF_1STK 0x0B000000LU
| Stack variable?
#define | FF_1FLT 0x0C000000LU
| Floating point number?
#define | FF_1CUST 0x0D000000LU
| Custom representation?
#define | OPND_OUTER 0x80
| outer offset base (combined with operand number). More...
#define | OPND_MASK 0x07
| mask for operand number
#define | OPND_ALL OPND_MASK
| all operands
#define | DT_TYPE 0xF0000000LU
| Mask for DATA typing.
#define | FF_BYTE 0x00000000LU
| byte
#define | FF_WORD 0x10000000LU
| word
#define | FF_DWRD 0x20000000LU
| double word
#define | FF_QWRD 0x30000000LU
| quadro word
#define | FF_TBYT 0x40000000LU
| tbyte
#define | FF_ASCI 0x50000000LU
| ASCII ?
#define | FF_STRU 0x60000000LU
| Struct ?
#define | FF_OWRD 0x70000000LU
| octaword/xmm word (16 bytes/128 bits)
#define | FF_FLOAT 0x80000000LU
| float
#define | FF_DOUBLE 0x90000000LU
| double
#define | FF_PACKREAL 0xA0000000LU
| packed decimal real
#define | FF_ALIGN 0xB0000000LU
| alignment directive
#define | FF_3BYTE 0xC0000000LU
| 3-byte data (only with support from the processor module)
#define | FF_CUSTOM 0xD0000000LU
| custom data type
#define | FF_YWRD 0xE0000000LU
| ymm word (32 bytes/256 bits)
#define | FF_ZWRD 0xF0000000LU
| zmm word (64 bytes/512 bits)
#define | ALOPT_IGNHEADS 0x01
| don't stop if another data item is encountered. More...
#define | ALOPT_IGNPRINT 0x02
| if set, stop only at the terminating character. More...
#define | ACFOPT_ASCII 0x00000000
| convert Unicode strings to ASCII
#define | ACFOPT_UTF16 0x00000001
| return UTF-16 (aka wide-char) array for Unicode strings More...
#define | ACFOPT_UTF8 0x00000002
| convert Unicode strings to UTF-8 More...
#define | ACFOPT_CONVMASK 0x0000000F
#define | ACFOPT_ESCAPE 0x00000010
| convert non-printable characters to C escapes ( , , ) More...
#define | MS_CODE 0xF0000000LU
| Mask for code bits.
#define | FF_FUNC 0x10000000LU
| function start?
#define | FF_IMMD 0x40000000LU
| Has Immediate value ?
#define | FF_JUMP 0x80000000LU
| Has jump table or switch_info?
#define | DTP_NODUP 0x0001
| do not use dup construct
#define | BIN_SEARCH_FORWARD 1
| Search forward for bytes.
#define | BIN_SEARCH_BACKWARD (-1)
| Search backward for bytes.
#define | BIN_SEARCH_CASE 0x01
| case sensitive
#define | BIN_SEARCH_NOCASE 0x00
| case insensitive
#define | BIN_SEARCH_NOBREAK 0x02
| don't check for Ctrl-Break
#define | BIN_SEARCH_INITED 0x04
| find_byte, find_byter: any initilized value
#define | SKIP_FF_MASK ((const uchar *)0xFF)
| Used by equal_bytes() to skip 0xFF when searching the program.

## Typedefs
typedef tid_t | enum_t
typedef bool idaapi | testf_t(flags_t flags, void *ud)
| Flag tester - see nextthat(), prevthat()
typedef qvector< const data_type_t * > | data_types_t
| vector of data types
typedef qvector< const data_format_t * > | data_formats_t
| vector of data formats

## Variables
bool | del_code_comments
| Delete an indented comment attached to an instruction when the instruction is deleted.
idaman areacb_t ida_export_data | hidden_areas

## Macro Definition Documentation

#define GFE_NOVALUE 0x0001

get flags without FF_IVL & MS_VAL.

It is much faster under remote debugging because the kernel does not need to check if the memory is available and readable

## Function Documentation

idaman error_t ida_export enable_flags | ( | ea_t | startEA,
|  | ea_t | endEA,
|  | storage_type_t | stt
| ) |  |

Allocate flags for address range.

This function does not change the storage type of existing ranges. Exit with an error message if not enough disk space.

Parameters

  startEA | should be lower than endEA.
  endEA | does not belong to the range.
  stt | storage_type_t

Returns
  0 if ok, otherwise an error code

idaman error_t ida_export disable_flags | ( | ea_t | startEA,
|  | ea_t | endEA
| ) |  |

Deallocate flags for address range.

Exit with an error message if not enough disk space (this may occur too).

Parameters

  startEA | should be lower than endEA.
  endEA | does not belong to the range.

Returns
  0 if ok, otherwise return error code

idaman error_t ida_export change_storage_type | ( | ea_t | startEA,
|  | ea_t | endEA,
|  | storage_type_t | stt
| ) |  |

Change flag storage type for address range.

Parameters

  startEA | should be lower than endEA.
  endEA | does not belong to the range.
  stt | storage_type_t

Returns
  error code

idaman ea_t ida_export nextaddr | ( | ea_t | ea | ) |

Get next address in the program (i.e.

next address which has flags).

Returns
  BADADDR if no such address exist.

idaman ea_t ida_export prevaddr | ( | ea_t | ea | ) |

Get previous address in the program.

Returns
  BADADDR if no such address exist.

idaman ea_t ida_export nextchunk | ( | ea_t | ea | ) |

Get the first address of next contiguous chunk in the program.

Returns
  BADADDR if next chunk doesn't exist.

idaman ea_t ida_export prevchunk | ( | ea_t | ea | ) |

Get the last address of previous contiguous chunk in the program.

Returns
  BADADDR if previous chunk doesn't exist.

idaman ea_t ida_export chunkstart | ( | ea_t | ea | ) |

Get start of the contiguous address block containing 'ea'.

Returns
  BADADDR if 'ea' doesn't belong to the program.

idaman asize_t ida_export chunksize | ( | ea_t | ea | ) |

Get size of the contiguous address block containing 'ea'.

Returns
  0 if 'ea' doesn't belong to the program.

idaman ea_t ida_export freechunk | ( | ea_t | bottom,
|  | asize_t | size,
|  | int32 | step
| ) |  |

Search for a hole in the addressing space of the program.

Parameters

  bottom | address to start searching
  size | size of desired block
  step | bit mask for the start of hole (0xF would align hole to a paragraph). if 'step' is negative, the bottom address with be aligned. otherwise the kernel will try to use it as is and align it only when the hole is too small.

Returns
  start of the hole or BADADDR

idaman ea_t ida_export nextthat | ( | ea_t | ea,
|  | ea_t | maxea,
|  | testf_t * | testf,
|  | void * | ud
| ) |  |

Find next address with a flag satisfying the function 'testf'.

Note
  do not pass f_isUnknown() to this function to find unexplored bytes. It will fail under the debugger. To find unexplored bytes, use next_unknown().

Parameters

  ea | start searching at this address + 1
  maxea | not included in the search range.
  ud | user data - may point to anything. it will be passed to testf.

Returns
  the found address or BADADDR.

idaman ea_t ida_export prevthat | ( | ea_t | ea,
|  | ea_t | minea,
|  | testf_t * | testf,
|  | void * | ud
| ) |  |

Find previous address with a flag satisfying the function 'testf'.

Note
  do not pass f_isUnknown() to this function to find unexplored bytes It will fail under the debugger. To find unexplored bytes, use prev_unknown().

Parameters

  ea | start searching from this address - 1.
  minea | included in the search range.
  ud | user data - may point to anything. it will be passed to testf.

Returns
  the found address or BADADDR.

idaman ea_t ida_export prev_head | ( | ea_t | ea,
|  | ea_t | minea
| ) |  |

Get start of previous defined item.

Parameters

  ea | begin search at this address
  minea | included in the search range

Returns
  BADADDR if none exists.

idaman ea_t ida_export next_head | ( | ea_t | ea,
|  | ea_t | maxea
| ) |  |

Get start of next defined item.

Parameters

  ea | begin search at this address
  maxea | not included in the search range

Returns
  BADADDR if none exists.

idaman ea_t ida_export prev_not_tail | ( | ea_t | ea | ) |

Get address of previous non-tail byte.

Returns
  BADADDR if none exists.

idaman ea_t ida_export next_not_tail | ( | ea_t | ea | ) |

Get address of next non-tail byte.

Returns
  BADADDR if none exists.

ea_t adjust_visea | ( | ea_t | ea | ) |

Adjust the address and get the nearest visible address.

(i.e. an address which will appear in the disassembly)

Returns
  BADADDR only if no addresses are valid

idaman ea_t ida_export prev_visea | ( | ea_t | ea | ) |

Get previous visible address.

Returns
  BADADDR if none exists.

idaman ea_t ida_export next_visea | ( | ea_t | ea | ) |

Get next visible address.

Returns
  BADADDR if none exists.

ea_t idaapi get_item_head | ( | ea_t | ea | ) |
| inline

Get the start address of the item at 'ea'.

If there is no current item, then 'ea' will be returned (see definition at the end of bytes.hpp source)

idaman ea_t ida_export get_item_end | ( | ea_t | ea | ) |

Get the end address of the item at 'ea'.

The returned address doesn't belong to the current item. Unexplored bytes are counted as 1 byte entities.

idaman ea_t ida_export calc_max_item_end | ( | ea_t | ea,
|  | int | how = `15`
| ) |  |

Calculate maximal reasonable end address of a new item.

This function will limit the item with the current segment bounds.

Parameters

  ea | linear address
  how | when to stop the search. A combination of Item end search flags

Returns
  end of new item. If it is not possible to create an item, it will return 'ea'.

asize_t get_item_size | ( | ea_t | ea | ) |
| inline

Get size of item (instruction/data) in bytes.

Unexplored bytes have length of 1 byte. This function never returns 0.

flags_t idaapi get_flags_novalue | ( | ea_t | ea | ) |
| inline

get flags without FF_IVL & MS_VAL.

It is much faster under remote debugging because the kernel does not need to check if the memory is available and readable

flags_t idaapi getFlags | ( | ea_t | ea | ) |
| inline

Get flags value for address 'ea'.

Returns
  0 if address is not present in the program

idaman flags_t ida_export get_item_flag | ( | ea_t | from,
|  | int | n,
|  | ea_t | ea,
|  | bool | appzero
| ) |  |

Get flag of the item at 'ea' even if it is a tail byte of some array or structure.

This function is used to get flags of structure members or array elements.

Parameters

  from | linear address of the instruction which refers to 'ea'
  n | number of operand which refers to 'ea'
  ea | the referenced address
  appzero | append a struct field name if the field offset is zero? meaningful only if the name refers to a structure.

Returns
  flags or 0 (if failed)

idaman void ida_export setFlags | ( | ea_t | ea,
|  | flags_t | flags
| ) |  |

Modify flags value for address 'ea' (ONLY KERNEL MAY USE THIS FUNCTION!).

This function never changes FF_IVL and MS_VAL fields

idaman bool ida_export setFlbits | ( | ea_t | EA,
|  | flags_t | bits
| ) |  |

Set the specified bits of flags (ONLY KERNEL MAY USE THIS FUNCTION!).

This function never changes FF_IVL and MS_VAL fields

Returns
  true if any new bits have been set

idaman bool ida_export clrFlbits | ( | ea_t | EA,
|  | flags_t | bits
| ) |  |

Clear the specified bits of flags (ONLY KERNEL MAY USE THIS FUNCTION!).

This function never changes FF_IVL and MS_VAL fields

Returns
  true if any new bits have been cleared

idaman void ida_export delValue | ( | ea_t | ea | ) |

Delete byte value from flags.

The corresponding byte becomes uninitialized.

idaman int ida_export nbits | ( | ea_t | ea | ) |

Get number of bits in a byte at the given address.

Returns
  processor_t::dnbits() if the address doesn't belong to a segment, otherwise the result depends on the segment type

idaman uchar ida_export get_byte | ( | ea_t | ea | ) |

Get one byte (8-bit) of the program at 'ea'.

This function works only for 8bit byte processors.

idaman uchar ida_export get_db_byte | ( | ea_t | ea | ) |

Get one byte (8-bit) of the program at 'ea' from the database.

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.

idaman ushort ida_export get_word | ( | ea_t | ea | ) |

Get one word (16-bit) of the program at 'ea'.

This function takes into account order of bytes specified in idainfo::mf This function works only for 8bit byte processors.

idaman uint32 ida_export get_3byte | ( | ea_t | ea | ) |

Get one 3byte (24-bit) of the program at 'ea'.

This function takes into account order of bytes specified in idainfo::tribyte_order This function works only for 8bit byte processors.

idaman uint32 ida_export get_long | ( | ea_t | ea | ) |

Get one dword (32-bit) of the program at 'ea'.

This function takes into account order of bytes specified in idainfo::mf This function works only for 8bit byte processors.

idaman uint64 ida_export get_qword | ( | ea_t | ea | ) |

Get one qword (64-bit) of the program at 'ea'.

This function takes into account order of bytes specified in idainfo::mf This function works only for 8bit byte processors.

idaman uint32 ida_export get_full_byte | ( | ea_t | ea | ) |

Get one wide byte of the program at 'ea'.

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.

idaman uint64 ida_export get_full_word | ( | ea_t | ea | ) |

Get one wide word (2 'byte') of the program at 'ea'.

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::mf

idaman uint64 ida_export get_full_long | ( | ea_t | ea | ) |

Get two wide words (4 'bytes') of the program at 'ea'.

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::mf

Note
  this function works incorrectly if processor_t::nbits > 16

idaman uchar ida_export get_8bit | ( | ea_t & | ea,
|  | uint32 & | v,
|  | int & | nbit
| ) |  |

Get 8 bits of the program at 'ea'.

The main usage of this function is to iterate range of bytes. Here is an example:

1 uint32 v;
2 int nbit = 0;
3 for ( .... ) {
4 uchar byte = get_8bit(ea,v,nbit);
5 ...
6 }

'ea' is incremented each time when a new byte is read. In the above example, it will be incremented in the first loop iteration.

idaman uint32 ida_export get_16bit | ( | ea_t | ea | ) |

Get 16bits of the program at 'ea'.

Returns
  1 byte (getFullByte()) if the current processor has 16-bit byte, otherwise return get_word()

idaman uint32 ida_export get_32bit | ( | ea_t | ea | ) |

Get not more than 32bits of the program at 'ea'.

Returns
  32 bit value, depending on processor_t::nbits:
  - if ( nbits <= 8 ) return get_long(ea);
  - if ( nbits <= 16) return get_full_word(ea);
  - return get_full_byte(ea);

idaman uint64 ida_export get_64bit | ( | ea_t | ea | ) |

Get not more than 64bits of the program at 'ea'.

Returns
  64 bit value, depending on processor_t::nbits:
  - if ( nbits <= 8 ) return get_qword(ea);
  - if ( nbits <= 16) return get_full_long(ea);
  - return get_full_byte(ea);

idaman bool ida_export get_data_value | ( | ea_t | ea,
|  | uval_t * | v,
|  | asize_t | size
| ) |  |

Get the value at of the item at 'ea'.

This function works with entities up to sizeof(ea_t) (bytes, word, etc)

Parameters

  ea | linear address
  v | pointer to the result. may be NULL
  size | size of data to read. If 0, then the item type at 'ea' will be used

Returns
  success

idaman int ida_export visit_patched_bytes | ( | ea_t | ea1,
|  | ea_t | ea2,
|  | int(idaapi *)(ea_t ea, int32 fpos, uint32 o, uint32 v, void *ud) | cb,
|  | void * | ud = `NULL`
| ) |  |

Visit all the patched bytes one byte at a time.

Parameters

  ea1 | start linear address
  ea2 | end linear address
  cb | callback called for each found byte. if the callback returns non-zero then that value will be returned to the caller and the enumeration will be interrupted.
  ud | user data passed to the callback

Returns
  the return value returned by the callback (if any) or zero if the enumeration was completed.

idaman uint32 ida_export get_original_byte | ( | ea_t | ea | ) |

Get original byte value (that was before patching).

This function works for wide byte processors too.

idaman uint64 ida_export get_original_word | ( | ea_t | ea | ) |

Get original word value (that was before patching).

This function works for wide byte processors too. This function takes into account order of bytes specified in idainfo::mf

idaman uint64 ida_export get_original_long | ( | ea_t | ea | ) |

Get original long value (that was before patching) This function works for wide byte processors too.

This function takes into account order of bytes specified in idainfo::mf

idaman uint64 ida_export get_original_qword | ( | ea_t | ea | ) |

Get original qword value (that was before patching) This function DOESN'T work for wide byte processors too.

This function takes into account order of bytes specified in idainfo::mf

idaman bool ida_export put_byte | ( | ea_t | ea,
|  | uint32 | x
| ) |  |

Set value of one byte of the program.

This function modifies the database. If the debugger is active then the debugged process memory is patched too.

Note
  The original value of the byte is completely lost and can't be recovered by the get_original_byte() function. See also put_dbg_byte() to write to the process memory directly when the debugger is active. This function can handle wide byte processors.

Parameters

  ea | linear address
  x | byte value

Returns
  true if the database has been modified

idaman void ida_export put_word | ( | ea_t | ea,
|  | uint64 | x
| ) |  |

Set value of one word of the program.

This function takes into account order of bytes specified in idainfo::mf This function works for wide byte processors too.

Note
  The original value of the word is completely lost and can't be recovered by the get_original_word() function. ea - linear address x - word value

idaman void ida_export put_long | ( | ea_t | ea,
|  | uint64 | x
| ) |  |

Set value of one dword of the program.

This function takes into account order of bytes specified in idainfo::mf This function works for wide byte processors too.

Parameters

  ea | linear address
  x | dword value

Note
  the original value of the dword is completely lost and can't be recovered by the get_original_long() function.

idaman void ida_export put_qword | ( | ea_t | ea,
|  | uint64 | x
| ) |  |

Set value of one qword (8 bytes) of the program.

This function takes into account order of bytes specified in idainfo::mf This function DOESN'T works for wide byte processors.

Parameters

  ea | linear address
  x | qword value

idaman bool ida_export patch_byte | ( | ea_t | ea,
|  | uint32 | x
| ) |  |

Patch a byte of the program.

The original value of the byte is saved and can be obtained by get_original_byte(). This function works for wide byte processors too.

Return values

  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.

idaman bool ida_export patch_word | ( | ea_t | ea,
|  | uint64 | x
| ) |  |

Patch a word of the program.

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::mf

Return values

  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.

idaman bool ida_export patch_long | ( | ea_t | ea,
|  | uint64 | x
| ) |  |

Patch a dword of the program.

The original value of the dword is saved and can be obtained by get_original_long(). This function DOESN'T work for wide byte processors. This function takes into account order of bytes specified in idainfo::mf

Return values

  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.

idaman bool ida_export patch_qword | ( | ea_t | ea,
|  | uint64 | x
| ) |  |

Patch a qword of the program.

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::mf

Return values

  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.

idaman void ida_export add_byte | ( | ea_t | ea,
|  | uint32 | value
| ) |  |

Add a value to one byte of the program.

This function works for wide byte processors too.

Parameters

  ea | linear address
  value | byte value

idaman void ida_export add_word | ( | ea_t | ea,
|  | uint64 | value
| ) |  |

Add a value to one word of the program.

This function works for wide byte processors too. This function takes into account order of bytes specified in idainfo::mf

Parameters

  ea | linear address
  value | byte value

idaman void ida_export add_long | ( | ea_t | ea,
|  | uint64 | value
| ) |  |

Add a value to one dword of the program.

This function works for wide byte processors too. This function takes into account order of bytes specified in idainfo::mf

Note
  this function works incorrectly if processor_t::nbits > 16

Parameters

  ea | linear address
  value | byte value

idaman void ida_export add_qword | ( | ea_t | ea,
|  | uint64 | value
| ) |  |

Add a value to one qword of the program.

This function does not work for wide byte processors. This function takes into account order of bytes specified in idainfo::mf

Parameters

  ea | linear address
  value | byte value

idaman bool ida_export get_zero_areas | ( | areaset_t * | zareas,
|  | const area_t * | range
| ) |  |

Return set of ranges with zero initialized bytes.

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.

Parameters

  zareas | pointer to the return value. can not be NULL
  range | the range of addresses to verify. can be NULL - means all areas

Returns
  true if the result is a non-empty set

idaman int ida_export get_many_bytes_ex | ( | ea_t | ea,
|  | void * | buf,
|  | ssize_t | size,
|  | void * | mask
| ) |  |

Get the specified number of bytes of the program into the buffer.

If mask was specified it will contain a bitmap of initialized / uninitialized database bytes.

Parameters

  ea | linear address
  buf | buffer to hold bytes (may be NULL)
  size | size of buffer in normal 8-bit bytes (sizeof(buf))
  mask | bitmap of initialize/uninitialized bytes (must be at least (size+7)/8)

Return values

  -1 | user cancelled
  0 | partial read
  1 | success

idaman bool ida_export get_many_bytes | ( | ea_t | ea,
|  | void * | buf,
|  | ssize_t | size
| ) |  |

Get the specified number of bytes of the program into the buffer.

Parameters

  ea | linear address
  buf | buffer to hold bytes
  size | size of buffer in normal 8-bit bytes (sizeof(buf))

Return values

  1 | ok 0 failure (out of program address space or uninited bytes, for example)

idaman void ida_export put_many_bytes | ( | ea_t | ea,
|  | const void * | buf,
|  | size_t | size
| ) |  |

Modify the specified number of bytes of the program.

This function does not save the original values of bytes.

Note
  This function is for the kernel only. See also patch_many_bytes().

Parameters

  ea | linear address
  buf | buffer with new values of bytes
  size | size of buffer in normal 8-bit bytes (sizeof(buf))

idaman void ida_export patch_many_bytes | ( | ea_t | ea,
|  | const void * | buf,
|  | size_t | size
| ) |  |

Patch the specified number of bytes of the program.

Original values of bytes are saved and are available with get_original...() functions.

Note
  this function is for the kernel only See also put_many_bytes().

Parameters

  ea | linear address
  buf | buffer with new values of bytes
  size | size of buffer in normal 8-bit bytes (sizeof(buf))

idaman bool ida_export do_unknown | ( | ea_t | ea,
|  | int | flags
| ) |  |

Convert item (instruction/data) to unexplored bytes.

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

Parameters

  ea | any address within the item to delete
  flags | combination of Unexplored byte conversion flags

Returns
  success

idaman void ida_export do_unknown_range | ( | ea_t | ea,
|  | size_t | size,
|  | int | flags
| ) |  |

Convert range of addresses to unexplored bytes.

The whole items (including the head and tail bytes) will be destroyed.

Parameters

  ea | starting linear address
  size | number of bytes in the area to be undefined
  flags | combination of Unexplored byte conversion flags

idaman bool ida_export is_manual_insn | ( | ea_t | ea | ) |

Is the instruction overridden?

Parameters

  ea | linear address of the instruction or data item

idaman char* ida_export get_manual_insn | ( | ea_t | ea,
|  | char * | buf,
|  | size_t | bufsize
| ) |  |

Retrieve the user-specified string for the manual instruction.

Parameters

  ea | linear address of the instruction or data item
  buf | the input buffer for the string. if NULL, the buffer will be allocated in heap
  bufsize | size of the buffer if buf != NULL. otherwise bufsize should be 0

Returns
  NULL if no user-specified string

idaman void ida_export set_manual_insn | ( | ea_t | ea,
|  | const char * | manual_insn
| ) |  |

Set manual instruction string.

Parameters

  ea | linear address of the instruction or data item
  manual_insn | "" - delete manual string. NULL - do nothing

idaman void ida_export doVar | ( | ea_t | ea,
|  | bool | isvar = `true`
| ) |  |

Set the variableness of an address.

The variable addresses are marked with '*' in the disassembly

Parameters

  ea | linear address
  isvar | 0: clear 'variable' mark 1: set 'variable' mark

idaman size_t ida_export get_max_ascii_length | ( | ea_t | ea,
|  | int32 | strtype,
|  | int | options = `0`
| ) |  |

Determine maximum length of ascii string.

Parameters

  ea | starting address
  strtype | string type. one of String type codes
  options | combination of ASCII length options

Returns
  length of the string in bytes, including the terminating byte(s), if any

idaman bool ida_export get_ascii_contents2 | ( | ea_t | ea,
|  | size_t | len,
|  | int32 | type,
|  | void * | buf,
|  | size_t | bufsize,
|  | size_t * | usedsize = `NULL`,
|  | int | flags = `ACFOPT_ASCII`
| ) |  |

Get contents of ascii string.

This function returns the displayed part of the string It works even if the string has not been created in the database yet.

Parameters

  ea | linear address of the string
  len | length of the string in bytes
  type | type of the string. one of String type codes
  buf | output buffer
  bufsize | size of output buffer
  usedsize | on exit, number of bytes in buf filled with string data (not counting terminating zeroes) can be NULL if not needed
  flags | combination of ASCII conversion flags

Returns
  1 ok
  0 ascii string is too long and was truncated

idaman bool ida_export make_ascii_string | ( | ea_t | start,
|  | size_t | len,
|  | int32 | strtype
| ) |  |

Convert to ascii string and give a meaningful name.

'start' may be higher than 'end', the kernel will swap them in this case

Parameters

  start | starting address
  len | length of the string in bytes. if 0, then get_max_ascii_length() will be used to determine the length
  strtype | string type. one of String type codes

Returns
  success

idaman char* ida_export print_ascii_string_type | ( | char * | buf,
|  | size_t | bufsize,
|  | int32 | strtype
| ) |  |

Print the string type name.

Parameters

  buf | the output buffer
  bufsize | sizeof(buf)
  strtype | the string type

Returns
  ptr to buf

idaman opinfo_t* ida_export get_opinfo | ( | ea_t | ea,
|  | int | n,
|  | flags_t | flags,
|  | opinfo_t * | buf
| ) |  |

Get additional information about an operand representation.

Parameters

  ea | linear address of item
  n | number of operand, 0 or 1
  flags | flags of the item
  buf | buffer to receive the result. may not be NULL

Returns
  NULL if no additional representation information

idaman bool ida_export set_opinfo | ( | ea_t | ea,
|  | int | n,
|  | flags_t | flag,
|  | const opinfo_t * | ti
| ) |  |

Set additional information about an operand representation.

This function is a low level one. Only the kernel should use it.

Parameters

  ea | linear address of the item
  n | number of operand, 0 or 1
  flag | flags of the item
  ti | additional representation information

Returns
  1 ok
  0 ti is NULL while it shouldn't be NULL

void del_one_opinfo | ( | ea_t | ea,
|  | int | n,
|  | flags_t | flag
| ) |  |

Delete additional information about an operand representation.

This function is a low level one. Only the kernel should use it.

Parameters

  ea | linear address of the item
  n | number of operand, 0 or 1
  flag | flags of the item

idaman asize_t ida_export get_data_elsize | ( | ea_t | ea,
|  | flags_t | F,
|  | const opinfo_t * | ti = `NULL`
| ) |  |

Get size of data type specified in flags 'F'.

Parameters

  ea | linear address of the item
  F | flags
  ti | 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 NULL). If specified as NULL, will be automatically retrieved from the database

Returns
  - byte : 1
  - word : 2
  - etc...

If flags doesn't specify a data, then return 1

asize_t get_full_data_elsize | ( | ea_t | ea,
|  | flags_t | F,
|  | const opinfo_t * | ti = `NULL`
| ) |  |
| inline

Get full size of data type specified in flags 'F'.

takes into account processors with wide bytes e.g. returns 2 for a byte element with 16-bit bytes

idaman int ida_export is_varsize_item | ( | ea_t | ea,
|  | flags_t | F,
|  | const opinfo_t * | ti = `NULL`,
|  | asize_t * | itemsize = `NULL`
| ) |  |

Is the item at 'ea' variable size?.

Parameters

  ea | linear address of the item
  F | flags
  ti | 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 NULL). If specified as NULL, will be automatically retrieved from the database
  itemsize | if not NULL and the item is varsize, itemsize will contain the calculated item size (for struct types, the minimal size is returned)

Return values

  1 | varsize item
  0 | fixed item
  -1 | error (bad data definition)

idaman bool ida_export can_define_item | ( | ea_t | ea,
|  | asize_t | length,
|  | flags_t | flags
| ) |  |

Can define item (instruction/data) of the specified 'length', starting at 'ea'?

Note
  if there is an item starting at 'ea', this function ignores it
  this function converts to unexplored all encountered data items with fixup information. Should be fixed in the future.

Parameters

  flags | 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,wordflag()) - true, word at 1004 is destroyed

Returns
  1-yes, 0-no

This function may return 0 if:

- a new item would cross segment boundaries
- a new item would overlap with existing items (except items specified by 'flags')

idaman int ida_export register_custom_data_type | ( | const data_type_t * | dtinfo | ) |

Register a new data type.

Parameters

  dtinfo | description of the new data type

Returns
  > 0 : new custom data id, < 0 : error
  dtid 0 is reserved for built-in data types.

idaman bool ida_export unregister_custom_data_type | ( | int | dtid | ) |

Unregister a data type.

When the idb is closed, all custom data types are automatically unregistered, but since it happens too late (plugin modules could already be unloaded) one has to unregister custom data types explicitly.

Parameters

  dtid | data type to unregister

Return values

  true | ok
  false | no such dtid

idaman int ida_export register_custom_data_format | ( | int | dtid,
|  | const data_format_t * | dtform
| ) |  |

Register a new data format.

Parameters

  dtform | description of the new data format
  dtid | 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.

Returns
  >= 0 : new custom format id, < 0 : error

idaman bool ida_export unregister_custom_data_format | ( | int | dtid,
|  | int | fid
| ) |  |

Unregister a data format.

Unregistering a custom data type unregisters all attached data formats, no need to unregister them explicitly.

Parameters

  fid | data format id to unregister

Return values

  true | ok
  false | no such dtform

idaman const data_type_t* ida_export get_custom_data_type | ( | int | dtid | ) |

Get definition of a registered custom data type.

Parameters

  dtid | data type id

Returns
  data type definition or NULL

idaman const data_format_t* ida_export get_custom_data_format | ( | int | dtid,
|  | int | fid
| ) |  |

Get definition of a registered custom data format.

Parameters

  dtid | data type id. -1 means any data type, 0 means data formats for built-in data types
  fid | data format id

Returns
  data format definition or NULL

idaman int ida_export get_custom_data_types | ( | intvec_t * | out,
|  | asize_t | min_size = `0`,
|  | asize_t | max_size = `BADADDR`
| ) |  |

Get list of registered custom data type ids.

Parameters

  out | buffer for the output. may be NULL
  min_size | minimum value size
  max_size | maximum value size

Returns
  number of custom data types with the specified size limits

idaman int ida_export get_custom_data_formats | ( | intvec_t * | out,
|  | int | dtid
| ) |  |

Get list of registered custom data formats for the specified data type.

Parameters

  out | buffer for the output. may be NULL
  dtid | data type id

Returns
  number of returned custom data formats. if error, returns -1

idaman int ida_export find_custom_data_type | ( | const char * | name | ) |

Get id of a custom data type.

Parameters

  name | name of the custom data type

Returns
  id or -1

idaman int ida_export find_custom_data_format | ( | const char * | name | ) |

Get id of a custom data format.

Parameters

  name | name of the custom data format

Returns
  id or -1

idaman bool ida_export set_cmt | ( | ea_t | ea,
|  | const char * | comm,
|  | bool | rptble
| ) |  |

Set an indented comment.

Parameters

  ea | linear address
  comm | comment string
  rptble | is repeatable?

Returns
  success

idaman ssize_t ida_export get_cmt | ( | ea_t | ea,
|  | bool | rptble,
|  | char * | buf,
|  | size_t | bufsize
| ) |  |

Get an indented comment.

Parameters

  ea | linear address. may point to tail byte, the function will find start of the item
  rptble | get repeatable comment?
  buf | output buffer, may be NULL
  bufsize | size of output buffer

Returns
  size of comment or -1

char* get_repeatable_cmt | ( | ea_t | ea | ) |

Get a repeatable comment of any type (indented or function comment).

This function is used to display an indented comment if no regular (non-repeatable) comment is present.

Parameters

  ea | linear address. may point to tail byte, the function will find start of the item

Returns
  comment or NULL. The caller must qfree() the result.

char* get_any_indented_cmt | ( | ea_t | ea,
|  | color_t * | cmttype
| ) |  |

Get any indented comment (regular or repeatable indented or function).

This function is used to display an indented comment for an item. It looks for a regular comment and calls get_repeatable_cmt() if it is not found.

Parameters

  ea | linear address
  cmttype | will contain color of the comment. The color depends on the type of the comment.

Returns
  comment or NULL. The caller must qfree() the result.

idaman bool ida_export append_cmt | ( | ea_t | ea,
|  | const char * | str,
|  | bool | rptble
| ) |  |

Append to an indented comment.

Creates a new comment if none exists. Appends a newline character and the specified string otherwise.

Parameters

  ea | linear address
  str | comment string to append
  rptble | append to repeatable comment?

Returns
  success

idaman ea_t ida_export find_byte | ( | ea_t | sEA,
|  | asize_t | size,
|  | uchar | value,
|  | int | bin_search_flags
| ) |  |

Find forward a byte with the specified value (only 8-bit value from the database).

example: ea=4 size=3 will inspect addresses 4, 5, and 6

Parameters

  sEA | linear address
  size | number of bytes to inspect
  value | value to find
  bin_search_flags | combination of Search flags

Returns
  address of byte or BADADDR

idaman ea_t ida_export find_byter | ( | ea_t | sEA,
|  | asize_t | size,
|  | uchar | value,
|  | int | bin_search_flags
| ) |  |

Find reverse a byte with the specified value (only 8-bit value from the database).

example: ea=4 size=3 will inspect addresses 6, 5, and 4

Parameters

  sEA | the lower address of the search range
  size | number of bytes to inspect
  value | value to find
  bin_search_flags | combination of Search flags

Returns
  address of byte or BADADDR

idaman ea_t ida_export bin_search | ( | ea_t | startEA,
|  | ea_t | endEA,
|  | const uchar * | image,
|  | const uchar * | mask,
|  | size_t | len,
|  | int | step,
|  | int | flags
| ) |  |

Search for a string in the program.

Parameters

  startEA | linear address, start of area to search
  endEA | linear address, end of area to search (exclusive)
  image | stream of bytes to search
  mask | array of 1/0 bytes, it's length is 'len'. 1 means to perform the comparison of the corresponding byte. 0 means not to perform. if mask == NULL, then all bytes of 'image' will be compared.
  len | length of 'image' in bytes
  step | one of Search directions
  flags | combination of Search flags

Returns
  BADADDR (if pressed Ctrl-Break or not found) or string address.

idaman bool ida_export equal_bytes | ( | ea_t | ea,
|  | const uchar * | image,
|  | const uchar * | mask,
|  | size_t | len,
|  | bool | sense_case
| ) |  |

Compare 'len' bytes of the program starting from 'ea' with 'image'.

Parameters

  ea | linear address
  image | bytes to compare with
  len | length of block to compare in bytes.
  sense_case | case-sensitive comparison?
  mask | array of 1/0 bytes, it's length is 'len'. 1 means to perform the comparison of the corresponding byte. 0 means not to perform. if mask == NULL, then all bytes of 'image' will be compared. if mask == SKIP_FF_MASK then 0xFF bytes will be skipped

Return values

  1 | equal
  0 | not equal

idaman bool ida_export add_hidden_area | ( | ea_t | ea1,
|  | ea_t | ea2,
|  | const char * | description,
|  | const char * | header,
|  | const char * | footer,
|  | bgcolor_t | color
| ) |  |

Mark a range of addresses as hidden.

The area will be created in the invisible state with the default color

Parameters

  ea1 | linear address of start of the address range
  ea2 | linear address of end of the address range
  description,header,footer | area parameters

Returns
  success

hidden_area_t* idaapi get_hidden_area | ( | ea_t | ea | ) |
| inline

Get pointer to hidden area structure, in: linear address.

Parameters

  ea | any address in the hidden area

hidden_area_t* idaapi getn_hidden_area | ( | int | n | ) |
| inline

Get pointer to hidden area structure, in: number of hidden area.

Parameters

  n | number of hidden area, is in range 0..get_hidden_area_qty()-1

int idaapi get_hidden_area_num | ( | ea_t | ea | ) |
| inline

Get number of a hidden area.

Parameters

  ea | any address in the hidden area

Returns
  number of hidden area (0..get_hidden_area_qty()-1)

hidden_area_t* idaapi get_prev_hidden_area | ( | ea_t | ea | ) |
| inline

Get pointer to previous hidden area.

Parameters

  ea | any address in the program

Returns
  ptr to hidden area or NULL if previous hidden area doesn't exist

hidden_area_t* idaapi get_next_hidden_area | ( | ea_t | ea | ) |
| inline

Get pointer to next hidden area.

Parameters

  ea | any address in the program

Returns
  ptr to hidden area or NULL if next hidden area doesn't exist

bool idaapi del_hidden_area | ( | ea_t | ea | ) |
| inline

Delete hidden area.

Parameters

  ea | any address in the hidden area

Returns
  success