rvalue.c File Reference

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

Go to the source code of this file.

Typedefs
typedef ut32	ut27

Functions
RZ_API RzBitVector *	rz_reg_get_bv (RZ_NONNULL RzReg *reg, RZ_NONNULL RzRegItem *item)
RZ_API bool	rz_reg_set_bv (RZ_NONNULL RzReg *reg, RZ_NONNULL RzRegItem *item, RZ_NONNULL const RzBitVector *bv)
static ut27	rz_read_me27 (const ut8 *buf, int boff)
RZ_API ut64	rz_reg_get_value_big (RzReg *reg, RzRegItem *item, utX *val)
RZ_API ut64	rz_reg_get_value (RzReg *reg, RzRegItem *item)
RZ_API ut64	rz_reg_get_value_by_role (RzReg *reg, RzRegisterId role)
RZ_API bool	rz_reg_set_value (RzReg *reg, RzRegItem *item, ut64 value)
RZ_API bool	rz_reg_set_value_by_role (RzReg *reg, RzRegisterId role, ut64 val)
RZ_API ut64	rz_reg_set_bvalue (RzReg *reg, RzRegItem *item, const char *str)
RZ_API RZ_HEAP char *	rz_reg_get_bvalue (RzReg *reg, RzRegItem *item)
RZ_API ut64	rz_reg_get_pack (RzReg *reg, RzRegItem *item, int packidx, int packbits)
RZ_API int	rz_reg_set_pack (RzReg *reg, RzRegItem *item, int packidx, int packbits, ut64 val)

Typedef Documentation

ut27

typedef ut32 ut27

Definition at line 51 of file rvalue.c.

Function Documentation

rz_read_me27()

static ut27 rz_read_me27 ( const ut8 *  buf, int  boff  )

static

Definition at line 52 of file rvalue.c.

                                                   {
    ut27 ret = 0;
    rz_mem_copybits_delta((ut8 *)&ret, 18, buf, boff, 9);
    rz_mem_copybits_delta((ut8 *)&ret, 9, buf, boff + 9, 9);
    rz_mem_copybits_delta((ut8 *)&ret, 0, buf, boff + 18, 9);
    return ret;
}

References rz_mem_copybits_delta().

Referenced by rz_reg_get_value().

rz_reg_get_bv()

RZ_API RzBitVector* rz_reg_get_bv	(	RZ_NONNULL RzReg *	reg,
		RZ_NONNULL RzRegItem *	item
	)

Read the value of the given register as a bit vector

Definition at line 11 of file rvalue.c.

                                                                                     {
    rz_return_val_if_fail(reg && item, NULL);
    RzRegSet *regset = &reg->regset[item->arena];
    if (reg->big_endian) {
        return rz_bv_new_from_bytes_be(regset->arena->bytes, item->offset, item->size);
    } else {
        return rz_bv_new_from_bytes_le(regset->arena->bytes, item->offset, item->size);
    }
}

References rz_reg_set_t::arena, rz_reg_arena_t::bytes, NULL, reg, rz_bv_new_from_bytes_be(), rz_bv_new_from_bytes_le(), and rz_return_val_if_fail.

Referenced by rz_il_vm_sync_from_reg().

rz_reg_get_bvalue()

RZ_API RZ_HEAP char* rz_reg_get_bvalue	(	RzReg *	reg,
		RzRegItem *	item
	)

Definition at line 291 of file rvalue.c.

                                                                    {
    char *out = NULL;
    if (reg && item && item->flags) {
        out = malloc(strlen(item->flags) + 1);
        if (out) {
            ut64 num = rz_reg_get_value(reg, item);
            rz_str_bits(out, (ut8 *)&num,
                strlen(item->flags) * 8, item->flags);
        }
    }
    return out;
}

References rz_reg_item_t::flags, malloc(), NULL, num, out, reg, rz_reg_get_value(), rz_str_bits(), and ut64().

rz_reg_get_pack()

RZ_API ut64 rz_reg_get_pack	(	RzReg *	reg,
		RzRegItem *	item,
		int	packidx,
		int	packbits
	)

Definition at line 308 of file rvalue.c.

                                                                                    {
    rz_return_val_if_fail(reg && item, 0LL);
 
    if (packbits < 1) {
        packbits = item->packed_size;
    }
    if (packbits > 64) {
        packbits = 64;
        eprintf("Does not support pack bits > 64\n");
    }
 
    ut64 ret = 0LL;
    const int packbytes = packbits / 8;
    const int packmod = packbits % 8;
    if (packmod) {
        eprintf("Invalid bit size for packet register\n");
        return 0LL;
    }
    if ((packidx + 1) * packbits > item->size) {
        eprintf("Packed index is beyond the register size\n");
        return 0LL;
    }
    RzRegSet *regset = &reg->regset[item->arena];
    if (!regset->arena) {
        return 0LL;
    }
    int off = BITS2BYTES(item->offset);
    off += (packidx * packbytes);
    if (regset->arena->size - off - 1 >= 0) {
        int i;
        for (i = packbytes - 1; i >= 0; i--) {
            ret = (ret << 8) | regset->arena->bytes[off + i];
        }
    }
    return ret;
}

References rz_reg_item_t::arena, rz_reg_set_t::arena, BITS2BYTES, rz_reg_arena_t::bytes, eprintf, i, off, rz_reg_item_t::offset, rz_reg_item_t::packed_size, reg, rz_return_val_if_fail, rz_reg_item_t::size, rz_reg_arena_t::size, and ut64().

rz_reg_get_value()

RZ_API ut64 rz_reg_get_value	(	RzReg *	reg,
		RzRegItem *	item
	)

Definition at line 114 of file rvalue.c.

                                                          {
    rz_return_val_if_fail(reg && item, 0);
    if (!reg || !item || item->offset == -1) {
        return 0LL;
    }
    int off = BITS2BYTES(item->offset);
    RzRegSet *regset = &reg->regset[item->arena];
    if (!regset->arena) {
        return 0LL;
    }
    switch (item->size) {
    case 1: {
        int offset = item->offset / 8;
        if (offset >= regset->arena->size) {
            break;
        }
        return (regset->arena->bytes[offset] &
                   (1 << (item->offset % 8)))
            ? 1
            : 0;
    } break;
    case 4:
        if (regset->arena->size - off - 1 >= 0) {
            return (rz_read_at_ble8(regset->arena->bytes, off)) & 0xF;
        }
        break;
    case 8:
        if (regset->arena->size - off - 1 >= 0) {
            return rz_read_at_ble8(regset->arena->bytes, off);
        }
        break;
    case 16:
        if (regset->arena->size - off - 2 >= 0) {
            return rz_read_ble16(regset->arena->bytes + off, reg->big_endian);
        }
        break;
    case 27:
        if (off + 3 < regset->arena->size) {
            return rz_read_me27(regset->arena->bytes + off, 0);
        }
        break;
    case 32:
        if (off + 4 <= regset->arena->size) {
            return rz_read_ble32(regset->arena->bytes + off, reg->big_endian);
        }
        eprintf("rz_reg_get_value: 32bit oob read %d\n", off);
        break;
    case 64:
        if (regset->arena && regset->arena->bytes && (off + 8 <= regset->arena->size)) {
            return rz_read_ble64(regset->arena->bytes + off, reg->big_endian);
        }
        // eprintf ("rz_reg_get_value: null or oob arena for current regset\n");
        break;
    case 80: // long double
    case 96: // long floating value
        // FIXME: It is a precision loss, please implement me properly!
        return (ut64)rz_reg_get_longdouble(reg, item);
    case 128:
    case 256:
        // XXX 128 & 256 bit
        return (ut64)rz_reg_get_longdouble(reg, item);
    default:
        break;
    }
    return 0LL;
}

References rz_reg_item_t::arena, rz_reg_set_t::arena, BITS2BYTES, rz_reg_arena_t::bytes, eprintf, off, rz_reg_item_t::offset, reg, rz_read_at_ble8(), rz_read_ble16(), rz_read_ble32(), rz_read_ble64(), rz_read_me27(), rz_reg_get_longdouble(), rz_return_val_if_fail, rz_reg_item_t::size, rz_reg_arena_t::size, and ut64().

Referenced by agraph_refresh(), backtrace_fuzzy(), backtrace_x86_32(), backtrace_x86_32_analysis(), backtrace_x86_64(), backtrace_x86_64_analysis(), cmd_print_format(), foreach_reg_set_or_clear(), format_reg_value(), i8051_reg_read(), internal_esil_reg_read(), num_callback(), references_handler(), reg_has_changed(), regs_to_flags(), rop_classify_arithmetic(), rop_classify_arithmetic_const(), rop_classify_constant(), rop_classify_mov(), rz_analysis_value_to_ut64(), rz_core_disasm_pde(), rz_core_reg_print_diff(), rz_core_rtr_gdb_cb(), rz_debug_add_checkpoint(), rz_debug_execute(), rz_debug_num_callback(), rz_debug_qnx_reg_write(), rz_debug_trace_ins_after(), rz_debug_trace_ins_before(), rz_debug_wait(), rz_il_vm_sync_from_reg(), rz_main_rizin(), rz_reg_cond_get_value(), rz_reg_flags_handler(), rz_reg_get_bvalue(), rz_reg_get_value_by_role(), rz_reg_getv(), rz_reg_getv_by_role_or_name(), rz_regs_show_valgroup(), and show_regs_handler().

rz_reg_get_value_big()

RZ_API ut64 rz_reg_get_value_big	(	RzReg *	reg,
		RzRegItem *	item,
		utX *	val
	)

Definition at line 60 of file rvalue.c.

                                                                        {
    rz_return_val_if_fail(reg && item, 0);
 
    ut64 ret = 0LL;
    int off = BITS2BYTES(item->offset);
    RzRegSet *regset = &reg->regset[item->arena];
    if (!regset->arena) {
        return 0LL;
    }
    switch (item->size) {
    case 80: // word + qword
        if (regset->arena->bytes && (off + 10 <= regset->arena->size)) {
            val->v80.Low = *((ut64 *)(regset->arena->bytes + off));
            val->v80.High = *((ut16 *)(regset->arena->bytes + off + 8));
        } else {
            eprintf("rz_reg_get_value: null or oob arena for current regset\n");
        }
        ret = val->v80.Low;
        break;
    case 96: // dword + qword
        if (regset->arena->bytes && (off + 12 <= regset->arena->size)) {
            val->v96.Low = *((ut64 *)(regset->arena->bytes + off));
            val->v96.High = *((ut32 *)(regset->arena->bytes + off + 8));
        } else {
            eprintf("rz_reg_get_value: null or oob arena for current regset\n");
        }
        ret = val->v96.Low;
        break;
    case 128: // qword + qword
        if (regset->arena->bytes && (off + 16 <= regset->arena->size)) {
            val->v128.Low = *((ut64 *)(regset->arena->bytes + off));
            val->v128.High = *((ut64 *)(regset->arena->bytes + off + 8));
        } else {
            eprintf("rz_reg_get_value: null or oob arena for current regset\n");
        }
        ret = val->v128.Low;
        break;
    case 256: // qword + qword + qword + qword
        if (regset->arena->bytes && (off + 32 <= regset->arena->size)) {
            val->v256.Low.Low = *((ut64 *)(regset->arena->bytes + off));
            val->v256.Low.High = *((ut64 *)(regset->arena->bytes + off + 8));
            val->v256.High.Low = *((ut64 *)(regset->arena->bytes + off + 16));
            val->v256.High.High = *((ut64 *)(regset->arena->bytes + off + 24));
        } else {
            eprintf("rz_reg_get_value: null or oob arena for current regset\n");
        }
        ret = val->v256.Low.Low;
        break;
    default:
        break;
    }
    return ret;
}

References rz_reg_item_t::arena, rz_reg_set_t::arena, BITS2BYTES, rz_reg_arena_t::bytes, eprintf, off, rz_reg_item_t::offset, reg, rz_return_val_if_fail, rz_reg_item_t::size, rz_reg_arena_t::size, ut64(), and val.

Referenced by format_reg_value(), and rz_core_rtr_gdb_cb().

rz_reg_get_value_by_role()

RZ_API ut64 rz_reg_get_value_by_role	(	RzReg *	reg,
		RzRegisterId	role
	)

Definition at line 181 of file rvalue.c.

                                                                    {
    // TODO use mapping from RzRegisterId to RzRegItem (via RzRegSet)
    return rz_reg_get_value(reg, rz_reg_get(reg, rz_reg_get_name(reg, role), -1));
}

References reg, rz_reg_get(), rz_reg_get_name(), and rz_reg_get_value().

Referenced by rz_core_arg_get(), rz_core_debug_print_status(), rz_core_il_step(), and rz_il_vm_step_until_addr_handler().

rz_reg_set_bv()

RZ_API bool rz_reg_set_bv	(	RZ_NONNULL RzReg *	reg,
		RZ_NONNULL RzRegItem *	item,
		RZ_NONNULL const RzBitVector *	bv
	)

Set the value of the given register from the given bit vector

Parameters

bv	bitvector of exactly item->len bits

Returns

wether the write succeeded

Definition at line 26 of file rvalue.c.

                                                                                                               {
    rz_return_val_if_fail(reg && item && bv, false);
    if (rz_bv_len(bv) != item->size) {
        return false;
    }
    if (item->offset % 8) {
        // TODO: this needs a bit offset arg in rz_bv_set_to_bytes_be()
        if (item->size == 1) {
            // workaround for flags edge-case while the offset mentioned above is not implemented yet
            rz_reg_set_value(reg, item, rz_bv_to_ut64(bv));
            return true;
        }
        RZ_LOG_ERROR("rz_reg_set_bv() for non-byte-aligned regs not supported yet.\n");
        return false;
    }
    RzRegSet *regset = &reg->regset[item->arena];
    int boff = item->offset / 8;
    if (reg->big_endian) {
        rz_bv_set_to_bytes_be(bv, regset->arena->bytes + boff);
    } else {
        rz_bv_set_to_bytes_le(bv, regset->arena->bytes + boff);
    }
    return true;
}

References rz_reg_set_t::arena, rz_reg_arena_t::bytes, reg, rz_bv_len(), rz_bv_set_to_bytes_be(), rz_bv_set_to_bytes_le(), rz_bv_to_ut64(), RZ_LOG_ERROR, rz_reg_set_value(), and rz_return_val_if_fail.

Referenced by rz_il_vm_sync_to_reg().

rz_reg_set_bvalue()

RZ_API ut64 rz_reg_set_bvalue	(	RzReg *	reg,
		RzRegItem *	item,
		const char *	str
	)

Definition at line 279 of file rvalue.c.

                                                                            {
    ut64 num = UT64_MAX;
    if (item && item->flags && str) {
        num = rz_str_bits_from_string(str, item->flags);
        if (num == UT64_MAX) {
            num = rz_num_math(NULL, str);
        }
        rz_reg_set_value(reg, item, num);
    }
    return num;
}

References rz_reg_item_t::flags, NULL, num, reg, rz_num_math(), rz_reg_set_value(), rz_str_bits_from_string(), cmd_descs_generate::str, ut64(), and UT64_MAX.

rz_reg_set_pack()

RZ_API int rz_reg_set_pack	(	RzReg *	reg,
		RzRegItem *	item,
		int	packidx,
		int	packbits,
		ut64	val
	)

Definition at line 346 of file rvalue.c.

                                                                                             {
    rz_return_val_if_fail(reg && reg->regset->arena && item, false);
 
    if (packbits < 1) {
        packbits = item->packed_size;
    }
    if (packbits > 64) {
        packbits = 64;
        eprintf("Does not support pack bits > 64\n");
    }
 
    int packbytes = packbits / 8;
    if ((packidx + 1) * packbits > item->size) {
        eprintf("Packed index is beyond the register size\n");
        return false;
    }
    int off = BITS2BYTES(item->offset);
    off += (packidx * packbytes);
    if (reg->regset[item->arena].arena->size - BITS2BYTES(off) - BITS2BYTES(packbytes) >= 0) {
        ut8 *dst = reg->regset[item->arena].arena->bytes + off;
        int i;
        for (i = 0; i < packbytes; i++, val >>= 8) {
            dst[i] = val & 0xff;
        }
        return true;
    }
    eprintf("rz_reg_set_value: Cannot set %s to 0x%" PFMT64x "\n", item->name, val);
    return false;
}

References rz_reg_item_t::arena, BITS2BYTES, dst, eprintf, i, rz_reg_item_t::name, off, rz_reg_item_t::offset, rz_reg_item_t::packed_size, PFMT64x, reg, rz_return_val_if_fail, rz_reg_item_t::size, and val.

rz_reg_set_value()

RZ_API bool rz_reg_set_value	(	RzReg *	reg,
		RzRegItem *	item,
		ut64	value
	)

Definition at line 186 of file rvalue.c.

                                                                      {
    ut8 bytes[12];
    ut8 *src = bytes;
    bool unset_src = false;
    rz_return_val_if_fail(reg && item, false);
 
    if (rz_reg_is_readonly(reg, item)) {
        return true;
    }
    if (item->offset < 0) {
        return true;
    }
    RzRegArena *arena = reg->regset[item->arena].arena;
    if (!arena) {
        return false;
    }
    switch (item->size) {
    case 80:
    case 96: // long floating value
        rz_reg_set_longdouble(reg, item, (long double)value);
        unset_src = true;
        break;
    case 64:
        if (reg->big_endian) {
            rz_write_be64(src, value);
        } else {
            rz_write_le64(src, value);
        }
        break;
    case 32:
        if (reg->big_endian) {
            rz_write_be32(src, value);
        } else {
            rz_write_le32(src, value);
        }
        break;
    case 16:
        if (reg->big_endian) {
            rz_write_be16(src, value);
        } else {
            rz_write_le16(src, value);
        }
        break;
    case 8:
        rz_write_ble8(src, (ut8)(value & UT8_MAX));
        break;
    case 1:
        if (value) {
            ut8 *buf = arena->bytes + (item->offset / 8);
            int bit = (item->offset % 8);
            ut8 mask = (1 << bit);
            buf[0] = (buf[0] & (0xff ^ mask)) | mask;
        } else {
            int idx = item->offset / 8;
            if (idx + item->size > arena->size) {
                eprintf("RzRegSetOverflow %d vs %d\n", idx + item->size, arena->size);
                return false;
            }
            ut8 *buf = arena->bytes + idx;
            int bit = item->offset % 8;
            ut8 mask = 0xff ^ (1 << bit);
            buf[0] = (buf[0] & mask) | 0;
        }
        return true;
    case 128:
    case 256:
        // XXX 128 & 256 bit
        return false; // (ut64)rz_reg_get_longdouble (reg, item);
    default:
        RZ_LOG_ERROR("rz_reg_set_value: Bit size %d not supported\n", item->size);
        return false;
    }
    const bool fits_in_arena = (arena->size - BITS2BYTES(item->offset) - BITS2BYTES(item->size)) >= 0;
    if (!unset_src && fits_in_arena) {
        rz_mem_copybits(reg->regset[item->arena].arena->bytes +
                BITS2BYTES(item->offset),
            src, item->size);
        return true;
    }
    eprintf("rz_reg_set_value: Cannot set %s to 0x%" PFMT64x "\n", item->name, value);
    return false;
}

References rz_reg_item_t::arena, bit, BITS2BYTES, bytes, rz_reg_arena_t::bytes, eprintf, setup::idx, mask, rz_reg_item_t::name, rz_reg_item_t::offset, PFMT64x, reg, RZ_LOG_ERROR, rz_mem_copybits(), rz_reg_is_readonly(), rz_reg_set_longdouble(), rz_return_val_if_fail, rz_write_be16(), rz_write_be32(), rz_write_be64(), rz_write_ble8(), rz_write_le16(), rz_write_le32(), rz_write_le64(), rz_reg_item_t::size, rz_reg_arena_t::size, src, UT8_MAX, and value.

Referenced by _set_register(), esil_6502_init(), esil_gb_init(), fillRegisterValues(), i8051_reg_write(), internal_esil_reg_write(), internal_esil_reg_write_no_null(), pic_midrange_reg_write(), restore_register(), rop_classify_constant(), rop_classify_mov(), rz_analysis_value_set_ut64(), rz_core_analysis_set_reg(), rz_core_analysis_type_match(), rz_core_disasm_pde(), rz_core_link_stroff(), rz_core_reg_assign_sync(), rz_core_reg_set_by_role_or_name(), rz_debug_bp_hit(), rz_debug_execute(), rz_debug_reg_set(), rz_reg_cond_set(), rz_reg_set_bv(), rz_reg_set_bvalue(), rz_reg_set_value_by_role(), rz_reg_setv(), and set_retval().

rz_reg_set_value_by_role()

RZ_API bool rz_reg_set_value_by_role	(	RzReg *	reg,
		RzRegisterId	role,
		ut64	val
	)

Definition at line 269 of file rvalue.c.

                                                                              {
    // TODO use mapping from RzRegisterId to RzRegItem (via RzRegSet)
    const char *name = rz_reg_get_name(reg, role);
    if (!name) {
        return false;
    }
    RzRegItem *r = rz_reg_get(reg, name, -1);
    return rz_reg_set_value(reg, r, val);
}

References r, reg, rz_reg_get(), rz_reg_get_name(), rz_reg_set_value(), and val.

Referenced by __analysis_esil_function(), rz_core_analysis_esil_init_mem(), rz_core_analysis_esil_reinit(), and rz_core_analysis_il_reinit().