Module ida_funcs

This file also contains routines for working with library signatures (e.g. FLIRT).

Each function consists of function chunks. At least one function chunk must be present in the function definition - the function entry chunk. Other chunks are called function tails. There may be several of them for a function.

A function tail is a continuous range of addresses. It can be used in the definition of one or more functions. One function using the tail is singled out and called the tail owner. This function is considered as 'possessing' the tail. get_func() on a tail address will return the function possessing the tail. You can enumerate the functions using the tail by using func_parent_iterator_t.

Each function chunk in the disassembly is represented as an "range" (a range of addresses, see range.hpp for details) with characteristics.

A function entry must start with an instruction (code) byte.

Global Variables

FIND_FUNC_DEFINE

FIND_FUNC_DEFINE = 1

FIND_FUNC_EXIST

FIND_FUNC_EXIST = 2

FIND_FUNC_IGNOREFN

FIND_FUNC_IGNOREFN = 2

FIND_FUNC_KEEPBD

FIND_FUNC_KEEPBD = 4

FIND_FUNC_NORMAL

FIND_FUNC_NORMAL = 0

FIND_FUNC_OK

FIND_FUNC_OK = 1

FIND_FUNC_UNDEF

FIND_FUNC_UNDEF = 0

FUNC_BOTTOMBP

FUNC_BOTTOMBP = 256

FUNC_CATCH

FUNC_CATCH = 1048576

FUNC_FAR

FUNC_FAR = 2

FUNC_FRAME

FUNC_FRAME = 16

FUNC_FUZZY_SP

FUNC_FUZZY_SP = 2048

FUNC_HIDDEN

FUNC_HIDDEN = 64

FUNC_LIB

FUNC_LIB = 4

FUNC_LUMINA

FUNC_LUMINA = 65536

FUNC_NORET

FUNC_NORET = 1

FUNC_NORET_PENDING

FUNC_NORET_PENDING = 512

FUNC_OUTLINE

FUNC_OUTLINE = 131072

FUNC_PROLOG_OK

FUNC_PROLOG_OK = 4096

FUNC_PURGED_OK

FUNC_PURGED_OK = 16384

FUNC_REANALYZE

FUNC_REANALYZE = 262144

FUNC_SP_READY

FUNC_SP_READY = 1024

FUNC_STATICDEF

FUNC_STATICDEF = 8

FUNC_TAIL

FUNC_TAIL = 32768

FUNC_THUNK

FUNC_THUNK = 128

FUNC_UNWIND

FUNC_UNWIND = 524288

FUNC_USERFAR

FUNC_USERFAR = 32

IDASGN_APPLIED

IDASGN_APPLIED = 2

IDASGN_BADARG

IDASGN_BADARG = 1

IDASGN_CURRENT

IDASGN_CURRENT = 3

IDASGN_OK

IDASGN_OK = 0

IDASGN_PLANNED

IDASGN_PLANNED = 4

LIBFUNC_DELAY

LIBFUNC_DELAY = 2

LIBFUNC_FOUND

LIBFUNC_FOUND = 0

LIBFUNC_NONE

LIBFUNC_NONE = 1

MOVE_FUNC_BADSTART

MOVE_FUNC_BADSTART = 2

MOVE_FUNC_NOCODE

MOVE_FUNC_NOCODE = 1

MOVE_FUNC_NOFUNC

MOVE_FUNC_NOFUNC = 3

MOVE_FUNC_OK

MOVE_FUNC_OK = 0

MOVE_FUNC_REFUSED

MOVE_FUNC_REFUSED = 4

Functions

**add_func(*args) ‑> bool**

add_func(ea1, ea2=BADADDR) -> bool Add a new function. If the function end address is BADADDR, then IDA will try to determine the function bounds by calling find_func_bounds(..., FIND_FUNC_DEFINE).

ea1: (C++: ea_t) start address
ea2: (C++: ea_t) end address
return: success

add_func_ex(pfn: func_t) ‑> bool

add_func_ex(pfn) -> bool Add a new function. If the fn->end_ea is BADADDR, then IDA will try to determine the function bounds by calling find_func_bounds(..., FIND_FUNC_DEFINE).

pfn: (C++: func_t *) ptr to filled function structure
return: success

**add_regarg(pfn: func_t, reg: int, tif: tinfo_t, name: char const *) ‑> void**

add_regarg(pfn, reg, tif, name)

pfn: func_t *
reg: int
tif: tinfo_t const &
name: char const *

append_func_tail(pfn: func_t, ea1: ea_t, ea2: ea_t) ‑> bool

append_func_tail(pfn, ea1, ea2) -> bool Append a new tail chunk to the function definition. If the tail already exists, then it will simply be added to the function tail list Otherwise a new tail will be created and its owner will be set to be our function If a new tail cannot be created, then this function will fail.

pfn: (C++: func_t *) pointer to the function
ea1: (C++: ea_t) start of the tail. If a tail already exists at the specified address
           it must start at 'ea1'
ea2: (C++: ea_t) end of the tail. If a tail already exists at the specified address
           it must end at 'ea2'. If specified as BADADDR, IDA will determine
           the end address itself.

**apply_idasgn_to(signame: char const *, ea: ea_t, is_startup: bool) ‑> int**

apply_idasgn_to(signame, ea, is_startup) -> int Apply a signature file to the specified address.

signame: (C++: const char *) short name of signature file (the file name without path)
ea: (C++: ea_t) address to apply the signature
is_startup: (C++: bool) if set, then the signature is treated as a startup one for
                  startup signature ida doesn't rename the first function of
                  the applied module.
return: Library function codes

**apply_startup_sig(ea: ea_t, startup: char const *) ‑> bool**

apply_startup_sig(ea, startup) -> bool Apply a startup signature file to the specified address.

ea: (C++: ea_t) address to apply the signature to; usually idainfo::start_ea
startup: (C++: const char *) the name of the signature file without path and extension
return: true if successfully applied the signature

calc_func_size(pfn: func_t) ‑> asize_t

calc_func_size(pfn) -> asize_t Calculate function size. This function takes into account all fragments of the function.

pfn: (C++: func_t *) ptr to function structure

calc_idasgn_state(n: int) ‑> int

calc_idasgn_state(n) -> int Get state of a signature in the list of planned signatures

n: (C++: int) number of signature in the list (0..get_idasgn_qty()-1)
return: state of signature or IDASGN_BADARG

**calc_thunk_func_target(*args)**

calc_thunk_func_target(pfn) -> ea_t Calculate target of a thunk function.

pfn: (C++: func_t *) pointer to function (may not be nullptr)
return: the target function or BADADDR

del_func(ea: ea_t) ‑> bool

del_func(ea) -> bool Delete a function.

ea: (C++: ea_t) any address in the function entry chunk
return: success

del_idasgn(n: int) ‑> int

del_idasgn(n) -> int Remove signature from the list of planned signatures.

n: (C++: int) number of signature in the list (0..get_idasgn_qty()-1)
return: IDASGN_OK, IDASGN_BADARG, IDASGN_APPLIED

**f_any(arg1: flags64_t, arg2: void *) ‑> bool**

f_any(arg1, arg2) -> bool Helper function to accept any address.

arg1: flags64_t
arg2: void *

find_func_bounds(nfn: func_t, flags: int) ‑> int

find_func_bounds(nfn, flags) -> int Determine the boundaries of a new function. This function tries to find the start and end addresses of a new function. It calls the module with processor_t::func_bounds in order to fine tune the function boundaries.

nfn: (C++: func_t *) structure to fill with information \ nfn->start_ea points to the
           start address of the new function.
flags: (C++: int) Find function bounds flags
return: Find function bounds result codes

free_regarg(v: regarg_t) ‑> void

free_regarg(v)

v: regarg_t *

func_contains(pfn: func_t, ea: ea_t) ‑> bool

func_contains(pfn, ea) -> bool Does the given function contain the given address?

pfn: (C++: func_t *)
ea: (C++: ea_t)

func_does_return(callee: ea_t) ‑> bool

func_does_return(callee) -> bool Does the function return?. To calculate the answer, FUNC_NORET flag and is_noret() are consulted The latter is required for imported functions in the .idata section. Since in .idata we have only function pointers but not functions, we have to introduce a special flag for them.

callee: (C++: ea_t)

func_parent_iterator_set(fpi: func_parent_iterator_t, pfn: func_t) ‑> bool

func_parent_iterator_set(fpi, pfn) -> bool

fpi: func_parent_iterator_t *
pfn: func_t *

func_t__from_ptrval__(ptrval: size_t) ‑> func_t *

func_t__from_ptrval__(ptrval) -> func_t

ptrval: size_t

func_tail_iterator_set(fti: func_tail_iterator_t, pfn: func_t, ea: ea_t) ‑> bool

func_tail_iterator_set(fti, pfn, ea) -> bool

fti: func_tail_iterator_t *
pfn: func_t *
ea: ea_t

func_tail_iterator_set_ea(fti: func_tail_iterator_t, ea: ea_t) ‑> bool

func_tail_iterator_set_ea(fti, ea) -> bool

fti: func_tail_iterator_t *
ea: ea_t

get_current_idasgn() ‑> int

get_current_idasgn() -> int Get number of the the current signature.

return: 0..n-1

get_fchunk(ea: ea_t) ‑> func_t *

get_fchunk(ea) -> func_t Get pointer to function chunk structure by address.

ea: (C++: ea_t) any address in a function chunk
return: ptr to a function chunk or nullptr. This function may return a function
        entry as well as a function tail.

get_fchunk_num(ea: ea_t) ‑> int

get_fchunk_num(ea) -> int Get ordinal number of a function chunk in the global list of function chunks.

ea: (C++: ea_t) any address in the function chunk
return: number of function chunk (0..get_fchunk_qty()-1). -1 means 'no function
        chunk at the specified address'.

get_fchunk_qty() ‑> size_t

get_fchunk_qty() -> size_t Get total number of function chunks in the program.

get_fchunk_referer(ea: ea_t, idx: size_t) ‑> ea_t

get_fchunk_referer(ea, idx) -> ea_t

ea: ea_t
idx: size_t

get_func(ea: ea_t) ‑> func_t *

get_func(ea) -> func_t Get pointer to function structure by address.

ea: (C++: ea_t) any address in a function
return: ptr to a function or nullptr. This function returns a function entry
        chunk.

get_func_bitness(pfn: func_t) ‑> int

get_func_bitness(pfn) -> int Get function bitness (which is equal to the function segment bitness). pfn==nullptr => returns 0 retval 0: 16 retval 1: 32 retval 2: 64

pfn: (C++: const func_t *) func_t const *

get_func_bits(pfn: func_t) ‑> int

get_func_bits(pfn) -> int Get number of bits in the function addressing.

pfn: (C++: const func_t *) func_t const *

get_func_bytes(pfn: func_t) ‑> int

get_func_bytes(pfn) -> int Get number of bytes in the function addressing.

pfn: (C++: const func_t *) func_t const *

get_func_chunknum(pfn: func_t, ea: ea_t) ‑> int

get_func_chunknum(pfn, ea) -> int Get the containing tail chunk of 'ea'. retval -1: means 'does not contain ea' retval 0: means the 'pfn' itself contains ea retval >0: the number of the containing function tail chunk

pfn: (C++: func_t *)
ea: (C++: ea_t)

get_func_cmt(pfn: func_t, repeatable: bool) ‑> qstring *

get_func_cmt(pfn, repeatable) -> str Get function comment.

pfn: (C++: const func_t *) ptr to function structure
repeatable: (C++: bool) get repeatable comment?
return: size of comment or -1 In fact this function works with function chunks
        too.

get_func_name(ea: ea_t) ‑> qstring *

get_func_name(ea) -> str Get function name.

ea: (C++: ea_t) any address in the function
return: length of the function name

get_func_num(ea: ea_t) ‑> int

get_func_num(ea) -> int Get ordinal number of a function.

ea: (C++: ea_t) any address in the function
return: number of function (0..get_func_qty()-1). -1 means 'no function at the
        specified address'.

get_func_qty() ‑> size_t

get_func_qty() -> size_t Get total number of functions in the program.

get_func_ranges(ranges: rangeset_t, pfn: func_t) ‑> ea_t

get_func_ranges(ranges, pfn) -> ea_t Get function ranges.

ranges: (C++: rangeset_t *) buffer to receive the range info
pfn: (C++: func_t *) ptr to function structure
return: end address of the last function range (BADADDR-error)

get_idasgn_desc(n: int) ‑> PyObject *

get_idasgn_desc(n) -> (str, str) Get information about a signature in the list. It returns: (name of signature, names of optional libraries)

get_idasgn_desc_with_matches(n: int) ‑> PyObject *

get_idasgn_desc_with_matches(n) -> (str, str, int) Get information about a signature in the list. It returns: (name of signature, names of optional libraries, number of matches)

n: number of signature in the list (0..get_idasgn_qty()-1)
return: None on failure or tuple(signame, optlibs, nmatches)

get_idasgn_qty() ‑> int

get_idasgn_qty() -> int Get number of signatures in the list of planned and applied signatures.

return: 0..n

get_idasgn_title(name: char const ) ‑> qstring

get_idasgn_title(name) -> str Get full description of the signature by its short name.

name: (C++: const char *) short name of a signature
return: size of signature description or -1

get_next_fchunk(ea: ea_t) ‑> func_t *

get_next_fchunk(ea) -> func_t Get pointer to the next function chunk in the global list.

ea: (C++: ea_t) any address in the program
return: ptr to function chunk or nullptr if next function chunk doesn't exist

get_next_func(ea: ea_t) ‑> func_t *

get_next_func(ea) -> func_t Get pointer to the next function.

ea: (C++: ea_t) any address in the program
return: ptr to function or nullptr if next function doesn't exist

get_next_func_addr(pfn: func_t, ea: ea_t) ‑> ea_t

get_next_func_addr(pfn, ea) -> ea_t

pfn: func_t *
ea: ea_t

get_prev_fchunk(ea: ea_t) ‑> func_t *

get_prev_fchunk(ea) -> func_t Get pointer to the previous function chunk in the global list.

ea: (C++: ea_t) any address in the program
return: ptr to function chunk or nullptr if previous function chunk doesn't
        exist

get_prev_func(ea: ea_t) ‑> func_t *

get_prev_func(ea) -> func_t Get pointer to the previous function.

ea: (C++: ea_t) any address in the program
return: ptr to function or nullptr if previous function doesn't exist

get_prev_func_addr(pfn: func_t, ea: ea_t) ‑> ea_t

get_prev_func_addr(pfn, ea) -> ea_t

pfn: func_t *
ea: ea_t

getn_fchunk(n: int) ‑> func_t *

getn_fchunk(n) -> func_t Get pointer to function chunk structure by number.

n: (C++: int) number of function chunk, is in range 0..get_fchunk_qty()-1
return: ptr to a function chunk or nullptr. This function may return a function
        entry as well as a function tail.

getn_func(n: size_t) ‑> func_t *

getn_func(n) -> func_t Get pointer to function structure by number.

n: (C++: size_t) number of function, is in range 0..get_func_qty()-1
return: ptr to a function or nullptr. This function returns a function entry
        chunk.

is_finally_visible_func(pfn: func_t) ‑> bool

is_finally_visible_func(pfn) -> bool Is the function visible (event after considering SCF_SHHID_FUNC)?

pfn: (C++: func_t *)

is_func_entry(pfn: func_t) ‑> bool

is_func_entry(pfn) -> bool Does function describe a function entry chunk?

pfn: (C++: const func_t *) func_t const *

is_func_locked(pfn: func_t) ‑> bool

is_func_locked(pfn) -> bool Is the function pointer locked?

pfn: (C++: const func_t *) func_t const *

is_func_tail(pfn: func_t) ‑> bool

is_func_tail(pfn) -> bool Does function describe a function tail chunk?

pfn: (C++: const func_t *) func_t const *

is_same_func(ea1: ea_t, ea2: ea_t) ‑> bool

is_same_func(ea1, ea2) -> bool Do two addresses belong to the same function?

ea1: (C++: ea_t)
ea2: (C++: ea_t)

is_visible_func(pfn: func_t) ‑> bool

is_visible_func(pfn) -> bool Is the function visible (not hidden)?

pfn: (C++: func_t *)

lock_func_range(pfn: func_t, lock: bool) ‑> void

lock_func_range(pfn, lock) Lock function pointer Locked pointers are guaranteed to remain valid until they are unlocked. Ranges with locked pointers cannot be deleted or moved.

pfn: (C++: const func_t *) func_t const *
lock: (C++: bool)

**plan_to_apply_idasgn(fname: char const *) ‑> int**

plan_to_apply_idasgn(fname) -> int Add a signature file to the list of planned signature files.

fname: (C++: const char *) file name. should not contain directory part.
return: 0 if failed, otherwise number of planned (and applied) signatures

read_regargs(pfn: func_t) ‑> void

read_regargs(pfn)

pfn: func_t *

**reanalyze_function(*args) ‑> void**

reanalyze_function(pfn, ea1=0, ea2=BADADDR, analyze_parents=False) Reanalyze a function. This function plans to analyzes all chunks of the given function. Optional parameters (ea1, ea2) may be used to narrow the analyzed range.

pfn: (C++: func_t *) pointer to a function
ea1: (C++: ea_t) start of the range to analyze
ea2: (C++: ea_t) end of range to analyze
analyze_parents: (C++: bool) meaningful only if pfn points to a function tail. if
                       true, all tail parents will be reanalyzed. if false,
                       only the given tail will be reanalyzed.

reanalyze_noret_flag(ea: ea_t) ‑> bool

reanalyze_noret_flag(ea) -> bool Plan to reanalyze noret flag. This function does not remove FUNC_NORET if it is already present. It just plans to reanalysis.

ea: (C++: ea_t)

remove_func_tail(pfn: func_t, tail_ea: ea_t) ‑> bool

remove_func_tail(pfn, tail_ea) -> bool Remove a function tail. If the tail belongs only to one function, it will be completely removed. Otherwise if the function was the tail owner, the first function using this tail becomes the owner of the tail.

pfn: (C++: func_t *) pointer to the function
tail_ea: (C++: ea_t) any address inside the tail to remove

**set_func_cmt(pfn: func_t, cmt: char const *, repeatable: bool) ‑> bool**

set_func_cmt(pfn, cmt, repeatable) -> bool Set function comment. This function works with function chunks too.

pfn: (C++: const func_t *) ptr to function structure
cmt: (C++: const char *) comment string, may be multiline (with '

'). Use empty str ("") to delete comment repeatable: (C++: bool) set repeatable comment?

set_func_end(ea: ea_t, newend: ea_t) ‑> bool

set_func_end(ea, newend) -> bool Move function chunk end address.

ea: (C++: ea_t) any address in the function
newend: (C++: ea_t) new end address of the function
return: success

**set_func_name_if_jumpfunc(pfn: func_t, oldname: char const *) ‑> int**

set_func_name_if_jumpfunc(pfn, oldname) -> int Give a meaningful name to function if it consists of only 'jump' instruction.

pfn: (C++: func_t *) pointer to function (may be nullptr)
oldname: (C++: const char *) old name of function. if old name was in "j_..." form, then we
               may discard it and set a new name. if oldname is not known, you
               may pass nullptr.
return: success

set_func_start(ea: ea_t, newstart: ea_t) ‑> int

set_func_start(ea, newstart) -> int Move function chunk start address.

ea: (C++: ea_t) any address in the function
newstart: (C++: ea_t) new end address of the function
return: Function move result codes

set_noret_insn(insn_ea: ea_t, noret: bool) ‑> bool

set_noret_insn(insn_ea, noret) -> bool Signal a non-returning instruction. This function can be used by the processor module to tell the kernel about non-returning instructions (like call exit). The kernel will perform the global function analysis and find out if the function returns at all. This analysis will be done at the first call to func_does_return()

insn_ea: (C++: ea_t)
noret: (C++: bool)
return: true if the instruction 'noret' flag has been changed

set_tail_owner(fnt: func_t, new_owner: ea_t) ‑> bool

set_tail_owner(fnt, new_owner) -> bool Set a new owner of a function tail. The new owner function must be already referring to the tail (after append_func_tail).

fnt: (C++: func_t *) pointer to the function tail
new_owner: (C++: ea_t) the entry point of the new owner function

set_visible_func(pfn: func_t, visible: bool) ‑> void

set_visible_func(pfn, visible) Set visibility of function.

pfn: (C++: func_t *)
visible: (C++: bool)

try_to_add_libfunc(ea: ea_t) ‑> int

try_to_add_libfunc(ea) -> int Apply the currently loaded signature file to the specified address. If a library function is found, then create a function and name it accordingly.

ea: (C++: ea_t) any address in the program
return: Library function codes

update_func(pfn: func_t) ‑> bool

update_func(pfn) -> bool Update information about a function in the database (func_t). You must not change the function start and end addresses using this function. Use set_func_start() and set_func_end() for it.

pfn: (C++: func_t *) ptr to function structure
return: success

Classes

dyn_ea_array(_data: unsigned long long *, _count: size_t)

: Proxy of C++ dynamic_wrapped_array_t< ea_t > class.

__init__(self, _data, _count) -> dyn_ea_array

 _data: unsigned long long *
 _count: size_t

Instance variables

count: size_t count

data: unsigned long long * data

dyn_range_array(_data: range_t, _count: size_t)

: Proxy of C++ dynamic_wrapped_array_t< range_t > class.

__init__(self, _data, _count) -> dyn_range_array

 _data: range_t *
 _count: size_t

Instance variables

count: size_t count

data: range_t * data

dyn_regarg_array(_data: regarg_t, _count: size_t)

: Proxy of C++ dynamic_wrapped_array_t< regarg_t > class.

__init__(self, _data, _count) -> dyn_regarg_array

 _data: regarg_t *
 _count: size_t

Instance variables

count: size_t count

data: regarg_t * data

dyn_regvar_array(_data: regvar_t *, _count: size_t)

: Proxy of C++ dynamic_wrapped_array_t< regvar_t > class.

__init__(self, _data, _count) -> dyn_regvar_array

 _data: regvar_t *
 _count: size_t

Instance variables

count: size_t count

data: regvar_t * data

dyn_stkpnt_array(_data: stkpnt_t *, _count: size_t)

: Proxy of C++ dynamic_wrapped_array_t< stkpnt_t > class.

__init__(self, _data, _count) -> dyn_stkpnt_array

 _data: stkpnt_t *
 _count: size_t

Instance variables

count: size_t count

data: stkpnt_t * data

func_item_iterator_t(*args)

: Proxy of C++ func_item_iterator_t class.

__init__(self) -> func_item_iterator_t
__init__(self, pfn, _ea=BADADDR) -> func_item_iterator_t

 pfn: func_t *
 _ea: ea_t

Methods

addresses(self) Provide an iterator on addresses contained within the function

chunk(self) ‑> range_t const & chunk(self) -> range_t

code_items(self) Provide an iterator on code items contained within the function

current(self) ‑> ea_t current(self) -> ea_t

data_items(self) Provide an iterator on data items contained within the function

decode_preceding_insn(self, visited: eavec_t *, p_farref: bool *, out: insn_t *) ‑> bool decode_preceding_insn(self, visited, p_farref, out) -> bool
visited: eavec_t * p_farref: bool * out: insn_t *

decode_prev_insn(self, out: insn_t *) ‑> bool decode_prev_insn(self, out) -> bool
out: insn_t *

first(self) ‑> bool first(self) -> bool

head_items(self) Provide an iterator on item heads contained within the function

last(self) ‑> bool last(self) -> bool

next(self, func: testf_t *) ‑> bool next(self, func) -> bool
func: testf_t *

next_addr(self) ‑> bool next_addr(self) -> bool

next_code(self) ‑> bool next_code(self) -> bool

next_data(self) ‑> bool next_data(self) -> bool

next_head(self) ‑> bool next_head(self) -> bool

next_not_tail(self) ‑> bool next_not_tail(self) -> bool

not_tails(self) Provide an iterator on non-tail addresses contained within the function

prev(self, func: testf_t *) ‑> bool prev(self, func) -> bool
func: testf_t *

prev_addr(self) ‑> bool prev_addr(self) -> bool

prev_code(self) ‑> bool prev_code(self) -> bool

prev_data(self) ‑> bool prev_data(self) -> bool

prev_head(self) ‑> bool prev_head(self) -> bool

prev_not_tail(self) ‑> bool prev_not_tail(self) -> bool

set(self, *args) ‑> bool set(self, pfn, _ea=BADADDR) -> bool Set a function range. if pfn == nullptr then a segment range will be set.
pfn: (C++: func_t *) _ea: (C++: ea_t)

set_ea(self, _ea: ea_t) ‑> bool set_ea(self, _ea) -> bool
_ea: ea_t

set_range(self, ea1: ea_t, ea2: ea_t) ‑> bool set_range(self, ea1, ea2) -> bool Set an arbitrary range.
ea1: (C++: ea_t) ea2: (C++: ea_t)

succ(self, func: testf_t *) ‑> bool succ(self, func) -> bool Similar to next(), but succ() iterates the chunks from low to high addresses, while next() iterates through chunks starting at the function entry chunk
func: (C++: testf_t *)

succ_code(self) ‑> bool succ_code(self) -> bool

func_parent_iterator_t(*args)

: Proxy of C++ func_parent_iterator_t class.

__init__(self) -> func_parent_iterator_t
__init__(self, _fnt) -> func_parent_iterator_t

 _fnt: func_t *

Methods

first(self) ‑> bool first(self) -> bool

last(self) ‑> bool last(self) -> bool

next(self) ‑> bool next(self) -> bool

parent(self) ‑> ea_t parent(self) -> ea_t

prev(self) ‑> bool prev(self) -> bool

reset_fnt(self, _fnt: func_t) ‑> void reset_fnt(self, _fnt)
_fnt: func_t *

set(self, _fnt: func_t) ‑> bool set(self, _fnt) -> bool
_fnt: func_t *

func_t(start: ea_t = 0, end: ea_t = 0, f: flags64_t = 0)

: Proxy of C++ func_t class.

__init__(self, start=0, end=0, f=0) -> func_t

 start: ea_t
 end: ea_t
 f: flags64_t

Ancestors (in MRO)

* ida_range.range_t

Instance variables

argsize: asize_t argsize

color: bgcolor_t color

flags: uint64 flags

fpd: asize_t fpd

frame: uval_t frame

frregs: ushort frregs

frsize: asize_t frsize

owner: ea_t owner

pntqty: uint32 pntqty

points: dynamic_wrapped_array_t< stkpnt_t > __get_points__(self) -> dyn_stkpnt_array

referers: dynamic_wrapped_array_t< ea_t > __get_referers__(self) -> dyn_ea_array

refqty: int refqty

regargqty: int regargqty

regargs: dynamic_wrapped_array_t< regarg_t > __get_regargs__(self) -> dyn_regarg_array

regvarqty: int regvarqty

regvars: dynamic_wrapped_array_t< regvar_t > __get_regvars__(self) -> dyn_regvar_array

tailqty: int tailqty

tails: dynamic_wrapped_array_t< range_t > __get_tails__(self) -> dyn_range_array

Methods

addresses(self) Alias for func_item_iterator_t(self).addresses()

analyzed_sp(self) ‑> bool analyzed_sp(self) -> bool Has SP-analysis been performed?

code_items(self) Alias for func_item_iterator_t(self).code_items()

data_items(self) Alias for func_item_iterator_t(self).data_items()

does_return(self) ‑> bool does_return(self) -> bool Does function return?

head_items(self) Alias for func_item_iterator_t(self).head_items()

is_far(self) ‑> bool is_far(self) -> bool Is a far function?

need_prolog_analysis(self) ‑> bool need_prolog_analysis(self) -> bool Needs prolog analysis?

not_tails(self) Alias for func_item_iterator_t(self).not_tails()

func_tail_iterator_t(*args)

: Proxy of C++ func_tail_iterator_t class.

__init__(self) -> func_tail_iterator_t
__init__(self, _pfn, ea=BADADDR) -> func_tail_iterator_t

 _pfn: func_t *
 ea: ea_t

Methods

chunk(self) ‑> range_t const & chunk(self) -> range_t

first(self) ‑> bool first(self) -> bool

last(self) ‑> bool last(self) -> bool

main(self) ‑> bool main(self) -> bool

next(self) ‑> bool next(self) -> bool

prev(self) ‑> bool prev(self) -> bool

set(self, *args) ‑> bool set(self, _pfn, ea=BADADDR) -> bool
_pfn: func_t * ea: ea_t

set_ea(self, ea: ea_t) ‑> bool set_ea(self, ea) -> bool
ea: ea_t

set_range(self, ea1: ea_t, ea2: ea_t) ‑> bool set_range(self, ea1, ea2) -> bool
ea1: ea_t ea2: ea_t

lock_func(_pfn: func_t)

: Proxy of C++ lock_func class.

__init__(self, _pfn) -> lock_func

 _pfn: func_t const *

lock_func_with_tails_t(pfn: func_t)

: Proxy of C++ lock_func_with_tails_t class.

__init__(self, pfn) -> lock_func_with_tails_t

 pfn: func_t *

regarg_t(*args)

: Proxy of C++ regarg_t class.

__init__(self) -> regarg_t
__init__(self, r) -> regarg_t

 r: regarg_t const &

Instance variables

name: char * name

reg: int reg

type: type_t * type

Methods

swap(self, r: regarg_t) ‑> void swap(self, r)
r: regarg_t &

PreviousModule ida_frame NextModule ida_gdl

Last updated 1 month ago