ida_bytes Namespace 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
class	compiled_binpat_t
class	compiled_binpat_vec_t
class	data_format_t
class	data_type_t
class	hidden_range_t
class	octet_generator_t

Functions
'error_t'	enable_flags (ida_idaapi.ea_t start_ea, ida_idaapi.ea_t end_ea, 'storage_type_t' stt)
'error_t'	disable_flags (ida_idaapi.ea_t start_ea, ida_idaapi.ea_t end_ea)
'error_t'	change_storage_type (ida_idaapi.ea_t start_ea, ida_idaapi.ea_t end_ea, 'storage_type_t' stt)
ida_idaapi.ea_t	next_addr (ida_idaapi.ea_t ea)
ida_idaapi.ea_t	prev_addr (ida_idaapi.ea_t ea)
ida_idaapi.ea_t	next_chunk (ida_idaapi.ea_t ea)
ida_idaapi.ea_t	prev_chunk (ida_idaapi.ea_t ea)
ida_idaapi.ea_t	chunk_start (ida_idaapi.ea_t ea)
'asize_t'	chunk_size (ida_idaapi.ea_t ea)
ida_idaapi.ea_t	find_free_chunk (ida_idaapi.ea_t start, 'asize_t' size, 'asize_t' alignment)
ida_idaapi.ea_t	next_that (ida_idaapi.ea_t ea, ida_idaapi.ea_t maxea, 'testf_t *' testf)
ida_idaapi.ea_t	next_unknown (ida_idaapi.ea_t ea, ida_idaapi.ea_t maxea)
ida_idaapi.ea_t	prev_that (ida_idaapi.ea_t ea, ida_idaapi.ea_t minea, 'testf_t *' testf)
ida_idaapi.ea_t	prev_unknown (ida_idaapi.ea_t ea, ida_idaapi.ea_t minea)
ida_idaapi.ea_t	prev_head (ida_idaapi.ea_t ea, ida_idaapi.ea_t minea)
ida_idaapi.ea_t	next_head (ida_idaapi.ea_t ea, ida_idaapi.ea_t maxea)
ida_idaapi.ea_t	prev_not_tail (ida_idaapi.ea_t ea)
ida_idaapi.ea_t	next_not_tail (ida_idaapi.ea_t ea)
ida_idaapi.ea_t	prev_visea (ida_idaapi.ea_t ea)
ida_idaapi.ea_t	next_visea (ida_idaapi.ea_t ea)
ida_idaapi.ea_t	get_item_head (ida_idaapi.ea_t ea)
ida_idaapi.ea_t	get_item_end (ida_idaapi.ea_t ea)
ida_idaapi.ea_t	calc_max_item_end (ida_idaapi.ea_t ea, int how=15)
'asize_t'	get_item_size (ida_idaapi.ea_t ea)
bool	is_mapped (ida_idaapi.ea_t ea)
'flags64_t'	get_flags_ex (ida_idaapi.ea_t ea, int how)
'flags64_t'	get_flags (ida_idaapi.ea_t ea)
'flags64_t'	get_full_flags (ida_idaapi.ea_t ea)
'flags64_t'	get_item_flag (ida_idaapi.ea_t _from, int n, ida_idaapi.ea_t ea, bool appzero)
bool	get_item_refinfo ('refinfo_t' ri, ida_idaapi.ea_t ea, int n)
bool	has_value ('flags64_t' F)
None	del_value (ida_idaapi.ea_t ea)
bool	is_loaded (ida_idaapi.ea_t ea)
int	nbits (ida_idaapi.ea_t ea)
int	bytesize (ida_idaapi.ea_t ea)
'uchar'	get_byte (ida_idaapi.ea_t ea)
'uchar'	get_db_byte (ida_idaapi.ea_t ea)
'ushort'	get_word (ida_idaapi.ea_t ea)
int	get_dword (ida_idaapi.ea_t ea)
'uint64'	get_qword (ida_idaapi.ea_t ea)
'uint64'	get_wide_byte (ida_idaapi.ea_t ea)
'uint64'	get_wide_word (ida_idaapi.ea_t ea)
'uint64'	get_wide_dword (ida_idaapi.ea_t ea)
'uchar *'	get_octet ('octet_generator_t' ogen)
int	get_16bit (ida_idaapi.ea_t ea)
int	get_32bit (ida_idaapi.ea_t ea)
'uint64'	get_64bit (ida_idaapi.ea_t ea)
bool	get_data_value ('uval_t *' v, ida_idaapi.ea_t ea, 'asize_t' size)
'uint64'	get_original_byte (ida_idaapi.ea_t ea)
'uint64'	get_original_word (ida_idaapi.ea_t ea)
'uint64'	get_original_dword (ida_idaapi.ea_t ea)
'uint64'	get_original_qword (ida_idaapi.ea_t ea)
bool	put_byte (ida_idaapi.ea_t ea, 'uint64' x)
None	put_word (ida_idaapi.ea_t ea, 'uint64' x)
None	put_dword (ida_idaapi.ea_t ea, 'uint64' x)
None	put_qword (ida_idaapi.ea_t ea, 'uint64' x)
bool	patch_byte (ida_idaapi.ea_t ea, 'uint64' x)
bool	patch_word (ida_idaapi.ea_t ea, 'uint64' x)
bool	patch_dword (ida_idaapi.ea_t ea, 'uint64' x)
bool	patch_qword (ida_idaapi.ea_t ea, 'uint64' x)
bool	revert_byte (ida_idaapi.ea_t ea)
None	add_byte (ida_idaapi.ea_t ea, int value)
None	add_word (ida_idaapi.ea_t ea, 'uint64' value)
None	add_dword (ida_idaapi.ea_t ea, 'uint64' value)
None	add_qword (ida_idaapi.ea_t ea, 'uint64' value)
bool	get_zero_ranges ('rangeset_t' zranges, 'range_t' range)
None	put_bytes (ida_idaapi.ea_t ea, 'void const *' buf)
None	patch_bytes (ida_idaapi.ea_t ea, 'void const *' buf)
bool	is_code ('flags64_t' F)
bool	f_is_code ('flags64_t' F, 'void *' arg2)
bool	is_data ('flags64_t' F)
bool	f_is_data ('flags64_t' F, 'void *' arg2)
bool	is_tail ('flags64_t' F)
bool	f_is_tail ('flags64_t' F, 'void *' arg2)
bool	is_not_tail ('flags64_t' F)
bool	f_is_not_tail ('flags64_t' F, 'void *' arg2)
bool	is_unknown ('flags64_t' F)
bool	is_head ('flags64_t' F)
bool	f_is_head ('flags64_t' F, 'void *' arg2)
bool	del_items (ida_idaapi.ea_t ea, int flags=0, 'asize_t' nbytes=1, 'may_destroy_cb_t *' may_destroy=None)
bool	is_manual_insn (ida_idaapi.ea_t ea)
str	get_manual_insn (ida_idaapi.ea_t ea)
None	set_manual_insn (ida_idaapi.ea_t ea, str manual_insn)
bool	is_flow ('flags64_t' F)
bool	has_extra_cmts ('flags64_t' F)
bool	f_has_extra_cmts ('flags64_t' f, 'void *' arg2)
bool	has_cmt ('flags64_t' F)
bool	f_has_cmt ('flags64_t' f, 'void *' arg2)
bool	has_xref ('flags64_t' F)
bool	f_has_xref ('flags64_t' f, 'void *' arg2)
bool	has_name ('flags64_t' F)
bool	f_has_name ('flags64_t' f, 'void *' arg2)
bool	has_dummy_name ('flags64_t' F)
bool	f_has_dummy_name ('flags64_t' f, 'void *' arg2)
bool	has_auto_name ('flags64_t' F)
bool	has_any_name ('flags64_t' F)
bool	has_user_name ('flags64_t' F)
bool	f_has_user_name ('flags64_t' F, 'void *' arg2)
bool	is_invsign (ida_idaapi.ea_t ea, 'flags64_t' F, int n)
bool	toggle_sign (ida_idaapi.ea_t ea, int n)
bool	is_bnot (ida_idaapi.ea_t ea, 'flags64_t' F, int n)
bool	toggle_bnot (ida_idaapi.ea_t ea, int n)
bool	is_lzero (ida_idaapi.ea_t ea, int n)
bool	set_lzero (ida_idaapi.ea_t ea, int n)
bool	clr_lzero (ida_idaapi.ea_t ea, int n)
bool	toggle_lzero (ida_idaapi.ea_t ea, int n)
bool	leading_zero_important (ida_idaapi.ea_t ea, int n)
int	get_operand_type_shift (int n)
'flags64_t'	get_operand_flag ('uint8' typebits, int n)
bool	is_flag_for_operand ('flags64_t' F, 'uint8' typebits, int n)
bool	is_defarg0 ('flags64_t' F)
bool	is_defarg1 ('flags64_t' F)
bool	is_off0 ('flags64_t' F)
bool	is_off1 ('flags64_t' F)
bool	is_char0 ('flags64_t' F)
bool	is_char1 ('flags64_t' F)
bool	is_seg0 ('flags64_t' F)
bool	is_seg1 ('flags64_t' F)
bool	is_enum0 ('flags64_t' F)
bool	is_enum1 ('flags64_t' F)
bool	is_stroff0 ('flags64_t' F)
bool	is_stroff1 ('flags64_t' F)
bool	is_stkvar0 ('flags64_t' F)
bool	is_stkvar1 ('flags64_t' F)
bool	is_float0 ('flags64_t' F)
bool	is_float1 ('flags64_t' F)
bool	is_custfmt0 ('flags64_t' F)
bool	is_custfmt1 ('flags64_t' F)
bool	is_numop0 ('flags64_t' F)
bool	is_numop1 ('flags64_t' F)
'flags64_t'	get_optype_flags0 ('flags64_t' F)
'flags64_t'	get_optype_flags1 ('flags64_t' F)
bool	is_defarg ('flags64_t' F, int n)
bool	is_off ('flags64_t' F, int n)
bool	is_char ('flags64_t' F, int n)
bool	is_seg ('flags64_t' F, int n)
bool	is_enum ('flags64_t' F, int n)
bool	is_manual ('flags64_t' F, int n)
bool	is_stroff ('flags64_t' F, int n)
bool	is_stkvar ('flags64_t' F, int n)
bool	is_fltnum ('flags64_t' F, int n)
bool	is_custfmt ('flags64_t' F, int n)
bool	is_numop ('flags64_t' F, int n)
bool	is_suspop (ida_idaapi.ea_t ea, 'flags64_t' F, int n)
bool	op_adds_xrefs ('flags64_t' F, int n)
bool	set_op_type (ida_idaapi.ea_t ea, 'flags64_t' type, int n)
bool	op_seg (ida_idaapi.ea_t ea, int n)
bool	op_enum (ida_idaapi.ea_t ea, int n, 'tid_t' id, 'uchar' serial=0)
'uchar *'	get_enum_id (ida_idaapi.ea_t ea, int n)
bool	op_based_stroff ('insn_t const &' insn, int n, 'adiff_t' opval, ida_idaapi.ea_t base)
bool	op_stkvar (ida_idaapi.ea_t ea, int n)
bool	set_forced_operand (ida_idaapi.ea_t ea, int n, str op)
str	get_forced_operand (ida_idaapi.ea_t ea, int n)
bool	is_forced_operand (ida_idaapi.ea_t ea, int n)
'flags64_t'	combine_flags ('flags64_t' F)
'flags64_t'	char_flag ()
'flags64_t'	off_flag ()
'flags64_t'	enum_flag ()
'flags64_t'	stroff_flag ()
'flags64_t'	stkvar_flag ()
'flags64_t'	flt_flag ()
'flags64_t'	custfmt_flag ()
'flags64_t'	seg_flag ()
'flags64_t'	num_flag ()
'flags64_t'	hex_flag ()
'flags64_t'	dec_flag ()
'flags64_t'	oct_flag ()
'flags64_t'	bin_flag ()
bool	op_chr (ida_idaapi.ea_t ea, int n)
bool	op_num (ida_idaapi.ea_t ea, int n)
bool	op_hex (ida_idaapi.ea_t ea, int n)
bool	op_dec (ida_idaapi.ea_t ea, int n)
bool	op_oct (ida_idaapi.ea_t ea, int n)
bool	op_bin (ida_idaapi.ea_t ea, int n)
bool	op_flt (ida_idaapi.ea_t ea, int n)
bool	op_custfmt (ida_idaapi.ea_t ea, int n, int fid)
bool	clr_op_type (ida_idaapi.ea_t ea, int n)
int	get_default_radix ()
int	get_radix ('flags64_t' F, int n)
'flags64_t'	code_flag ()
'flags64_t'	byte_flag ()
'flags64_t'	word_flag ()
'flags64_t'	dword_flag ()
'flags64_t'	qword_flag ()
'flags64_t'	oword_flag ()
'flags64_t'	yword_flag ()
'flags64_t'	zword_flag ()
'flags64_t'	tbyte_flag ()
'flags64_t'	strlit_flag ()
'flags64_t'	stru_flag ()
'flags64_t'	cust_flag ()
'flags64_t'	align_flag ()
'flags64_t'	float_flag ()
'flags64_t'	double_flag ()
'flags64_t'	packreal_flag ()
bool	is_byte ('flags64_t' F)
bool	is_word ('flags64_t' F)
bool	is_dword ('flags64_t' F)
bool	is_qword ('flags64_t' F)
bool	is_oword ('flags64_t' F)
bool	is_yword ('flags64_t' F)
bool	is_zword ('flags64_t' F)
bool	is_tbyte ('flags64_t' F)
bool	is_float ('flags64_t' F)
bool	is_double ('flags64_t' F)
bool	is_pack_real ('flags64_t' F)
bool	is_strlit ('flags64_t' F)
bool	is_struct ('flags64_t' F)
bool	is_align ('flags64_t' F)
bool	is_custom ('flags64_t' F)
bool	f_is_byte ('flags64_t' F, 'void *' arg2)
bool	f_is_word ('flags64_t' F, 'void *' arg2)
bool	f_is_dword ('flags64_t' F, 'void *' arg2)
bool	f_is_qword ('flags64_t' F, 'void *' arg2)
bool	f_is_oword ('flags64_t' F, 'void *' arg2)
bool	f_is_yword ('flags64_t' F, 'void *' arg2)
bool	f_is_tbyte ('flags64_t' F, 'void *' arg2)
bool	f_is_float ('flags64_t' F, 'void *' arg2)
bool	f_is_double ('flags64_t' F, 'void *' arg2)
bool	f_is_pack_real ('flags64_t' F, 'void *' arg2)
bool	f_is_strlit ('flags64_t' F, 'void *' arg2)
bool	f_is_struct ('flags64_t' F, 'void *' arg2)
bool	f_is_align ('flags64_t' F, 'void *' arg2)
bool	f_is_custom ('flags64_t' F, 'void *' arg2)
bool	is_same_data_type ('flags64_t' F1, 'flags64_t' F2)
'flags64_t'	get_flags_by_size ('size_t' size)
bool	create_data (ida_idaapi.ea_t ea, 'flags64_t' dataflag, 'asize_t' size, 'tid_t' tid)
'flags64_t'	calc_dflags ('flags64_t' f, bool force)
bool	create_byte (ida_idaapi.ea_t ea, 'asize_t' length, bool force=False)
bool	create_word (ida_idaapi.ea_t ea, 'asize_t' length, bool force=False)
bool	create_dword (ida_idaapi.ea_t ea, 'asize_t' length, bool force=False)
bool	create_qword (ida_idaapi.ea_t ea, 'asize_t' length, bool force=False)
bool	create_oword (ida_idaapi.ea_t ea, 'asize_t' length, bool force=False)
bool	create_yword (ida_idaapi.ea_t ea, 'asize_t' length, bool force=False)
bool	create_zword (ida_idaapi.ea_t ea, 'asize_t' length, bool force=False)
bool	create_tbyte (ida_idaapi.ea_t ea, 'asize_t' length, bool force=False)
bool	create_float (ida_idaapi.ea_t ea, 'asize_t' length, bool force=False)
bool	create_double (ida_idaapi.ea_t ea, 'asize_t' length, bool force=False)
bool	create_packed_real (ida_idaapi.ea_t ea, 'asize_t' length, bool force=False)
bool	create_struct (ida_idaapi.ea_t ea, 'asize_t' length, 'tid_t' tid, bool force=False)
bool	create_custdata (ida_idaapi.ea_t ea, 'asize_t' length, int dtid, int fid, bool force=False)
bool	create_align (ida_idaapi.ea_t ea, 'asize_t' length, int alignment)
int	calc_min_align ('asize_t' length)
int	calc_max_align (ida_idaapi.ea_t endea)
int	calc_def_align (ida_idaapi.ea_t ea, int mina, int maxa)
bool	create_16bit_data (ida_idaapi.ea_t ea, 'asize_t' length)
bool	create_32bit_data (ida_idaapi.ea_t ea, 'asize_t' length)
'size_t'	get_max_strlit_length (ida_idaapi.ea_t ea, int strtype, int options=0)
bool	create_strlit (ida_idaapi.ea_t start, 'size_t' len, int strtype)
'opinfo_t *'	get_opinfo ('opinfo_t' buf, ida_idaapi.ea_t ea, int n, 'flags64_t' flags)
bool	set_opinfo (ida_idaapi.ea_t ea, int n, 'flags64_t' flag, 'opinfo_t' ti, bool suppress_events=False)
'asize_t'	get_data_elsize (ida_idaapi.ea_t ea, 'flags64_t' F, 'opinfo_t' ti=None)
'asize_t'	get_full_data_elsize (ida_idaapi.ea_t ea, 'flags64_t' F, 'opinfo_t' ti=None)
int	is_varsize_item (ida_idaapi.ea_t ea, 'flags64_t' F, 'opinfo_t' ti=None, 'asize_t *' itemsize=None)
'asize_t'	get_possible_item_varsize (ida_idaapi.ea_t ea, 'tinfo_t' tif)
bool	can_define_item (ida_idaapi.ea_t ea, 'asize_t' length, 'flags64_t' flags)
bool	has_immd ('flags64_t' F)
bool	is_func ('flags64_t' F)
bool	set_immd (ida_idaapi.ea_t ea)
'data_type_t const *'	get_custom_data_type (int dtid)
'data_format_t const *'	get_custom_data_format (int dfid)
bool	attach_custom_data_format (int dtid, int dfid)
bool	detach_custom_data_format (int dtid, int dfid)
bool	is_attached_custom_data_format (int dtid, int dfid)
int	get_custom_data_types (*args)
int	get_custom_data_formats ('intvec_t *' out, int dtid)
int	find_custom_data_type (str name)
int	find_custom_data_format (str name)
bool	set_cmt (ida_idaapi.ea_t ea, str comm, bool rptble)
str	get_cmt (ida_idaapi.ea_t ea, bool rptble)
bool	append_cmt (ida_idaapi.ea_t ea, str str, bool rptble)
str	get_predef_insn_cmt ('insn_t const &' ins)
ida_idaapi.ea_t	find_byte (ida_idaapi.ea_t sEA, 'asize_t' size, 'uchar' value, int bin_search_flags)
ida_idaapi.ea_t	find_byter (ida_idaapi.ea_t sEA, 'asize_t' size, 'uchar' value, int bin_search_flags)
bool	parse_binpat_str ('compiled_binpat_vec_t' out, ida_idaapi.ea_t ea, str _in, int radix, int strlits_encoding=0)
	bin_search (*args)
ida_idaapi.ea_t	next_inited (ida_idaapi.ea_t ea, ida_idaapi.ea_t maxea)
ida_idaapi.ea_t	prev_inited (ida_idaapi.ea_t ea, ida_idaapi.ea_t minea)
bool	equal_bytes (ida_idaapi.ea_t ea, 'uchar const *' image, 'uchar const *' mask, 'size_t' len, int bin_search_flags)
bool	update_hidden_range ('hidden_range_t' ha)
bool	add_hidden_range (*args)
'hidden_range_t *'	get_hidden_range (ida_idaapi.ea_t ea)
'hidden_range_t *'	getn_hidden_range (int n)
int	get_hidden_range_qty ()
int	get_hidden_range_num (ida_idaapi.ea_t ea)
'hidden_range_t *'	get_prev_hidden_range (ida_idaapi.ea_t ea)
'hidden_range_t *'	get_next_hidden_range (ida_idaapi.ea_t ea)
'hidden_range_t *'	get_first_hidden_range ()
'hidden_range_t *'	get_last_hidden_range ()
bool	del_hidden_range (ida_idaapi.ea_t ea)
bool	add_mapping (ida_idaapi.ea_t _from, ida_idaapi.ea_t to, 'asize_t' size)
None	del_mapping (ida_idaapi.ea_t ea)
ida_idaapi.ea_t	use_mapping (ida_idaapi.ea_t ea)
'size_t'	get_mappings_qty ()
'ea_t *, ea_t *, asize_t *'	get_mapping ('size_t' n)
	visit_patched_bytes (ida_idaapi.ea_t ea1, ida_idaapi.ea_t ea2, callable)
	get_bytes (ida_idaapi.ea_t ea, int size, int gmb_flags=GMB_READALL)
	get_bytes_and_mask (ida_idaapi.ea_t ea, int size, int gmb_flags=GMB_READALL)
	get_strlit_contents (ida_idaapi.ea_t ea, int len, int type, int flags=0)
'PyObject *'	print_strlit_type (int strtype, int flags=0)
bool	op_stroff (*args)
	get_stroff_path (*args)
	register_custom_data_type (dt)
	unregister_custom_data_type (dtid)
	register_custom_data_format (df)
	unregister_custom_data_format (dfid)
	register_data_types_and_formats (formats)
	unregister_data_types_and_formats (formats)
int	find_bytes (typing.Union[bytes, bytearray, str] bs, int range_start, typing.Optional[int] range_size=None, typing.Optional[int] range_end=ida_idaapi.BADADDR, typing.Optional[typing.Union[bytes, bytearray]] mask=None, typing.Optional[int] flags=BIN_SEARCH_FORWARD|BIN_SEARCH_NOSHOW, typing.Optional[int] radix=16, typing.Optional[typing.Union[int, str]] strlit_encoding=PBSENC_DEF1BPU)
int	find_string (str _str, int range_start, typing.Optional[int] range_end=ida_idaapi.BADADDR, typing.Optional[int] range_size=None, typing.Optional[typing.Union[int, str]] strlit_encoding=PBSENC_DEF1BPU, typing.Optional[int] flags=BIN_SEARCH_FORWARD|BIN_SEARCH_NOSHOW)

Variables
	ITEM_END_FIXUP = _ida_bytes.ITEM_END_FIXUP
	ITEM_END_INITED = _ida_bytes.ITEM_END_INITED
	ITEM_END_NAME = _ida_bytes.ITEM_END_NAME
	ITEM_END_XREF = _ida_bytes.ITEM_END_XREF
	ITEM_END_CANCEL = _ida_bytes.ITEM_END_CANCEL
	GFE_VALUE = _ida_bytes.GFE_VALUE
	GFE_IDB_VALUE = _ida_bytes.GFE_IDB_VALUE
	MS_VAL = _ida_bytes.MS_VAL
	FF_IVL = _ida_bytes.FF_IVL
	GMB_READALL = _ida_bytes.GMB_READALL
	GMB_WAITBOX = _ida_bytes.GMB_WAITBOX
	MS_CLS = _ida_bytes.MS_CLS
	FF_CODE = _ida_bytes.FF_CODE
	FF_DATA = _ida_bytes.FF_DATA
	FF_TAIL = _ida_bytes.FF_TAIL
	FF_UNK = _ida_bytes.FF_UNK
	DELIT_SIMPLE = _ida_bytes.DELIT_SIMPLE
	DELIT_EXPAND = _ida_bytes.DELIT_EXPAND
	DELIT_DELNAMES = _ida_bytes.DELIT_DELNAMES
	DELIT_NOTRUNC = _ida_bytes.DELIT_NOTRUNC
	DELIT_NOUNAME = _ida_bytes.DELIT_NOUNAME
	DELIT_NOCMT = _ida_bytes.DELIT_NOCMT
	DELIT_KEEPFUNC = _ida_bytes.DELIT_KEEPFUNC
	MS_COMM = _ida_bytes.MS_COMM
	FF_COMM = _ida_bytes.FF_COMM
	FF_REF = _ida_bytes.FF_REF
	FF_LINE = _ida_bytes.FF_LINE
	FF_NAME = _ida_bytes.FF_NAME
	FF_LABL = _ida_bytes.FF_LABL
	FF_FLOW = _ida_bytes.FF_FLOW
	FF_SIGN = _ida_bytes.FF_SIGN
	FF_BNOT = _ida_bytes.FF_BNOT
	FF_UNUSED = _ida_bytes.FF_UNUSED
	FF_ANYNAME = _ida_bytes.FF_ANYNAME
	MS_N_TYPE = _ida_bytes.MS_N_TYPE
	FF_N_VOID = _ida_bytes.FF_N_VOID
	FF_N_NUMH = _ida_bytes.FF_N_NUMH
	FF_N_NUMD = _ida_bytes.FF_N_NUMD
	FF_N_CHAR = _ida_bytes.FF_N_CHAR
	FF_N_SEG = _ida_bytes.FF_N_SEG
	FF_N_OFF = _ida_bytes.FF_N_OFF
	FF_N_NUMB = _ida_bytes.FF_N_NUMB
	FF_N_NUMO = _ida_bytes.FF_N_NUMO
	FF_N_ENUM = _ida_bytes.FF_N_ENUM
	FF_N_FOP = _ida_bytes.FF_N_FOP
	FF_N_STRO = _ida_bytes.FF_N_STRO
	FF_N_STK = _ida_bytes.FF_N_STK
	FF_N_FLT = _ida_bytes.FF_N_FLT
	FF_N_CUST = _ida_bytes.FF_N_CUST
	OPND_OUTER = _ida_bytes.OPND_OUTER
	OPND_MASK = _ida_bytes.OPND_MASK
	OPND_ALL = _ida_bytes.OPND_ALL
	DT_TYPE = _ida_bytes.DT_TYPE
	FF_BYTE = _ida_bytes.FF_BYTE
	FF_WORD = _ida_bytes.FF_WORD
	FF_DWORD = _ida_bytes.FF_DWORD
	FF_QWORD = _ida_bytes.FF_QWORD
	FF_TBYTE = _ida_bytes.FF_TBYTE
	FF_STRLIT = _ida_bytes.FF_STRLIT
	FF_STRUCT = _ida_bytes.FF_STRUCT
	FF_OWORD = _ida_bytes.FF_OWORD
	FF_FLOAT = _ida_bytes.FF_FLOAT
	FF_DOUBLE = _ida_bytes.FF_DOUBLE
	FF_PACKREAL = _ida_bytes.FF_PACKREAL
	FF_ALIGN = _ida_bytes.FF_ALIGN
	FF_CUSTOM = _ida_bytes.FF_CUSTOM
	FF_YWORD = _ida_bytes.FF_YWORD
	FF_ZWORD = _ida_bytes.FF_ZWORD
	ALOPT_IGNHEADS = _ida_bytes.ALOPT_IGNHEADS
	ALOPT_IGNPRINT = _ida_bytes.ALOPT_IGNPRINT
	ALOPT_IGNCLT = _ida_bytes.ALOPT_IGNCLT
	ALOPT_MAX4K = _ida_bytes.ALOPT_MAX4K
	ALOPT_ONLYTERM = _ida_bytes.ALOPT_ONLYTERM
	ALOPT_APPEND = _ida_bytes.ALOPT_APPEND
	STRCONV_ESCAPE = _ida_bytes.STRCONV_ESCAPE
	STRCONV_REPLCHAR = _ida_bytes.STRCONV_REPLCHAR
	STRCONV_INCLLEN = _ida_bytes.STRCONV_INCLLEN
	PSTF_TNORM = _ida_bytes.PSTF_TNORM
	PSTF_TBRIEF = _ida_bytes.PSTF_TBRIEF
	PSTF_TINLIN = _ida_bytes.PSTF_TINLIN
	PSTF_TMASK = _ida_bytes.PSTF_TMASK
	PSTF_HOTKEY = _ida_bytes.PSTF_HOTKEY
	PSTF_ENC = _ida_bytes.PSTF_ENC
	PSTF_ONLY_ENC = _ida_bytes.PSTF_ONLY_ENC
	PSTF_ATTRIB = _ida_bytes.PSTF_ATTRIB
	MS_CODE = _ida_bytes.MS_CODE
	FF_FUNC = _ida_bytes.FF_FUNC
	FF_IMMD = _ida_bytes.FF_IMMD
	FF_JUMP = _ida_bytes.FF_JUMP
	DTP_NODUP = _ida_bytes.DTP_NODUP
	PBSENC_DEF1BPU = _ida_bytes.PBSENC_DEF1BPU
	PBSENC_ALL = _ida_bytes.PBSENC_ALL
	BIN_SEARCH_CASE = _ida_bytes.BIN_SEARCH_CASE
	BIN_SEARCH_NOCASE = _ida_bytes.BIN_SEARCH_NOCASE
	BIN_SEARCH_NOBREAK = _ida_bytes.BIN_SEARCH_NOBREAK
	BIN_SEARCH_INITED = _ida_bytes.BIN_SEARCH_INITED
	BIN_SEARCH_NOSHOW = _ida_bytes.BIN_SEARCH_NOSHOW
	BIN_SEARCH_FORWARD = _ida_bytes.BIN_SEARCH_FORWARD
	BIN_SEARCH_BACKWARD = _ida_bytes.BIN_SEARCH_BACKWARD
	BIN_SEARCH_BITMASK = _ida_bytes.BIN_SEARCH_BITMASK
	MS_0TYPE = _ida_bytes.MS_0TYPE
	FF_0VOID = _ida_bytes.FF_0VOID
	FF_0NUMH = _ida_bytes.FF_0NUMH
	FF_0NUMD = _ida_bytes.FF_0NUMD
	FF_0CHAR = _ida_bytes.FF_0CHAR
	FF_0SEG = _ida_bytes.FF_0SEG
	FF_0OFF = _ida_bytes.FF_0OFF
	FF_0NUMB = _ida_bytes.FF_0NUMB
	FF_0NUMO = _ida_bytes.FF_0NUMO
	FF_0ENUM = _ida_bytes.FF_0ENUM
	FF_0FOP = _ida_bytes.FF_0FOP
	FF_0STRO = _ida_bytes.FF_0STRO
	FF_0STK = _ida_bytes.FF_0STK
	FF_0FLT = _ida_bytes.FF_0FLT
	FF_0CUST = _ida_bytes.FF_0CUST
	MS_1TYPE = _ida_bytes.MS_1TYPE
	FF_1VOID = _ida_bytes.FF_1VOID
	FF_1NUMH = _ida_bytes.FF_1NUMH
	FF_1NUMD = _ida_bytes.FF_1NUMD
	FF_1CHAR = _ida_bytes.FF_1CHAR
	FF_1SEG = _ida_bytes.FF_1SEG
	FF_1OFF = _ida_bytes.FF_1OFF
	FF_1NUMB = _ida_bytes.FF_1NUMB
	FF_1NUMO = _ida_bytes.FF_1NUMO
	FF_1ENUM = _ida_bytes.FF_1ENUM
	FF_1FOP = _ida_bytes.FF_1FOP
	FF_1STRO = _ida_bytes.FF_1STRO
	FF_1STK = _ida_bytes.FF_1STK
	FF_1FLT = _ida_bytes.FF_1FLT
	FF_1CUST = _ida_bytes.FF_1CUST

Function Documentation

add_byte()

None add_byte	(	ida_idaapi.ea_t	ea,
		int	value )

Add a value to one byte of the program. This function works for wide byte processors too. 
    
@param ea: linear address
@param value: byte value

add_dword()

None add_dword	(	ida_idaapi.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::is_be() 
    
@param ea: linear address
@param value: byte value

add_hidden_range()

bool add_hidden_range

(

*

args

)

Mark a range of addresses as hidden. The range will be created in the invisible state with the default color 
    
@param ea1: linear address of start of the address range
@param ea2: linear address of end of the address range
@param description: range parameters
@param header: range parameters
@param footer: range parameters
@param color: the range color
@returns success

add_mapping()

bool add_mapping	(	ida_idaapi.ea_t	_from,
		ida_idaapi.ea_t	to,
		'asize_t'	size )

IDA supports memory mapping. References to the addresses from the mapped range use data and meta-data from the mapping range. 
    
@param to: start of the mapping range (existent address)
@param size: size of the range
@returns success

add_qword()

None add_qword	(	ida_idaapi.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::is_be() 
    
@param ea: linear address
@param value: byte value

add_word()

None add_word	(	ida_idaapi.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::is_be() 
    
@param ea: linear address
@param value: byte value

align_flag()

'flags64_t' align_flag

(

)

Get a flags64_t representing an alignment directive.

append_cmt()

bool append_cmt	(	ida_idaapi.ea_t	ea,
		str	str,
		bool	rptble )

Append to an indented comment. Creates a new comment if none exists. Appends a newline character and the specified string otherwise. 
    
@param ea: linear address
@param str: comment string to append
@param rptble: append to repeatable comment?
@returns success

attach_custom_data_format()

bool attach_custom_data_format	(	int	dtid,
		int	dfid )

Attach the data format to the data type. 
    
@param 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.
@param dfid: data format id
@retval true: ok
@retval false: no such `dtid`, or no such `dfid', or the data format has already been attached to the data type

bin_flag()

'flags64_t' bin_flag

(

)

Get number flag of the base, regardless of current processor - better to use num_flag()

bin_search()

bin_search

(

*

args

)

Search for a set of bytes in the program

This function has the following signatures:

1. bin_search(start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t, data: compiled_binpat_vec_t, flags: int) -> Tuple[ida_idaapi.ea_t, int]
2. bin_search(start_ea: ida_idaapi.ea_t, end_ea: ida_idaapi.ea_t, image: bytes, mask: bytes, len: int, flags: int) -> ida_idaapi.ea_t

The return value type will differ depending on the form:

1. a tuple `(matched-address, index-in-compiled_binpat_vec_t)` (1st form)
2. the address of a match, or ida_idaapi.BADADDR if not found (2nd form)

This is a low-level function; more user-friendly alternatives
are available. Please see 'find_bytes' and 'find_string'.

@param start_ea: linear address, start of range to search
@param end_ea: linear address, end of range to search (exclusive)
@param data: (1st form) the prepared data to search for (see parse_binpat_str())
@param bytes: (2nd form) a set of bytes to match
@param mask: (2nd form) a mask to apply to the set of bytes
@param flags: combination of BIN_SEARCH_* flags
@return: either a tuple holding both the address of the match and the index of the compiled pattern that matched, or the address of a match (ida_idaapi.BADADDR if not found)

byte_flag()

'flags64_t' byte_flag

(

)

Get a flags64_t representing a byte.

bytesize()

int bytesize

(

ida_idaapi.ea_t

ea

)

Get number of bytes required to store a byte at the given address.

calc_def_align()

int calc_def_align	(	ida_idaapi.ea_t	ea,
		int	mina,
		int	maxa )

Calculate the default alignment exponent. 
    
@param ea: linear address
@param mina: minimal possible alignment exponent.
@param maxa: minimal possible alignment exponent.

calc_dflags()

'flags64_t' calc_dflags	(	'flags64_t'	f,
		bool	force )

calc_max_align()

int calc_max_align

(

ida_idaapi.ea_t

endea

)

Calculate the maximal possible alignment exponent. 
    
@param endea: end address of the alignment item.
@returns a value in the 0..32 range

calc_max_item_end()

ida_idaapi.ea_t calc_max_item_end	(	ida_idaapi.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. 
    
@param ea: linear address
@param 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'. If operation was cancelled by user, it will return 'ea'

calc_min_align()

int calc_min_align

(

'asize_t'

length

)

Calculate the minimal possible alignment exponent. 
    
@param length: size of the item in bytes.
@returns a value in the 1..32 range

can_define_item()

bool can_define_item	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		'flags64_t'	flags )

Can define item (instruction/data) of the specified 'length', starting at 'ea'? 
* a new item would cross segment boundaries
* a new item would overlap with existing items (except items specified by 'flags') 


    
@param ea: start of the range for the new item
@param length: length of the new item in bytes
@param 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, word_flag()) - true, word at 1004 is destroyed
@returns 1-yes, 0-no

change_storage_type()

'error_t' change_storage_type	(	ida_idaapi.ea_t	start_ea,
		ida_idaapi.ea_t	end_ea,
		'storage_type_t'	stt )

Change flag storage type for address range. 
    
@param start_ea: should be lower than end_ea.
@param end_ea: does not belong to the range.
@param stt: storage_type_t
@returns error code

char_flag()

'flags64_t' char_flag

(

)

see FF_opbits

chunk_size()

'asize_t' chunk_size

(

ida_idaapi.ea_t

ea

)

Get size of the contiguous address block containing 'ea'. 
    
@returns 0 if 'ea' doesn't belong to the program.

chunk_start()

ida_idaapi.ea_t chunk_start

(

ida_idaapi.ea_t

ea

)

Get start of the contiguous address block containing 'ea'. 
    
@returns BADADDR if 'ea' doesn't belong to the program.

clr_lzero()

bool clr_lzero	(	ida_idaapi.ea_t	ea,
		int	n )

Clear toggle lzero bit. This function reset the display of leading zeroes for the specified operand to the default. If the default is not to display leading zeroes, leading zeroes will not be displayed, as vice versa. 
    
@param ea: the item (insn/data) address
@param n: the operand number (0-first operand, 1-other operands)
@returns success

clr_op_type()

bool clr_op_type	(	ida_idaapi.ea_t	ea,
		int	n )

Remove operand representation information. (set operand representation to be 'undefined') 
    
@param ea: linear address
@param n: 0..UA_MAXOP-1 operand number, OPND_ALL all operands
@returns success

code_flag()

'flags64_t' code_flag

(

)

FF_CODE

combine_flags()

'flags64_t' combine_flags

(

'flags64_t'

F

)

create_16bit_data()

bool create_16bit_data	(	ida_idaapi.ea_t	ea,
		'asize_t'	length )

Convert to 16-bit quantity (take the byte size into account)

create_32bit_data()

bool create_32bit_data	(	ida_idaapi.ea_t	ea,
		'asize_t'	length )

Convert to 32-bit quantity (take the byte size into account)

create_align()

bool create_align	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		int	alignment )

Create an alignment item. 
    
@param ea: linear address
@param length: size of the item in bytes. 0 means to infer from ALIGNMENT
@param alignment: alignment exponent. Example: 3 means align to 8 bytes. 0 means to infer from LENGTH It is forbidden to specify both LENGTH and ALIGNMENT as 0.
@returns success

create_byte()

bool create_byte	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		bool	force = False )

Convert to byte.

create_custdata()

bool create_custdata	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		int	dtid,
		int	fid,
		bool	force = False )

Convert to custom data type.

create_data()

bool create_data	(	ida_idaapi.ea_t	ea,
		'flags64_t'	dataflag,
		'asize_t'	size,
		'tid_t'	tid )

Convert to data (byte, word, dword, etc). This function may be used to create arrays. 
    
@param ea: linear address
@param dataflag: type of data. Value of function byte_flag(), word_flag(), etc.
@param size: size of array in bytes. should be divisible by the size of one item of the specified type. for variable sized items it can be specified as 0, and the kernel will try to calculate the size.
@param tid: type id. If the specified type is a structure, then tid is structure id. Otherwise should be BADNODE.
@returns success

create_double()

bool create_double	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		bool	force = False )

Convert to double.

create_dword()

bool create_dword	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		bool	force = False )

Convert to dword.

create_float()

bool create_float	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		bool	force = False )

Convert to float.

create_oword()

bool create_oword	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		bool	force = False )

Convert to octaword/xmm word.

create_packed_real()

bool create_packed_real	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		bool	force = False )

Convert to packed decimal real.

create_qword()

bool create_qword	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		bool	force = False )

Convert to quadword.

create_strlit()

bool create_strlit	(	ida_idaapi.ea_t	start,
		'size_t'	len,
		int	strtype )

Convert to string literal and give a meaningful name. 'start' may be higher than 'end', the kernel will swap them in this case 
    
@param start: starting address
@param len: length of the string in bytes. if 0, then get_max_strlit_length() will be used to determine the length
@param strtype: string type. one of String type codes
@returns success

create_struct()

bool create_struct	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		'tid_t'	tid,
		bool	force = False )

Convert to struct.

create_tbyte()

bool create_tbyte	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		bool	force = False )

Convert to tbyte.

create_word()

bool create_word	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		bool	force = False )

Convert to word.

create_yword()

bool create_yword	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		bool	force = False )

Convert to ymm word.

create_zword()

bool create_zword	(	ida_idaapi.ea_t	ea,
		'asize_t'	length,
		bool	force = False )

Convert to zmm word.

cust_flag()

'flags64_t' cust_flag

(

)

Get a flags64_t representing custom type data.

custfmt_flag()

'flags64_t' custfmt_flag

(

)

see FF_opbits

dec_flag()

'flags64_t' dec_flag

(

)

Get number flag of the base, regardless of current processor - better to use num_flag()

del_hidden_range()

bool del_hidden_range

(

ida_idaapi.ea_t

ea

)

Delete hidden range. 
    
@param ea: any address in the hidden range
@returns success

del_items()

bool del_items	(	ida_idaapi.ea_t	ea,
		int	flags = 0,
		'asize_t'	nbytes = 1,
		'may_destroy_cb_t *'	may_destroy = None )

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 
    
@param ea: any address within the first item to delete
@param flags: combination of Unexplored byte conversion flags
@param nbytes: number of bytes in the range to be undefined
@param may_destroy: optional routine invoked before deleting a head item. If callback returns false then item is not to be deleted and operation fails
@returns true on sucessful operation, otherwise false

del_mapping()

None del_mapping

(

ida_idaapi.ea_t

ea

)

Delete memory mapping range. 
    
@param ea: any address in the mapped range

del_value()

None del_value

(

ida_idaapi.ea_t

ea

)

Delete byte value from flags. The corresponding byte becomes uninitialized. 

detach_custom_data_format()

bool detach_custom_data_format	(	int	dtid,
		int	dfid )

Detach the data format from the data type. Unregistering a custom data type detaches all attached data formats, no need to detach them explicitly. You still need unregister them. Unregistering a custom data format detaches it from all attached data types. 
    
@param dtid: data type id to detach data format from
@param dfid: data format id to detach
@retval true: ok
@retval false: no such `dtid`, or no such `dfid', or the data format was not attached to the data type

disable_flags()

'error_t' disable_flags	(	ida_idaapi.ea_t	start_ea,
		ida_idaapi.ea_t	end_ea )

Deallocate flags for address range. Exit with an error message if not enough disk space (this may occur too). 
    
@param start_ea: should be lower than end_ea.
@param end_ea: does not belong to the range.
@returns 0 if ok, otherwise return error code

double_flag()

'flags64_t' double_flag

(

)

Get a flags64_t representing a double.

dword_flag()

'flags64_t' dword_flag

(

)

Get a flags64_t representing a double word.

enable_flags()

'error_t' enable_flags	(	ida_idaapi.ea_t	start_ea,
		ida_idaapi.ea_t	end_ea,
		'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. 
    
@param start_ea: should be lower than end_ea.
@param end_ea: does not belong to the range.
@param stt: storage_type_t
@returns 0 if ok, otherwise an error code

enum_flag()

'flags64_t' enum_flag

(

)

see FF_opbits

equal_bytes()

bool equal_bytes	(	ida_idaapi.ea_t	ea,
		'uchar const *'	image,
		'uchar const *'	mask,
		'size_t'	len,
		int	bin_search_flags )

Compare 'len' bytes of the program starting from 'ea' with 'image'. 
    
@param ea: linear address
@param image: bytes to compare with
@param mask: array of mask bytes, it's length is 'len'. if the flag BIN_SEARCH_BITMASK is passsed, 'bitwise AND' is used to compare. if not; 1 means to perform the comparison of the corresponding byte. 0 means not to perform. if mask == nullptr, then all bytes of 'image' will be compared. if mask == SKIP_FF_MASK then 0xFF bytes will be skipped
@param len: length of block to compare in bytes.
@param bin_search_flags: combination of Search flags
@retval 1: equal
@retval 0: not equal

f_has_cmt()

bool f_has_cmt	(	'flags64_t'	f,
		'void *'	arg2 )

f_has_dummy_name()

bool f_has_dummy_name	(	'flags64_t'	f,
		'void *'	arg2 )

Does the current byte have dummy (auto-generated, with special prefix) name?

f_has_extra_cmts()

bool f_has_extra_cmts	(	'flags64_t'	f,
		'void *'	arg2 )

f_has_name()

bool f_has_name	(	'flags64_t'	f,
		'void *'	arg2 )

Does the current byte have non-trivial (non-dummy) name?

f_has_user_name()

bool f_has_user_name	(	'flags64_t'	F,
		'void *'	arg2 )

Does the current byte have user-specified name?

f_has_xref()

bool f_has_xref	(	'flags64_t'	f,
		'void *'	arg2 )

Does the current byte have cross-references to it?

f_is_align()

bool f_is_align	(	'flags64_t'	F,
		'void *'	arg2 )

See is_align()

f_is_byte()

bool f_is_byte	(	'flags64_t'	F,
		'void *'	arg2 )

See is_byte()

f_is_code()

bool f_is_code	(	'flags64_t'	F,
		'void *'	arg2 )

Does flag denote start of an instruction?

f_is_custom()

bool f_is_custom	(	'flags64_t'	F,
		'void *'	arg2 )

See is_custom()

f_is_data()

bool f_is_data	(	'flags64_t'	F,
		'void *'	arg2 )

Does flag denote start of data?

f_is_double()

bool f_is_double	(	'flags64_t'	F,
		'void *'	arg2 )

See is_double()

f_is_dword()

bool f_is_dword	(	'flags64_t'	F,
		'void *'	arg2 )

See is_dword()

f_is_float()

bool f_is_float	(	'flags64_t'	F,
		'void *'	arg2 )

See is_float()

f_is_head()

bool f_is_head	(	'flags64_t'	F,
		'void *'	arg2 )

Does flag denote start of instruction OR data?

f_is_not_tail()

bool f_is_not_tail	(	'flags64_t'	F,
		'void *'	arg2 )

Does flag denote tail byte?

f_is_oword()

bool f_is_oword	(	'flags64_t'	F,
		'void *'	arg2 )

See is_oword()

f_is_pack_real()

bool f_is_pack_real	(	'flags64_t'	F,
		'void *'	arg2 )

See is_pack_real()

f_is_qword()

bool f_is_qword	(	'flags64_t'	F,
		'void *'	arg2 )

See is_qword()

f_is_strlit()

bool f_is_strlit	(	'flags64_t'	F,
		'void *'	arg2 )

See is_strlit()

f_is_struct()

bool f_is_struct	(	'flags64_t'	F,
		'void *'	arg2 )

See is_struct()

f_is_tail()

bool f_is_tail	(	'flags64_t'	F,
		'void *'	arg2 )

Does flag denote tail byte?

f_is_tbyte()

bool f_is_tbyte	(	'flags64_t'	F,
		'void *'	arg2 )

See is_tbyte()

f_is_word()

bool f_is_word	(	'flags64_t'	F,
		'void *'	arg2 )

See is_word()

f_is_yword()

bool f_is_yword	(	'flags64_t'	F,
		'void *'	arg2 )

See is_yword()

find_byte()

ida_idaapi.ea_t find_byte	(	ida_idaapi.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 
    
@param sEA: linear address
@param size: number of bytes to inspect
@param value: value to find
@param bin_search_flags: combination of Search flags
@returns address of byte or BADADDR

find_byter()

ida_idaapi.ea_t find_byter	(	ida_idaapi.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 
    
@param sEA: the lower address of the search range
@param size: number of bytes to inspect
@param value: value to find
@param bin_search_flags: combination of Search flags
@returns address of byte or BADADDR

find_bytes()

int find_bytes	(	typing.Union[bytes, bytearray, str]	bs,
		int	range_start,
		typing.Optional[int]	range_size = None,
		typing.Optional[int]	range_end = ida_idaapi.BADADDR,
		typing.Optional[typing.Union[bytes, bytearray ]]	mask = None,
		typing.Optional[int]	flags = BIN_SEARCH_FORWARD |     BIN_SEARCH_NOSHOW,
		typing.Optional[int]	radix = 16,
		typing.Optional[typing.Union[int, str]]	strlit_encoding = PBSENC_DEF1BPU )

find_custom_data_format()

int find_custom_data_format

(

str

name

)

Get id of a custom data format. 
    
@param name: name of the custom data format
@returns id or -1

find_custom_data_type()

int find_custom_data_type

(

str

name

)

Get id of a custom data type. 
    
@param name: name of the custom data type
@returns id or -1

find_free_chunk()

ida_idaapi.ea_t find_free_chunk	(	ida_idaapi.ea_t	start,
		'asize_t'	size,
		'asize_t'	alignment )

Search for a hole in the addressing space of the program. 
    
@param start: Address to start searching from
@param size: Size of the desired empty range
@param alignment: Alignment bitmask, must be a pow2-1. (for example, 0xF would align the returned range to 16 bytes).
@returns Start of the found empty range or BADADDR

find_string()

int find_string	(	str	_str,
		int	range_start,
		typing.Optional[int ]	range_end = ida_idaapi.BADADDR,
		typing.Optional[int]	range_size = None,
		typing.Optional[typing.Union[int, str]]	strlit_encoding = PBSENC_DEF1BPU,
		typing.Optional[int]	flags = BIN_SEARCH_FORWARD | BIN_SEARCH_NOSHOW )

float_flag()

'flags64_t' float_flag

(

)

Get a flags64_t representing a float.

flt_flag()

'flags64_t' flt_flag

(

)

see FF_opbits

get_16bit()

int get_16bit

(

ida_idaapi.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()

get_32bit()

int get_32bit

(

ida_idaapi.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_dword(ea);
* if ( nbits <= 16) return get_wide_word(ea);
* return get_wide_byte(ea);

get_64bit()

'uint64' get_64bit

(

ida_idaapi.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_wide_dword(ea);
* return get_wide_byte(ea);

get_byte()

'uchar' get_byte

(

ida_idaapi.ea_t

ea

)

Get one byte (8-bit) of the program at 'ea'. This function works only for 8bit byte processors. 

get_bytes()

get_bytes	(	ida_idaapi.ea_t	ea,
		int	size,
		int	gmb_flags = GMB_READALL )

Get the specified number of bytes of the program.

@param ea: program address
@param size: number of bytes to return
@param gmb_flags: OR'ed combination of GMB_* values (defaults to GMB_READALL)
@return: the bytes (as bytes object), or None in case of failure

get_bytes_and_mask()

get_bytes_and_mask	(	ida_idaapi.ea_t	ea,
		int	size,
		int	gmb_flags = GMB_READALL )

Get the specified number of bytes of the program, and a bitmask
specifying what bytes are defined and what bytes are not.

@param ea: program address
@param size: number of bytes to return
@param gmb_flags: OR'ed combination of GMB_* values (defaults to GMB_READALL)
@return: a tuple (bytes, mask), or None in case of failure.
     Both 'bytes' and 'mask' are 'str' instances.

get_cmt()

str get_cmt	(	ida_idaapi.ea_t	ea,
		bool	rptble )

Get an indented comment. 
    
@param ea: linear address. may point to tail byte, the function will find start of the item
@param rptble: get repeatable comment?
@returns size of comment or -1

get_custom_data_format()

'data_format_t const *' get_custom_data_format

(

int

dfid

)

Get definition of a registered custom data format. 
    
@param dfid: data format id
@returns data format definition or nullptr

get_custom_data_formats()

int get_custom_data_formats	(	'intvec_t *'	out,
		int	dtid )

Get list of attached custom data formats for the specified data type. 
    
@param out: buffer for the output. may be nullptr
@param dtid: data type id
@returns number of returned custom data formats. if error, returns -1

get_custom_data_type()

'data_type_t const *' get_custom_data_type

(

int

dtid

)

Get definition of a registered custom data type. 
    
@param dtid: data type id
@returns data type definition or nullptr

get_custom_data_types()

int get_custom_data_types

(

*

args

)

Get list of registered custom data type ids. 
    
@param out: buffer for the output. may be nullptr
@param min_size: minimum value size
@param max_size: maximum value size
@returns number of custom data types with the specified size limits

get_data_elsize()

'asize_t' get_data_elsize	(	ida_idaapi.ea_t	ea,
		'flags64_t'	F,
		'opinfo_t'	ti = None )

Get size of data type specified in flags 'F'. 
    
@param ea: linear address of the item
@param F: flags
@param 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 nullptr). If specified as nullptr, will be automatically retrieved from the database
@returns * byte : 1
* word : 2
* etc...

get_data_value()

bool get_data_value	(	'uval_t *'	v,
		ida_idaapi.ea_t	ea,
		'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) 
    
@param v: pointer to the result. may be nullptr
@param ea: linear address
@param size: size of data to read. If 0, then the item type at 'ea' will be used
@returns success

get_db_byte()

'uchar' get_db_byte

(

ida_idaapi.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. 

get_default_radix()

int get_default_radix

(

)

Get default base of number for the current processor. 
    
@returns 2, 8, 10, 16

get_dword()

int get_dword

(

ida_idaapi.ea_t

ea

)

Get one dword (32-bit) of the program at 'ea'. This function takes into account order of bytes specified in idainfo::is_be() This function works only for 8bit byte processors. 

get_enum_id()

'uchar *' get_enum_id	(	ida_idaapi.ea_t	ea,
		int	n )

Get enum id of 'enum' operand. 
    
@param ea: linear address
@param n: 0..UA_MAXOP-1 operand number, OPND_ALL one of the operands
@returns id of enum or BADNODE

get_first_hidden_range()

'hidden_range_t *' get_first_hidden_range

(

)

Get pointer to the first hidden range. 
    
@returns ptr to hidden range or nullptr

get_flags()

'flags64_t' get_flags

(

ida_idaapi.ea_t

ea

)

get flags with FF_IVL & MS_VAL. It is much slower under remote debugging because the kernel needs to read the process memory. 

get_flags_by_size()

'flags64_t' get_flags_by_size

(

'size_t'

size

)

Get flags from size (in bytes). Supported sizes: 1, 2, 4, 8, 16, 32. For other sizes returns 0 

get_flags_ex()

'flags64_t' get_flags_ex	(	ida_idaapi.ea_t	ea,
		int	how )

Get flags for the specified address, extended form.

get_forced_operand()

str get_forced_operand	(	ida_idaapi.ea_t	ea,
		int	n )

Get forced operand. 
    
@param ea: linear address
@param n: 0..UA_MAXOP-1 operand number
@returns size of forced operand or -1

get_full_data_elsize()

'asize_t' get_full_data_elsize	(	ida_idaapi.ea_t	ea,
		'flags64_t'	F,
		'opinfo_t'	ti = None )

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 

get_full_flags()

'flags64_t' get_full_flags

(

ida_idaapi.ea_t

ea

)

Get flags value for address 'ea'. 
    
@returns 0 if address is not present in the program

get_hidden_range()

'hidden_range_t *' get_hidden_range

(

ida_idaapi.ea_t

ea

)

Get pointer to hidden range structure, in: linear address. 
    
@param ea: any address in the hidden range

get_hidden_range_num()

int get_hidden_range_num

(

ida_idaapi.ea_t

ea

)

Get number of a hidden range. 
    
@param ea: any address in the hidden range
@returns number of hidden range (0..get_hidden_range_qty()-1)

get_hidden_range_qty()

int get_hidden_range_qty

(

)

Get number of hidden ranges.

get_item_end()

ida_idaapi.ea_t get_item_end

(

ida_idaapi.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. 

get_item_flag()

'flags64_t' get_item_flag	(	ida_idaapi.ea_t	_from,
		int	n,
		ida_idaapi.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. 
    
@param n: operand number which refers to 'ea' or OPND_ALL for one of the operands
@param ea: the referenced address
@param 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)

get_item_head()

ida_idaapi.ea_t get_item_head

(

ida_idaapi.ea_t

ea

)

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) 

get_item_refinfo()

bool get_item_refinfo	(	'refinfo_t'	ri,
		ida_idaapi.ea_t	ea,
		int	n )

Get refinfo of the item at 'ea'. This function works for a regular offset operand as well as for a tail byte of a structure variable (in this case refinfo to corresponding structure member will be returned) 
    
@param ri: refinfo holder
@param ea: the item address
@param n: operand number which refers to 'ea' or OPND_ALL for one of the operands
@returns success

get_item_size()

'asize_t' get_item_size

(

ida_idaapi.ea_t

ea

)

Get size of item (instruction/data) in bytes. Unexplored bytes have length of 1 byte. This function returns 0 only for BADADDR. 

get_last_hidden_range()

'hidden_range_t *' get_last_hidden_range

(

)

Get pointer to the last hidden range. 
    
@returns ptr to hidden range or nullptr

get_manual_insn()

str get_manual_insn

(

ida_idaapi.ea_t

ea

)

Retrieve the user-specified string for the manual instruction. 
    
@param ea: linear address of the instruction or data item
@returns size of manual instruction or -1

get_mapping()

'ea_t *, ea_t *, asize_t *' get_mapping

(

'size_t'

n

)

Get memory mapping range by its number. 
    
@param n: number of mapping range (0..get_mappings_qty()-1)
@returns false if the specified range doesn't exist, otherwise returns `from`, `to`, `size`

get_mappings_qty()

'size_t' get_mappings_qty

(

)

Get number of mappings.

get_max_strlit_length()

'size_t' get_max_strlit_length	(	ida_idaapi.ea_t	ea,
		int	strtype,
		int	options = 0 )

Determine maximum length of string literal.
If the string literal has a length prefix (e.g., STRTYPE_LEN2 has a two-byte length prefix), the length of that prefix (i.e., 2) will be part of the returned value.

@param ea: starting address
@param strtype: string type. one of String type codes
@param options: combination of string literal length options
@returns length of the string in octets (octet==8bit)

get_next_hidden_range()

'hidden_range_t *' get_next_hidden_range

(

ida_idaapi.ea_t

ea

)

Get pointer to next hidden range. 
    
@param ea: any address in the program
@returns ptr to hidden range or nullptr if next hidden range doesn't exist

get_octet()

'uchar *' get_octet

(

'octet_generator_t'

ogen

)

get_operand_flag()

'flags64_t' get_operand_flag	(	'uint8'	typebits,
		int	n )

Place operand `n`'s type flag in the right nibble of a 64-bit flags set.

@param typebits: the type bits (one of `FF_N_`)
@param n: the operand number
@returns the shift to the nibble

get_operand_type_shift()

int get_operand_type_shift

(

int

n

)

Get the shift in `flags64_t` for the nibble representing operand `n`'s type
Note: n must be < UA_MAXOP, and is not checked

@param n: the operand number
@returns the shift to the nibble

get_opinfo()

'opinfo_t *' get_opinfo	(	'opinfo_t'	buf,
		ida_idaapi.ea_t	ea,
		int	n,
		'flags64_t'	flags )

Get additional information about an operand representation. 
    
@param buf: buffer to receive the result. may not be nullptr
@param ea: linear address of item
@param n: number of operand, 0 or 1
@param flags: flags of the item
@returns nullptr if no additional representation information

get_optype_flags0()

'flags64_t' get_optype_flags0

(

'flags64_t'

F

)

Get flags for first operand.

get_optype_flags1()

'flags64_t' get_optype_flags1

(

'flags64_t'

F

)

Get flags for second operand.

get_original_byte()

'uint64' get_original_byte

(

ida_idaapi.ea_t

ea

)

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

get_original_dword()

'uint64' get_original_dword

(

ida_idaapi.ea_t

ea

)

Get original dword (that was before patching) This function works for wide byte processors too. This function takes into account order of bytes specified in idainfo::is_be() 

get_original_qword()

'uint64' get_original_qword

(

ida_idaapi.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::is_be() 

get_original_word()

'uint64' get_original_word

(

ida_idaapi.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::is_be() 

get_possible_item_varsize()

'asize_t' get_possible_item_varsize	(	ida_idaapi.ea_t	ea,
		'tinfo_t'	tif )

Return the possible size of the item at EA of type TIF if TIF is the variable structure. 
    
@param ea: the linear address of the item
@param tif: the item type
@returns the possible size
@retval asize_t(-1): TIF is not a variable structure

get_predef_insn_cmt()

str get_predef_insn_cmt

(

'insn_t const &'

ins

)

Get predefined comment. 
    
@param ins: current instruction information
@returns size of comment or -1

get_prev_hidden_range()

'hidden_range_t *' get_prev_hidden_range

(

ida_idaapi.ea_t

ea

)

Get pointer to previous hidden range. 
    
@param ea: any address in the program
@returns ptr to hidden range or nullptr if previous hidden range doesn't exist

get_qword()

'uint64' get_qword

(

ida_idaapi.ea_t

ea

)

Get one qword (64-bit) of the program at 'ea'. This function takes into account order of bytes specified in idainfo::is_be() This function works only for 8bit byte processors. 

get_radix()

int get_radix	(	'flags64_t'	F,
		int	n )

Get radix of the operand, in: flags. If the operand is not a number, returns get_default_radix() 
    
@param F: flags
@param n: number of operand (0, 1, -1)
@returns 2, 8, 10, 16

get_strlit_contents()

get_strlit_contents	(	ida_idaapi.ea_t	ea,
		int	len,
		int	type,
		int	flags = 0 )

Get contents of string literal, as UTF-8-encoded codepoints.
It works even if the string has not been created in the database yet.

Note that the returned value will be of type 'bytes'; if
you want auto-conversion to unicode strings (that is: real Python
strings), you should probably be using the idautils.Strings class.

@param ea: linear address of the string
@param len: length of the string in bytes (including terminating 0)
@param type: type of the string. Represents both the character encoding,
         <u>and</u> the 'type' of string at the given location.
@param flags: combination of STRCONV_..., to perform output conversion.
@return: a bytes-filled str object.

get_stroff_path()

get_stroff_path

(

*

args

)

Get the structure offset path for operand `n`, at the
specified address.

This function has the following signatures:

1. get_stroff_path(ea: ida_idaapi.ea_t, n : int) -> Tuple[List[int], int]
2. get_stroff_path(path: tid_array, delta: sval_pointer, ea: ida_idaapi.ea_t, n : int) (backward-compatibility only)

@param ea address where the operand holds a path to a structure offset (1st form)
@param n operand number (1st form)
@return a tuple holding a (list_of_tid_t's, delta_within_the_last_type), or (None, None)

get_wide_byte()

'uint64' get_wide_byte

(

ida_idaapi.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. 

get_wide_dword()

'uint64' get_wide_dword

(

ida_idaapi.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::is_be() 

get_wide_word()

'uint64' get_wide_word

(

ida_idaapi.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::is_be() 

get_word()

'ushort' get_word

(

ida_idaapi.ea_t

ea

)

Get one word (16-bit) of the program at 'ea'. This function takes into account order of bytes specified in idainfo::is_be() This function works only for 8bit byte processors. 

get_zero_ranges()

bool get_zero_ranges	(	'rangeset_t'	zranges,
		'range_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. 
    
@param zranges: pointer to the return value. cannot be nullptr
@param range: the range of addresses to verify. can be nullptr - means all ranges
@returns true if the result is a non-empty set

getn_hidden_range()

'hidden_range_t *' getn_hidden_range

(

int

n

)

Get pointer to hidden range structure, in: number of hidden range. 
    
@param n: number of hidden range, is in range 0..get_hidden_range_qty()-1

has_any_name()

bool has_any_name

(

'flags64_t'

F

)

Does the current byte have any name?

has_auto_name()

bool has_auto_name

(

'flags64_t'

F

)

Does the current byte have auto-generated (no special prefix) name?

has_cmt()

bool has_cmt

(

'flags64_t'

F

)

Does the current byte have an indented comment?

has_dummy_name()

bool has_dummy_name

(

'flags64_t'

F

)

Does the current byte have dummy (auto-generated, with special prefix) name?

has_extra_cmts()

bool has_extra_cmts

(

'flags64_t'

F

)

Does the current byte have additional anterior or posterior lines?

has_immd()

bool has_immd

(

'flags64_t'

F

)

Has immediate value?

has_name()

bool has_name

(

'flags64_t'

F

)

Does the current byte have non-trivial (non-dummy) name?

has_user_name()

bool has_user_name

(

'flags64_t'

F

)

Does the current byte have user-specified name?

has_value()

bool has_value

(

'flags64_t'

F

)

Do flags contain byte value?

has_xref()

bool has_xref

(

'flags64_t'

F

)

Does the current byte have cross-references to it?

hex_flag()

'flags64_t' hex_flag

(

)

Get number flag of the base, regardless of current processor - better to use num_flag()

is_align()

bool is_align

(

'flags64_t'

F

)

FF_ALIGN

is_attached_custom_data_format()

bool is_attached_custom_data_format	(	int	dtid,
		int	dfid )

Is the custom data format attached to the custom data type? 
    
@param dtid: data type id
@param dfid: data format id
@returns true or false

is_bnot()

bool is_bnot	(	ida_idaapi.ea_t	ea,
		'flags64_t'	F,
		int	n )

Should we negate the operand?. asm_t::a_bnot should be defined in the idp module in order to work with this function 

is_byte()

bool is_byte

(

'flags64_t'

F

)

FF_BYTE

is_char()

bool is_char	(	'flags64_t'	F,
		int	n )

is character constant?

is_char0()

bool is_char0

(

'flags64_t'

F

)

Is the first operand character constant? (example: push 'a')

is_char1()

bool is_char1

(

'flags64_t'

F

)

Is the second operand character constant? (example: mov al, 'a')

is_code()

bool is_code

(

'flags64_t'

F

)

Does flag denote start of an instruction?

is_custfmt()

bool is_custfmt	(	'flags64_t'	F,
		int	n )

is custom data format?

is_custfmt0()

bool is_custfmt0

(

'flags64_t'

F

)

Does the first operand use a custom data representation?

is_custfmt1()

bool is_custfmt1

(

'flags64_t'

F

)

Does the second operand use a custom data representation?

is_custom()

bool is_custom

(

'flags64_t'

F

)

FF_CUSTOM

is_data()

bool is_data

(

'flags64_t'

F

)

Does flag denote start of data?

is_defarg()

bool is_defarg	(	'flags64_t'	F,
		int	n )

is defined?

is_defarg0()

bool is_defarg0

(

'flags64_t'

F

)

Is the first operand defined? Initially operand has no defined representation.

is_defarg1()

bool is_defarg1

(

'flags64_t'

F

)

Is the second operand defined? Initially operand has no defined representation.

is_double()

bool is_double

(

'flags64_t'

F

)

FF_DOUBLE

is_dword()

bool is_dword

(

'flags64_t'

F

)

FF_DWORD

is_enum()

bool is_enum	(	'flags64_t'	F,
		int	n )

is enum?

is_enum0()

bool is_enum0

(

'flags64_t'

F

)

Is the first operand a symbolic constant (enum member)?

is_enum1()

bool is_enum1

(

'flags64_t'

F

)

Is the second operand a symbolic constant (enum member)?

is_flag_for_operand()

bool is_flag_for_operand	(	'flags64_t'	F,
		'uint8'	typebits,
		int	n )

Check that the 64-bit flags set has the expected type for operand `n`.

@param F: the flags
@param typebits: the type bits (one of `FF_N_`)
@param n: the operand number
@returns success

is_float()

bool is_float

(

'flags64_t'

F

)

FF_FLOAT

is_float0()

bool is_float0

(

'flags64_t'

F

)

Is the first operand a floating point number?

is_float1()

bool is_float1

(

'flags64_t'

F

)

Is the second operand a floating point number?

is_flow()

bool is_flow

(

'flags64_t'

F

)

Does the previous instruction exist and pass execution flow to the current byte?

is_fltnum()

bool is_fltnum	(	'flags64_t'	F,
		int	n )

is floating point number?

is_forced_operand()

bool is_forced_operand	(	ida_idaapi.ea_t	ea,
		int	n )

Is operand manually defined?. 
    
@param ea: linear address
@param n: 0..UA_MAXOP-1 operand number

is_func()

bool is_func

(

'flags64_t'

F

)

Is function start?

is_head()

bool is_head

(

'flags64_t'

F

)

Does flag denote start of instruction OR data?

is_invsign()

bool is_invsign	(	ida_idaapi.ea_t	ea,
		'flags64_t'	F,
		int	n )

Should sign of n-th operand inverted during output?. allowed values of n: 0-first operand, 1-other operands 

is_loaded()

bool is_loaded

(

ida_idaapi.ea_t

ea

)

Does the specified address have a byte value (is initialized?)

is_lzero()

bool is_lzero	(	ida_idaapi.ea_t	ea,
		int	n )

Display leading zeroes? Display leading zeroes in operands. The global switch for the leading zeroes is in idainfo::s_genflags Note: the leading zeroes doesn't work if for the target assembler octal numbers start with 0. 
    
@param ea: the item (insn/data) address
@param n: the operand number (0-first operand, 1-other operands)
@returns success

is_manual()

bool is_manual	(	'flags64_t'	F,
		int	n )

is forced operand? (use is_forced_operand())

is_manual_insn()

bool is_manual_insn

(

ida_idaapi.ea_t

ea

)

Is the instruction overridden? 
    
@param ea: linear address of the instruction or data item

is_mapped()

bool is_mapped

(

ida_idaapi.ea_t

ea

)

Is the specified address 'ea' present in the program?

is_not_tail()

bool is_not_tail

(

'flags64_t'

F

)

Does flag denote tail byte?

is_numop()

bool is_numop	(	'flags64_t'	F,
		int	n )

is number (bin, oct, dec, hex)?

is_numop0()

bool is_numop0

(

'flags64_t'

F

)

Is the first operand a number (i.e. binary, octal, decimal or hex?)

is_numop1()

bool is_numop1

(

'flags64_t'

F

)

Is the second operand a number (i.e. binary, octal, decimal or hex?)

is_off()

bool is_off	(	'flags64_t'	F,
		int	n )

is offset?

is_off0()

bool is_off0

(

'flags64_t'

F

)

Is the first operand offset? (example: push offset xxx)

is_off1()

bool is_off1

(

'flags64_t'

F

)

Is the second operand offset? (example: mov ax, offset xxx)

is_oword()

bool is_oword

(

'flags64_t'

F

)

FF_OWORD

is_pack_real()

bool is_pack_real

(

'flags64_t'

F

)

FF_PACKREAL

is_qword()

bool is_qword

(

'flags64_t'

F

)

FF_QWORD

is_same_data_type()

bool is_same_data_type	(	'flags64_t'	F1,
		'flags64_t'	F2 )

Do the given flags specify the same data type?

is_seg()

bool is_seg	(	'flags64_t'	F,
		int	n )

is segment?

is_seg0()

bool is_seg0

(

'flags64_t'

F

)

Is the first operand segment selector? (example: push seg seg001)

is_seg1()

bool is_seg1

(

'flags64_t'

F

)

Is the second operand segment selector? (example: mov dx, seg dseg)

is_stkvar()

bool is_stkvar	(	'flags64_t'	F,
		int	n )

is stack variable?

is_stkvar0()

bool is_stkvar0

(

'flags64_t'

F

)

Is the first operand a stack variable?

is_stkvar1()

bool is_stkvar1

(

'flags64_t'

F

)

Is the second operand a stack variable?

is_strlit()

bool is_strlit

(

'flags64_t'

F

)

FF_STRLIT

is_stroff()

bool is_stroff	(	'flags64_t'	F,
		int	n )

is struct offset?

is_stroff0()

bool is_stroff0

(

'flags64_t'

F

)

Is the first operand an offset within a struct?

is_stroff1()

bool is_stroff1

(

'flags64_t'

F

)

Is the second operand an offset within a struct?

is_struct()

bool is_struct

(

'flags64_t'

F

)

FF_STRUCT

is_suspop()

bool is_suspop	(	ida_idaapi.ea_t	ea,
		'flags64_t'	F,
		int	n )

is suspicious operand?

is_tail()

bool is_tail

(

'flags64_t'

F

)

Does flag denote tail byte?

is_tbyte()

bool is_tbyte

(

'flags64_t'

F

)

FF_TBYTE

is_unknown()

bool is_unknown

(

'flags64_t'

F

)

Does flag denote unexplored byte?

is_varsize_item()

int is_varsize_item	(	ida_idaapi.ea_t	ea,
		'flags64_t'	F,
		'opinfo_t'	ti = None,
		'asize_t *'	itemsize = None )

Is the item at 'ea' variable size?. 
    
@param ea: linear address of the item
@param F: flags
@param 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 nullptr). If specified as nullptr, will be automatically retrieved from the database
@param itemsize: if not nullptr and the item is varsize, itemsize will contain the calculated item size (for struct types, the minimal size is returned)
@retval 1: varsize item
@retval 0: fixed item
@retval -1: error (bad data definition)

is_word()

bool is_word

(

'flags64_t'

F

)

FF_WORD

is_yword()

bool is_yword

(

'flags64_t'

F

)

FF_YWORD

is_zword()

bool is_zword

(

'flags64_t'

F

)

FF_ZWORD

leading_zero_important()

bool leading_zero_important	(	ida_idaapi.ea_t	ea,
		int	n )

Check if leading zeroes are important.

nbits()

int nbits

(

ida_idaapi.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

next_addr()

ida_idaapi.ea_t next_addr

(

ida_idaapi.ea_t

ea

)

Get next address in the program (i.e. next address which has flags). 
    
@returns BADADDR if no such address exist.

next_chunk()

ida_idaapi.ea_t next_chunk

(

ida_idaapi.ea_t

ea

)

Get the first address of next contiguous chunk in the program. 
    
@returns BADADDR if next chunk doesn't exist.

next_head()

ida_idaapi.ea_t next_head	(	ida_idaapi.ea_t	ea,
		ida_idaapi.ea_t	maxea )

Get start of next defined item. 
    
@param ea: begin search at this address
@param maxea: not included in the search range
@returns BADADDR if none exists.

next_inited()

ida_idaapi.ea_t next_inited	(	ida_idaapi.ea_t	ea,
		ida_idaapi.ea_t	maxea )

Find the next initialized address.

next_not_tail()

ida_idaapi.ea_t next_not_tail

(

ida_idaapi.ea_t

ea

)

Get address of next non-tail byte. 
    
@returns BADADDR if none exists.

next_that()

ida_idaapi.ea_t next_that	(	ida_idaapi.ea_t	ea,
		ida_idaapi.ea_t	maxea,
		'testf_t *'	testf )

Find next address with a flag satisfying the function 'testf'. 
    
@param ea: start searching at this address + 1
@param maxea: not included in the search range.
@param testf: test function to find next address
@returns the found address or BADADDR.

next_unknown()

ida_idaapi.ea_t next_unknown	(	ida_idaapi.ea_t	ea,
		ida_idaapi.ea_t	maxea )

Similar to next_that(), but will find the next address that is unexplored.

next_visea()

ida_idaapi.ea_t next_visea

(

ida_idaapi.ea_t

ea

)

Get next visible address. 
    
@returns BADADDR if none exists.

num_flag()

'flags64_t' num_flag

(

)

Get number of default base (bin, oct, dec, hex) 

oct_flag()

'flags64_t' oct_flag

(

)

Get number flag of the base, regardless of current processor - better to use num_flag()

off_flag()

'flags64_t' off_flag

(

)

see FF_opbits

op_adds_xrefs()

bool op_adds_xrefs	(	'flags64_t'	F,
		int	n )

Should processor module create xrefs from the operand?. Currently 'offset' and 'structure offset' operands create xrefs 

op_based_stroff()

bool op_based_stroff	(	'insn_t const &'	insn,
		int	n,
		'adiff_t'	opval,
		ida_idaapi.ea_t	base )

Set operand representation to be 'struct offset' if the operand likely points to a structure member. For example, let's there is a structure at 1000 1000 stru_1000 Elf32_Sym <...> the operand #8 will be represented as '#Elf32_Sym.st_size' after the call of 'op_based_stroff(..., 8, 0x1000)' By the way, after the call of 'op_plain_offset(..., 0x1000)' it will be represented as '#(stru_1000.st_size - 0x1000)' 
    
@param insn: the instruction
@param n: 0..UA_MAXOP-1 operand number, OPND_ALL all operands
@param opval: operand value (usually op_t::value or op_t::addr)
@param base: base reference
@returns success

op_bin()

bool op_bin	(	ida_idaapi.ea_t	ea,
		int	n )

set op type to bin_flag()

op_chr()

bool op_chr	(	ida_idaapi.ea_t	ea,
		int	n )

set op type to char_flag()

op_custfmt()

bool op_custfmt	(	ida_idaapi.ea_t	ea,
		int	n,
		int	fid )

Set custom data format for operand (fid-custom data format id)

op_dec()

bool op_dec	(	ida_idaapi.ea_t	ea,
		int	n )

set op type to dec_flag()

op_enum()

bool op_enum	(	ida_idaapi.ea_t	ea,
		int	n,
		'tid_t'	id,
		'uchar'	serial = 0 )

Set operand representation to be enum type If applied to unexplored bytes, converts them to 16/32bit word data 
    
@param ea: linear address
@param n: 0..UA_MAXOP-1 operand number, OPND_ALL all operands
@param id: id of enum
@param serial: the serial number of the constant in the enumeration, usually 0. the serial numbers are used if the enumeration contains several constants with the same value
@returns success

op_flt()

bool op_flt	(	ida_idaapi.ea_t	ea,
		int	n )

set op type to flt_flag()

op_hex()

bool op_hex	(	ida_idaapi.ea_t	ea,
		int	n )

set op type to hex_flag()

op_num()

bool op_num	(	ida_idaapi.ea_t	ea,
		int	n )

set op type to num_flag()

op_oct()

bool op_oct	(	ida_idaapi.ea_t	ea,
		int	n )

set op type to oct_flag()

op_seg()

bool op_seg	(	ida_idaapi.ea_t	ea,
		int	n )

Set operand representation to be 'segment'. If applied to unexplored bytes, converts them to 16/32bit word data 
    
@param ea: linear address
@param n: 0..UA_MAXOP-1 operand number, OPND_ALL all operands
@returns success

op_stkvar()

bool op_stkvar	(	ida_idaapi.ea_t	ea,
		int	n )

Set operand representation to be 'stack variable'. Should be applied to an instruction within a function. Should be applied after creating a stack var using insn_t::create_stkvar(). 
    
@param ea: linear address
@param n: 0..UA_MAXOP-1 operand number, OPND_ALL all operands
@returns success

op_stroff()

bool op_stroff

(

*

args

)

Set operand representation to be 'struct offset'.

This function has the following signatures:

1. op_stroff(ins: ida_ua.insn_t, n: int, path: List[int], delta: int)
2. op_stroff(ins: ida_ua.insn_t, n: int, path: ida_pro.tid_array, path_len: int, delta: int) (backward-compatibility only)

Here is an example using this function:

ins = ida_ua.insn_t()
if ida_ua.decode_insn(ins, some_address):
    operand = 0
    path = [ida_typeinf.get_named_type_tid("my_stucture_t")] # a one-element path
    ida_bytes.op_stroff(ins, operand, path, 0)

oword_flag()

'flags64_t' oword_flag

(

)

Get a flags64_t representing a octaword.

packreal_flag()

'flags64_t' packreal_flag

(

)

Get a flags64_t representing a packed decimal real.

parse_binpat_str()

bool parse_binpat_str	(	'compiled_binpat_vec_t'	out,
		ida_idaapi.ea_t	ea,
		str	_in,
		int	radix,
		int	strlits_encoding = 0 )

Convert user-specified binary string to internal representation. The 'in' parameter contains space-separated tokens: 
 numbers (numeric base is determined by 'radix')
    - if value of number fits a byte, it is considered as a byte
    - if value of number fits a word, it is considered as 2 bytes
    - if value of number fits a dword,it is considered as 4 bytes
 "..." string constants
 'x'  single-character constants
 ?    variable bytes


Note that string constants are surrounded with double quotes.
Here are a few examples (assuming base 16): 
 21          - bytes 0xCD, 0x21
           - bytes 0xCD, 0x21 (little endian ) or 0x21, 0xCD (big-endian)
 0     - the null terminated string "Hello"
       - 'H', 0, 'e', 0, 'l', 0, 'l', 0, 'o', 0
 ? ? ? ? 90  - byte 0xB8, 4 bytes with any value, byte 0x90


    
@param out: a vector of compiled binary patterns, for use with bin_search()
@param ea: linear address to convert for (the conversion depends on the address, because the number of bits in a byte depend on the segment type)
@param radix: numeric base of numbers (8,10,16)
@param strlits_encoding: the target encoding into which the string literals present in 'in', should be encoded. Can be any from [1, get_encoding_qty()), or the special values PBSENC_*
@returns false either in case of parsing error, or if at least one requested target encoding couldn't encode the string literals present in "in".

patch_byte()

bool patch_byte	(	ida_idaapi.ea_t	ea,
		'uint64'	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. 
    
@retval true: the database has been modified,
@retval 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.

patch_bytes()

None patch_bytes	(	ida_idaapi.ea_t	ea,
		'void const *'	buf )

Patch the specified number of bytes of the program. Original values of bytes are saved and are available with get_original...() functions. See also put_bytes(). 
    
@param ea: linear address
@param buf: buffer with new values of bytes

patch_dword()

bool patch_dword	(	ida_idaapi.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_dword(). This function DOESN'T work for wide byte processors. This function takes into account order of bytes specified in idainfo::is_be() 
    
@retval true: the database has been modified,
@retval 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.

patch_qword()

bool patch_qword	(	ida_idaapi.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::is_be() 
    
@retval true: the database has been modified,
@retval 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.

patch_word()

bool patch_word	(	ida_idaapi.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::is_be() 
    
@retval true: the database has been modified,
@retval 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.

prev_addr()

ida_idaapi.ea_t prev_addr

(

ida_idaapi.ea_t

ea

)

Get previous address in the program. 
    
@returns BADADDR if no such address exist.

prev_chunk()

ida_idaapi.ea_t prev_chunk

(

ida_idaapi.ea_t

ea

)

Get the last address of previous contiguous chunk in the program. 
    
@returns BADADDR if previous chunk doesn't exist.

prev_head()

ida_idaapi.ea_t prev_head	(	ida_idaapi.ea_t	ea,
		ida_idaapi.ea_t	minea )

Get start of previous defined item. 
    
@param ea: begin search at this address
@param minea: included in the search range
@returns BADADDR if none exists.

prev_inited()

ida_idaapi.ea_t prev_inited	(	ida_idaapi.ea_t	ea,
		ida_idaapi.ea_t	minea )

Find the previous initialized address.

prev_not_tail()

ida_idaapi.ea_t prev_not_tail

(

ida_idaapi.ea_t

ea

)

Get address of previous non-tail byte. 
    
@returns BADADDR if none exists.

prev_that()

ida_idaapi.ea_t prev_that	(	ida_idaapi.ea_t	ea,
		ida_idaapi.ea_t	minea,
		'testf_t *'	testf )

Find previous address with a flag satisfying the function 'testf'. 
    
@param ea: start searching from this address - 1.
@param minea: included in the search range.
@param testf: test function to find previous address
@returns the found address or BADADDR.

prev_unknown()

ida_idaapi.ea_t prev_unknown	(	ida_idaapi.ea_t	ea,
		ida_idaapi.ea_t	minea )

Similar to prev_that(), but will find the previous address that is unexplored.

prev_visea()

ida_idaapi.ea_t prev_visea

(

ida_idaapi.ea_t

ea

)

Get previous visible address. 
    
@returns BADADDR if none exists.

print_strlit_type()

'PyObject *' print_strlit_type	(	int	strtype,
		int	flags = 0 )

Get string type information: the string type name (possibly decorated with hotkey markers), and the tooltip.

@param strtype: the string type
@param flags: or'ed PSTF_* constants
@returns length of generated text

put_byte()

bool put_byte	(	ida_idaapi.ea_t	ea,
		'uint64'	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. 
    
@param ea: linear address
@param x: byte value
@returns true if the database has been modified

put_bytes()

None put_bytes	(	ida_idaapi.ea_t	ea,
		'void const *'	buf )

Modify the specified number of bytes of the program. This function does not save the original values of bytes. See also patch_bytes(). 
    
@param ea: linear address
@param buf: buffer with new values of bytes

put_dword()

None put_dword	(	ida_idaapi.ea_t	ea,
		'uint64'	x )

Set value of one dword of the program. This function takes into account order of bytes specified in idainfo::is_be() This function works for wide byte processors too. 
    
@param ea: linear address
@param x: dword value

put_qword()

None put_qword	(	ida_idaapi.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::is_be() This function DOESN'T works for wide byte processors. 
    
@param ea: linear address
@param x: qword value

put_word()

None put_word	(	ida_idaapi.ea_t	ea,
		'uint64'	x )

Set value of one word of the program. This function takes into account order of bytes specified in idainfo::is_be() This function works for wide byte processors too. 

qword_flag()

'flags64_t' qword_flag

(

)

Get a flags64_t representing a quad word.

register_custom_data_format()

register_custom_data_format

(

df

)

Registers a custom data format with a given data type.

@param df: an instance of data_format_t
@return:
< 0 if failed to register
> 0 data format id

register_custom_data_type()

register_custom_data_type

(

dt

)

Registers a custom data type.

@param dt: an instance of the data_type_t class
@return:
< 0 if failed to register
> 0 data type id

register_data_types_and_formats()

register_data_types_and_formats

(

formats

)

Registers multiple data types and formats at once.
To register one type/format at a time use register_custom_data_type/register_custom_data_format

It employs a special table of types and formats described below:

The 'formats' is a list of tuples. If a tuple has one element then it is the format to be registered with dtid=0
If the tuple has more than one element, then tuple[0] is the data type and tuple[1:] are the data formats. For example:
many_formats = [
  (pascal_data_type(), pascal_data_format()),
  (simplevm_data_type(), simplevm_data_format()),
  (makedword_data_format(),),
  (simplevm_data_format(),)
]
The first two tuples describe data types and their associated formats.
The last two tuples describe two data formats to be used with built-in data types.
The data format may be attached to several data types. The id of the
data format is stored in the first data_format_t object. For example:
assert many_formats[1][1] != -1
assert many_formats[2][0] != -1
assert many_formats[3][0] == -1

revert_byte()

bool revert_byte

(

ida_idaapi.ea_t

ea

)

Revert patched byte 
    
@retval true: byte was patched before and reverted now

seg_flag()

'flags64_t' seg_flag

(

)

see FF_opbits

set_cmt()

bool set_cmt	(	ida_idaapi.ea_t	ea,
		str	comm,
		bool	rptble )

Set an indented comment. 
    
@param ea: linear address
@param comm: comment string
* nullptr: do nothing (return 0)
* "" : delete comment
@param rptble: is repeatable?
@returns success

set_forced_operand()

bool set_forced_operand	(	ida_idaapi.ea_t	ea,
		int	n,
		str	op )

Set forced operand. 
    
@param ea: linear address
@param n: 0..UA_MAXOP-1 operand number
@param op: text of operand
* nullptr: do nothing (return 0)
* "" : delete forced operand
@returns success

set_immd()

bool set_immd

(

ida_idaapi.ea_t

ea

)

Set 'has immediate operand' flag. Returns true if the FF_IMMD bit was not set and now is set 

set_lzero()

bool set_lzero	(	ida_idaapi.ea_t	ea,
		int	n )

Set toggle lzero bit. This function changes the display of leading zeroes for the specified operand. If the default is not to display leading zeroes, this function will display them and vice versa. 
    
@param ea: the item (insn/data) address
@param n: the operand number (0-first operand, 1-other operands)
@returns success

set_manual_insn()

None set_manual_insn	(	ida_idaapi.ea_t	ea,
		str	manual_insn )

Set manual instruction string. 
    
@param ea: linear address of the instruction or data item
@param manual_insn: "" - delete manual string. nullptr - do nothing

set_op_type()

bool set_op_type	(	ida_idaapi.ea_t	ea,
		'flags64_t'	type,
		int	n )

(internal function) change representation of operand(s). 
    
@param ea: linear address
@param type: new flag value (should be obtained from char_flag(), num_flag() and similar functions)
@param n: 0..UA_MAXOP-1 operand number, OPND_ALL all operands
@retval 1: ok
@retval 0: failed (applied to a tail byte)

set_opinfo()

bool set_opinfo	(	ida_idaapi.ea_t	ea,
		int	n,
		'flags64_t'	flag,
		'opinfo_t'	ti,
		bool	suppress_events = False )

Set additional information about an operand representation. This function is a low level one. Only the kernel should use it. 
    
@param ea: linear address of the item
@param n: number of operand, 0 or 1 (see the note below)
@param flag: flags of the item
@param ti: additional representation information
@param suppress_events: do not generate changing_op_type and op_type_changed events
@returns success

stkvar_flag()

'flags64_t' stkvar_flag

(

)

see FF_opbits

strlit_flag()

'flags64_t' strlit_flag

(

)

Get a flags64_t representing a string literal.

stroff_flag()

'flags64_t' stroff_flag

(

)

see FF_opbits

stru_flag()

'flags64_t' stru_flag

(

)

Get a flags64_t representing a struct.

tbyte_flag()

'flags64_t' tbyte_flag

(

)

Get a flags64_t representing a tbyte.

toggle_bnot()

bool toggle_bnot	(	ida_idaapi.ea_t	ea,
		int	n )

Toggle binary negation of operand. also see is_bnot()

toggle_lzero()

bool toggle_lzero	(	ida_idaapi.ea_t	ea,
		int	n )

Toggle lzero bit. 
    
@param ea: the item (insn/data) address
@param n: the operand number (0-first operand, 1-other operands)
@returns success

toggle_sign()

bool toggle_sign	(	ida_idaapi.ea_t	ea,
		int	n )

Toggle sign of n-th operand. allowed values of n: 0-first operand, 1-other operands 

unregister_custom_data_format()

unregister_custom_data_format

(

dfid

)

Unregisters a custom data format

@param dfid: data format id
@return: Boolean

unregister_custom_data_type()

unregister_custom_data_type

(

dtid

)

Unregisters a custom data type.

@param dtid: the data type id
@return: Boolean

unregister_data_types_and_formats()

unregister_data_types_and_formats

(

formats

)

As opposed to register_data_types_and_formats(), this function
unregisters multiple data types and formats at once.

update_hidden_range()

bool update_hidden_range

(

'hidden_range_t'

ha

)

Update hidden range information in the database. You cannot use this function to change the range boundaries 
    
@param ha: range to update
@returns success

use_mapping()

ida_idaapi.ea_t use_mapping

(

ida_idaapi.ea_t

ea

)

Translate address according to current mappings. 
    
@param ea: address to translate
@returns translated address

visit_patched_bytes()

visit_patched_bytes	(	ida_idaapi.ea_t	ea1,
		ida_idaapi.ea_t	ea2,
			callable )

Enumerates patched bytes in the given range and invokes a callable

@param ea1: start address
@param ea2: end address
@param callable: a Python callable with the following prototype:
             callable(ea, fpos, org_val, patch_val).
             If the callable returns non-zero then that value will be
             returned to the caller and the enumeration will be
             interrupted.
@return: Zero if the enumeration was successful or the return
     value of the callback if enumeration was interrupted.

word_flag()

'flags64_t' word_flag

(

)

Get a flags64_t representing a word.

yword_flag()

'flags64_t' yword_flag

(

)

Get a flags64_t representing a ymm word.

zword_flag()

'flags64_t' zword_flag

(

)

Get a flags64_t representing a zmm word.

Variable Documentation

ALOPT_APPEND

ALOPT_APPEND = _ida_bytes.ALOPT_APPEND

ALOPT_IGNCLT

ALOPT_IGNCLT = _ida_bytes.ALOPT_IGNCLT

ALOPT_IGNHEADS

ALOPT_IGNHEADS = _ida_bytes.ALOPT_IGNHEADS

ALOPT_IGNPRINT

ALOPT_IGNPRINT = _ida_bytes.ALOPT_IGNPRINT

ALOPT_MAX4K

ALOPT_MAX4K = _ida_bytes.ALOPT_MAX4K

ALOPT_ONLYTERM

ALOPT_ONLYTERM = _ida_bytes.ALOPT_ONLYTERM

BIN_SEARCH_BACKWARD

BIN_SEARCH_BACKWARD = _ida_bytes.BIN_SEARCH_BACKWARD

BIN_SEARCH_BITMASK

BIN_SEARCH_BITMASK = _ida_bytes.BIN_SEARCH_BITMASK

BIN_SEARCH_CASE

BIN_SEARCH_CASE = _ida_bytes.BIN_SEARCH_CASE

BIN_SEARCH_FORWARD

BIN_SEARCH_FORWARD = _ida_bytes.BIN_SEARCH_FORWARD

BIN_SEARCH_INITED

BIN_SEARCH_INITED = _ida_bytes.BIN_SEARCH_INITED

BIN_SEARCH_NOBREAK

BIN_SEARCH_NOBREAK = _ida_bytes.BIN_SEARCH_NOBREAK

BIN_SEARCH_NOCASE

BIN_SEARCH_NOCASE = _ida_bytes.BIN_SEARCH_NOCASE

BIN_SEARCH_NOSHOW

BIN_SEARCH_NOSHOW = _ida_bytes.BIN_SEARCH_NOSHOW

DELIT_DELNAMES

DELIT_DELNAMES = _ida_bytes.DELIT_DELNAMES

DELIT_EXPAND

DELIT_EXPAND = _ida_bytes.DELIT_EXPAND

DELIT_KEEPFUNC

DELIT_KEEPFUNC = _ida_bytes.DELIT_KEEPFUNC

DELIT_NOCMT

DELIT_NOCMT = _ida_bytes.DELIT_NOCMT

DELIT_NOTRUNC

DELIT_NOTRUNC = _ida_bytes.DELIT_NOTRUNC

DELIT_NOUNAME

DELIT_NOUNAME = _ida_bytes.DELIT_NOUNAME

DELIT_SIMPLE

DELIT_SIMPLE = _ida_bytes.DELIT_SIMPLE

DT_TYPE

DT_TYPE = _ida_bytes.DT_TYPE

DTP_NODUP

int DTP_NODUP = _ida_bytes.DTP_NODUP

FF_0CHAR

FF_0CHAR = _ida_bytes.FF_0CHAR

FF_0CUST

FF_0CUST = _ida_bytes.FF_0CUST

FF_0ENUM

FF_0ENUM = _ida_bytes.FF_0ENUM

FF_0FLT

FF_0FLT = _ida_bytes.FF_0FLT

FF_0FOP

FF_0FOP = _ida_bytes.FF_0FOP

FF_0NUMB

FF_0NUMB = _ida_bytes.FF_0NUMB

FF_0NUMD

FF_0NUMD = _ida_bytes.FF_0NUMD

FF_0NUMH

FF_0NUMH = _ida_bytes.FF_0NUMH

FF_0NUMO

FF_0NUMO = _ida_bytes.FF_0NUMO

FF_0OFF

FF_0OFF = _ida_bytes.FF_0OFF

FF_0SEG

FF_0SEG = _ida_bytes.FF_0SEG

FF_0STK

FF_0STK = _ida_bytes.FF_0STK

FF_0STRO

FF_0STRO = _ida_bytes.FF_0STRO

FF_0VOID

FF_0VOID = _ida_bytes.FF_0VOID

FF_1CHAR

FF_1CHAR = _ida_bytes.FF_1CHAR

FF_1CUST

FF_1CUST = _ida_bytes.FF_1CUST

FF_1ENUM

FF_1ENUM = _ida_bytes.FF_1ENUM

FF_1FLT

FF_1FLT = _ida_bytes.FF_1FLT

FF_1FOP

FF_1FOP = _ida_bytes.FF_1FOP

FF_1NUMB

FF_1NUMB = _ida_bytes.FF_1NUMB

FF_1NUMD

FF_1NUMD = _ida_bytes.FF_1NUMD

FF_1NUMH

FF_1NUMH = _ida_bytes.FF_1NUMH

FF_1NUMO

FF_1NUMO = _ida_bytes.FF_1NUMO

FF_1OFF

FF_1OFF = _ida_bytes.FF_1OFF

FF_1SEG

FF_1SEG = _ida_bytes.FF_1SEG

FF_1STK

FF_1STK = _ida_bytes.FF_1STK

FF_1STRO

FF_1STRO = _ida_bytes.FF_1STRO

FF_1VOID

FF_1VOID = _ida_bytes.FF_1VOID

FF_ALIGN

FF_ALIGN = _ida_bytes.FF_ALIGN

FF_ANYNAME

FF_ANYNAME = _ida_bytes.FF_ANYNAME

FF_BNOT

FF_BNOT = _ida_bytes.FF_BNOT

FF_BYTE

FF_BYTE = _ida_bytes.FF_BYTE

FF_CODE

FF_CODE = _ida_bytes.FF_CODE

FF_COMM

FF_COMM = _ida_bytes.FF_COMM

FF_CUSTOM

FF_CUSTOM = _ida_bytes.FF_CUSTOM

FF_DATA

FF_DATA = _ida_bytes.FF_DATA

FF_DOUBLE

FF_DOUBLE = _ida_bytes.FF_DOUBLE

FF_DWORD

FF_DWORD = _ida_bytes.FF_DWORD

FF_FLOAT

FF_FLOAT = _ida_bytes.FF_FLOAT

FF_FLOW

FF_FLOW = _ida_bytes.FF_FLOW

FF_FUNC

FF_FUNC = _ida_bytes.FF_FUNC

FF_IMMD

FF_IMMD = _ida_bytes.FF_IMMD

FF_IVL

FF_IVL = _ida_bytes.FF_IVL

FF_JUMP

FF_JUMP = _ida_bytes.FF_JUMP

FF_LABL

FF_LABL = _ida_bytes.FF_LABL

FF_LINE

FF_LINE = _ida_bytes.FF_LINE

FF_N_CHAR

FF_N_CHAR = _ida_bytes.FF_N_CHAR

FF_N_CUST

FF_N_CUST = _ida_bytes.FF_N_CUST

FF_N_ENUM

FF_N_ENUM = _ida_bytes.FF_N_ENUM

FF_N_FLT

FF_N_FLT = _ida_bytes.FF_N_FLT

FF_N_FOP

FF_N_FOP = _ida_bytes.FF_N_FOP

FF_N_NUMB

FF_N_NUMB = _ida_bytes.FF_N_NUMB

FF_N_NUMD

FF_N_NUMD = _ida_bytes.FF_N_NUMD

FF_N_NUMH

FF_N_NUMH = _ida_bytes.FF_N_NUMH

FF_N_NUMO

FF_N_NUMO = _ida_bytes.FF_N_NUMO

FF_N_OFF

FF_N_OFF = _ida_bytes.FF_N_OFF

FF_N_SEG

FF_N_SEG = _ida_bytes.FF_N_SEG

FF_N_STK

FF_N_STK = _ida_bytes.FF_N_STK

FF_N_STRO

FF_N_STRO = _ida_bytes.FF_N_STRO

FF_N_VOID

FF_N_VOID = _ida_bytes.FF_N_VOID

FF_NAME

FF_NAME = _ida_bytes.FF_NAME

FF_OWORD

FF_OWORD = _ida_bytes.FF_OWORD

FF_PACKREAL

FF_PACKREAL = _ida_bytes.FF_PACKREAL

FF_QWORD

FF_QWORD = _ida_bytes.FF_QWORD

FF_REF

FF_REF = _ida_bytes.FF_REF

FF_SIGN

FF_SIGN = _ida_bytes.FF_SIGN

FF_STRLIT

FF_STRLIT = _ida_bytes.FF_STRLIT

FF_STRUCT

FF_STRUCT = _ida_bytes.FF_STRUCT

FF_TAIL

FF_TAIL = _ida_bytes.FF_TAIL

FF_TBYTE

FF_TBYTE = _ida_bytes.FF_TBYTE

FF_UNK

FF_UNK = _ida_bytes.FF_UNK

FF_UNUSED

FF_UNUSED = _ida_bytes.FF_UNUSED

FF_WORD

FF_WORD = _ida_bytes.FF_WORD

FF_YWORD

FF_YWORD = _ida_bytes.FF_YWORD

FF_ZWORD

FF_ZWORD = _ida_bytes.FF_ZWORD

GFE_IDB_VALUE

GFE_IDB_VALUE = _ida_bytes.GFE_IDB_VALUE

GFE_VALUE

GFE_VALUE = _ida_bytes.GFE_VALUE

GMB_READALL

GMB_READALL = _ida_bytes.GMB_READALL

GMB_WAITBOX

GMB_WAITBOX = _ida_bytes.GMB_WAITBOX

ITEM_END_CANCEL

ITEM_END_CANCEL = _ida_bytes.ITEM_END_CANCEL

ITEM_END_FIXUP

ITEM_END_FIXUP = _ida_bytes.ITEM_END_FIXUP

ITEM_END_INITED

ITEM_END_INITED = _ida_bytes.ITEM_END_INITED

ITEM_END_NAME

ITEM_END_NAME = _ida_bytes.ITEM_END_NAME

ITEM_END_XREF

ITEM_END_XREF = _ida_bytes.ITEM_END_XREF

MS_0TYPE

MS_0TYPE = _ida_bytes.MS_0TYPE

MS_1TYPE

MS_1TYPE = _ida_bytes.MS_1TYPE

MS_CLS

MS_CLS = _ida_bytes.MS_CLS

MS_CODE

MS_CODE = _ida_bytes.MS_CODE

MS_COMM

MS_COMM = _ida_bytes.MS_COMM

MS_N_TYPE

MS_N_TYPE = _ida_bytes.MS_N_TYPE

MS_VAL

MS_VAL = _ida_bytes.MS_VAL

OPND_ALL

OPND_ALL = _ida_bytes.OPND_ALL

OPND_MASK

OPND_MASK = _ida_bytes.OPND_MASK

OPND_OUTER

OPND_OUTER = _ida_bytes.OPND_OUTER

PBSENC_ALL

PBSENC_ALL = _ida_bytes.PBSENC_ALL

PBSENC_DEF1BPU

PBSENC_DEF1BPU = _ida_bytes.PBSENC_DEF1BPU

PSTF_ATTRIB

PSTF_ATTRIB = _ida_bytes.PSTF_ATTRIB

PSTF_ENC

PSTF_ENC = _ida_bytes.PSTF_ENC

PSTF_HOTKEY

PSTF_HOTKEY = _ida_bytes.PSTF_HOTKEY

PSTF_ONLY_ENC

PSTF_ONLY_ENC = _ida_bytes.PSTF_ONLY_ENC

PSTF_TBRIEF

PSTF_TBRIEF = _ida_bytes.PSTF_TBRIEF

PSTF_TINLIN

PSTF_TINLIN = _ida_bytes.PSTF_TINLIN

PSTF_TMASK

PSTF_TMASK = _ida_bytes.PSTF_TMASK

PSTF_TNORM

PSTF_TNORM = _ida_bytes.PSTF_TNORM

STRCONV_ESCAPE

STRCONV_ESCAPE = _ida_bytes.STRCONV_ESCAPE

STRCONV_INCLLEN

STRCONV_INCLLEN = _ida_bytes.STRCONV_INCLLEN

STRCONV_REPLCHAR

STRCONV_REPLCHAR = _ida_bytes.STRCONV_REPLCHAR