Struct idalib_sys::hexrays::cfunc_t

#[repr(C)]
pub struct cfunc_t {

    pub entry_ea: c_ulonglong,
    pub mba: *mut mba_t,
    pub body: cinsn_t,
    pub argidx: *mut qvector<c_int>,
    pub maturity: c_uint,
    pub user_labels: *mut u8,
    pub user_cmts: *mut u8,
    pub numforms: *mut u8,
    pub user_iflags: *mut u8,
    pub user_unions: *mut u8,
    pub refcnt: c_int,
    pub statebits: c_int,
    pub eamap: *mut u8,
    pub boundaries: *mut u8,
    pub sv: qvector<simpleline_t>,
    pub hdrlines: c_int,
    pub treeitems: qvector<*mut citem_t>,
    pub reserved: __IncompleteArrayField<c_char>,
}

Decompiled function. Decompilation result is kept here.

Fields

entry_ea: c_ulonglong

< function entry address

mba: *mut mba_t

< underlying microcode

body: cinsn_t

< function body, must be a block

argidx: *mut qvector<c_int>

< list of arguments (indexes into vars)

maturity: c_uint

< maturity level

user_labels: *mut u8

< user-defined labels.

user_cmts: *mut u8

< user-defined comments.

numforms: *mut u8

< user-defined number formats.

user_iflags: *mut u8

< user-defined item flags \ref CIT_

user_unions: *mut u8

< user-defined union field selections.

refcnt: c_int

< reference count to this object. use cfuncptr_t

statebits: c_int

< current cfunc_t state. see \ref CFS_

eamap: *mut u8

< ea->insn map. use \ref get_eamap

boundaries: *mut u8

< map of instruction boundaries. use \ref get_boundaries

sv: qvector<simpleline_t>

< decompilation output: function text. use \ref get_pseudocode

hdrlines: c_int

< number of lines in the declaration area

treeitems: qvector<*mut citem_t>

< vector of pointers to citem_t objects (nodes constituting the ctree)

reserved: __IncompleteArrayField<c_char>

Implementations

impl cfunc_t

pub unsafe fn new(mba: *mut mba_t) -> Self

pub unsafe fn new1(arg1: *const cfunc_t) -> Self

Trait Implementations

impl ExternType for cfunc_t

type Id = (c, f, u, n, c, __, t)

A type-level representation of the type’s C++ namespace and type name.

type Kind = Opaque

Either cxx::kind::Opaque or cxx::kind::Trivial.