Module index

Module ida_funcs

IDA Plugin SDK API wrapper: funcs

Global variables

var FIND_FUNC_DEFINE
create instruction if undefined byte is encountered
var FIND_FUNC_EXIST
function exists already. its bounds are returned in 'nfn'.
var FIND_FUNC_IGNOREFN
ignore existing function boundaries. by default the function returns function boundaries if ea belongs to a function.
var FIND_FUNC_KEEPBD
do not modify incoming function boundaries, just create instructions inside the boundaries.
var FIND_FUNC_NORMAL
stop processing if undefined byte is encountered
var FIND_FUNC_OK
ok, 'nfn' is ready for 'add_func()'
var FIND_FUNC_UNDEF
function has instructions that pass execution flow to unexplored bytes. nfn->end_ea will have the address of the unexplored byte.
var FUNC_BOTTOMBP
BP points to the bottom of the stack frame.
var FUNC_FAR
Far function.
var FUNC_FRAME
Function uses frame pointer (BP)
var FUNC_FUZZY_SP
Function changes SP in untraceable way, for example: and esp, 0FFFFFFF0h
var FUNC_HIDDEN
A hidden function chunk.
var FUNC_LIB
Library function.
var FUNC_LUMINA
Function info is provided by Lumina.
var FUNC_NORET
Function doesn't return.
var FUNC_NORET_PENDING
Function 'non-return' analysis must be performed. This flag is verified upon 'func_does_return()'
var FUNC_PROLOG_OK
Prolog analysis has be performed by last SP-analysis
var FUNC_PURGED_OK
'argsize' field has been validated. If this bit is clear and 'argsize' is 0, then we do not known the real number of bytes removed from the stack. This bit is handled by the processor module.
var FUNC_SP_READY
SP-analysis has been performed. If this flag is on, the stack change points should not be not modified anymore. Currently this analysis is performed only for PC
var FUNC_STATICDEF
Static function.
var FUNC_TAIL
This is a function tail. Other bits must be clear (except 'FUNC_HIDDEN' ).
var FUNC_THUNK
Thunk (jump) function.
var FUNC_USERFAR
User has specified far-ness of the function
var IDASGN_APPLIED
signature is already applied
var IDASGN_BADARG
bad number of signature
var IDASGN_CURRENT
signature is currently being applied
var IDASGN_OK
ok
var IDASGN_PLANNED
signature is planned to be applied
var LIBFUNC_DELAY
no decision because of lack of information
var LIBFUNC_FOUND
ok, library function is found
var LIBFUNC_NONE
no, this is not a library function
var MOVE_FUNC_BADSTART
bad new start address
var MOVE_FUNC_NOCODE
no instruction at 'newstart'
var MOVE_FUNC_NOFUNC
no function at 'ea'
var MOVE_FUNC_OK
ok
var MOVE_FUNC_REFUSED
a plugin refused the action

Functions

def add_func(*args) ‑> 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' ).
add_func(ea1, ea2=BADADDR) -> bool
ea1: start address (C++: ea_t)
ea2: end address (C++: ea_t)
return: success
def add_func_ex(*args) ‑> 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' ).
add_func_ex(pfn) -> bool
pfn: ptr to filled function structure (C++: func_t *)
return: success
def add_regarg(*args) ‑> void
add_regarg(pfn, reg, tif, name)
pfn (C++: func_t *)
reg (C++: int)
tif (C++: const tinfo_t &)
name (C++: const char *)
def append_func_tail(*args) ‑> 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.
append_func_tail(pfn, ea1, ea2) -> bool
pfn (C++: func_t *)
ea1: start of the tail. If a tail already exists at the
specified address it must start at 'ea1' (C++: ea_t)
ea2: 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. (C++: ea_t)
def apply_idasgn_to(*args) ‑> int
Apply a signature file to the specified address.
apply_idasgn_to(signame, ea, is_startup) -> int
signame: short name of signature file (the file name without
path) (C++: const char *)
ea: address to apply the signature (C++: ea_t)
is_startup: 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. (C++: bool)
return: Library function codes
def apply_startup_sig(*args) ‑> bool
Apply a startup signature file to the specified address.
apply_startup_sig(ea, startup) -> bool
ea: address to apply the signature to; usually \inf{start_ea}
(C++: ea_t)
startup: the name of the signature file without path and
extension (C++: const char *)
return: true if successfully applied the signature
def calc_func_size(*args) ‑> asize_t
Calculate function size. This function takes into account all fragments of the function.
calc_func_size(pfn) -> asize_t
pfn: ptr to function structure (C++: func_t *)
def calc_idasgn_state(*args) ‑> int
Get state of a signature in the list of planned signatures
calc_idasgn_state(n) -> int
n: number of signature in the list (0.. get_idasgn_qty() -1)
(C++: int)
return: state of signature or IDASGN_BADARG
def calc_thunk_func_target(*args)
Calculate target of a thunk function.
calc_thunk_func_target(pfn) -> ea_t
pfn: pointer to function (may not be nullptr) (C++: func_t *)
return: the target function or BADADDR
def del_func(*args) ‑> bool
Delete a function.
del_func(ea) -> bool
ea: any address in the function entry chunk (C++: ea_t)
return: success
def del_idasgn(*args) ‑> int
Remove signature from the list of planned signatures.
del_idasgn(n) -> int
n: number of signature in the list (0.. get_idasgn_qty() -1)
(C++: int)
return: IDASGN_OK , IDASGN_BADARG , IDASGN_APPLIED
def f_any(*args) ‑> bool
Helper function to accept any address.
f_any(arg1, arg2) -> bool
arg1: flags_t arg2: void *
def find_func_bounds(*args) ‑> 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 \ph{func_bounds} in order to fine tune the function boundaries.
find_func_bounds(nfn, flags) -> int
nfn: structure to fill with information \ nfn->start_ea points
to the start address of the new function. (C++: func_t *)
flags: Find function bounds flags (C++: int)
return: Find function bounds result codes
def free_regarg(*args) ‑> void
free_regarg(v)
v (C++: struct regarg_t *)
def func_contains(*args) ‑> bool
Does the given function contain the given address?
func_contains(pfn, ea) -> bool
pfn (C++: func_t *)
ea (C++: ea_t)
def func_does_return(*args) ‑> 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.
func_does_return(callee) -> bool
callee (C++: ea_t)
def func_parent_iterator_set(*args) ‑> bool
func_parent_iterator_set(fpi, pfn) -> bool
fpi: func_parent_iterator_t * pfn: func_t *
def func_t__from_ptrval__(*args) ‑> func_t *
func_t__from_ptrval__(ptrval) -> func_t
ptrval: size_t
def func_tail_iterator_set(*args) ‑> bool
func_tail_iterator_set(fti, pfn, ea) -> bool
fti: func_tail_iterator_t * pfn: func_t * ea: ea_t
def func_tail_iterator_set_ea(*args) ‑> bool
func_tail_iterator_set_ea(fti, ea) -> bool
fti: func_tail_iterator_t * ea: ea_t
def get_current_idasgn(*args) ‑> int
Get number of the the current signature.
def get_fchunk(*args) ‑> func_t *
Get pointer to function chunk structure by address.
get_fchunk(ea) -> func_t
ea: any address in a function chunk (C++: ea_t)
return: ptr to a function chunk or nullptr. This function may return
a function entry as well as a function tail.
def get_fchunk_num(*args) ‑> int
Get ordinal number of a function chunk in the global list of function chunks.
get_fchunk_num(ea) -> int
ea: any address in the function chunk (C++: ea_t)
return: number of function chunk (0.. get_fchunk_qty() -1). -1 means
'no function chunk at the specified address'.
def get_fchunk_qty(*args) ‑> size_t
Get total number of function chunks in the program.
def get_fchunk_referer(*args) ‑> ea_t
get_fchunk_referer(ea, idx) -> ea_t
ea: ea_t idx: size_t
def get_func(*args) ‑> func_t *
Get pointer to function structure by address.
get_func(ea) -> func_t
ea: any address in a function (C++: ea_t)
return: ptr to a function or nullptr. This function returns a
function entry chunk.
def get_func_bitness(*args) ‑> int
Get function bitness (which is equal to the function segment bitness). pfn==nullptr => returns 0
get_func_bitness(pfn) -> int
pfn (C++: const func_t *)
retval: 0 - 16
retval: 1 - 32
retval: 2 - 64
def get_func_bits(*args) ‑> int
Get number of bits in the function addressing.
get_func_bits(pfn) -> int
pfn (C++: const func_t *)
def get_func_bytes(*args) ‑> int
Get number of bytes in the function addressing.
get_func_bytes(pfn) -> int
pfn (C++: const func_t *)
def get_func_chunknum(*args) ‑> int
Get the containing tail chunk of 'ea'.
get_func_chunknum(pfn, ea) -> int
pfn (C++: func_t *)
ea (C++: ea_t)
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
def get_func_cmt(*args) ‑> qstring *
Get function comment.
get_func_cmt(pfn, repeatable) -> str
pfn: ptr to function structure (C++: const func_t *)
repeatable: get repeatable comment? (C++: bool)
return: size of comment or -1 In fact this function works with
function chunks too.
def get_func_name(*args) ‑> qstring *
Get function name.
get_func_name(ea) -> str
ea: any address in the function (C++: ea_t)
return: length of the function name
def get_func_num(*args) ‑> int
Get ordinal number of a function.
get_func_num(ea) -> int
ea: any address in the function (C++: ea_t)
return: number of function (0.. get_func_qty() -1). -1 means 'no
function at the specified address'.
def get_func_qty(*args) ‑> size_t
Get total number of functions in the program.
def get_func_ranges(*args) ‑> ea_t
Get function ranges.
get_func_ranges(ranges, pfn) -> ea_t
ranges: buffer to receive the range info (C++: rangeset_t *)
pfn: ptr to function structure (C++: func_t *)
return: end address of the last function range (BADADDR-error)
def get_idasgn_desc(*args) ‑> PyObject *
get_idasgn_desc(n) -> PyObject *
Get information about a signature in the list. It returns: (name of signature, names of optional libraries)
See also: get_idasgn_desc_with_matches
n: number of signature in the list (0..get_idasgn_qty()-1)
return: None on failure or tuple(signame, optlibs)
def get_idasgn_desc_with_matches(*args) ‑> PyObject *
get_idasgn_desc_with_matches(n) -> PyObject *
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)
def get_idasgn_qty(*args) ‑> int
Get number of signatures in the list of planned and applied signatures.
def get_idasgn_title(*args) ‑> qstring *
Get full description of the signature by its short name.
get_idasgn_title(name) -> str
name: short name of a signature (C++: const char *)
return: size of signature description or -1
def get_next_fchunk(*args) ‑> func_t *
Get pointer to the next function chunk in the global list.
get_next_fchunk(ea) -> func_t
ea: any address in the program (C++: ea_t)
return: ptr to function chunk or nullptr if next function chunk
doesn't exist
def get_next_func(*args) ‑> func_t *
Get pointer to the next function.
get_next_func(ea) -> func_t
ea: any address in the program (C++: ea_t)
return: ptr to function or nullptr if next function doesn't exist
def get_next_func_addr(*args) ‑> ea_t
get_next_func_addr(pfn, ea) -> ea_t
pfn (C++: func_t *)
ea (C++: ea_t)
def get_prev_fchunk(*args) ‑> func_t *
Get pointer to the previous function chunk in the global list.
get_prev_fchunk(ea) -> func_t
ea: any address in the program (C++: ea_t)
return: ptr to function chunk or nullptr if previous function chunk
doesn't exist
def get_prev_func(*args) ‑> func_t *
Get pointer to the previous function.
get_prev_func(ea) -> func_t
ea: any address in the program (C++: ea_t)
return: ptr to function or nullptr if previous function doesn't exist
def get_prev_func_addr(*args) ‑> ea_t
get_prev_func_addr(pfn, ea) -> ea_t
pfn (C++: func_t *)
ea (C++: ea_t)
def getn_fchunk(*args) ‑> func_t *
Get pointer to function chunk structure by number.
getn_fchunk(n) -> func_t
n: number of function chunk, is in range 0.. get_fchunk_qty()
-1 (C++: int)
return: ptr to a function chunk or nullptr. This function may return
a function entry as well as a function tail.
def getn_func(*args) ‑> func_t *
Get pointer to function structure by number.
getn_func(n) -> func_t
n: number of function, is in range 0.. get_func_qty() -1 (C++:
size_t)
return: ptr to a function or nullptr. This function returns a
function entry chunk.
def is_finally_visible_func(*args) ‑> bool
Is the function visible (event after considering 'SCF_SHHID_FUNC' )?
is_finally_visible_func(pfn) -> bool
pfn (C++: func_t *)
def is_func_entry(*args) ‑> bool
Does function describe a function entry chunk?
is_func_entry(pfn) -> bool
pfn (C++: const func_t *)
def is_func_locked(*args) ‑> bool
Is the function pointer locked?
is_func_locked(pfn) -> bool
pfn (C++: const func_t *)
def is_func_tail(*args) ‑> bool
Does function describe a function tail chunk?
is_func_tail(pfn) -> bool
pfn (C++: const func_t *)
def is_same_func(*args) ‑> bool
Do two addresses belong to the same function?
is_same_func(ea1, ea2) -> bool
ea1 (C++: ea_t)
ea2 (C++: ea_t)
def is_visible_func(*args) ‑> bool
Is the function visible (not hidden)?
is_visible_func(pfn) -> bool
pfn (C++: func_t *)
def lock_func_range(*args) ‑> void
Lock function pointer Locked pointers are guaranteed to remain valid until they are unlocked. Ranges with locked pointers cannot be deleted or moved.
lock_func_range(pfn, lock)
pfn (C++: const func_t *)
lock (C++: bool)
def plan_to_apply_idasgn(*args) ‑> int
Add a signature file to the list of planned signature files.
plan_to_apply_idasgn(fname) -> int
fname: file name. should not contain directory part. (C++:
const char *)
return: 0 if failed, otherwise number of planned (and applied)
signatures
def read_regargs(*args) ‑> void
read_regargs(pfn)
pfn (C++: func_t *)
def reanalyze_function(*args) ‑> void
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.
reanalyze_function(pfn, ea1=0, ea2=BADADDR, analyze_parents=False)
pfn: pointer to a function (C++: func_t *)
ea1: start of the range to analyze (C++: ea_t)
ea2: end of range to analyze (C++: ea_t)
analyze_parents: 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. (C++: bool)
def reanalyze_noret_flag(*args) ‑> bool
Plan to reanalyze noret flag. This function does not remove FUNC_NORET if it is already present. It just plans to reanalysis.
reanalyze_noret_flag(ea) -> bool
ea (C++: ea_t)
def remove_func_tail(*args) ‑> 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.
remove_func_tail(pfn, tail_ea) -> bool
pfn (C++: func_t *)
tail_ea (C++: ea_t)
def set_func_cmt(*args) ‑> bool
Set function comment. This function works with function chunks too.
set_func_cmt(pfn, cmt, repeatable) -> bool
pfn: ptr to function structure (C++: const func_t *)
cmt: comment string, may be multiline (with ' '). Use empty
str ("") to delete comment (C++: const char *)
repeatable: set repeatable comment? (C++: bool)
def set_func_end(*args) ‑> bool
Move function chunk end address.
set_func_end(ea, newend) -> bool
ea: any address in the function (C++: ea_t)
newend: new end address of the function (C++: ea_t)
return: success
def set_func_name_if_jumpfunc(*args) ‑> int
Give a meaningful name to function if it consists of only 'jump' instruction.
set_func_name_if_jumpfunc(pfn, oldname) -> int
pfn: pointer to function (may be nullptr) (C++: func_t *)
oldname: 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. (C++: const char *)
return: success
def set_func_start(*args) ‑> int
Move function chunk start address.
set_func_start(ea, newstart) -> int
ea: any address in the function (C++: ea_t)
newstart: new end address of the function (C++: ea_t)
return: Function move result codes
def set_noret_insn(*args) ‑> 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()'
set_noret_insn(insn_ea, noret) -> bool
insn_ea (C++: ea_t)
noret (C++: bool)
return: true if the instruction 'noret' flag has been changed
def set_tail_owner(*args) ‑> bool
Set a function as the possessing function of a function tail. The function should already refer to the tail (after append_func_tail).
set_tail_owner(fnt, func_start) -> bool
fnt (C++: func_t *)
func_start (C++: ea_t)
def set_visible_func(*args) ‑> void
Set visibility of function.
set_visible_func(pfn, visible)
pfn (C++: func_t *)
visible (C++: bool)
def try_to_add_libfunc(*args) ‑> 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.
try_to_add_libfunc(ea) -> int
ea: any address in the program (C++: ea_t)
return: Library function codes
def update_func(*args) ‑> 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.
update_func(pfn) -> bool
pfn: ptr to function structure (C++: func_t *)
return: success

Classes

class dyn_ea_array (*args)
Proxy of C++ dynamic_wrapped_array_t< ea_t > class.
__init__(self, _data, _count) -> dyn_ea_array
_data: unsigned int * _count: size_t

Instance variables

var count
dyn_ea_array_count_get(self) -> size_t
var data
dyn_ea_array_data_get(self) -> unsigned int *
class dyn_range_array (*args)
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

var count
dyn_range_array_count_get(self) -> size_t
var data
dyn_range_array_data_get(self) -> range_t
class dyn_regarg_array (*args)
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

var count
dyn_regarg_array_count_get(self) -> size_t
var data
dyn_regarg_array_data_get(self) -> regarg_t
class dyn_regvar_array (*args)
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

var count
dyn_regvar_array_count_get(self) -> size_t
var data
dyn_regvar_array_data_get(self) -> regvar_t *
class dyn_stkpnt_array (*args)
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

var count
dyn_stkpnt_array_count_get(self) -> size_t
var data
dyn_stkpnt_array_data_get(self) -> stkpnt_t *
class func_item_iterator_t (*args)
Proxy of C++ func_item_iterator_t class.
__init__(self) -> func_item_iterator_t
pfn: func_t * _ea: ea_t

Methods

def chunk(self, *args) ‑> range_t const &
chunk(self) -> range_t
def current(self, *args) ‑> ea_t
current(self) -> ea_t
def decode_preceding_insn(self, *args) ‑> bool
decode_preceding_insn(self, visited, p_farref, out) -> bool
visited (C++: eavec_t *)
p_farref (C++: bool *)
out (C++: insn_t *)
def decode_prev_insn(self, *args) ‑> bool
decode_prev_insn(self, out) -> bool
out (C++: insn_t *)
def first(self, *args) ‑> bool
first(self) -> bool
def last(self, *args) ‑> bool
last(self) -> bool
def next(self, *args) ‑> bool
__next__(self, func) -> bool
func: testf_t *
def next_addr(self, *args) ‑> bool
next_addr(self) -> bool
def next_code(self, *args) ‑> bool
next_code(self) -> bool
def next_data(self, *args) ‑> bool
next_data(self) -> bool
def next_head(self, *args) ‑> bool
next_head(self) -> bool
def next_not_tail(self, *args) ‑> bool
next_not_tail(self) -> bool
def prev(self, *args) ‑> bool
prev(self, func) -> bool
func (C++: testf_t *)
def prev_addr(self, *args) ‑> bool
prev_addr(self) -> bool
def prev_code(self, *args) ‑> bool
prev_code(self) -> bool
def prev_data(self, *args) ‑> bool
prev_data(self) -> bool
def prev_head(self, *args) ‑> bool
prev_head(self) -> bool
def prev_not_tail(self, *args) ‑> bool
prev_not_tail(self) -> bool
def set(self, *args) ‑> bool
Set a function range. if pfn == nullptr then a segment range will be set.
set(self, pfn, _ea=BADADDR) -> bool
pfn (C++: func_t *)
_ea (C++: ea_t)
def set_range(self, *args) ‑> bool
Set an arbitrary range.
set_range(self, ea1, ea2) -> bool
ea1 (C++: ea_t)
ea2 (C++: ea_t)
class func_parent_iterator_t (*args)
Proxy of C++ func_parent_iterator_t class.
__init__(self) -> func_parent_iterator_t
_fnt: func_t *

Methods

def first(self, *args) ‑> bool
first(self) -> bool
def last(self, *args) ‑> bool
last(self) -> bool
def next(self, *args) ‑> bool
__next__(self) -> bool
def parent(self, *args) ‑> ea_t
parent(self) -> ea_t
def prev(self, *args) ‑> bool
prev(self) -> bool
def reset_fnt(self, *args) ‑> void
reset_fnt(self, _fnt)
_fnt (C++: func_t *)
def set(self, *args) ‑> bool
set(self, _fnt) -> bool
_fnt (C++: func_t *)
class func_t (*args)
Proxy of C++ func_t class.
__init__(self, start=0, end=0, f=0) -> func_t
start: ea_t end: ea_t f: flags_t

Ancestors

Instance variables

var argsize
func_t_argsize_get(self) -> asize_t
var color
func_t_color_get(self) -> bgcolor_t
var flags
func_t_flags_get(self) -> uint64
var fpd
func_t_fpd_get(self) -> asize_t
var frame
func_t_frame_get(self) -> uval_t
var frregs
func_t_frregs_get(self) -> ushort
var frsize
func_t_frsize_get(self) -> asize_t
var owner
func_t_owner_get(self) -> ea_t
var pntqty
func_t_pntqty_get(self) -> uint32
var points : dynamic_wrapped_array_t< stkpnt_t >
__get_points__(self) -> dyn_stkpnt_array
var referers : dynamic_wrapped_array_t< ea_t >
__get_referers__(self) -> dyn_ea_array
var refqty
func_t_refqty_get(self) -> int
var regargqty
func_t_regargqty_get(self) -> int
var regargs : dynamic_wrapped_array_t< regarg_t >
__get_regargs__(self) -> dyn_regarg_array
var regvarqty
func_t_regvarqty_get(self) -> int
var regvars : dynamic_wrapped_array_t< regvar_t >
__get_regvars__(self) -> dyn_regvar_array
var tailqty
func_t_tailqty_get(self) -> int
var tails : dynamic_wrapped_array_t< range_t >
__get_tails__(self) -> dyn_range_array

Methods

def analyzed_sp(self, *args) ‑> bool
Has SP-analysis been performed?
def does_return(self, *args) ‑> bool
Does function return?
def is_far(self, *args) ‑> bool
Is a far function?
def need_prolog_analysis(self, *args) ‑> bool
Needs prolog analysis?

Inherited members

class func_tail_iterator_t (*args)
Proxy of C++ func_tail_iterator_t class.
__init__(self) -> func_tail_iterator_t
_pfn: func_t * ea: ea_t

Methods

def chunk(self, *args) ‑> range_t const &
chunk(self) -> range_t
def first(self, *args) ‑> bool
first(self) -> bool
def last(self, *args) ‑> bool
last(self) -> bool
def main(self, *args) ‑> bool
main(self) -> bool
def next(self, *args) ‑> bool
__next__(self) -> bool
def prev(self, *args) ‑> bool
prev(self) -> bool
def set(self, *args) ‑> bool
set(self, _pfn, ea=BADADDR) -> bool
_pfn (C++: func_t *)
ea (C++: ea_t)
def set_ea(self, *args) ‑> bool
set_ea(self, ea) -> bool
ea (C++: ea_t)
def set_range(self, *args) ‑> bool
set_range(self, ea1, ea2) -> bool
ea1 (C++: ea_t)
ea2 (C++: ea_t)
class lock_func (*args)
Proxy of C++ lock_func class.
__init__(self, _pfn) -> lock_func
_pfn: func_t const *
class regarg_t (*args)
Proxy of C++ regarg_t class.
__init__(self) -> regarg_t
r: regarg_t const &

Instance variables

var name
regarg_t_name_get(self) -> char *
var reg
regarg_t_reg_get(self) -> int
var type
regarg_t_type_get(self) -> type_t *

Methods

def swap(self, *args) ‑> void
swap(self, r)
r (C++: regarg_t &)