cmd_regs.c File Reference

#include <rz_core.h>
#include "../core_private.h"

Go to the source code of this file.

Macros
#define	SYNC_READ(type, failed)
#define	SYNC_READ_LIST(ritems, failed)
#define	SYNC_WRITE(type, failed)

Functions
	HEAPTYPE (ut64)
static RzList *	filter_reg_items (RzReg *reg, RZ_NULLABLE const char *filter)
static void	format_reg_value (RzReg *reg, RzRegItem *item, char *out, size_t out_size)
	Format the value of a register as a nice hex string. More...
static bool	reg_has_changed (RzReg *reg, RzRegItem *item)
	Check whether the given item's value has changed in the last step. More...
static void	print_reg_not_found (const char *arg)
RZ_API bool	rz_core_reg_assign_sync (RZ_NONNULL RzCore *core, RZ_NONNULL RzReg *reg, RzCmdRegSync sync_cb, RZ_NONNULL const char *name, ut64 val)
static RzCmdStatus	assign_reg (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, RZ_NONNULL const char *arg, size_t eq_pos)
	(Sub)handler for register assignments like reg=0x42 More...
static const char *	get_reg_color (RzCore *core, RzReg *reg, RzRegItem *item)
static const char *	get_reg_role_name (RzReg *reg, RzRegItem *item)
RZ_API RZ_OWN RzList *	rz_core_reg_filter_items_sync (RZ_NONNULL RzCore *core, RZ_NONNULL RzReg *reg, RzCmdRegSync sync_cb, RZ_NULLABLE const char *filter)
static RzCmdStatus	show_regs_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, const char *filter, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_regs_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_regs_columns_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv)
static RzCmdStatus	references_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, RzList *ritems, RzOutputMode mode)
RZ_IPI RzCmdStatus	rz_regs_references_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv, RzOutputMode mode)
static int	valgroup_regcmp (const void *a, const void *b)
static bool	valgroup_regcb (void *u, const ut64 k, const void *v)
RZ_IPI void	rz_regs_show_valgroup (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, const RzList *list)
RZ_IPI RzCmdStatus	rz_regs_valgroup_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reg_arenas_handler (RzCore *core, RzReg *reg, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reg_arenas_push_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reg_arenas_pop_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reg_arenas_swap_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reg_arenas_zero_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reg_arenas_hexdump_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reg_arenas_stack_size_handler (RzCore *core, RzReg *reg, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reg_arenas_write_hex_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_regs_args_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv, RzOutputMode mode)
RZ_IPI RzCmdStatus	rz_reg_types_handler (RzCore *core, RzReg *reg, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reg_roles_handler (RzCore *core, RzReg *reg, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reg_flags_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv, bool unset)
RZ_IPI RzCmdStatus	rz_reg_profile_handler (RzCore *core, RzReg *reg, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_reg_profile_comments_handler (RzCore *core, RzReg *reg, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reg_profile_open_handler (RzCore *core, RzReg *reg, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reg_profile_gdb_handler (RzCore *core, RzReg *reg, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reg_cond_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reg_cc_handler (RzCore *core, RzReg *reg, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_regs_diff_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_regs_prev_handler (RzCore *core, RzReg *reg, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_regs_fpu_handler (RzCore *core, RzReg *reg, RzCmdRegSync sync_cb, int argc, const char **argv)

Macro Definition Documentation

SYNC_READ

#define SYNC_READ	(		type,
			failed
	)

Value:

    do { \
        failed = false; \
        if (sync_cb && !sync_cb(core, type, false)) { \
            RZ_LOG_ERROR("Failed to read registers.\n"); \
            failed = true; \
        } \
    } while (0)

Definition at line 9 of file cmd_regs.c.

SYNC_READ_LIST

#define SYNC_READ_LIST	(		ritems,
			failed
	)

Value:

    do { \
        failed = false; \
        if (rz_list_length(ritems) == 1) { \
            SYNC_READ(((RzRegItem *)rz_list_head(ritems))->type, failed); \
        } else if (rz_list_length(ritems) > 1) { \
            SYNC_READ(RZ_REG_TYPE_ANY, failed); \
        } \
    } while (0)

Definition at line 17 of file cmd_regs.c.

SYNC_WRITE

#define SYNC_WRITE	(		type,
			failed
	)

Value:

    do { \
        failed = false; \
        if (sync_cb && !sync_cb(core, type, true)) { \
            RZ_LOG_ERROR("Failed to write registers.\n"); \
            failed = true; \
        } \
        rz_core_reg_update_flags(core); \
    } while (0)

Definition at line 26 of file cmd_regs.c.

Function Documentation

assign_reg()

static RzCmdStatus assign_reg ( RzCore *  core, RzReg *  reg, RzCmdRegSync  sync_cb, RZ_NONNULL const char *  arg, size_t  eq_pos  )

static

(Sub)handler for register assignments like reg=0x42

Parameters

arg	the full argument string, like "reg = 0x42"
eq_pos	index of the '=' in arg

Definition at line 159 of file cmd_regs.c.

                                                                                                                         {
    char *str = strdup(arg);
    if (!str) {
        return RZ_CMD_STATUS_ERROR;
    }
    str[eq_pos] = 0;
    char *val = str + eq_pos + 1;
    rz_str_trim(str);
    rz_str_trim(val);
    ut64 nval = rz_num_math(core->num, val);
    return rz_core_reg_assign_sync(core, reg, sync_cb, str, nval) ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References rz_core_t::num, reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_reg_assign_sync(), rz_num_math(), rz_str_trim(), cmd_descs_generate::str, strdup(), ut64(), and val.

Referenced by rz_regs_handler().

filter_reg_items()

static RzList* filter_reg_items ( RzReg *  reg, RZ_NULLABLE const char *  filter  )

static

Definition at line 36 of file cmd_regs.c.

                                                                            {
    rz_return_val_if_fail(reg, NULL);
    // default
    if (RZ_STR_ISEMPTY(filter)) {
        // default selection (only gpr, omit smaller regs that are fully covered by larger ones)
        return rz_reg_filter_items_covered(reg->regset[RZ_REG_TYPE_GPR].regs);
    }
    // all
    if (!strcmp(filter, "all")) {
        return rz_list_clone(reg->allregs);
    }
    // bit size
    char *end = NULL;
    unsigned long bits = strtoul(filter, &end, 0);
    if (!*end) {
        RzList *ret = rz_list_new();
        if (!ret) {
            return NULL;
        }
        RzListIter *iter;
        RzRegItem *ri;
        rz_list_foreach (reg->regset[RZ_REG_TYPE_GPR].regs, iter, ri) {
            if (ri->size == bits) {
                rz_list_push(ret, ri);
            }
        }
        return ret;
    }
    // type
    int type = rz_reg_type_by_name(filter);
    if (type >= 0) {
        return rz_list_clone(reg->regset[type].regs);
    }
    // role
    int role = rz_reg_role_by_name(filter);
    if (role >= 0) {
        const char *itemname = rz_reg_get_name(reg, role);
        if (!itemname) {
            return NULL;
        }
        filter = itemname; // fallthrough to the below query with the resolved reg name
    }
    // single register name
    RzRegItem *ri = rz_reg_get(reg, filter, RZ_REG_TYPE_ANY);
    if (!ri) {
        return NULL;
    }
    return rz_list_new_from_array((const void **)&ri, 1);
}

References bits(), test_evm::end, NULL, reg, rz_list_clone(), rz_list_new(), rz_list_new_from_array(), rz_list_push(), rz_reg_filter_items_covered(), rz_reg_get(), rz_reg_get_name(), rz_reg_role_by_name(), RZ_REG_TYPE_ANY, rz_reg_type_by_name(), RZ_REG_TYPE_GPR, rz_return_val_if_fail, RZ_STR_ISEMPTY, rz_reg_item_t::size, and type.

Referenced by rz_core_reg_filter_items_sync(), rz_reg_flags_handler(), rz_regs_references_handler(), and rz_regs_valgroup_handler().

format_reg_value()

static void format_reg_value ( RzReg *  reg, RzRegItem *  item, char *  out, size_t  out_size  )

static

Format the value of a register as a nice hex string.

Definition at line 87 of file cmd_regs.c.

                                                                                      {
    // TODO: This could be done much nicer with RzBitVector, but it's not in RzUtil yet :-(
    if (item->size < 80) {
        ut64 value = rz_reg_get_value(reg, item);
        snprintf(out, out_size, "0x%08" PFMT64x, value);
    } else {
        utX valueBig;
        rz_reg_get_value_big(reg, item, &valueBig);
        switch (item->size) {
        case 80:
            snprintf(out, out_size, "0x%04x%016" PFMT64x "", valueBig.v80.High, valueBig.v80.Low);
            break;
        case 96:
            snprintf(out, out_size, "0x%08x%016" PFMT64x "", valueBig.v96.High, valueBig.v96.Low);
            break;
        case 128:
            snprintf(out, out_size, "0x%016" PFMT64x "%016" PFMT64x "", valueBig.v128.High, valueBig.v128.Low);
            break;
        case 256:
            snprintf(out, out_size, "0x%016" PFMT64x "%016" PFMT64x "%016" PFMT64x "%016" PFMT64x "",
                valueBig.v256.High.High, valueBig.v256.High.Low, valueBig.v256.Low.High, valueBig.v256.Low.Low);
            break;
        default:
            snprintf(out, out_size, "ERROR");
        }
    }
}

References _ut80::High, _ut96::High, _ut128::High, _ut256::High, _ut80::Low, _ut96::Low, _ut128::Low, _ut256::Low, out, PFMT64x, reg, rz_reg_get_value(), rz_reg_get_value_big(), rz_reg_item_t::size, snprintf, ut64(), _utX::v128, _utX::v256, _utX::v80, _utX::v96, and value.

Referenced by rz_regs_columns_handler(), and show_regs_handler().

get_reg_color()

static const char* get_reg_color ( RzCore *  core, RzReg *  reg, RzRegItem *  item  )

static

Definition at line 172 of file cmd_regs.c.

                                                                            {
    if (!rz_config_get_i(core->config, "scr.color")) {
        return NULL;
    }
    if (reg_has_changed(reg, item)) {
        return (core->cons && core->cons->context->pal.creg)
            ? core->cons->context->pal.creg
            : Color_BWHITE;
    }
    return NULL;
}

References Color_BWHITE, rz_core_t::config, rz_core_t::cons, rz_cons_t::context, rz_cons_printable_palette_t::creg, NULL, rz_cons_context_t::pal, reg, reg_has_changed(), and rz_config_get_i().

Referenced by references_handler(), rz_regs_columns_handler(), and show_regs_handler().

get_reg_role_name()

static const char* get_reg_role_name ( RzReg *  reg, RzRegItem *  item  )

static

Definition at line 184 of file cmd_regs.c.

                                                                  {
    for (int i = 0; i < RZ_REG_NAME_LAST; i++) {
        const char *t = rz_reg_get_name(reg, i);
        if (t && !strcmp(t, item->name)) {
            return rz_reg_get_role(i);
        }
    }
    return NULL;
}

References i, rz_reg_item_t::name, NULL, reg, rz_reg_get_name(), rz_reg_get_role(), and RZ_REG_NAME_LAST.

Referenced by references_handler(), and show_regs_handler().

HEAPTYPE()

HEAPTYPE

(

ut64

)

print_reg_not_found()

static void print_reg_not_found ( const char *  arg )

static

Definition at line 124 of file cmd_regs.c.

                                                 {
    RZ_LOG_ERROR("No such register or register type: \"%s\"\n", rz_str_get(arg));
}

References RZ_LOG_ERROR, and rz_str_get().

Referenced by rz_reg_flags_handler(), rz_regs_columns_handler(), rz_regs_references_handler(), rz_regs_valgroup_handler(), and show_regs_handler().

references_handler()

static RzCmdStatus references_handler ( RzCore *  core, RzReg *  reg, RzCmdRegSync  sync_cb, RzList *  ritems, RzOutputMode  mode  )

static

Definition at line 346 of file cmd_regs.c.

                                                                                                                         {
    bool failed;
    SYNC_READ_LIST(ritems, failed);
    if (failed) {
        return RZ_CMD_STATUS_ERROR;
    }
 
    int use_colors = rz_config_get_i(core->config, "scr.color");
 
    int had_colors = use_colors;
    if (use_colors && mode == RZ_OUTPUT_MODE_JSON) {
        use_colors = 0;
        // for rz_core_analysis_hasrefs() below
        rz_config_set_i(core->config, "scr.color", 0);
    }
 
    RzTable *t = rz_core_table(core);
    rz_table_set_columnsf(t, "ssss", "role", "reg", "value", "refstr");
    RzListIter *iter;
    RzRegItem *r;
    rz_list_foreach (ritems, iter, r) {
        ut64 value = rz_reg_get_value(reg, r);
        const char *color = mode == RZ_OUTPUT_MODE_JSON ? NULL : get_reg_color(core, reg, r);
        char *namestr = rz_str_newf("%s%s%s", rz_str_get(color), r->name, color ? Color_RESET : "");
        char *valuestr = rz_str_newf("%s0x%" PFMT64x "%s", rz_str_get(color), value, color ? Color_RESET : "");
        char *rrstr = rz_core_analysis_hasrefs(core, value, true);
        rz_table_add_rowf(t, "ssss", rz_str_get(get_reg_role_name(reg, r)), namestr, valuestr, rz_str_get(rrstr));
        free(namestr);
        free(valuestr);
        free(rrstr);
    }
 
    if (mode == RZ_OUTPUT_MODE_JSON && had_colors) {
        rz_config_set_i(core->config, "scr.color", had_colors);
    }
 
    char *s = (mode == RZ_OUTPUT_MODE_JSON) ? rz_table_tojson(t) : rz_table_tostring(t);
    rz_cons_print(s);
    if (mode == RZ_OUTPUT_MODE_JSON) {
        rz_cons_print("\n");
    }
    free(s);
    rz_table_free(t);
    return RZ_CMD_STATUS_OK;
}

References color, Color_RESET, rz_core_t::config, free(), get_reg_color(), get_reg_role_name(), NULL, PFMT64x, r, reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_config_get_i(), rz_config_set_i(), rz_core_analysis_hasrefs(), rz_core_table(), RZ_OUTPUT_MODE_JSON, rz_reg_get_value(), rz_str_get(), rz_str_newf(), rz_table_add_rowf(), rz_table_free(), rz_table_set_columnsf(), rz_table_tojson(), rz_table_tostring(), s, SYNC_READ_LIST, ut64(), and value.

Referenced by rz_regs_args_handler(), and rz_regs_references_handler().

reg_has_changed()

static bool reg_has_changed ( RzReg *  reg, RzRegItem *  item  )

static

Check whether the given item's value has changed in the last step.

Definition at line 116 of file cmd_regs.c.

                                                         {
    ut64 value = rz_reg_get_value(reg, item);
    rz_reg_arena_swap(reg, false);
    ut64 old = rz_reg_get_value(reg, item);
    rz_reg_arena_swap(reg, false);
    return old != value;
}

References reg, rz_reg_arena_swap(), rz_reg_get_value(), ut64(), and value.

Referenced by get_reg_color().

rz_core_reg_assign_sync()

RZ_API bool rz_core_reg_assign_sync	(	RZ_NONNULL RzCore *	core,
		RZ_NONNULL RzReg *	reg,
		RzCmdRegSync	sync_cb,
		RZ_NONNULL const char *	name,
		ut64	val
	)

Register assignment like reg=0x42

Parameters

core	The RzCore instance
reg	The RzReg instance
sync_cb	Callback for synchronizing register state in command
name	Register name
val	Value

Returns

success

Definition at line 138 of file cmd_regs.c.

                                                                                                                                                 {
    rz_return_val_if_fail(core && reg && name, false);
    RzRegItem *ri = rz_reg_get(reg, name, RZ_REG_TYPE_ANY);
    if (!ri) {
        return false;
    }
    bool failed;
    SYNC_READ(ri->type, failed);
    if (failed) {
        return false;
    }
    rz_reg_set_value(reg, ri, val);
    SYNC_WRITE(ri->type, failed);
    return true;
}

References reg, rz_reg_get(), rz_reg_set_value(), RZ_REG_TYPE_ANY, rz_return_val_if_fail, SYNC_READ, SYNC_WRITE, rz_reg_item_t::type, and val.

Referenced by assign_reg().

rz_core_reg_filter_items_sync()

RZ_API RZ_OWN RzList* rz_core_reg_filter_items_sync	(	RZ_NONNULL RzCore *	core,
		RZ_NONNULL RzReg *	reg,
		RzCmdRegSync	sync_cb,
		RZ_NULLABLE const char *	filter
	)

Filter a list of RzRegItem and sync read

Parameters

core	The RzCore instance
reg	The RzReg instance
sync_cb	Callback for synchronizing register state in command
filter	Filter registers

Returns

List of RzRegItem

Definition at line 203 of file cmd_regs.c.

                                                                                                                                                            {
    rz_return_val_if_fail(core && reg, NULL);
    RzList *ritems = filter_reg_items(reg, filter);
    if (!ritems) {
        return NULL;
    }
 
    bool failed;
    SYNC_READ_LIST(ritems, failed);
    if (failed) {
        rz_list_free(ritems);
        return NULL;
    }
    return ritems;
}

References filter_reg_items(), NULL, reg, rz_list_free(), rz_return_val_if_fail, and SYNC_READ_LIST.

Referenced by rz_regs_columns_handler(), and show_regs_handler().

rz_reg_arenas_handler()

RZ_IPI RzCmdStatus rz_reg_arenas_handler	(	RzCore *	core,
		RzReg *	reg,
		int	argc,
		const char **	argv
	)

Definition at line 483 of file cmd_regs.c.

                                                                                                {
    int i, j;
    RzRegArena *a;
    RzListIter *iter;
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        RzRegSet *rs = &reg->regset[i];
        j = 0;
        rz_list_foreach (rs->pool, iter, a) {
            rz_cons_printf("%s %p %d %d %s %d\n",
                (a == rs->arena) ? "*" : ".", a,
                i, j, rz_reg_get_type(i), a->size);
            j++;
        }
    }
    return RZ_CMD_STATUS_OK;
}

References a, i, reg, rs, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_reg_get_type(), and RZ_REG_TYPE_LAST.

rz_reg_arenas_hexdump_handler()

RZ_IPI RzCmdStatus rz_reg_arenas_hexdump_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv
	)

Definition at line 544 of file cmd_regs.c.

                                                                                                                              {
    int t = RZ_REG_TYPE_GPR;
    if (argc > 1) {
        t = rz_reg_type_by_name(argv[1]);
        if (t < 0) {
            RZ_LOG_ERROR("No such register type: \"%s\"\n", argv[2]);
            return RZ_CMD_STATUS_ERROR;
        }
    }
    bool failed;
    SYNC_READ(t, failed);
    if (failed) {
        return RZ_CMD_STATUS_ERROR;
    }
    int len = 0;
    ut8 *buf = rz_reg_get_bytes(reg, t, &len);
    if (buf) {
        rz_core_print_hexdump(core, 0LL, buf, len, 32, 4, 1);
        free(buf);
    }
    return RZ_CMD_STATUS_OK;
}

References argv, free(), len, reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_print_hexdump(), RZ_LOG_ERROR, rz_reg_get_bytes(), rz_reg_type_by_name(), RZ_REG_TYPE_GPR, and SYNC_READ.

rz_reg_arenas_pop_handler()

RZ_IPI RzCmdStatus rz_reg_arenas_pop_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv
	)

Definition at line 511 of file cmd_regs.c.

                                                                                                                          {
    rz_reg_arena_pop(reg);
    bool failed;
    SYNC_WRITE(RZ_REG_TYPE_ANY, failed);
    return failed ? RZ_CMD_STATUS_ERROR : RZ_CMD_STATUS_OK;
}

References reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_reg_arena_pop(), RZ_REG_TYPE_ANY, and SYNC_WRITE.

rz_reg_arenas_push_handler()

RZ_IPI RzCmdStatus rz_reg_arenas_push_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv
	)

Definition at line 500 of file cmd_regs.c.

                                                                                                                           {
    bool failed;
    SYNC_READ(RZ_REG_TYPE_ANY, failed);
    if (failed) {
        return RZ_CMD_STATUS_ERROR;
    }
    rz_reg_arena_push(reg);
    SYNC_WRITE(RZ_REG_TYPE_ANY, failed);
    return failed ? RZ_CMD_STATUS_ERROR : RZ_CMD_STATUS_OK;
}

References reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_reg_arena_push(), RZ_REG_TYPE_ANY, SYNC_READ, and SYNC_WRITE.

rz_reg_arenas_stack_size_handler()

RZ_IPI RzCmdStatus rz_reg_arenas_stack_size_handler	(	RzCore *	core,
		RzReg *	reg,
		int	argc,
		const char **	argv
	)

Definition at line 567 of file cmd_regs.c.

                                                                                                           {
    rz_cons_printf("%d\n", (int)rz_list_length(reg->regset[0].pool));
    return RZ_CMD_STATUS_OK;
}

References reg, RZ_CMD_STATUS_OK, rz_cons_printf(), and rz_list_length().

rz_reg_arenas_swap_handler()

RZ_IPI RzCmdStatus rz_reg_arenas_swap_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv
	)

Definition at line 518 of file cmd_regs.c.

                                                                                                                           {
    bool failed;
    SYNC_READ(RZ_REG_TYPE_ANY, failed);
    if (failed) {
        return RZ_CMD_STATUS_ERROR;
    }
    rz_reg_arena_swap(reg, false);
    SYNC_WRITE(RZ_REG_TYPE_ANY, failed);
    return failed ? RZ_CMD_STATUS_ERROR : RZ_CMD_STATUS_OK;
}

References reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_reg_arena_swap(), RZ_REG_TYPE_ANY, SYNC_READ, and SYNC_WRITE.

rz_reg_arenas_write_hex_handler()

RZ_IPI RzCmdStatus rz_reg_arenas_write_hex_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv
	)

Definition at line 572 of file cmd_regs.c.

                                                                                                                                {
    rz_return_val_if_fail(argc > 1, RZ_CMD_STATUS_WRONG_ARGS);
    RzRegisterType type = RZ_REG_TYPE_GPR;
    if (argc > 2) {
        type = rz_reg_type_by_name(argv[2]);
        if (type < 0 || type >= RZ_REG_TYPE_LAST) {
            RZ_LOG_ERROR("No such register type: \"%s\"\n", argv[2]);
            return RZ_CMD_STATUS_ERROR;
        }
    }
    bool failed;
    SYNC_READ(type, failed);
    if (failed) {
        return RZ_CMD_STATUS_ERROR;
    }
    const char *hex = argv[1];
    size_t maxsz = (strlen(hex) + 1) / 2;
    if (!maxsz) {
        return RZ_CMD_STATUS_ERROR;
    }
    ut8 *buf = malloc(maxsz);
    if (!buf) {
        return RZ_CMD_STATUS_ERROR;
    }
    int sz = rz_hex_str2bin(hex, buf);
    if (sz <= 0) {
        RZ_LOG_ERROR("Invalid hex string given.\n");
        free(buf);
        return RZ_CMD_STATUS_ERROR;
    }
    RzRegArena *a = reg->regset[type].arena;
    if (!a || !a->bytes) {
        free(buf);
        // nothing to write, this is fine
        return RZ_CMD_STATUS_OK;
    }
    memcpy(a->bytes, buf, RZ_MIN(sz, a->size));
    free(buf);
    SYNC_WRITE(type, failed);
    return failed ? RZ_CMD_STATUS_ERROR : RZ_CMD_STATUS_OK;
}

References a, argv, free(), hex, malloc(), memcpy(), reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, RZ_CMD_STATUS_WRONG_ARGS, rz_hex_str2bin(), RZ_LOG_ERROR, RZ_MIN, rz_reg_type_by_name(), RZ_REG_TYPE_GPR, RZ_REG_TYPE_LAST, rz_return_val_if_fail, SYNC_READ, SYNC_WRITE, and type.

rz_reg_arenas_zero_handler()

RZ_IPI RzCmdStatus rz_reg_arenas_zero_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv
	)

Definition at line 529 of file cmd_regs.c.

                                                                                                                           {
    int t = RZ_REG_TYPE_ANY;
    if (argc > 1) {
        t = rz_reg_type_by_name(argv[1]);
        if (t < 0) {
            RZ_LOG_ERROR("No such register type: \"%s\"\n", argv[2]);
            return RZ_CMD_STATUS_ERROR;
        }
    }
    rz_reg_arena_zero(reg, t);
    bool failed;
    SYNC_WRITE(t, failed);
    return failed ? RZ_CMD_STATUS_ERROR : RZ_CMD_STATUS_OK;
}

References argv, reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, RZ_LOG_ERROR, rz_reg_arena_zero(), RZ_REG_TYPE_ANY, rz_reg_type_by_name(), and SYNC_WRITE.

rz_reg_cc_handler()

RZ_IPI RzCmdStatus rz_reg_cc_handler	(	RzCore *	core,
		RzReg *	reg,
		int	argc,
		const char **	argv
	)

Definition at line 797 of file cmd_regs.c.

                                                                                            {
    char *s = rz_reg_profile_to_cc(reg);
    if (s) {
        rz_cons_printf("%s\n", s);
        free(s);
    }
    return RZ_CMD_STATUS_OK;
}

References free(), reg, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_reg_profile_to_cc(), and s.

rz_reg_cond_handler()

RZ_IPI RzCmdStatus rz_reg_cond_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv
	)

Definition at line 776 of file cmd_regs.c.

                                                                                                                    {
    bool failed;
    SYNC_READ(RZ_REG_TYPE_ANY, failed);
    if (failed) {
        return RZ_CMD_STATUS_ERROR;
    }
    RzRegFlags *rf = rz_reg_cond_retrieve(reg, NULL);
    if (!rf) {
        return RZ_CMD_STATUS_ERROR;
    }
    rz_cons_printf("| s:%d z:%d c:%d o:%d p:%d\n",
        rf->s, rf->z, rf->c, rf->o, rf->p);
    for (int i = 0; i < RZ_REG_COND_LAST; i++) {
        rz_cons_printf("%d %s\n",
            rz_reg_cond_bits(reg, i, rf),
            rz_reg_cond_to_string(i));
    }
    free(rf);
    return RZ_CMD_STATUS_OK;
}

References rz_reg_flags_t::c, free(), i, NULL, rz_reg_flags_t::o, rz_reg_flags_t::p, reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_reg_cond_bits(), RZ_REG_COND_LAST, rz_reg_cond_retrieve(), rz_reg_cond_to_string(), RZ_REG_TYPE_ANY, rz_reg_flags_t::s, SYNC_READ, and rz_reg_flags_t::z.

rz_reg_flags_handler()

RZ_IPI RzCmdStatus rz_reg_flags_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv,
		bool	unset
	)

Definition at line 658 of file cmd_regs.c.

                                                                                                                                 {
    const char *filter = argc > 1 && *argv[1] ? argv[1] : NULL;
    RzList *ritems;
    if (filter) {
        ritems = filter_reg_items(reg, filter);
        if (!ritems) {
            print_reg_not_found(filter);
            return RZ_CMD_STATUS_ERROR;
        }
    } else {
        ritems = rz_core_reg_flags_candidates(core, reg);
        if (!ritems) {
            return RZ_CMD_STATUS_ERROR;
        }
    }
    if (!unset) {
        rz_cons_print("fss+ " RZ_FLAGS_FS_REGISTERS "\n");
        bool failed;
        SYNC_READ_LIST(ritems, failed);
        if (failed) {
            rz_list_free(ritems);
            return RZ_CMD_STATUS_ERROR;
        }
    }
    RzListIter *iter;
    RzRegItem *item;
    rz_list_foreach (ritems, iter, item) {
        if (!unset) {
            ut64 v = rz_reg_get_value(reg, item);
            rz_cons_printf("f+ %s @ 0x%" PFMT64x "\n", item->name, v);
        } else {
            rz_cons_printf("f- %s\n", item->name);
        }
    }
    if (!unset) {
        rz_cons_print("fss-\n");
    }
    rz_list_free(ritems);
    return RZ_CMD_STATUS_OK;
}

References argv, filter_reg_items(), rz_reg_item_t::name, NULL, PFMT64x, print_reg_not_found(), reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_core_reg_flags_candidates(), RZ_FLAGS_FS_REGISTERS, rz_list_free(), rz_reg_get_value(), SYNC_READ_LIST, ut64(), and v.

rz_reg_profile_comments_handler()

RZ_IPI RzCmdStatus rz_reg_profile_comments_handler	(	RzCore *	core,
		RzReg *	reg,
		int	argc,
		const char **	argv
	)

Definition at line 749 of file cmd_regs.c.

                                                                                                          {
    if (reg->reg_profile_cmt) {
        rz_cons_println(reg->reg_profile_cmt);
    }
    return RZ_CMD_STATUS_OK;
}

References reg, RZ_CMD_STATUS_OK, and rz_cons_println().

rz_reg_profile_gdb_handler()

RZ_IPI RzCmdStatus rz_reg_profile_gdb_handler	(	RzCore *	core,
		RzReg *	reg,
		int	argc,
		const char **	argv
	)

Definition at line 762 of file cmd_regs.c.

                                                                                                     {
    rz_return_val_if_fail(argc > 1, RZ_CMD_STATUS_WRONG_ARGS);
    char *rz_profile = rz_reg_parse_gdb_profile(argv[1]);
    if (!rz_profile) {
        RZ_LOG_ERROR("Cannot parse gdb profile.\n");
        core->num->value = 1;
        return RZ_CMD_STATUS_ERROR;
    }
    rz_cons_println(rz_profile);
    core->num->value = 0;
    free(rz_profile);
    return RZ_CMD_STATUS_OK;
}

References argv, free(), rz_core_t::num, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, RZ_CMD_STATUS_WRONG_ARGS, rz_cons_println(), RZ_LOG_ERROR, rz_reg_parse_gdb_profile(), rz_return_val_if_fail, and rz_num_t::value.

rz_reg_profile_handler()

RZ_IPI RzCmdStatus rz_reg_profile_handler	(	RzCore *	core,
		RzReg *	reg,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 699 of file cmd_regs.c.

                                                                                                                          {
    switch (state->mode) {
    case RZ_OUTPUT_MODE_STANDARD:
        if (reg->reg_profile_str) {
            rz_cons_println(reg->reg_profile_str);
        } else {
            eprintf("No register profile defined.\n");
        }
        break;
    case RZ_OUTPUT_MODE_JSON: {
        RzListIter *iter;
        RzRegItem *r;
        int i;
        PJ *pj = state->d.pj;
        pj_o(pj);
        pj_k(pj, "alias_info");
        pj_a(pj);
        for (i = 0; i < RZ_REG_NAME_LAST; i++) {
            if (reg->name[i]) {
                pj_o(pj);
                pj_kn(pj, "role", i);
                pj_ks(pj, "role_str", rz_reg_get_role(i));
                pj_ks(pj, "reg", reg->name[i]);
                pj_end(pj);
            }
        }
        pj_end(pj);
        pj_k(pj, "reg_info");
        pj_a(pj);
        for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
            rz_list_foreach (reg->regset[i].regs, iter, r) {
                pj_o(pj);
                pj_kn(pj, "type", r->type);
                pj_ks(pj, "type_str", rz_reg_get_type(r->type));
                pj_ks(pj, "name", r->name);
                pj_kn(pj, "size", r->size);
                pj_kn(pj, "offset", r->offset);
                pj_end(pj);
            }
        }
        pj_end(pj);
        pj_end(pj);
        break;
    }
    default:
        break;
    }
    return RZ_CMD_STATUS_OK;
}

References eprintf, i, pj_a(), pj_end(), pj_k(), pj_kn(), pj_ks(), pj_o(), r, reg, RZ_CMD_STATUS_OK, rz_cons_println(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_STANDARD, rz_reg_get_role(), rz_reg_get_type(), RZ_REG_NAME_LAST, and RZ_REG_TYPE_LAST.

rz_reg_profile_open_handler()

RZ_IPI RzCmdStatus rz_reg_profile_open_handler	(	RzCore *	core,
		RzReg *	reg,
		int	argc,
		const char **	argv
	)

Definition at line 756 of file cmd_regs.c.

                                                                                                      {
    rz_return_val_if_fail(argc > 1, RZ_CMD_STATUS_WRONG_ARGS);
    rz_reg_set_profile(reg, argv[1]);
    return RZ_CMD_STATUS_OK;
}

References argv, reg, RZ_CMD_STATUS_OK, RZ_CMD_STATUS_WRONG_ARGS, rz_reg_set_profile(), and rz_return_val_if_fail.

rz_reg_roles_handler()

RZ_IPI RzCmdStatus rz_reg_roles_handler	(	RzCore *	core,
		RzReg *	reg,
		int	argc,
		const char **	argv
	)

Definition at line 647 of file cmd_regs.c.

                                                                                               {
    for (int i = 0; i < RZ_REG_NAME_LAST; i++) {
        rz_cons_print(rz_reg_get_role(i));
        if (reg->name[i]) {
            rz_cons_printf(" -> %s", reg->name[i]);
        }
        rz_cons_print("\n");
    }
    return RZ_CMD_STATUS_OK;
}

References i, reg, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_reg_get_role(), and RZ_REG_NAME_LAST.

rz_reg_types_handler()

RZ_IPI RzCmdStatus rz_reg_types_handler	(	RzCore *	core,
		RzReg *	reg,
		int	argc,
		const char **	argv
	)

Definition at line 640 of file cmd_regs.c.

                                                                                               {
    for (int i = 0; i < RZ_REG_TYPE_LAST; i++) {
        rz_cons_println(rz_reg_get_type(i));
    }
    return RZ_CMD_STATUS_OK;
}

References i, RZ_CMD_STATUS_OK, rz_cons_println(), rz_reg_get_type(), and RZ_REG_TYPE_LAST.

rz_regs_args_handler()

RZ_IPI RzCmdStatus rz_regs_args_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv,
		RzOutputMode	mode
	)

Definition at line 614 of file cmd_regs.c.

                                                                                                                                        {
    RzList *ritems = rz_list_new();
    if (!ritems) {
        return RZ_CMD_STATUS_ERROR;
    }
    for (int i = RZ_REG_NAME_A0; i <= RZ_REG_NAME_A9; i++) {
        const char *name = rz_reg_get_name(reg, i);
        if (!name) {
            break;
        }
        RzRegItem *item = rz_reg_get(reg, name, RZ_REG_TYPE_ANY);
        if (!item) {
            continue;
        }
        rz_list_push(ritems, item);
    }
    RzCmdStatus r = RZ_CMD_STATUS_OK;
    if (rz_list_empty(ritems)) {
        eprintf("No argument roles defined.\n");
    } else {
        r = references_handler(core, reg, sync_cb, ritems, mode);
    }
    rz_list_free(ritems);
    return r;
}

References eprintf, i, r, references_handler(), reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_list_free(), rz_list_new(), rz_list_push(), rz_reg_get(), rz_reg_get_name(), RZ_REG_NAME_A0, RZ_REG_NAME_A9, and RZ_REG_TYPE_ANY.

rz_regs_columns_handler()

RZ_IPI RzCmdStatus rz_regs_columns_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv
	)

Definition at line 298 of file cmd_regs.c.

                                                                                                                        {
    const char *filter = argc > 1 ? argv[1] : NULL;
    RzList *ritems = rz_core_reg_filter_items_sync(core, reg, sync_cb, filter);
    if (!ritems) {
        print_reg_not_found(filter);
        return RZ_CMD_STATUS_ERROR;
    }
 
    int cols = 4; // how many registers in a row
    int colwidth = 24;
    RzListIter *iter;
    RzRegItem *item;
    char whites[32], content[300];
    char strvalue[256] = { 0 };
    size_t idx = 0;
    rz_list_foreach (ritems, iter, item) {
        const char *color = get_reg_color(core, reg, item);
        if (color) {
            rz_cons_print(color);
        }
        format_reg_value(reg, item, strvalue, sizeof(strvalue));
        int len = snprintf(content, sizeof(content), "%7s %s", item->name, strvalue);
        if (len < 0) {
            break;
        }
        rz_cons_print(content);
        if (color) {
            rz_cons_print(Color_RESET);
        }
        if ((idx + 1) % cols) {
            int rem = colwidth - strlen(content);
            rem = RZ_MIN(sizeof(whites) - 1, RZ_MAX(0, rem));
            memset(whites, ' ', rem);
            whites[rem] = 0;
            rz_cons_print(whites);
        } else {
            rz_cons_print("\n");
        }
        idx++;
    }
    if (idx % cols) {
        // only print newline if not already done in the loop above
        rz_cons_print("\n");
    }
    rz_list_free(ritems);
    return RZ_CMD_STATUS_OK;
}

References argv, color, Color_RESET, format_reg_value(), get_reg_color(), setup::idx, len, memset(), rz_reg_item_t::name, NULL, print_reg_not_found(), reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_reg_filter_items_sync(), rz_list_free(), RZ_MAX, RZ_MIN, and snprintf.

rz_regs_diff_handler()

RZ_IPI RzCmdStatus rz_regs_diff_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv
	)

Definition at line 806 of file cmd_regs.c.

                                                                                                                     {
    bool failed;
    SYNC_READ(RZ_REG_TYPE_ANY, failed);
    if (failed) {
        return RZ_CMD_STATUS_ERROR;
    }
    rz_core_reg_print_diff(reg, reg->allregs);
    return RZ_CMD_STATUS_OK;
}

References reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_reg_print_diff(), RZ_REG_TYPE_ANY, and SYNC_READ.

rz_regs_fpu_handler()

RZ_IPI RzCmdStatus rz_regs_fpu_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv
	)

Definition at line 824 of file cmd_regs.c.

                                                                                                                    {
    // TODO: everything here needs to be rewritten. It was taken from the old "drf" command.
    bool failed;
    if (argc <= 1) {
        // TODO: Do not use this hack to print fpu register:
        // By sending a negative value, this is signalling all the way through to the debug plugin,
        // which then does the printing.
        // This should be rewritten directly above the RzReg.
        SYNC_READ(-RZ_REG_TYPE_FPU, failed);
        if (failed) {
            return RZ_CMD_STATUS_ERROR;
        }
        return RZ_CMD_STATUS_OK;
    }
    char *name = rz_str_trim_dup(argv[1]);
    char *eq = strchr(name, '=');
    if (eq) {
        *eq++ = 0;
    }
    char *p = strchr(name, ' ');
    if (p) {
        *p++ = 0;
    }
    RzCmdStatus ret = RZ_CMD_STATUS_ERROR;
    SYNC_READ(RZ_REG_TYPE_GPR, failed);
    if (failed) {
        goto error;
    }
    SYNC_READ(RZ_REG_TYPE_FPU, failed);
    if (failed) {
        goto error;
    }
    RzRegItem *item = rz_reg_get(reg, name, -1);
    if (item) {
        if (eq) {
            long double val = 0.0f;
#if __windows__
            double dval = 0.0f;
            sscanf(eq, "%lf", (double *)&dval);
            val = dval;
#else
            sscanf(eq, "%Lf", &val);
#endif
            rz_reg_set_double(reg, item, val);
            SYNC_WRITE(RZ_REG_TYPE_GPR, failed);
            if (failed) {
                goto error;
            }
            SYNC_WRITE(RZ_REG_TYPE_FPU, failed);
            if (failed) {
                goto error;
            }
        } else {
            long double res = rz_reg_get_longdouble(reg, item);
            rz_cons_printf("%Lf\n", res);
        }
    } else {
        /* note, that negative type forces sync to print the regs from the backend */
        eprintf("cannot find multimedia register '%s'\n", name);
    }
 
error:
    free(name);
    return ret;
}

References argv, eprintf, eq, error(), free(), p, reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_reg_get(), rz_reg_get_longdouble(), rz_reg_set_double(), RZ_REG_TYPE_FPU, RZ_REG_TYPE_GPR, rz_str_trim_dup(), SYNC_READ, SYNC_WRITE, and val.

rz_regs_handler()

RZ_IPI RzCmdStatus rz_regs_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 283 of file cmd_regs.c.

                                                                                                                                         {
    const char *filter = argc > 1 ? argv[1] : NULL;
 
    // check if the argument is an assignment like reg=0x42
    if (filter) {
        char *eq = strchr(filter, '=');
        if (eq) {
            return assign_reg(core, reg, sync_cb, filter, eq - filter);
        }
    }
 
    // just show
    return show_regs_handler(core, reg, sync_cb, filter, state);
}

References argv, assign_reg(), eq, NULL, reg, and show_regs_handler().

rz_regs_prev_handler()

RZ_IPI RzCmdStatus rz_regs_prev_handler	(	RzCore *	core,
		RzReg *	reg,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 816 of file cmd_regs.c.

                                                                                                                        {
    const char *filter = argc > 1 ? argv[1] : NULL;
    rz_reg_arena_swap(reg, false);
    RzCmdStatus r = show_regs_handler(core, reg, NULL, filter, state); // sync_cb = NULL on purpose to not overwrite
    rz_reg_arena_swap(reg, false);
    return r;
}

References argv, NULL, r, reg, rz_reg_arena_swap(), and show_regs_handler().

rz_regs_references_handler()

RZ_IPI RzCmdStatus rz_regs_references_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv,
		RzOutputMode	mode
	)

Definition at line 392 of file cmd_regs.c.

                                                                                                                                              {
    const char *filter = argc > 1 ? argv[1] : NULL;
    RzList *ritems = filter_reg_items(reg, filter);
    if (!ritems) {
        print_reg_not_found(filter);
        return RZ_CMD_STATUS_ERROR;
    }
    RzCmdStatus r = references_handler(core, reg, sync_cb, ritems, mode);
    rz_list_free(ritems);
    return r;
}

References argv, filter_reg_items(), NULL, print_reg_not_found(), r, references_handler(), reg, RZ_CMD_STATUS_ERROR, and rz_list_free().

rz_regs_show_valgroup()

RZ_IPI void rz_regs_show_valgroup	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		const RzList *	list
	)

Definition at line 423 of file cmd_regs.c.

                                                                                                      {
    int use_colors = rz_config_get_i(core->config, "scr.color");
 
    RzListIter *iter;
    RzRegItem *r;
    HtUP *db = ht_up_new0();
    rz_list_foreach (list, iter, r) {
        if (r->size != core->rasm->bits) {
            continue;
        }
        ut64 value = rz_reg_get_value(reg, r);
        RzList *list = ht_up_find(db, value, NULL);
        if (!list) {
            list = rz_list_newf(NULL);
            ht_up_update(db, value, list);
        }
        rz_list_append(list, r->name);
    }
 
    RzList *sorted = rz_list_newf(free);
    ht_up_foreach(db, valgroup_regcb, sorted);
    ut64 *addr;
    rz_list_foreach (sorted, iter, addr) {
        rz_cons_printf("0x%08" PFMT64x " ", *addr);
        RzList *list = ht_up_find(db, *addr, NULL);
        if (list) {
            RzListIter *iter;
            const char *r;
            if (use_colors) {
                rz_cons_strcat(Color_YELLOW);
            }
            rz_list_foreach (list, iter, r) {
                rz_cons_printf(" %s", r);
            }
            if (use_colors) {
                rz_cons_strcat(Color_RESET);
            }
            char *rrstr = rz_core_analysis_hasrefs(core, *addr, true);
            if (rrstr && *rrstr && strchr(rrstr, 'R')) {
                rz_cons_printf("    ;%s%s", rrstr, use_colors ? Color_RESET : "");
            }
            rz_cons_newline();
        }
    }
    rz_list_free(sorted);
    ht_up_free(db);
}

References addr, rz_asm_t::bits, Color_RESET, Color_YELLOW, rz_core_t::config, free(), list(), NULL, PFMT64x, r, rz_core_t::rasm, reg, rz_config_get_i(), rz_cons_newline(), rz_cons_printf(), rz_cons_strcat(), rz_core_analysis_hasrefs(), rz_list_append(), rz_list_free(), rz_list_newf(), rz_reg_get_value(), ut64(), valgroup_regcb(), and value.

Referenced by rz_core_debug_ri(), and rz_regs_valgroup_handler().

rz_regs_valgroup_handler()

RZ_IPI RzCmdStatus rz_regs_valgroup_handler	(	RzCore *	core,
		RzReg *	reg,
		RzCmdRegSync	sync_cb,
		int	argc,
		const char **	argv
	)

Definition at line 471 of file cmd_regs.c.

                                                                                                                         {
    const char *filter = argc > 1 ? argv[1] : NULL;
    RzList *list = filter_reg_items(reg, filter);
    if (!list) {
        print_reg_not_found(filter);
        return RZ_CMD_STATUS_ERROR;
    }
    rz_regs_show_valgroup(core, reg, sync_cb, list);
    rz_list_free(list);
    return RZ_CMD_STATUS_OK;
}

References argv, filter_reg_items(), list(), NULL, print_reg_not_found(), reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_list_free(), and rz_regs_show_valgroup().

show_regs_handler()

static RzCmdStatus show_regs_handler ( RzCore *  core, RzReg *  reg, RzCmdRegSync  sync_cb, const char *  filter, RzCmdStateOutput *  state  )

static

Definition at line 219 of file cmd_regs.c.

                                                                                                                                  {
    RzList *ritems = rz_core_reg_filter_items_sync(core, reg, sync_cb, filter);
    if (!ritems) {
        print_reg_not_found(filter);
        return RZ_CMD_STATUS_ERROR;
    }
 
    if (state->mode == RZ_OUTPUT_MODE_TABLE) {
        rz_table_set_columnsf(state->d.t, "ssXxs", "role", "name", "value", "size", "type");
    } else if (state->mode == RZ_OUTPUT_MODE_JSON) {
        pj_o(state->d.pj);
    }
 
    RzListIter *iter;
    RzRegItem *item;
    char buf[256] = { 0 };
    rz_list_foreach (ritems, iter, item) {
        switch (state->mode) {
        case RZ_OUTPUT_MODE_STANDARD: {
            format_reg_value(reg, item, buf, sizeof(buf));
            const char *color = get_reg_color(core, reg, item);
            if (color) {
                rz_cons_print(color);
            }
            rz_cons_printf("%s = %s", item->name, buf);
            if (color) {
                rz_cons_print(Color_RESET);
            }
            rz_cons_print("\n");
            break;
        }
        case RZ_OUTPUT_MODE_QUIET:
            format_reg_value(reg, item, buf, sizeof(buf));
            rz_cons_printf("%s\n", buf);
            break;
        case RZ_OUTPUT_MODE_RIZIN:
            format_reg_value(reg, item, buf, sizeof(buf));
            rz_cons_printf("ar %s = %s\n", item->name, buf);
            break;
        case RZ_OUTPUT_MODE_TABLE:
            rz_table_add_rowf(state->d.t, "ssXxs",
                rz_str_get(get_reg_role_name(reg, item)),
                item->name, rz_reg_get_value(reg, item), (ut64)item->size, rz_reg_get_type(item->type));
            break;
        case RZ_OUTPUT_MODE_JSON:
            if (item->size <= 64) {
                pj_kn(state->d.pj, item->name, rz_reg_get_value(reg, item));
            } else {
                format_reg_value(reg, item, buf, sizeof(buf));
                pj_ks(state->d.pj, item->name, buf);
            }
            break;
        default:
            break;
        }
    }
    rz_list_free(ritems);
 
    if (state->mode == RZ_OUTPUT_MODE_JSON) {
        pj_end(state->d.pj);
    }
    return RZ_CMD_STATUS_OK;
}

References color, Color_RESET, format_reg_value(), get_reg_color(), get_reg_role_name(), rz_reg_item_t::name, pj_end(), pj_kn(), pj_ks(), pj_o(), print_reg_not_found(), reg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_core_reg_filter_items_sync(), rz_list_free(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_RIZIN, RZ_OUTPUT_MODE_STANDARD, RZ_OUTPUT_MODE_TABLE, rz_reg_get_type(), rz_reg_get_value(), rz_str_get(), rz_table_add_rowf(), rz_table_set_columnsf(), rz_reg_item_t::size, rz_reg_item_t::type, and ut64().

Referenced by rz_regs_handler(), and rz_regs_prev_handler().

valgroup_regcb()

static bool valgroup_regcb ( void *  u, const ut64  k, const void *  v  )

static

Definition at line 416 of file cmd_regs.c.

                                                                 {
    RzList *sorted = (RzList *)u;
    ut64 *n = ut64_new(k);
    rz_list_add_sorted(sorted, n, valgroup_regcmp);
    return true;
}

References k, n, rz_list_add_sorted(), ut64(), and valgroup_regcmp().

Referenced by rz_regs_show_valgroup().

valgroup_regcmp()

static int valgroup_regcmp ( const void *  a, const void *  b  )

static

Definition at line 404 of file cmd_regs.c.

                                                         {
    const ut64 *A = (const ut64 *)a;
    const ut64 *B = (const ut64 *)b;
    if (*A > *B) {
        return 1;
    }
    if (*A == *B) {
        return 0;
    }
    return -1;
}

References a, A, b, B, and ut64().

Referenced by valgroup_regcb().