analysis.c File Reference

#include <rz_analysis.h>
#include <rz_util.h>
#include <rz_list.h>
#include <rz_util/rz_path.h>
#include <config.h>

Go to the source code of this file.

Macros
#define	K_NORET_ADDR(x)   sdb_fmt("addr.%" PFMT64x ".noreturn", x)
#define	K_NORET_FUNC(x)   sdb_fmt("func.%s.noreturn", x)

Functions
	RZ_LIB_VERSION (rz_analysis)
RZ_API void	rz_analysis_set_limits (RzAnalysis *analysis, ut64 from, ut64 to)
RZ_API void	rz_analysis_unset_limits (RzAnalysis *analysis)
static void	meta_unset_for (RzEvent *ev, int type, void *user, void *data)
static void	meta_count_for (RzEvent *ev, int type, void *user, void *data)
void	rz_analysis_hint_storage_init (RzAnalysis *a)
void	rz_analysis_hint_storage_fini (RzAnalysis *a)
static void	rz_meta_item_fini (RzAnalysisMetaItem *item)
static void	rz_meta_item_free (void *_item)
static void	global_kv_free (HtPPKv *kv)
RZ_API RzAnalysis *	rz_analysis_new (void)
RZ_API void	plugin_fini (RzAnalysis *analysis)
void	__block_free_rb (RBNode *node, void *user)
RZ_API RzAnalysis *	rz_analysis_free (RzAnalysis *a)
RZ_API int	rz_analysis_add (RzAnalysis *analysis, RzAnalysisPlugin *p)
RZ_API bool	rz_analysis_use (RzAnalysis *analysis, const char *name)
RZ_API char *	rz_analysis_get_reg_profile (RzAnalysis *analysis)
RZ_API bool	rz_analysis_set_reg_profile (RzAnalysis *analysis)
static bool	analysis_set_os (RzAnalysis *analysis, const char *os)
RZ_API bool	rz_analysis_set_triplet (RzAnalysis *analysis, const char *os, const char *arch, int bits)
RZ_API bool	rz_analysis_set_os (RzAnalysis *analysis, const char *os)
static bool	is_arm_thumb_hack (RzAnalysis *analysis, int bits)
RZ_API bool	rz_analysis_set_bits (RzAnalysis *analysis, int bits)
RZ_API int	rz_analysis_get_address_bits (RzAnalysis *analysis)
	The actual size of an address in bits. More...
RZ_API void	rz_analysis_set_cpu (RzAnalysis *analysis, const char *cpu)
RZ_API int	rz_analysis_set_big_endian (RzAnalysis *analysis, int bigend)
RZ_API ut8 *	rz_analysis_mask (RzAnalysis *analysis, ut32 size, const ut8 *data, ut64 at)
RZ_API void	rz_analysis_trace_bb (RzAnalysis *analysis, ut64 addr)
RZ_API RzList *	rz_analysis_get_fcns (RzAnalysis *analysis)
RZ_API RzAnalysisOp *	rz_analysis_op_hexstr (RzAnalysis *analysis, ut64 addr, const char *str)
RZ_API bool	rz_analysis_op_is_eob (RzAnalysisOp *op)
RZ_API void	rz_analysis_purge (RzAnalysis *analysis)
RZ_API int	rz_analysis_archinfo (RzAnalysis *analysis, int query)
RZ_API bool	rz_analysis_noreturn_add (RzAnalysis *analysis, const char *name, ut64 addr)
RZ_API bool	rz_analysis_noreturn_drop (RzAnalysis *analysis, const char *expr)
static bool	rz_analysis_is_noreturn (RzAnalysis *analysis, const char *name)
static bool	rz_analysis_noreturn_at_name (RzAnalysis *analysis, const char *name)
RZ_API bool	rz_analysis_noreturn_at_addr (RzAnalysis *analysis, ut64 addr)
static bool	noreturn_recurse (RzAnalysis *analysis, ut64 addr)
RZ_API bool	rz_analysis_noreturn_at (RzAnalysis *analysis, ut64 addr)
RZ_API RzList *	rz_analysis_noreturn_functions (RzAnalysis *analysis)
RZ_API void	rz_analysis_bind (RzAnalysis *analysis, RzAnalysisBind *b)
RZ_API RzList *	rz_analysis_preludes (RzAnalysis *analysis)
RZ_API bool	rz_analysis_is_prelude (RzAnalysis *analysis, const ut8 *data, int len)
RZ_API void	rz_analysis_add_import (RzAnalysis *analysis, const char *imp)
RZ_API void	rz_analysis_remove_import (RzAnalysis *analysis, const char *imp)
RZ_API void	rz_analysis_purge_imports (RzAnalysis *analysis)

Variables
static RzAnalysisPlugin *	analysis_static_plugins [] = { RZ_ANALYSIS_STATIC_PLUGINS }

Macro Definition Documentation

K_NORET_ADDR

#define K_NORET_ADDR

(

x

)

sdb_fmt("addr.%" PFMT64x ".noreturn", x)

Definition at line 463 of file analysis.c.

K_NORET_FUNC

#define K_NORET_FUNC

(

x

)

sdb_fmt("func.%s.noreturn", x)

Definition at line 464 of file analysis.c.

Function Documentation

__block_free_rb()

void __block_free_rb	(	RBNode *	node,
		void *	user
	)

Definition at line 85 of file block.c.

                                               {
    RzAnalysisBlock *block = unwrap(node);
    block_free(block);
}

References block_free(), and unwrap.

Referenced by rz_analysis_block_merge(), rz_analysis_block_unref(), and rz_analysis_free().

analysis_set_os()

static bool analysis_set_os ( RzAnalysis *  analysis, const char *  os  )

static

Definition at line 229 of file analysis.c.

                                                                  {
    rz_return_val_if_fail(analysis, false);
    if (!os || !*os) {
        os = RZ_SYS_OS;
    }
    free(analysis->os);
    analysis->os = strdup(os);
    char *types_dir = rz_path_system(RZ_SDB_TYPES);
    rz_type_db_set_os(analysis->typedb, os);
    rz_type_db_reload(analysis->typedb, types_dir);
    free(types_dir);
    return true;
}

References free(), rz_analysis_t::os, rz_path_system(), rz_return_val_if_fail, RZ_SDB_TYPES, RZ_SYS_OS, rz_type_db_reload(), rz_type_db_set_os(), strdup(), and rz_analysis_t::typedb.

Referenced by rz_analysis_set_triplet().

global_kv_free()

static void global_kv_free ( HtPPKv *  kv )

static

Definition at line 58 of file analysis.c.

                                       {
    free(kv->key);
    rz_analysis_var_global_free(kv->value);
}

References free(), and rz_analysis_var_global_free().

Referenced by rz_analysis_new().

is_arm_thumb_hack()

static bool is_arm_thumb_hack ( RzAnalysis *  analysis, int  bits  )

static

Definition at line 260 of file analysis.c.

                                                              {
    if (!analysis || !analysis->cpu) {
        return false;
    }
    if ((analysis->bits != bits) && !strcmp(analysis->cpu, "arm")) {
        return (analysis->bits == 16 && bits == 32) || (analysis->bits == 32 && bits == 16);
    }
    return false;
}

References rz_analysis_t::bits, bits(), and rz_analysis_t::cpu.

Referenced by rz_analysis_set_bits().

meta_count_for()

static void meta_count_for ( RzEvent *  ev, int  type, void *  user, void *  data  )

static

Definition at line 35 of file analysis.c.

                                                                          {
    RzSpaces *s = (RzSpaces *)ev->user;
    RzAnalysis *analysis = container_of(s, RzAnalysis, meta_spaces);
    RzSpaceEvent *se = (RzSpaceEvent *)data;
    se->res = rz_meta_space_count_for(analysis, se->data.count.space);
}

References container_of, rz_space_event_t::count, rz_space_event_t::data, rz_space_event_t::res, rz_meta_space_count_for(), s, and rz_event_t::user.

Referenced by rz_analysis_new().

meta_unset_for()

static void meta_unset_for ( RzEvent *  ev, int  type, void *  user, void *  data  )

static

Definition at line 28 of file analysis.c.

                                                                          {
    RzSpaces *s = (RzSpaces *)ev->user;
    RzAnalysis *analysis = container_of(s, RzAnalysis, meta_spaces);
    RzSpaceEvent *se = (RzSpaceEvent *)data;
    rz_meta_space_unset_for(analysis, se->data.unset.space);
}

References container_of, rz_space_event_t::data, rz_meta_space_unset_for(), s, rz_space_event_t::unset, and rz_event_t::user.

Referenced by rz_analysis_new().

noreturn_recurse()

static bool noreturn_recurse ( RzAnalysis *  analysis, ut64  addr  )

static

Definition at line 561 of file analysis.c.

                                                              {
    RzAnalysisOp op = { 0 };
    ut8 bbuf[0x10] = { 0 };
    ut64 recurse_addr = UT64_MAX;
    if (!analysis->iob.read_at(analysis->iob.io, addr, bbuf, sizeof(bbuf))) {
        RZ_LOG_ERROR("Cannot read buffer at 0x%" PFMT64x "\n", addr);
        return false;
    }
    if (rz_analysis_op(analysis, &op, addr, bbuf, sizeof(bbuf), RZ_ANALYSIS_OP_MASK_BASIC | RZ_ANALYSIS_OP_MASK_VAL) < 1) {
        return false;
    }
    switch (op.type & RZ_ANALYSIS_OP_TYPE_MASK) {
    case RZ_ANALYSIS_OP_TYPE_JMP:
        if (op.jump == UT64_MAX) {
            recurse_addr = op.ptr;
        } else {
            recurse_addr = op.jump;
        }
        break;
    case RZ_ANALYSIS_OP_TYPE_UCALL:
    case RZ_ANALYSIS_OP_TYPE_RCALL:
    case RZ_ANALYSIS_OP_TYPE_ICALL:
    case RZ_ANALYSIS_OP_TYPE_IRCALL:
        recurse_addr = op.ptr;
        break;
    case RZ_ANALYSIS_OP_TYPE_CCALL:
    case RZ_ANALYSIS_OP_TYPE_CALL:
        recurse_addr = op.jump;
        break;
    }
    if (recurse_addr == UT64_MAX || recurse_addr == addr) {
        return false;
    }
    return rz_analysis_noreturn_at(analysis, recurse_addr);
}

References addr, rz_io_bind_t::io, rz_analysis_t::iob, PFMT64x, rz_io_bind_t::read_at, rz_analysis_noreturn_at(), rz_analysis_op(), RZ_ANALYSIS_OP_MASK_BASIC, RZ_ANALYSIS_OP_MASK_VAL, RZ_ANALYSIS_OP_TYPE_CALL, RZ_ANALYSIS_OP_TYPE_CCALL, RZ_ANALYSIS_OP_TYPE_ICALL, RZ_ANALYSIS_OP_TYPE_IRCALL, RZ_ANALYSIS_OP_TYPE_JMP, RZ_ANALYSIS_OP_TYPE_MASK, RZ_ANALYSIS_OP_TYPE_RCALL, RZ_ANALYSIS_OP_TYPE_UCALL, RZ_LOG_ERROR, ut64(), and UT64_MAX.

Referenced by rz_analysis_noreturn_at().

plugin_fini()

RZ_API void plugin_fini

(

RzAnalysis *

analysis

)

Definition at line 127 of file analysis.c.

                                              {
    RzAnalysisPlugin *p = analysis->cur;
    if (p && p->fini && !p->fini(analysis->plugin_data)) {
        RZ_LOG_ERROR("analysis plugin '%s' failed to terminate.\n", p->name);
    }
    analysis->plugin_data = NULL;
}

References rz_analysis_t::cur, NULL, p, rz_analysis_t::plugin_data, and RZ_LOG_ERROR.

Referenced by rz_analysis_free(), and rz_analysis_use().

rz_analysis_add()

RZ_API int rz_analysis_add	(	RzAnalysis *	analysis,
		RzAnalysisPlugin *	p
	)

Definition at line 179 of file analysis.c.

                                                                      {
    rz_list_append(analysis->plugins, p);
    return true;
}

References p, rz_analysis_t::plugins, and rz_list_append().

Referenced by __lib_analysis_cb(), and rz_analysis_new().

rz_analysis_add_import()

RZ_API void rz_analysis_add_import	(	RzAnalysis *	analysis,
		const char *	imp
	)

Definition at line 693 of file analysis.c.

                                                                          {
    RzListIter *it;
    const char *eimp;
    rz_list_foreach (analysis->imports, it, eimp) {
        if (!strcmp(eimp, imp)) {
            return;
        }
    }
    char *cimp = strdup(imp);
    if (!cimp) {
        return;
    }
    rz_list_push(analysis->imports, cimp);
}

References rz_analysis_t::imports, rz_list_push(), and strdup().

Referenced by import_load_cb(), and rz_global_imports_handler().

rz_analysis_archinfo()

RZ_API int rz_analysis_archinfo	(	RzAnalysis *	analysis,
		int	query
	)

Definition at line 449 of file analysis.c.

                                                                 {
    rz_return_val_if_fail(analysis, -1);
    switch (query) {
    case RZ_ANALYSIS_ARCHINFO_MIN_OP_SIZE:
    case RZ_ANALYSIS_ARCHINFO_MAX_OP_SIZE:
    case RZ_ANALYSIS_ARCHINFO_ALIGN:
        if (analysis->cur && analysis->cur->archinfo) {
            return analysis->cur->archinfo(analysis, query);
        }
        break;
    }
    return -1;
}

References rz_analysis_plugin_t::archinfo, rz_analysis_t::cur, RZ_ANALYSIS_ARCHINFO_ALIGN, RZ_ANALYSIS_ARCHINFO_MAX_OP_SIZE, RZ_ANALYSIS_ARCHINFO_MIN_OP_SIZE, and rz_return_val_if_fail.

Referenced by _analysis_calls(), _CbInRangeAav(), alignCheck(), cb_analysis_cpu(), cb_asmarch(), cb_asmbits(), cmd_aea(), do_syscall_search(), prevop_addr(), rz_analysis_set_bits(), rz_analysis_set_cpu(), rz_analysis_update_analysis_range(), rz_core_analysis_bytes(), rz_core_analysis_esil_emulate(), rz_core_analysis_resolve_golang_strings(), rz_core_analysis_type_match(), rz_core_analysis_value_pointers(), rz_core_bin_apply_config(), rz_core_bin_info_print(), rz_core_disasm_pde(), rz_core_esil_step(), rz_core_get_stacksz(), rz_core_link_stroff(), rz_core_seek_opcode_backward(), and rz_debug_step_soft().

rz_analysis_bind()

RZ_API void rz_analysis_bind	(	RzAnalysis *	analysis,
		RzAnalysisBind *	b
	)

Definition at line 661 of file analysis.c.

                                                                      {
    if (b) {
        b->analysis = analysis;
        b->get_fcn_in = rz_analysis_get_fcn_in;
        b->get_hint = rz_analysis_hint_get;
    }
}

References b, rz_analysis_get_fcn_in(), and rz_analysis_hint_get().

Referenced by rz_core_init().

rz_analysis_free()

RZ_API RzAnalysis* rz_analysis_free

(

RzAnalysis *

a

)

Definition at line 137 of file analysis.c.

                                                   {
    if (!a) {
        return NULL;
    }
 
    plugin_fini(a);
 
    rz_hash_free(a->hash);
    rz_analysis_il_vm_cleanup(a);
    rz_list_free(a->fcns);
    ht_up_free(a->ht_addr_fun);
    ht_pp_free(a->ht_name_fun);
    set_u_free(a->visited);
    rz_analysis_hint_storage_fini(a);
    rz_interval_tree_fini(&a->meta);
    free(a->cpu);
    free(a->os);
    rz_list_free(a->plugins);
    rz_rbtree_free(a->bb_tree, __block_free_rb, NULL);
    rz_spaces_fini(&a->meta_spaces);
    rz_syscall_free(a->syscall);
    rz_platform_target_free(a->arch_target);
    rz_platform_target_index_free(a->platform_target);
    rz_reg_free(a->reg);
    ht_up_free(a->ht_xrefs_from);
    ht_up_free(a->ht_xrefs_to);
    ht_up_free(a->type_links);
    rz_list_free(a->leaddrs);
    rz_type_db_free(a->typedb);
    sdb_free(a->sdb);
    if (a->esil) {
        rz_analysis_esil_free(a->esil);
        a->esil = NULL;
    }
    free(a->last_disasm_reg);
    rz_list_free(a->imports);
    rz_str_constpool_fini(&a->constpool);
    ht_pp_free(a->ht_global_var);
    free(a);
    return NULL;
}

References __block_free_rb(), a, free(), NULL, plugin_fini(), rz_analysis_esil_free(), rz_analysis_hint_storage_fini(), rz_analysis_il_vm_cleanup(), rz_hash_free(), rz_interval_tree_fini(), rz_list_free(), rz_platform_target_free(), rz_platform_target_index_free(), rz_rbtree_free(), rz_reg_free(), rz_spaces_fini(), rz_str_constpool_fini(), rz_syscall_free(), rz_type_db_free(), sdb_free(), and set_u_free().

Referenced by __as_free(), and rz_core_fini().

rz_analysis_get_address_bits()

RZ_API int rz_analysis_get_address_bits

(

RzAnalysis *

analysis

)

The actual size of an address in bits.

This may differ from analysis.bits in some cases such as arm thumb being identified as bits=16, but still using 32-bit addresses, or "8-bit" architectures like 6502 which still use 16-bit addresses.

Definition at line 303 of file analysis.c.

                                                              {
    if (!analysis->cur || !analysis->cur->address_bits) {
        return analysis->bits;
    }
    int r = analysis->cur->address_bits(analysis, analysis->bits);
    return r > 0 ? r : analysis->bits;
}

References rz_analysis_plugin_t::address_bits, rz_analysis_t::bits, rz_analysis_t::cur, and r.

Referenced by rz_analysis_set_bits(), rz_core_reg_flags_candidates(), and rz_print_hexword_references_handler().

rz_analysis_get_fcns()

RZ_API RzList* rz_analysis_get_fcns

(

RzAnalysis *

analysis

)

Definition at line 392 of file analysis.c.

                                                            {
    // avoid received to free this thing
    analysis->fcns->free = NULL;
    return analysis->fcns;
}

References rz_analysis_t::fcns, rz_list_t::free, and NULL.

Referenced by rz_core_diff_show().

rz_analysis_get_reg_profile()

RZ_API char* rz_analysis_get_reg_profile

(

RzAnalysis *

analysis

)

Definition at line 212 of file analysis.c.

                                                               {
    return (analysis && analysis->cur && analysis->cur->get_reg_profile)
        ? analysis->cur->get_reg_profile(analysis)
        : NULL;
}

References rz_analysis_t::cur, rz_analysis_plugin_t::get_reg_profile, and NULL.

Referenced by __esil_reg_profile(), __io_reg_profile(), and rz_analysis_set_reg_profile().

rz_analysis_hint_storage_fini()

void rz_analysis_hint_storage_fini

(

RzAnalysis *

a

)

Definition at line 79 of file hint.c.

                                                  {
    ht_up_free(a->addr_hints);
    rz_rbtree_free(a->arch_hints, arch_hint_record_free_rb, NULL);
    rz_rbtree_free(a->bits_hints, bits_hint_record_free_rb, NULL);
}

References a, arch_hint_record_free_rb(), bits_hint_record_free_rb(), NULL, and rz_rbtree_free().

Referenced by rz_analysis_free(), and rz_analysis_hint_clear().

rz_analysis_hint_storage_init()

void rz_analysis_hint_storage_init

(

RzAnalysis *

a

)

Definition at line 72 of file hint.c.

                                                  {
    a->addr_hints = ht_up_new(NULL, addr_hint_record_ht_free, NULL);
    a->arch_hints = NULL;
    a->bits_hints = NULL;
}

References a, addr_hint_record_ht_free(), and NULL.

Referenced by rz_analysis_hint_clear(), and rz_analysis_new().

rz_analysis_is_noreturn()

static bool rz_analysis_is_noreturn ( RzAnalysis *  analysis, const char *  name  )

static

Definition at line 534 of file analysis.c.

                                                                            {
    return rz_type_func_is_noreturn(analysis->typedb, name) ||
        sdb_bool_get(analysis->sdb_noret, K_NORET_FUNC(name), NULL);
}

References K_NORET_FUNC, NULL, rz_type_func_is_noreturn(), sdb_bool_get(), rz_analysis_t::sdb_noret, and rz_analysis_t::typedb.

Referenced by rz_analysis_noreturn_at_name().

rz_analysis_is_prelude()

RZ_API bool rz_analysis_is_prelude	(	RzAnalysis *	analysis,
		const ut8 *	data,
		int	len
	)

Definition at line 676 of file analysis.c.

                                                                                   {
    RzList *l = rz_analysis_preludes(analysis);
    if (l) {
        RzSearchKeyword *kw;
        RzListIter *iter;
        rz_list_foreach (l, iter, kw) {
            int ks = kw->keyword_length;
            if (len >= ks && !memcmp(data, kw->bin_keyword, ks)) {
                rz_list_free(l);
                return true;
            }
        }
        rz_list_free(l);
    }
    return false;
}

References rz_search_keyword_t::bin_keyword, rz_search_keyword_t::keyword_length, len, rz_analysis_preludes(), and rz_list_free().

Referenced by run_basic_block_analysis(), and rz_analysis_check_fcn().

rz_analysis_mask()

RZ_API ut8* rz_analysis_mask	(	RzAnalysis *	analysis,
		ut32	size,
		const ut8 *	data,
		ut64	at
	)

Definition at line 334 of file analysis.c.

                                                                                        {
    RzAnalysisOp *op = NULL;
    ut8 *ret = NULL;
    int oplen = 0;
    ut32 idx = 0;
 
    if (!data) {
        return NULL;
    }
 
    if (analysis->cur && analysis->cur->analysis_mask) {
        return analysis->cur->analysis_mask(analysis, size, data, at);
    }
 
    if (!(op = rz_analysis_op_new())) {
        return NULL;
    }
 
    if (!(ret = malloc(size))) {
        rz_analysis_op_free(op);
        return NULL;
    }
 
    memset(ret, 0xff, size);
 
    while (idx < size) {
        if ((oplen = rz_analysis_op(analysis, op, at, data + idx, size - idx, RZ_ANALYSIS_OP_MASK_BASIC)) < 1) {
            break;
        }
        if ((op->ptr != UT64_MAX || op->jump != UT64_MAX) && op->nopcode != 0) {
            memset(ret + idx + op->nopcode, 0, oplen - op->nopcode);
        }
        idx += oplen;
        at += oplen;
        rz_analysis_op_fini(op);
        rz_analysis_op_init(op);
    }
 
    rz_analysis_op_free(op);
 
    return ret;
}

References rz_analysis_plugin_t::analysis_mask, rz_analysis_t::cur, setup::idx, malloc(), memset(), NULL, rz_analysis_op(), rz_analysis_op_fini(), rz_analysis_op_free(), rz_analysis_op_init(), RZ_ANALYSIS_OP_MASK_BASIC, rz_analysis_op_new(), and UT64_MAX.

Referenced by rz_core_analysis_bytes(), and rz_sign_flirt_node_new().

rz_analysis_new()

RZ_API RzAnalysis* rz_analysis_new

(

void

)

Definition at line 63 of file analysis.c.

                                         {
    int i;
    RzAnalysis *analysis = RZ_NEW0(RzAnalysis);
    if (!analysis) {
        return NULL;
    }
    if (!rz_str_constpool_init(&analysis->constpool)) {
        free(analysis);
        return NULL;
    }
    analysis->bb_tree = NULL;
    analysis->ht_addr_fun = ht_up_new0();
    analysis->ht_name_fun = ht_pp_new0();
    analysis->os = strdup(RZ_SYS_OS);
    analysis->esil_goto_limit = RZ_ANALYSIS_ESIL_GOTO_LIMIT;
    analysis->opt.nopskip = true; // skip nops in code analysis
    analysis->opt.hpskip = false; // skip `mov reg,reg` and `lea reg,[reg]`
    analysis->gp = 0LL;
    analysis->sdb = sdb_new0();
    analysis->cpp_abi = RZ_ANALYSIS_CPP_ABI_ITANIUM;
    analysis->opt.depth = 32;
    analysis->opt.noncode = false; // do not analyze data by default
    rz_spaces_init(&analysis->meta_spaces, "CS");
    rz_event_hook(analysis->meta_spaces.event, RZ_SPACE_EVENT_UNSET, meta_unset_for, NULL);
    rz_event_hook(analysis->meta_spaces.event, RZ_SPACE_EVENT_COUNT, meta_count_for, NULL);
 
    rz_analysis_hint_storage_init(analysis);
    rz_interval_tree_init(&analysis->meta, rz_meta_item_free);
    analysis->typedb = rz_type_db_new();
    analysis->type_links = ht_up_new0();
    analysis->sdb_fmts = sdb_ns(analysis->sdb, "spec", 1);
    analysis->sdb_cc = sdb_ns(analysis->sdb, "cc", 1);
    analysis->sdb_classes = sdb_ns(analysis->sdb, "classes", 1);
    analysis->sdb_classes_attrs = sdb_ns(analysis->sdb_classes, "attrs", 1);
    analysis->sdb_noret = sdb_ns(analysis->sdb, "noreturn", 1);
    (void)rz_analysis_xrefs_init(analysis);
    analysis->diff_thbb = RZ_ANALYSIS_THRESHOLDBB;
    analysis->diff_thfcn = RZ_ANALYSIS_THRESHOLDFCN;
    analysis->syscall = rz_syscall_new();
    analysis->arch_target = rz_platform_target_new();
    analysis->platform_target = rz_platform_target_index_new();
    rz_io_bind_init(analysis->iob);
    rz_flag_bind_init(analysis->flb);
    analysis->reg = rz_reg_new();
    analysis->last_disasm_reg = NULL;
    analysis->stackptr = 0;
    analysis->lineswidth = 0;
    analysis->fcns = rz_list_newf(rz_analysis_function_free);
    analysis->leaddrs = NULL;
    analysis->imports = rz_list_newf(free);
    rz_analysis_set_bits(analysis, 32);
    analysis->plugins = rz_list_newf(NULL);
    if (analysis->plugins) {
        for (i = 0; i < RZ_ARRAY_SIZE(analysis_static_plugins); i++) {
            rz_analysis_add(analysis, analysis_static_plugins[i]);
        }
    }
    analysis->ht_global_var = ht_pp_new(NULL, global_kv_free, NULL);
    analysis->global_var_tree = NULL;
    analysis->il_vm = NULL;
    analysis->hash = rz_hash_new();
    return analysis;
}

References analysis_static_plugins, rz_analysis_t::arch_target, rz_analysis_t::bb_tree, rz_analysis_t::constpool, rz_analysis_t::cpp_abi, rz_analysis_options_t::depth, rz_analysis_t::diff_thbb, rz_analysis_t::diff_thfcn, rz_analysis_t::esil_goto_limit, rz_spaces_t::event, rz_analysis_t::fcns, rz_analysis_t::flb, free(), global_kv_free(), rz_analysis_t::global_var_tree, rz_analysis_t::gp, rz_analysis_t::hash, rz_analysis_options_t::hpskip, rz_analysis_t::ht_addr_fun, rz_analysis_t::ht_global_var, rz_analysis_t::ht_name_fun, i, rz_analysis_t::il_vm, rz_analysis_t::imports, rz_analysis_t::iob, rz_analysis_t::last_disasm_reg, rz_analysis_t::leaddrs, rz_analysis_t::lineswidth, rz_analysis_t::meta, meta_count_for(), rz_analysis_t::meta_spaces, meta_unset_for(), rz_analysis_options_t::noncode, rz_analysis_options_t::nopskip, NULL, rz_analysis_t::opt, rz_analysis_t::os, rz_analysis_t::platform_target, rz_analysis_t::plugins, rz_analysis_t::reg, rz_analysis_add(), RZ_ANALYSIS_CPP_ABI_ITANIUM, RZ_ANALYSIS_ESIL_GOTO_LIMIT, rz_analysis_function_free(), rz_analysis_hint_storage_init(), rz_analysis_set_bits(), rz_analysis_xrefs_init(), RZ_ARRAY_SIZE, rz_event_hook(), rz_flag_bind_init, rz_hash_new(), rz_interval_tree_init(), rz_io_bind_init, rz_list_newf(), rz_meta_item_free(), RZ_NEW0, rz_platform_target_index_new(), rz_platform_target_new(), rz_reg_new(), RZ_SPACE_EVENT_COUNT, RZ_SPACE_EVENT_UNSET, rz_spaces_init(), rz_str_constpool_init(), RZ_SYS_OS, rz_syscall_new(), rz_type_db_new(), rz_analysis_t::sdb, rz_analysis_t::sdb_cc, rz_analysis_t::sdb_classes, rz_analysis_t::sdb_classes_attrs, rz_analysis_t::sdb_fmts, sdb_new0(), rz_analysis_t::sdb_noret, sdb_ns(), rz_analysis_t::stackptr, strdup(), rz_analysis_t::syscall, rz_analysis_t::type_links, and rz_analysis_t::typedb.

Referenced by __as_new(), and rz_core_init().

rz_analysis_noreturn_add()

RZ_API bool rz_analysis_noreturn_add	(	RzAnalysis *	analysis,
		const char *	name,
		ut64	addr
	)

Definition at line 466 of file analysis.c.

                                                                                        {
    const char *tmp_name = NULL;
    Sdb *NDB = analysis->sdb_noret;
    char *fnl_name = NULL;
    if (addr != UT64_MAX) {
        if (sdb_bool_set(NDB, K_NORET_ADDR(addr), true, 0)) {
            RzAnalysisFunction *fcn = rz_analysis_get_function_at(analysis, addr);
            if (fcn) {
                fcn->is_noreturn = true;
            }
            return true;
        }
    }
    if (name && *name) {
        tmp_name = name;
    } else {
        RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(analysis, addr, -1);
        RzFlagItem *fi = analysis->flb.get_at(analysis->flb.f, addr, false);
        if (!fcn && !fi) {
            RZ_LOG_ERROR("Cannot find function and flag at address 0x%" PFMT64x "\n", addr);
            return false;
        }
        tmp_name = fcn ? fcn->name : fi->name;
        if (fcn) {
            fcn->is_noreturn = true;
        }
    }
    if (rz_type_func_exist(analysis->typedb, tmp_name)) {
        fnl_name = strdup(tmp_name);
    } else if (!(fnl_name = rz_analysis_function_name_guess(analysis->typedb, (char *)tmp_name))) {
        if (addr == UT64_MAX) {
            if (name) {
                sdb_bool_set(NDB, K_NORET_FUNC(name), true, 0);
            } else {
                RZ_LOG_ERROR("Cannot find prototype for: %s\n", tmp_name);
            }
        } else {
            RZ_LOG_ERROR("Cannot find prototype for: %s\n", tmp_name);
        }
        // return false;
    }
    if (fnl_name) {
        sdb_bool_set(NDB, K_NORET_FUNC(fnl_name), true, 0);
        free(fnl_name);
    }
    return true;
}

References addr, rz_flag_bind_t::f, rz_analysis_t::flb, free(), rz_flag_bind_t::get_at, rz_analysis_function_t::is_noreturn, K_NORET_ADDR, K_NORET_FUNC, name, rz_analysis_function_t::name, rz_flag_item_t::name, NULL, PFMT64x, rz_analysis_function_name_guess(), rz_analysis_get_fcn_in(), rz_analysis_get_function_at(), RZ_LOG_ERROR, rz_type_func_exist(), sdb_bool_set(), rz_analysis_t::sdb_noret, strdup(), rz_analysis_t::typedb, and UT64_MAX.

Referenced by reanalyze_fcns_cb(), relocation_function_process_noreturn(), rz_core_analysis_propagate_noreturn(), and rz_type_list_noreturn_handler().

rz_analysis_noreturn_at()

RZ_API bool rz_analysis_noreturn_at	(	RzAnalysis *	analysis,
		ut64	addr
	)

Definition at line 597 of file analysis.c.

                                                                     {
    if (!addr || addr == UT64_MAX) {
        return false;
    }
    if (rz_analysis_noreturn_at_addr(analysis, addr)) {
        return true;
    }
    /* XXX this is very slow */
    RzAnalysisFunction *f = rz_analysis_get_function_at(analysis, addr);
    if (f) {
        if (rz_analysis_noreturn_at_name(analysis, f->name)) {
            return true;
        }
    }
    RzFlagItem *fi = analysis->flag_get(analysis->flb.f, addr);
    if (fi) {
        if (rz_analysis_noreturn_at_name(analysis, fi->realname ? fi->realname : fi->name)) {
            return true;
        }
    }
    if (analysis->recursive_noreturn) {
        return noreturn_recurse(analysis, addr);
    }
    return false;
}

References addr, rz_flag_bind_t::f, f, rz_analysis_t::flag_get, rz_analysis_t::flb, rz_flag_item_t::name, noreturn_recurse(), rz_flag_item_t::realname, rz_analysis_t::recursive_noreturn, rz_analysis_get_function_at(), rz_analysis_noreturn_at_addr(), rz_analysis_noreturn_at_name(), and UT64_MAX.

Referenced by noreturn_recurse(), run_basic_block_analysis(), and rz_core_debug_bp_add_noreturn_func().

rz_analysis_noreturn_at_addr()

RZ_API bool rz_analysis_noreturn_at_addr	(	RzAnalysis *	analysis,
		ut64	addr
	)

Definition at line 557 of file analysis.c.

                                                                          {
    return sdb_bool_get(analysis->sdb_noret, K_NORET_ADDR(addr), NULL);
}

References addr, K_NORET_ADDR, NULL, sdb_bool_get(), and rz_analysis_t::sdb_noret.

Referenced by rz_analysis_add_function(), rz_analysis_function_get_json(), and rz_analysis_noreturn_at().

rz_analysis_noreturn_at_name()

static bool rz_analysis_noreturn_at_name ( RzAnalysis *  analysis, const char *  name  )

static

Definition at line 539 of file analysis.c.

                                                                                 {
    if (rz_analysis_is_noreturn(analysis, name)) {
        return true;
    }
    char *tmp = rz_analysis_function_name_guess(analysis->typedb, (char *)name);
    if (tmp) {
        if (rz_analysis_is_noreturn(analysis, tmp)) {
            free(tmp);
            return true;
        }
        free(tmp);
    }
    if (rz_str_startswith(name, "reloc.")) {
        return rz_analysis_noreturn_at_name(analysis, name + 6);
    }
    return false;
}

References free(), rz_analysis_function_name_guess(), rz_analysis_is_noreturn(), rz_str_startswith(), autogen_x86imm::tmp, and rz_analysis_t::typedb.

Referenced by rz_analysis_noreturn_at().

rz_analysis_noreturn_drop()

RZ_API bool rz_analysis_noreturn_drop	(	RzAnalysis *	analysis,
		const char *	expr
	)

Definition at line 514 of file analysis.c.

                                                                              {
    Sdb *NDB = analysis->sdb_noret;
    expr = rz_str_trim_head_ro(expr);
    const char *fcnname = NULL;
    if (!strncmp(expr, "0x", 2)) {
        ut64 n = rz_num_math(NULL, expr);
        sdb_unset(NDB, K_NORET_ADDR(n), 0);
        RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(analysis, n, -1);
        if (!fcn) {
            // eprintf ("can't find function at 0x%"PFMT64x"\n", n);
            return false;
        }
        fcnname = fcn->name;
    } else {
        fcnname = expr;
    }
    sdb_unset(NDB, K_NORET_FUNC(fcnname), 0);
    return false;
}

References expr(), K_NORET_ADDR, K_NORET_FUNC, n, rz_analysis_function_t::name, NULL, rz_analysis_get_fcn_in(), rz_num_math(), rz_str_trim_head_ro(), rz_analysis_t::sdb_noret, sdb_unset(), and ut64().

rz_analysis_noreturn_functions()

RZ_API RzList* rz_analysis_noreturn_functions

(

RzAnalysis *

analysis

)

Definition at line 623 of file analysis.c.

                                                                      {
    rz_return_val_if_fail(analysis, NULL);
    // At first we read all noreturn functions from the Types DB
    RzList *noretl = rz_type_noreturn_function_names(analysis->typedb);
    // Then we propagate all noreturn functions that were inferred by
    // the analysis process
    SdbKv *kv;
    SdbListIter *iter;
    SdbList *l = sdb_foreach_list(analysis->sdb_noret, true);
    ls_foreach (l, iter, kv) {
        const char *k = sdbkv_key(kv);
        if (!strncmp(k, "func.", 5) && strstr(k, ".noreturn")) {
            char *s = strdup(k + 5);
            char *d = strchr(s, '.');
            if (d) {
                *d = 0;
            }
            rz_list_append(noretl, strdup(s));
            free(s);
        }
        if (!strncmp(k, "addr.", 5)) {
            char *off;
            if (!(off = strdup(k + 5))) {
                break;
            }
            char *ptr = strstr(off, ".noreturn");
            if (ptr) {
                *ptr = 0;
                char *addr = rz_str_newf("0x%s", off);
                rz_list_append(noretl, addr);
            }
            free(off);
        }
    }
    ls_free(l);
    return noretl;
}

References addr, d, free(), k, ls_foreach, ls_free(), NULL, off, rz_list_append(), rz_return_val_if_fail, rz_str_newf(), rz_type_noreturn_function_names(), s, sdb_foreach_list(), rz_analysis_t::sdb_noret, sdbkv_key(), strdup(), and rz_analysis_t::typedb.

Referenced by rz_core_analysis_propagate_noreturn_relocs().

rz_analysis_op_hexstr()

RZ_API RzAnalysisOp* rz_analysis_op_hexstr	(	RzAnalysis *	analysis,
		ut64	addr,
		const char *	str
	)

Definition at line 398 of file analysis.c.

                                                                                             {
    RzAnalysisOp *op = RZ_NEW0(RzAnalysisOp);
    if (!op) {
        return NULL;
    }
    ut8 *buf = calloc(1, strlen(str) + 1);
    if (!buf) {
        free(op);
        return NULL;
    }
    int len = rz_hex_str2bin(str, buf);
    rz_analysis_op(analysis, op, addr, buf, len, RZ_ANALYSIS_OP_MASK_BASIC);
    free(buf);
    return op;
}

References addr, calloc(), free(), len, NULL, op, rz_analysis_op(), RZ_ANALYSIS_OP_MASK_BASIC, rz_hex_str2bin(), RZ_NEW0, and cmd_descs_generate::str.

rz_analysis_op_is_eob()

RZ_API bool rz_analysis_op_is_eob

(

RzAnalysisOp *

op

)

Definition at line 414 of file analysis.c.

                                                    {
    if (op->eob) {
        return true;
    }
    switch (op->type) {
    case RZ_ANALYSIS_OP_TYPE_JMP:
    case RZ_ANALYSIS_OP_TYPE_UJMP:
    case RZ_ANALYSIS_OP_TYPE_RJMP:
    case RZ_ANALYSIS_OP_TYPE_IJMP:
    case RZ_ANALYSIS_OP_TYPE_IRJMP:
    case RZ_ANALYSIS_OP_TYPE_CJMP:
    case RZ_ANALYSIS_OP_TYPE_RET:
    case RZ_ANALYSIS_OP_TYPE_TRAP:
        return true;
    default:
        return false;
    }
}

References RZ_ANALYSIS_OP_TYPE_CJMP, RZ_ANALYSIS_OP_TYPE_IJMP, RZ_ANALYSIS_OP_TYPE_IRJMP, RZ_ANALYSIS_OP_TYPE_JMP, RZ_ANALYSIS_OP_TYPE_RET, RZ_ANALYSIS_OP_TYPE_RJMP, RZ_ANALYSIS_OP_TYPE_TRAP, and RZ_ANALYSIS_OP_TYPE_UJMP.

Referenced by num_callback().

rz_analysis_preludes()

RZ_API RzList* rz_analysis_preludes

(

RzAnalysis *

analysis

)

Definition at line 669 of file analysis.c.

                                                            {
    if (analysis->cur && analysis->cur->preludes) {
        return analysis->cur->preludes(analysis);
    }
    return NULL;
}

References rz_analysis_t::cur, NULL, and rz_analysis_plugin_t::preludes.

Referenced by rz_analysis_is_prelude(), and rz_core_search_preludes().

rz_analysis_purge()

RZ_API void rz_analysis_purge

(

RzAnalysis *

analysis

)

Definition at line 433 of file analysis.c.

                                                    {
    rz_analysis_hint_clear(analysis);
    rz_interval_tree_fini(&analysis->meta);
    rz_interval_tree_init(&analysis->meta, rz_meta_item_free);
    rz_type_db_purge(analysis->typedb);
    ht_up_free(analysis->type_links);
    analysis->type_links = ht_up_new0();
    sdb_reset(analysis->sdb_classes);
    sdb_reset(analysis->sdb_classes_attrs);
    sdb_reset(analysis->sdb_cc);
    sdb_reset(analysis->sdb_noret);
    rz_list_free(analysis->fcns);
    analysis->fcns = rz_list_newf(rz_analysis_function_free);
    rz_analysis_purge_imports(analysis);
}

References rz_analysis_t::fcns, rz_analysis_t::meta, rz_analysis_function_free(), rz_analysis_hint_clear(), rz_analysis_purge_imports(), rz_interval_tree_fini(), rz_interval_tree_init(), rz_list_free(), rz_list_newf(), rz_meta_item_free(), rz_type_db_purge(), rz_analysis_t::sdb_cc, rz_analysis_t::sdb_classes, rz_analysis_t::sdb_classes_attrs, rz_analysis_t::sdb_noret, sdb_reset(), rz_analysis_t::type_links, and rz_analysis_t::typedb.

Referenced by rz_open_close_all_handler(), and rz_serialize_analysis_load().

rz_analysis_purge_imports()

RZ_API void rz_analysis_purge_imports

(

RzAnalysis *

analysis

)

Definition at line 719 of file analysis.c.

                                                            {
    rz_list_purge(analysis->imports);
}

References rz_analysis_t::imports, and rz_list_purge().

Referenced by rz_analysis_purge(), and rz_delete_global_imports_handler().

rz_analysis_remove_import()

RZ_API void rz_analysis_remove_import	(	RzAnalysis *	analysis,
		const char *	imp
	)

Definition at line 708 of file analysis.c.

                                                                             {
    RzListIter *it;
    const char *eimp;
    rz_list_foreach (analysis->imports, it, eimp) {
        if (!strcmp(eimp, imp)) {
            rz_list_delete(analysis->imports, it);
            return;
        }
    }
}

References rz_analysis_t::imports, and rz_list_delete().

rz_analysis_set_big_endian()

RZ_API int rz_analysis_set_big_endian	(	RzAnalysis *	analysis,
		int	bigend
	)

Definition at line 325 of file analysis.c.

                                                                        {
    analysis->big_endian = bigend;
    if (analysis->reg) {
        analysis->reg->big_endian = bigend;
    }
    rz_type_db_set_endian(analysis->typedb, bigend);
    return true;
}

References rz_analysis_t::big_endian, rz_reg_t::big_endian, rz_analysis_t::reg, rz_type_db_set_endian(), and rz_analysis_t::typedb.

Referenced by cb_asmarch(), cb_bigendian(), and rz_main_rz_asm().

rz_analysis_set_bits()

RZ_API bool rz_analysis_set_bits	(	RzAnalysis *	analysis,
		int	bits
	)

Definition at line 270 of file analysis.c.

                                                                 {
    switch (bits) {
    case 8:
    case 16:
    case 27:
    case 32:
    case 64:
        if (analysis->bits != bits) {
            bool is_hack = is_arm_thumb_hack(analysis, bits);
            analysis->bits = bits;
            int v = rz_analysis_archinfo(analysis, RZ_ANALYSIS_ARCHINFO_ALIGN);
            analysis->pcalign = RZ_MAX(0, v);
            rz_type_db_set_bits(analysis->typedb, bits);
            rz_type_db_set_address_bits(analysis->typedb, rz_analysis_get_address_bits(analysis));
            if (!is_hack) {
                char *types_dir = rz_path_system(RZ_SDB_TYPES);
                rz_type_db_reload(analysis->typedb, types_dir);
                free(types_dir);
            }
            rz_analysis_set_reg_profile(analysis);
        }
        return true;
    }
    return false;
}

References rz_analysis_t::bits, bits(), free(), is_arm_thumb_hack(), rz_analysis_t::pcalign, rz_analysis_archinfo(), RZ_ANALYSIS_ARCHINFO_ALIGN, rz_analysis_get_address_bits(), rz_analysis_set_reg_profile(), RZ_MAX, rz_path_system(), RZ_SDB_TYPES, rz_type_db_reload(), rz_type_db_set_address_bits(), rz_type_db_set_bits(), rz_analysis_t::typedb, and v.

Referenced by __as_set_archbits(), cb_asmbits(), rz_analysis_new(), rz_analysis_set_triplet(), and rz_main_rz_asm().

rz_analysis_set_cpu()

RZ_API void rz_analysis_set_cpu	(	RzAnalysis *	analysis,
		const char *	cpu
	)

Definition at line 311 of file analysis.c.

                                                                       {
    free(analysis->cpu);
    analysis->cpu = cpu ? strdup(cpu) : NULL;
    int v = rz_analysis_archinfo(analysis, RZ_ANALYSIS_ARCHINFO_ALIGN);
    if (v != -1) {
        analysis->pcalign = v;
    }
    rz_analysis_set_reg_profile(analysis);
    rz_type_db_set_cpu(analysis->typedb, cpu);
    char *types_dir = rz_path_system(RZ_SDB_TYPES);
    rz_type_db_reload(analysis->typedb, types_dir);
    free(types_dir);
}

References cpu, rz_analysis_t::cpu, free(), NULL, rz_analysis_t::pcalign, rz_analysis_archinfo(), RZ_ANALYSIS_ARCHINFO_ALIGN, rz_analysis_set_reg_profile(), rz_path_system(), RZ_SDB_TYPES, rz_type_db_reload(), rz_type_db_set_cpu(), strdup(), rz_analysis_t::typedb, and v.

Referenced by cb_analysis_cpu(), and rz_main_rz_asm().

rz_analysis_set_limits()

RZ_API void rz_analysis_set_limits	(	RzAnalysis *	analysis,
		ut64	from,
		ut64	to
	)

Definition at line 15 of file analysis.c.

                                                                             {
    free(analysis->limit);
    analysis->limit = RZ_NEW0(RzAnalysisRange);
    if (analysis->limit) {
        analysis->limit->from = from;
        analysis->limit->to = to;
    }
}

References free(), rz_analysis_range_t::from, from, rz_analysis_t::limit, RZ_NEW0, rz_analysis_range_t::to, and to.

Referenced by cb_analysis_from(), and cb_analysis_limits().

rz_analysis_set_os()

RZ_API bool rz_analysis_set_os	(	RzAnalysis *	analysis,
		const char *	os
	)

Definition at line 256 of file analysis.c.

                                                                     {
    return rz_analysis_set_triplet(analysis, os, NULL, -1);
}

References NULL, and rz_analysis_set_triplet().

Referenced by cb_asmos().

rz_analysis_set_reg_profile()

RZ_API bool rz_analysis_set_reg_profile

(

RzAnalysis *

analysis

)

Definition at line 218 of file analysis.c.

                                                              {
    bool ret = false;
    char *p = rz_analysis_get_reg_profile(analysis);
    if (p) {
        rz_reg_set_profile_string(analysis->reg, p);
        ret = true;
    }
    free(p);
    return ret;
}

References free(), p, rz_analysis_t::reg, rz_analysis_get_reg_profile(), and rz_reg_set_profile_string().

Referenced by cb_asmbits(), rz_analysis_set_bits(), rz_analysis_set_cpu(), and rz_analysis_use().

rz_analysis_set_triplet()

RZ_API bool rz_analysis_set_triplet	(	RzAnalysis *	analysis,
		const char *	os,
		const char *	arch,
		int	bits
	)

Definition at line 243 of file analysis.c.

                                                                                                      {
    rz_return_val_if_fail(analysis, false);
    if (!arch || !*arch) {
        arch = analysis->cur ? analysis->cur->arch : RZ_SYS_ARCH;
    }
    if (bits < 1) {
        bits = analysis->bits;
    }
    analysis_set_os(analysis, os);
    rz_analysis_set_bits(analysis, bits);
    return rz_analysis_use(analysis, arch);
}

References analysis_set_os(), rz_analysis_plugin_t::arch, arch, rz_analysis_t::bits, bits(), rz_analysis_t::cur, rz_analysis_set_bits(), rz_analysis_use(), rz_return_val_if_fail, and RZ_SYS_ARCH.

Referenced by rz_analysis_set_os().

rz_analysis_trace_bb()

RZ_API void rz_analysis_trace_bb	(	RzAnalysis *	analysis,
		ut64	addr
	)

Definition at line 377 of file analysis.c.

                                                                  {
    RzAnalysisBlock *bbi;
    RzAnalysisFunction *fcni;
    RzListIter *iter2;
    fcni = rz_analysis_get_fcn_in(analysis, addr, 0);
    if (fcni) {
        rz_list_foreach (fcni->bbs, iter2, bbi) {
            if (addr >= bbi->addr && addr < (bbi->addr + bbi->size)) {
                bbi->traced = true;
                break;
            }
        }
    }
}

References addr, rz_analysis_bb_t::addr, rz_analysis_function_t::bbs, rz_analysis_get_fcn_in(), rz_analysis_bb_t::size, and rz_analysis_bb_t::traced.

Referenced by rz_debug_trace_add().

rz_analysis_unset_limits()

RZ_API void rz_analysis_unset_limits

(

RzAnalysis *

analysis

)

Definition at line 24 of file analysis.c.

                                                           {
    RZ_FREE(analysis->limit);
}

References rz_analysis_t::limit, and RZ_FREE.

Referenced by cb_analysis_limits().

rz_analysis_use()

RZ_API bool rz_analysis_use	(	RzAnalysis *	analysis,
		const char *	name
	)

Definition at line 184 of file analysis.c.

                                                                    {
    RzListIter *it;
    RzAnalysisPlugin *h;
 
    if (analysis) {
        if (analysis->cur && !strcmp(analysis->cur->name, name)) {
            return true;
        }
        rz_list_foreach (analysis->plugins, it, h) {
            if (!h || !h->name || strcmp(h->name, name)) {
                continue;
            }
            plugin_fini(analysis);
            analysis->cur = h;
            if (h->init && !h->init(&analysis->plugin_data)) {
                RZ_LOG_ERROR("analysis plugin '%s' failed to initialize.\n", h->name);
                return false;
            }
            rz_analysis_set_reg_profile(analysis);
            if (analysis->il_vm) {
                rz_analysis_il_vm_setup(analysis);
            }
            return true;
        }
    }
    return false;
}

References rz_analysis_t::cur, h, rz_analysis_t::il_vm, rz_analysis_plugin_t::name, rz_analysis_t::plugin_data, plugin_fini(), rz_analysis_t::plugins, rz_analysis_il_vm_setup(), rz_analysis_set_reg_profile(), and RZ_LOG_ERROR.

Referenced by __as_set_archbits(), cb_analysis_arch(), rz_analysis_set_triplet(), rz_core_init(), and rz_main_rz_asm().

RZ_LIB_VERSION()

RZ_LIB_VERSION

(

rz_analysis

)

rz_meta_item_fini()

static void rz_meta_item_fini ( RzAnalysisMetaItem *  item )

static

Definition at line 46 of file analysis.c.

                                                        {
    free(item->str);
}

References free(), and rz_analysis_meta_item_t::str.

Referenced by rz_meta_item_free().

rz_meta_item_free()

static void rz_meta_item_free ( void *  _item )

static

Definition at line 50 of file analysis.c.

                                           {
    if (_item) {
        RzAnalysisMetaItem *item = _item;
        rz_meta_item_fini(item);
        free(item);
    }
}

References free(), and rz_meta_item_fini().

Referenced by rz_analysis_new(), and rz_analysis_purge().

Variable Documentation

analysis_static_plugins

RzAnalysisPlugin* analysis_static_plugins[] = { RZ_ANALYSIS_STATIC_PLUGINS }

static

Definition at line 13 of file analysis.c.

Referenced by rz_analysis_new().