reg.c File Reference

#include <rz_list.h>
#include <rz_reg.h>
#include <rz_util.h>

Go to the source code of this file.

Functions
	RZ_LIB_VERSION (rz_reg)
RZ_API const char *	rz_reg_32_to_64 (RzReg *reg, const char *rreg32)
RZ_API const char *	rz_reg_64_to_32 (RzReg *reg, const char *rreg64)
RZ_API const char *	rz_reg_get_type (int idx)
RZ_API const char *	rz_reg_get_name_by_type (RzReg *reg, const char *alias_name)
RZ_API int	rz_reg_type_by_name (const char *str)
	Returns the register type for the given type abbreviation. More...
RZ_API void	rz_reg_item_free (RzRegItem *item)
RZ_API int	rz_reg_get_name_idx (const char *type)
RZ_API bool	rz_reg_set_name (RZ_NONNULL RzReg *reg, RzRegisterId role, RZ_NONNULL const char *name)
RZ_API const char *	rz_reg_get_name (RzReg *reg, int role)
RZ_API RzRegItem *	rz_reg_get_by_role (RzReg *reg, RzRegisterId role)
RZ_API const char *	rz_reg_get_role (int role)
RZ_API int	rz_reg_role_by_name (RZ_NONNULL const char *str)
	Get the RzRegisterId with the given name or -1. More...
RZ_API void	rz_reg_free_internal (RzReg *reg, bool init)
static int	regcmp (RzRegItem *a, RzRegItem *b)
RZ_API void	rz_reg_reindex (RzReg *reg)
RZ_API RzRegItem *	rz_reg_index_get (RzReg *reg, int idx)
RZ_API void	rz_reg_free (RzReg *reg)
RZ_API RzReg *	rz_reg_new (void)
RZ_API bool	rz_reg_is_readonly (RzReg *reg, RzRegItem *item)
RZ_API ut64	rz_reg_setv (RzReg *reg, const char *name, ut64 val)
RZ_API ut64	rz_reg_getv (RzReg *reg, const char *name)
RZ_API ut64	rz_reg_getv_by_role_or_name (RzReg *reg, const char *name)
RZ_API RzRegItem *	rz_reg_get (RzReg *reg, const char *name, int type)
RZ_API RzRegItem *	rz_reg_get_by_role_or_name (RzReg *reg, const char *name)
RZ_API const RzList *	rz_reg_get_list (RzReg *reg, int type)
RZ_API RzRegItem *	rz_reg_get_at (RzReg *reg, int type, int regsize, int delta)
RZ_API RzRegItem *	rz_reg_next_diff (RzReg *reg, int type, const ut8 *buf, int buflen, RzRegItem *prev_ri, int regsize)
RZ_API RzRegSet *	rz_reg_regset_get (RzReg *r, int type)
static bool	foreach_reg_cb (RzIntervalNode *node, void *user)
RZ_API RZ_OWN RzList *	rz_reg_filter_items_covered (RZ_BORROW RZ_NONNULL const RzList *regs)
	Filter out all register items that are smaller than but covered entirely by some other register. More...

Variables
static const char *	types [RZ_REG_TYPE_LAST+1]
static const char *	roles [RZ_REG_NAME_LAST+1]

Function Documentation

foreach_reg_cb()

static bool foreach_reg_cb ( RzIntervalNode *  node, void *  user  )

static

Definition at line 461 of file reg.c.

                                                             {
    RzRegItem *from_list = user;
    RzRegItem *from_tree = node->data;
    if (from_list == from_tree) {
        return true;
    }
    // Check if from_list is covered entirely by from_tree, but is also smaller than it.
    // We already know that
    //   from_tree->offset <= from_list->offset < from_tree->offset + from_tree->size
    if (from_list->offset + from_list->size > from_tree->offset + from_tree->size) {
        // from_list expands beyond from_tree, so it's not covered
        return true;
    }
    if (from_list->offset + from_list->size == from_tree->offset + from_tree->size) {
        // they end at the same position, so it is covered entirely, but is it also smaller?
        if (from_list->offset == from_tree->offset) {
            // nope
            return true;
        }
    }
    // from_list ends before from_tree, so it is covered and smaller
    return false;
}

References rz_interval_node_t::data, rz_reg_item_t::offset, and rz_reg_item_t::size.

Referenced by rz_reg_filter_items_covered().

regcmp()

static int regcmp ( RzRegItem *  a, RzRegItem *  b  )

static

Definition at line 237 of file reg.c.

                                              {
    int offa = (a->offset * 16) + a->size;
    int offb = (b->offset * 16) + b->size;
    return (offa > offb) - (offa < offb);
}

References a, and b.

Referenced by rz_reg_reindex().

RZ_LIB_VERSION()

RZ_LIB_VERSION

(

rz_reg

)

rz_reg_32_to_64()

RZ_API const char* rz_reg_32_to_64	(	RzReg *	reg,
		const char *	rreg32
	)

Definition at line 17 of file reg.c.

                                                                   {
    int i, j = -1;
    RzListIter *iter;
    RzRegItem *item;
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        rz_list_foreach (reg->regset[i].regs, iter, item) {
            if (item->size == 32 && !rz_str_casecmp(rreg32, item->name)) {
                j = item->offset;
                break;
            }
        }
    }
    if (j != -1) {
        for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
            rz_list_foreach (reg->regset[i].regs, iter, item) {
                if (item->offset == j && item->size == 64) {
                    return item->name;
                }
            }
        }
    }
    return NULL;
}

References i, rz_reg_item_t::name, NULL, rz_reg_item_t::offset, reg, RZ_REG_TYPE_LAST, rz_str_casecmp(), and rz_reg_item_t::size.

Referenced by anop_esil(), get_regname(), and get_src_regname().

rz_reg_64_to_32()

RZ_API const char* rz_reg_64_to_32	(	RzReg *	reg,
		const char *	rreg64
	)

Definition at line 44 of file reg.c.

                                                                   {
    int i, j = -1;
    RzListIter *iter;
    RzRegItem *item;
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        rz_list_foreach (reg->regset[i].regs, iter, item) {
            if (item->size == 64 && !rz_str_casecmp(rreg64, item->name)) {
                j = item->offset;
                break;
            }
        }
    }
    if (j != -1) {
        for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
            rz_list_foreach (reg->regset[i].regs, iter, item) {
                if (item->offset == j && item->size == 32) {
                    return item->name;
                }
            }
        }
    }
    return NULL;
}

References i, rz_reg_item_t::name, NULL, rz_reg_item_t::offset, reg, RZ_REG_TYPE_LAST, rz_str_casecmp(), and rz_reg_item_t::size.

Referenced by do_syscall_search().

rz_reg_filter_items_covered()

RZ_API RZ_OWN RzList* rz_reg_filter_items_covered

(

RZ_BORROW RZ_NONNULL const RzList *

regs

)

Filter out all register items that are smaller than but covered entirely by some other register.

Parameters

regs	list of RzRegItem

Definition at line 489 of file reg.c.

                                                                                               {
    rz_return_val_if_fail(regs, NULL);
    RzList *ret = rz_list_new();
    if (!ret) {
        return NULL;
    }
    RzIntervalTree t;
    rz_interval_tree_init(&t, NULL);
    RzRegItem *item;
    RzListIter *it;
    rz_list_foreach (regs, it, item) {
        if (item->offset < 0 || item->size <= 0) {
            continue;
        }
        rz_interval_tree_insert(&t, item->offset, item->offset + item->size - 1, item);
    }
    rz_list_foreach (regs, it, item) {
        if (item->offset < 0 || item->size <= 0) {
            rz_list_push(ret, item);
            continue;
        }
        if (!rz_interval_tree_all_in(&t, item->offset, true, foreach_reg_cb, item)) {
            // foreach_reg_cb break-ed so it found a cover
            continue;
        }
        rz_list_push(ret, item);
    }
    rz_interval_tree_fini(&t);
    return ret;
}

References foreach_reg_cb(), NULL, rz_reg_item_t::offset, regs, rz_interval_tree_all_in(), rz_interval_tree_fini(), rz_interval_tree_init(), rz_interval_tree_insert(), rz_list_new(), rz_list_push(), rz_return_val_if_fail, and rz_reg_item_t::size.

Referenced by filter_reg_items(), rz_core_debug_print_status(), and rz_il_reg_binding_derive().

rz_reg_free()

RZ_API void rz_reg_free

(

RzReg *

reg

)

Definition at line 279 of file reg.c.

                                    {
    if (reg) {
        rz_reg_free_internal(reg, false);
        free(reg);
    }
}

References free(), reg, and rz_reg_free_internal().

Referenced by rz_analysis_free(), rz_debug_free(), and setup_regs().

rz_reg_free_internal()

RZ_API void rz_reg_free_internal	(	RzReg *	reg,
		bool	init
	)

Definition at line 191 of file reg.c.

                                                        {
    rz_return_if_fail(reg);
    ut32 i;
 
    rz_list_free(reg->roregs);
    reg->roregs = NULL;
    RZ_FREE(reg->reg_profile_str);
    RZ_FREE(reg->reg_profile_cmt);
    rz_list_free(reg->reg_profile.alias);
    rz_list_free(reg->reg_profile.defs);
    reg->reg_profile.alias = 0;
    reg->reg_profile.defs = 0;
 
    for (i = 0; i < RZ_REG_NAME_LAST; i++) {
        if (reg->name[i]) {
            RZ_FREE(reg->name[i]);
        }
    }
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        ht_pp_free(reg->regset[i].ht_regs);
        reg->regset[i].ht_regs = NULL;
        if (!reg->regset[i].pool) {
            continue;
        }
        if (init) {
            rz_list_free(reg->regset[i].regs);
            reg->regset[i].regs = rz_list_newf((RzListFree)rz_reg_item_free);
        } else {
            rz_list_free(reg->regset[i].regs);
            reg->regset[i].regs = NULL;
            // Ensure arena is freed and its registered in the pool
            if (!rz_list_delete_data(reg->regset[i].pool, reg->regset[i].arena)) {
                rz_reg_arena_free(reg->regset[i].arena);
            }
            reg->regset[i].arena = NULL;
            rz_list_free(reg->regset[i].pool);
            reg->regset[i].pool = NULL;
        }
    }
    if (!init) {
        rz_list_free(reg->allregs);
        reg->allregs = NULL;
    }
    reg->size = 0;
}

References i, init, NULL, reg, RZ_FREE, rz_list_delete_data(), rz_list_free(), rz_list_newf(), rz_reg_arena_free(), rz_reg_item_free(), RZ_REG_NAME_LAST, RZ_REG_TYPE_LAST, and rz_return_if_fail.

Referenced by rz_reg_free(), and rz_reg_set_profile_string().

rz_reg_get()

RZ_API RzRegItem* rz_reg_get	(	RzReg *	reg,
		const char *	name,
		int	type
	)

Definition at line 344 of file reg.c.

                                                                     {
    int i, e;
    rz_return_val_if_fail(reg && name, NULL);
    // TODO: define flag register as RZ_REG_TYPE_FLG
    if (type == RZ_REG_TYPE_FLG) {
        type = RZ_REG_TYPE_GPR;
    }
    if (type == -1) {
        i = 0;
        e = RZ_REG_TYPE_LAST;
        int alias = rz_reg_get_name_idx(name);
        if (alias != -1) {
            const char *nname = rz_reg_get_name(reg, alias);
            if (nname) {
                name = nname;
            }
        }
    } else {
        i = type;
        e = type + 1;
    }
    for (; i < e; i++) {
        HtPP *pp = reg->regset[i].ht_regs;
        if (pp) {
            bool found = false;
            RzRegItem *item = ht_pp_find(pp, name, &found);
            if (found) {
                return item;
            }
        }
    }
    return NULL;
}

References e, found, i, NULL, reg, rz_reg_get_name(), rz_reg_get_name_idx(), RZ_REG_TYPE_FLG, RZ_REG_TYPE_GPR, RZ_REG_TYPE_LAST, rz_return_val_if_fail, and type.

Referenced by agraph_refresh(), analysis_fill_ai_rg(), analysis_fill_r0_reg_ref(), analysis_regrel_jump(), anop_esil(), backtrace_fuzzy(), backtrace_x86_32(), backtrace_x86_32_analysis(), backtrace_x86_64(), backtrace_x86_64_analysis(), cmd_print_format(), cs_reg2reg(), esil_6502_init(), esil_bigger(), esil_bigger_equal(), esil_cmp(), esil_gb_init(), esil_internal_sizeof_reg(), esil_smaller(), esil_smaller_equal(), filter_reg_items(), gb_analysis_add_hl(), gb_analysis_add_sp(), gb_analysis_and_bit(), gb_analysis_and_res(), gb_analysis_cb_rl(), gb_analysis_cb_rlc(), gb_analysis_cb_rr(), gb_analysis_cb_rrc(), gb_analysis_cb_sla(), gb_analysis_cb_sra(), gb_analysis_cb_srl(), gb_analysis_cb_swap(), gb_analysis_cond(), gb_analysis_id(), gb_analysis_jmp_hl(), gb_analysis_load(), gb_analysis_load_hl(), gb_analysis_mov_hl_sp(), gb_analysis_mov_ime(), gb_analysis_mov_imm(), gb_analysis_mov_reg(), gb_analysis_mov_scf(), gb_analysis_mov_sp_hl(), gb_analysis_or_set(), gb_analysis_pp(), gb_analysis_store(), gb_analysis_store_hl(), gb_analysis_xoaasc(), gb_analysis_xoaasc_imm(), gb_analysis_xor_ccf(), gb_analysis_xor_cpl(), get_regname(), get_src_regname(), getFunctionNamePrefix(), i8051_reg_read(), i8051_reg_write(), internal_esil_reg_read(), internal_esil_reg_write(), internal_esil_reg_write_no_null(), ispackedreg(), mips_op(), num_callback(), parse_reg64_name(), parse_reg_name(), pic_midrange_reg_write(), retype_callee_arg(), riscv_op(), rsp_op(), run_basic_block_analysis(), rz_analysis_dwarf_integrate_functions(), rz_analysis_esil_get_parm_type(), rz_analysis_esil_trace_op(), rz_analysis_extract_rarg(), rz_analysis_function_rebase_vars(), rz_analysis_function_vars_regs_getref_handler(), rz_analysis_function_vars_regs_handler(), rz_analysis_function_vars_regs_setref_handler(), rz_analysis_get_delta_jmptbl_info(), rz_analysis_get_jmptbl_info(), rz_analysis_var_get_argnum(), rz_core_analysis_set_reg(), rz_core_analysis_type_match(), rz_core_disasm_pde(), rz_core_esil_continue_back(), rz_core_link_stroff(), rz_core_reg_assign_sync(), rz_core_rtr_gdb_cb(), rz_debug_add_checkpoint(), rz_debug_continue_back(), rz_debug_continue_kill(), rz_debug_execute(), rz_debug_gdb_reg_write(), rz_debug_qnx_reg_write(), rz_debug_wait(), rz_il_reg_binding_exactly(), rz_il_vm_sync_from_reg(), rz_il_vm_sync_to_reg(), rz_main_rizin(), rz_reg_get_by_role(), rz_reg_get_by_role_or_name(), rz_reg_get_value_by_role(), rz_reg_getv(), rz_reg_set_profile_string(), rz_reg_set_value_by_role(), rz_reg_setv(), rz_regs_args_handler(), rz_regs_fpu_handler(), set_retval(), trace_hook_reg_write(), value_fill_addr_reg_disp(), and value_fill_addr_reg_regdelta().

rz_reg_get_at()

RZ_API RzRegItem* rz_reg_get_at	(	RzReg *	reg,
		int	type,
		int	regsize,
		int	delta
	)

Definition at line 414 of file reg.c.

                                                                              {
    rz_return_val_if_fail(reg, NULL);
    const RzList *list = rz_reg_get_list(reg, type);
    RzRegItem *ri;
    RzListIter *iter;
    rz_list_foreach (list, iter, ri) {
        if (ri->size == regsize) {
            if (BITS2BYTES(ri->offset) == delta) {
                return ri;
            }
        }
    }
    return NULL;
}

References BITS2BYTES, delta, list(), NULL, rz_reg_item_t::offset, reg, rz_reg_get_list(), rz_return_val_if_fail, rz_reg_item_t::size, and type.

rz_reg_get_by_role()

RZ_API RzRegItem* rz_reg_get_by_role	(	RzReg *	reg,
		RzRegisterId	role
	)

Definition at line 154 of file reg.c.

                                                                    {
    rz_return_val_if_fail(reg, NULL);
    const char *name = rz_reg_get_name(reg, role);
    if (!name) {
        return NULL;
    }
    return rz_reg_get(reg, name, RZ_REG_TYPE_ANY);
}

References NULL, reg, rz_reg_get(), rz_reg_get_name(), RZ_REG_TYPE_ANY, and rz_return_val_if_fail.

Referenced by rz_core_reg_flags_candidates(), rz_debug_continue_syscalls(), and rz_reg_get_by_role_or_name().

rz_reg_get_by_role_or_name()

RZ_API RzRegItem* rz_reg_get_by_role_or_name	(	RzReg *	reg,
		const char *	name
	)

Definition at line 378 of file reg.c.

                                                                           {
    int role = rz_reg_get_name_idx(name);
    if (role != -1) {
        RzRegItem *r = rz_reg_get_by_role(reg, role);
        if (r) {
            return r;
        }
    }
    return rz_reg_get(reg, name, RZ_REG_TYPE_ANY);
}

References r, reg, rz_reg_get(), rz_reg_get_by_role(), rz_reg_get_name_idx(), and RZ_REG_TYPE_ANY.

Referenced by rz_core_reg_set_by_role_or_name(), rz_debug_num_callback(), rz_debug_reg_set(), and rz_reg_getv_by_role_or_name().

rz_reg_get_list()

RZ_API const RzList* rz_reg_get_list	(	RzReg *	reg,
		int	type
	)

Definition at line 389 of file reg.c.

                                                             {
    if (type == RZ_REG_TYPE_ANY) {
        return reg->allregs;
    }
 
    RzList *regs;
    int i, mask;
    if (type < 0 || type > (RZ_REG_TYPE_LAST - 1)) {
        return NULL;
    }
 
    regs = reg->regset[type].regs;
    if (rz_list_length(regs) == 0) {
        mask = ((int)1 << type);
        for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
            if (reg->regset[i].maskregstype & mask) {
                regs = reg->regset[i].regs;
            }
        }
    }
 
    return regs;
}

References i, int, mask, NULL, reg, regs, rz_list_length(), RZ_REG_TYPE_ANY, RZ_REG_TYPE_LAST, and type.

Referenced by autocmplt_reg(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), fillRegisterValues(), filter(), foreach_reg_set_or_clear(), rop_classify_arithmetic(), rop_classify_arithmetic_const(), rop_classify_constant(), rop_classify_mov(), rz_core_cmd_foreach3(), rz_core_debug_ri(), rz_core_reg_flags_candidates(), and rz_reg_get_at().

rz_reg_get_name()

RZ_API const char* rz_reg_get_name	(	RzReg *	reg,
		int	role
	)

Definition at line 147 of file reg.c.

                                                         {
    if (reg && role >= 0 && role < RZ_REG_NAME_LAST) {
        return reg->name[role];
    }
    return NULL;
}

References NULL, reg, and RZ_REG_NAME_LAST.

Referenced by __init_panel_param(), __panels_check_stackbase(), __replaceRegisters(), agraph_refresh(), analysis_emul_init(), asciiart_backtrace(), backtrace_fuzzy(), backtrace_vars(), backtrace_windows(), do_syscall_search(), ds_print_esil_analysis(), ds_print_esil_analysis_fini(), ds_print_esil_analysis_init(), extract_arg(), filter_reg_items(), get_reg_role_name(), getpcfromstack(), internal_esil_reg_write_no_null(), linux_handle_signals(), list_vars(), num_callback(), prepend_current_pc(), rz_analysis_extract_vars(), rz_analysis_function_get_json(), rz_analysis_function_vars_handler(), rz_analysis_var_addr(), rz_core_analysis_continue_until_call(), rz_core_analysis_continue_until_syscall(), rz_core_analysis_esil(), rz_core_analysis_esil_emulate(), rz_core_analysis_esil_step_over(), rz_core_analysis_set_reg(), rz_core_analysis_type_match(), rz_core_esil_step(), rz_core_get_func_args(), rz_core_link_stroff(), rz_core_print_disasm(), rz_core_print_func_args(), rz_core_syscall_as_string(), rz_debug_gdb_reg_write(), rz_debug_qnx_reg_write(), rz_debug_step_soft(), rz_il_reg_binding_derive(), rz_il_vm_sync_from_reg(), rz_il_vm_sync_to_reg(), rz_reg_get(), rz_reg_get_by_role(), rz_reg_get_name_by_type(), rz_reg_get_value_by_role(), rz_reg_set_value_by_role(), rz_regs_args_handler(), and type_pos_hit().

rz_reg_get_name_by_type()

RZ_API const char* rz_reg_get_name_by_type	(	RzReg *	reg,
		const char *	alias_name
	)

Definition at line 72 of file reg.c.

                                                                               {
    const int n = rz_reg_get_name_idx(alias_name);
    return (n != -1) ? rz_reg_get_name(reg, n) : NULL;
}

References n, NULL, reg, rz_reg_get_name(), and rz_reg_get_name_idx().

Referenced by rz_reg_profile_to_cc().

rz_reg_get_name_idx()

RZ_API int rz_reg_get_name_idx

(

const char *

type

)

Definition at line 102 of file reg.c.

                                                 {
    rz_return_val_if_fail(type, -1);
    if (type[0] && type[1] && !type[2])
        switch (*type | (type[1] << 8)) {
        /* flags */
        case 'Z' + ('F' << 8): return RZ_REG_NAME_ZF;
        case 'S' + ('F' << 8): return RZ_REG_NAME_SF;
        case 'C' + ('F' << 8): return RZ_REG_NAME_CF;
        case 'O' + ('F' << 8): return RZ_REG_NAME_OF;
        /* gpr */
        case 'P' + ('C' << 8): return RZ_REG_NAME_PC;
        case 'S' + ('R' << 8): return RZ_REG_NAME_SR;
        case 'L' + ('R' << 8): return RZ_REG_NAME_LR;
        case 'S' + ('P' << 8): return RZ_REG_NAME_SP;
        case 'B' + ('P' << 8): return RZ_REG_NAME_BP;
        case 'S' + ('N' << 8): return RZ_REG_NAME_SN;
        /* args */
        case 'A' + ('0' << 8): return RZ_REG_NAME_A0;
        case 'A' + ('1' << 8): return RZ_REG_NAME_A1;
        case 'A' + ('2' << 8): return RZ_REG_NAME_A2;
        case 'A' + ('3' << 8): return RZ_REG_NAME_A3;
        case 'A' + ('4' << 8): return RZ_REG_NAME_A4;
        case 'A' + ('5' << 8): return RZ_REG_NAME_A5;
        case 'A' + ('6' << 8): return RZ_REG_NAME_A6;
        case 'A' + ('7' << 8): return RZ_REG_NAME_A7;
        case 'A' + ('8' << 8): return RZ_REG_NAME_A8;
        case 'A' + ('9' << 8): return RZ_REG_NAME_A9;
        /* return values */
        case 'R' + ('0' << 8): return RZ_REG_NAME_R0;
        case 'R' + ('1' << 8): return RZ_REG_NAME_R1;
        case 'R' + ('2' << 8): return RZ_REG_NAME_R2;
        case 'R' + ('3' << 8): return RZ_REG_NAME_R3;
        }
    return -1;
}

References RZ_REG_NAME_A0, RZ_REG_NAME_A1, RZ_REG_NAME_A2, RZ_REG_NAME_A3, RZ_REG_NAME_A4, RZ_REG_NAME_A5, RZ_REG_NAME_A6, RZ_REG_NAME_A7, RZ_REG_NAME_A8, RZ_REG_NAME_A9, RZ_REG_NAME_BP, RZ_REG_NAME_CF, RZ_REG_NAME_LR, RZ_REG_NAME_OF, RZ_REG_NAME_PC, RZ_REG_NAME_R0, RZ_REG_NAME_R1, RZ_REG_NAME_R2, RZ_REG_NAME_R3, RZ_REG_NAME_SF, RZ_REG_NAME_SN, RZ_REG_NAME_SP, RZ_REG_NAME_SR, RZ_REG_NAME_ZF, rz_return_val_if_fail, and type.

Referenced by num_callback(), parse_alias(), rz_analysis_function_get_json(), rz_core_analysis_set_reg(), rz_reg_get(), rz_reg_get_by_role_or_name(), and rz_reg_get_name_by_type().

rz_reg_get_role()

RZ_API const char* rz_reg_get_role

(

int

role

)

Definition at line 172 of file reg.c.

                                             {
    if (role >= 0 && role < RZ_REG_NAME_LAST) {
        return roles[role];
    }
    return NULL;
}

References NULL, roles, and RZ_REG_NAME_LAST.

Referenced by __replaceRegisters(), autocmplt_cmd_arg_reg_filter(), get_reg_role_name(), rz_reg_profile_handler(), and rz_reg_roles_handler().

rz_reg_get_type()

RZ_API const char* rz_reg_get_type

(

int

idx

)

Definition at line 68 of file reg.c.

                                            {
    return (idx >= 0 && idx < RZ_REG_TYPE_LAST) ? types[idx] : NULL;
}

References setup::idx, NULL, RZ_REG_TYPE_LAST, and types.

Referenced by autocmplt_cmd_arg_reg_filter(), autocmplt_cmd_arg_reg_type(), isFlag(), rz_reg_arenas_handler(), rz_reg_profile_handler(), rz_reg_types_handler(), and show_regs_handler().

rz_reg_getv()

RZ_API ut64 rz_reg_getv	(	RzReg *	reg,
		const char *	name
	)

Definition at line 332 of file reg.c.

                                                      {
    rz_return_val_if_fail(reg && name, UT64_MAX);
    RzRegItem *ri = rz_reg_get(reg, name, -1);
    return ri ? rz_reg_get_value(reg, ri) : UT64_MAX;
}

References reg, rz_reg_get(), rz_reg_get_value(), rz_return_val_if_fail, and UT64_MAX.

Referenced by __init_panel_param(), __panels_check_stackbase(), analysis_emul_init(), asciiart_backtrace(), backtrace_vars(), backtrace_windows(), cmd_analysis_esil(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), ds_init(), ds_print_esil_analysis(), ds_print_esil_analysis_init(), esilbreak_reg_write(), get_bb_body(), handle_var_stack_access(), loadGP(), pr_bb(), prepend_current_pc(), rz_analysis_appcall_handler(), rz_analysis_var_addr(), rz_core_analysis_address(), rz_core_analysis_esil(), rz_core_analysis_esil_emulate(), rz_core_analysis_esil_step_over(), rz_core_analysis_type_match(), rz_core_cmd_foreach3(), rz_core_esil_step(), rz_core_get_func_args(), rz_core_link_stroff(), rz_core_print_disasm(), rz_core_print_func_args(), rz_core_rtr_gdb_cb(), step_until_optype(), and type_pos_hit().

rz_reg_getv_by_role_or_name()

RZ_API ut64 rz_reg_getv_by_role_or_name	(	RzReg *	reg,
		const char *	name
	)

Definition at line 338 of file reg.c.

                                                                      {
    rz_return_val_if_fail(reg && name, UT64_MAX);
    RzRegItem *ri = rz_reg_get_by_role_or_name(reg, name);
    return ri ? rz_reg_get_value(reg, ri) : UT64_MAX;
}

References reg, rz_reg_get_by_role_or_name(), rz_reg_get_value(), rz_return_val_if_fail, and UT64_MAX.

Referenced by backtrace_generic(), rz_core_reg_getv_by_role_or_name(), and rz_debug_reg_get().

rz_reg_index_get()

RZ_API RzRegItem* rz_reg_index_get	(	RzReg *	reg,
		int	idx
	)

Definition at line 262 of file reg.c.

                                                        {
    RzRegItem *r;
    RzListIter *iter;
    if (idx < 0) {
        return NULL;
    }
    if (!reg->allregs) {
        rz_reg_reindex(reg);
    }
    rz_list_foreach (reg->allregs, iter, r) {
        if (r->index == idx) {
            return r;
        }
    }
    return NULL;
}

References setup::idx, NULL, r, reg, and rz_reg_reindex().

Referenced by core_analysis_var_list_show(), ds_show_functions(), rz_analysis_function_set_var(), rz_core_analysis_type_match(), rz_core_analysis_var_display(), and var_variables_show().

rz_reg_is_readonly()

RZ_API bool rz_reg_is_readonly	(	RzReg *	reg,
		RzRegItem *	item
	)

Definition at line 311 of file reg.c.

                                                            {
    const char *name;
    RzListIter *iter;
    if (!reg->roregs) {
        return false;
    }
    // XXX O(n)
    rz_list_foreach (reg->roregs, iter, name) {
        if (!strcmp(item->name, name)) {
            return true;
        }
    }
    return false;
}

References name, rz_reg_item_t::name, and reg.

Referenced by rz_reg_set_value().

rz_reg_item_free()

RZ_API void rz_reg_item_free

(

RzRegItem *

item

)

Definition at line 96 of file reg.c.

                                              {
    free(item->name);
    free(item->flags);
    free(item);
}

References rz_reg_item_t::flags, free(), and rz_reg_item_t::name.

Referenced by add_item_to_regset(), rz_reg_free_internal(), and rz_reg_new().

rz_reg_new()

RZ_API RzReg* rz_reg_new

(

void

)

Definition at line 286 of file reg.c.

                               {
    RzRegArena *arena;
    RzReg *reg = RZ_NEW0(RzReg);
    int i;
    if (!reg) {
        return NULL;
    }
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        arena = rz_reg_arena_new(0);
        if (!arena) {
            free(reg);
            return NULL;
        }
        reg->regset[i].pool = rz_list_newf((RzListFree)rz_reg_arena_free);
        reg->regset[i].regs = rz_list_newf((RzListFree)rz_reg_item_free);
        rz_list_push(reg->regset[i].pool, arena);
        reg->regset[i].arena = arena;
    }
    rz_reg_arena_push(reg);
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        reg->regset[i].cur = rz_list_tail(reg->regset[i].pool);
    }
    return reg;
}

References free(), i, NULL, reg, rz_list_newf(), rz_list_push(), RZ_NEW0, rz_reg_arena_free(), rz_reg_arena_new(), rz_reg_arena_push(), rz_reg_item_free(), and RZ_REG_TYPE_LAST.

Referenced by rz_analysis_new(), rz_debug_new(), and setup_regs().

rz_reg_next_diff()

RZ_API RzRegItem* rz_reg_next_diff	(	RzReg *	reg,
		int	type,
		const ut8 *	buf,
		int	buflen,
		RzRegItem *	prev_ri,
		int	regsize
	)

Definition at line 430 of file reg.c.

                                                                                                                      {
    rz_return_val_if_fail(reg && buf, NULL);
    if (type < 0 || type > (RZ_REG_TYPE_LAST - 1)) {
        return NULL;
    }
    RzRegArena *arena = reg->regset[type].arena;
    int prev_offset = prev_ri ? (prev_ri->offset / 8) + (prev_ri->size / 8) : 0;
    RzList *list = reg->regset[type].regs;
    RzRegItem *ri;
    RzListIter *iter;
    int offset;
    rz_list_foreach (list, iter, ri) {
        offset = ri->offset / 8;
        if (offset > prev_offset) {
            if (memcmp(arena->bytes + offset, buf + offset, ri->size / 8)) {
                return ri;
            }
        }
    }
    return NULL;
}

References rz_reg_arena_t::bytes, list(), NULL, rz_reg_item_t::offset, reg, RZ_REG_TYPE_LAST, rz_return_val_if_fail, rz_reg_item_t::size, and type.

Referenced by rz_debug_gdb_reg_write(), and rz_debug_qnx_reg_write().

rz_reg_regset_get()

RZ_API RzRegSet* rz_reg_regset_get	(	RzReg *	r,
		int	type
	)

Definition at line 452 of file reg.c.

                                                       {
    rz_return_val_if_fail(r, NULL);
    if (type < 0 || type >= RZ_REG_TYPE_LAST) {
        return NULL;
    }
    RzRegSet *rs = &r->regset[type];
    return rs->arena ? rs : NULL;
}

References NULL, r, rs, RZ_REG_TYPE_LAST, rz_return_val_if_fail, and type.

Referenced by ds_print_esil_analysis_fini(), ds_print_esil_analysis_init(), rz_core_analysis_address(), rz_reg_arena_dup(), rz_reg_arena_peek(), and rz_reg_arena_poke().

rz_reg_reindex()

RZ_API void rz_reg_reindex

(

RzReg *

reg

)

Definition at line 243 of file reg.c.

                                       {
    int i, index;
    RzListIter *iter;
    RzRegItem *r;
    RzList *all = rz_list_newf(NULL);
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        rz_list_foreach (reg->regset[i].regs, iter, r) {
            rz_list_append(all, r);
        }
    }
    rz_list_sort(all, (RzListComparator)regcmp);
    index = 0;
    rz_list_foreach (all, iter, r) {
        r->index = index++;
    }
    rz_list_free(reg->allregs);
    reg->allregs = all;
}

References test_group_name::all, i, NULL, r, reg, regcmp(), rz_list_append(), rz_list_free(), rz_list_newf(), rz_list_sort(), and RZ_REG_TYPE_LAST.

Referenced by rz_reg_index_get(), and rz_reg_set_profile_string().

rz_reg_role_by_name()

RZ_API int rz_reg_role_by_name

(

RZ_NONNULL const char *

str

)

Get the RzRegisterId with the given name or -1.

Definition at line 180 of file reg.c.

                                                           {
    rz_return_val_if_fail(str, -1);
    int i;
    for (i = 0; i < RZ_REG_NAME_LAST && roles[i]; i++) {
        if (!strcmp(roles[i], str)) {
            return i;
        }
    }
    return -1;
}

References i, roles, RZ_REG_NAME_LAST, rz_return_val_if_fail, and cmd_descs_generate::str.

Referenced by filter_reg_items().

rz_reg_set_name()

RZ_API bool rz_reg_set_name	(	RZ_NONNULL RzReg *	reg,
		RzRegisterId	role,
		RZ_NONNULL const char *	name
	)

Definition at line 138 of file reg.c.

                                                                                                   {
    rz_return_val_if_fail(reg && name, false);
    if (role >= 0 && role < RZ_REG_NAME_LAST) {
        reg->name[role] = rz_str_dup(reg->name[role], name);
        return true;
    }
    return false;
}

References reg, RZ_REG_NAME_LAST, rz_return_val_if_fail, and rz_str_dup().

Referenced by rz_reg_set_reg_profile().

rz_reg_setv()

RZ_API ut64 rz_reg_setv	(	RzReg *	reg,
		const char *	name,
		ut64	val
	)

Definition at line 326 of file reg.c.

                                                                {
    rz_return_val_if_fail(reg && name, UT64_MAX);
    RzRegItem *ri = rz_reg_get(reg, name, -1);
    return ri ? rz_reg_set_value(reg, ri, val) : UT64_MAX;
}

References reg, rz_reg_get(), rz_reg_set_value(), rz_return_val_if_fail, UT64_MAX, and val.

Referenced by backtrace_vars(), cmd_analysis_esil(), ds_print_esil_analysis(), ds_print_esil_analysis_fini(), ds_print_esil_analysis_init(), mipsTweak(), rz_analysis_appcall_handler(), rz_core_analysis_esil(), rz_core_analysis_esil_emulate(), rz_core_debug_step_skip(), and rz_core_esil_step().

rz_reg_type_by_name()

RZ_API int rz_reg_type_by_name

(

const char *

str

)

Returns the register type for the given type abbreviation.

Parameters

str	The type abbreviation (gpr, flg, sys etc.)

Returns

int The register type or -1 on failure.

Definition at line 83 of file reg.c.

                                                {
    rz_return_val_if_fail(str, -1);
    for (ut32 i = 0; i < RZ_REG_TYPE_LAST && types[i]; i++) {
        if (!strcmp(types[i], str)) {
            return i;
        }
    }
    if (!strcmp(str, "all")) {
        return RZ_REG_TYPE_ANY;
    }
    return -1;
}

References i, RZ_REG_TYPE_ANY, RZ_REG_TYPE_LAST, rz_return_val_if_fail, cmd_descs_generate::str, and types.

Referenced by expect_reg_type_by_name(), filter_reg_items(), rz_reg_arenas_hexdump_handler(), rz_reg_arenas_write_hex_handler(), and rz_reg_arenas_zero_handler().

Variable Documentation

roles

const char* roles[RZ_REG_NAME_LAST+1]

static

Initial value:

= {
    "PC", "SP", "SR", "BP", "LR",
    "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9",
    "R0", "R1", "R2", "R3",
    "ZF", "SF", "CF", "OF",
    "SN",
    NULL
}

Definition at line 163 of file reg.c.

Referenced by rz_reg_get_role(), and rz_reg_role_by_name().

types

const char* types[RZ_REG_TYPE_LAST+1]

static

Initial value:

= {
    "gpr", "drx", "fpu", "mmx", "xmm", "ymm", "flg", "seg", "sys", "sec", "vc", "vcc", "ctr", NULL
}

Definition at line 10 of file reg.c.

Referenced by rz_reg_get_type(), and rz_reg_type_by_name().