arena.c File Reference

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

Go to the source code of this file.

Functions
RZ_API ut8 *	rz_reg_get_bytes (RzReg *reg, int type, int *size)
RZ_API bool	rz_reg_read_regs (RzReg *reg, ut8 *buf, const int len)
RZ_API bool	rz_reg_set_bytes (RzReg *reg, int type, const ut8 *buf, const int len)
RZ_API int	rz_reg_fit_arena (RzReg *reg)
RZ_API RzRegArena *	rz_reg_arena_new (size_t size)
RZ_API void	rz_reg_arena_free (RzRegArena *ra)
RZ_API void	rz_reg_arena_swap (RzReg *reg, int copy)
RZ_API void	rz_reg_arena_pop (RzReg *reg)
RZ_API int	rz_reg_arena_push (RzReg *reg)
RZ_API void	rz_reg_arena_zero (RzReg *reg, RzRegisterType type)
RZ_API ut8 *	rz_reg_arena_peek (RzReg *reg)
RZ_API void	rz_reg_arena_poke (RzReg *reg, const ut8 *ret)
RZ_API ut8 *	rz_reg_arena_dup (RzReg *reg, const ut8 *source)
RZ_API int	rz_reg_arena_set_bytes (RzReg *reg, const char *str)
RZ_API void	rz_reg_arena_shrink (RzReg *reg)

Function Documentation

rz_reg_arena_dup()

RZ_API ut8* rz_reg_arena_dup	(	RzReg *	reg,
		const ut8 *	source
	)

Definition at line 301 of file arena.c.

                                                            {
    RzRegSet *regset = rz_reg_regset_get(reg, RZ_REG_TYPE_GPR);
    if (!reg || !regset || !regset->arena || (regset->arena->size < 1)) {
        return NULL;
    }
    ut8 *ret = malloc(regset->arena->size);
    if (!ret) {
        return NULL;
    }
    memcpy(ret, source, regset->arena->size);
    return ret;
}

References rz_reg_set_t::arena, malloc(), memcpy(), NULL, reg, rz_reg_regset_get(), RZ_REG_TYPE_GPR, rz_reg_arena_t::size, and source.

Referenced by get_bb_body(), and pr_bb().

rz_reg_arena_free()

RZ_API void rz_reg_arena_free

(

RzRegArena *

ra

)

Definition at line 189 of file arena.c.

                                              {
    if (ra) {
        free(ra->bytes);
        free(ra);
    }
}

References rz_reg_arena_t::bytes, and free().

Referenced by rz_analysis_esil_trace_free(), rz_analysis_rzil_trace_free(), rz_debug_checkpoint_fini(), rz_reg_arena_pop(), rz_reg_free_internal(), rz_reg_new(), and rz_reg_read_regs().

rz_reg_arena_new()

RZ_API RzRegArena* rz_reg_arena_new

(

size_t

size

)

Definition at line 170 of file arena.c.

                                                 {
    RzRegArena *arena = RZ_NEW0(RzRegArena);
    if (!arena) {
        RZ_LOG_ERROR("Failed to allocate RzRegArena.\n");
        return NULL;
    }
 
    arena->size = size;
    if (size < 1) {
        return arena;
    }
 
    if (!(arena->bytes = calloc(1, size + 8))) {
        RZ_LOG_ERROR("Failed to allocate arena bytes.\n");
        RZ_FREE(arena);
    }
    return arena;
}

References rz_reg_set_t::arena, rz_reg_arena_t::bytes, calloc(), NULL, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, and rz_reg_arena_t::size.

Referenced by deserialize_checkpoints_cb(), rz_analysis_esil_trace_new(), rz_analysis_rzil_trace_new(), rz_debug_add_checkpoint(), rz_reg_arena_push(), and rz_reg_new().

rz_reg_arena_peek()

RZ_API ut8* rz_reg_arena_peek

(

RzReg *

reg

)

Definition at line 280 of file arena.c.

                                          {
    RzRegSet *regset = rz_reg_regset_get(reg, RZ_REG_TYPE_GPR);
    if (!reg || !regset || !regset->arena || (regset->arena->size < 1)) {
        return NULL;
    }
    ut8 *ret = malloc(regset->arena->size);
    if (!ret) {
        return NULL;
    }
    memcpy(ret, regset->arena->bytes, regset->arena->size);
    return ret;
}

References rz_reg_set_t::arena, rz_reg_arena_t::bytes, malloc(), memcpy(), NULL, reg, rz_reg_regset_get(), RZ_REG_TYPE_GPR, and rz_reg_arena_t::size.

Referenced by backtrace_windows(), core_walk_function_blocks(), ds_print_esil_analysis_fini(), ds_print_esil_analysis_init(), func_walk_blocks(), get_bbnodes(), get_bbupdate(), and rz_core_analysis_types_propagation().

rz_reg_arena_poke()

RZ_API void rz_reg_arena_poke	(	RzReg *	reg,
		const ut8 *	ret
	)

Definition at line 293 of file arena.c.

                                                          {
    RzRegSet *regset = rz_reg_regset_get(reg, RZ_REG_TYPE_GPR);
    if (!ret || !regset || !regset->arena || !regset->arena->bytes) {
        return;
    }
    memcpy(regset->arena->bytes, ret, regset->arena->size);
}

References rz_reg_set_t::arena, rz_reg_arena_t::bytes, memcpy(), reg, rz_reg_regset_get(), RZ_REG_TYPE_GPR, and rz_reg_arena_t::size.

Referenced by core_walk_function_blocks(), ds_print_esil_analysis_fini(), func_walk_blocks(), get_bb_body(), get_bbnodes(), get_bbupdate(), pr_bb(), and rz_core_analysis_types_propagation().

rz_reg_arena_pop()

RZ_API void rz_reg_arena_pop

(

RzReg *

reg

)

Definition at line 216 of file arena.c.

                                         {
    RzRegArena *a;
    int i;
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        if (!reg->regset[i].pool) {
            continue;
        }
        if (rz_list_length(reg->regset[i].pool) < 2) {
            continue;
        }
        a = rz_list_pop(reg->regset[i].pool);
        rz_reg_arena_free(a);
        a = reg->regset[i].pool->tail->data;
        if (a) {
            reg->regset[i].arena = a;
            reg->regset[i].cur = reg->regset[i].pool->tail;
        }
    }
}

References a, i, reg, rz_list_length(), rz_list_pop(), rz_reg_arena_free(), and RZ_REG_TYPE_LAST.

Referenced by cmd_aea(), fillRegisterValues(), get_next_i(), rz_cmd_debug(), rz_core_analysis_esil(), rz_core_analysis_types_propagation(), rz_core_disasm_pde(), rz_core_link_stroff(), rz_core_print_disasm(), rz_core_print_disasm_instructions_with_buf(), rz_reg_arenas_pop_handler(), and rz_reg_set_profile_string().

rz_reg_arena_push()

RZ_API int rz_reg_arena_push

(

RzReg *

reg

)

Definition at line 236 of file arena.c.

                                         {
    int i;
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        RzRegArena *a = reg->regset[i].arena; // current arena
        if (!a) {
            continue;
        }
        RzRegArena *b = rz_reg_arena_new(a->size); // new arena
        if (!b) {
            continue;
        }
        // b->size == a->size always because of how rz_reg_arena_new behave
        if (a->bytes) {
            memcpy(b->bytes, a->bytes, b->size);
        }
        rz_list_push(reg->regset[i].pool, b);
        reg->regset[i].arena = b;
        reg->regset[i].cur = reg->regset[i].pool->tail;
    }
    if (reg->regset[0].pool) {
        return rz_list_length(reg->regset[0].pool);
    }
    return 0;
}

References a, b, i, memcpy(), reg, rz_list_length(), rz_list_push(), rz_reg_arena_new(), and RZ_REG_TYPE_LAST.

Referenced by cmd_aea(), fillRegisterValues(), get_next_i(), rz_cmd_debug(), rz_core_analysis_esil(), rz_core_analysis_types_propagation(), rz_core_disasm_pde(), rz_core_link_stroff(), rz_core_print_disasm(), rz_core_print_disasm_instructions_with_buf(), rz_reg_arenas_push_handler(), rz_reg_new(), and rz_reg_set_profile_string().

rz_reg_arena_set_bytes()

RZ_API int rz_reg_arena_set_bytes	(	RzReg *	reg,
		const char *	str
	)

Definition at line 314 of file arena.c.

                                                               {
    str = rz_str_trim_head_ro(str);
    int len = rz_hex_str_is_valid(str);
    if (len == -1) {
        eprintf("Invalid input\n");
        return -1;
    }
    int bin_str_len = (len + 1) / 2; // 2 hex chrs for 1 byte
    ut8 *bin_str = malloc(bin_str_len);
    if (!bin_str) {
        eprintf("Failed to decode hex str.\n");
        return -1;
    }
    rz_hex_str2bin(str, bin_str);
 
    int i, n = 0; // n - cumulative sum of arena's sizes
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        int sz = reg->regset[i].arena->size;
        int bl = bin_str_len - n; // bytes left
        int bln = bl - n;
        if (bln > 0 && bln < sz) {
            rz_reg_set_bytes(reg, i, bin_str + n, bln);
            break;
        }
        rz_reg_set_bytes(reg, i, bin_str + n, bin_str_len - n);
        n += sz;
    }
    free(bin_str);
    return 0;
}

References bl(), eprintf, free(), i, len, malloc(), n, reg, rz_hex_str2bin(), rz_hex_str_is_valid(), rz_reg_set_bytes(), RZ_REG_TYPE_LAST, rz_str_trim_head_ro(), and cmd_descs_generate::str.

Referenced by rz_core_bin_load().

rz_reg_arena_shrink()

RZ_API void rz_reg_arena_shrink

(

RzReg *

reg

)

Definition at line 345 of file arena.c.

                                            {
    RzListIter *iter;
    RzRegArena *a;
    int i;
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        rz_list_foreach (reg->regset[i].pool, iter, a) {
            free(a->bytes);
            /* ha ha ha */
            a->bytes = calloc(1024, 1);
            a->size = 1024;
            /* looks like sizing down the arena breaks the regsync */
            /* and sizing it up fixes reallocation when fit() is called */
        }
    }
}

References a, calloc(), free(), i, reg, and RZ_REG_TYPE_LAST.

Referenced by rz_reg_set_profile_string().

rz_reg_arena_swap()

RZ_API void rz_reg_arena_swap	(	RzReg *	reg,
		int	copy
	)

Definition at line 196 of file arena.c.

                                                    {
    /* XXX: swap current arena to head(previous arena) */
    int i;
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        if (!reg->regset[i].pool) {
            continue;
        }
        if (rz_list_length(reg->regset[i].pool) > 1) {
            RzListIter *ia = reg->regset[i].cur;
            RzListIter *ib = reg->regset[i].pool->head;
            void *tmp = ia->data;
            ia->data = ib->data;
            ib->data = tmp;
            reg->regset[i].arena = ia->data;
        } else {
            break;
        }
    }
}

References rz_list_iter_t::data, i, reg, rz_list_length(), RZ_REG_TYPE_LAST, and autogen_x86imm::tmp.

Referenced by cmd_debug_backtrace(), cmd_debug_cont_syscall(), debug_trace_calls(), reg_has_changed(), rop_classify_arithmetic(), rop_classify_arithmetic_const(), rop_classify_constant(), rop_classify_mov(), rz_cmd_debug_continue_call_handler(), rz_cmd_debug_continue_exception_handler(), rz_cmd_debug_continue_ret_handler(), rz_cmd_debug_continue_send_signal_handler(), rz_cmd_debug_step_line_handler(), rz_cmd_debug_step_prog_handler(), rz_cmd_debug_step_until_handler(), rz_core_debug_continue(), rz_core_debug_continue_until(), rz_core_debug_single_step_over(), rz_core_debug_step_one(), rz_core_debug_step_over(), rz_core_debug_step_skip(), rz_core_reg_print_diff(), rz_debug_select(), rz_reg_arenas_swap_handler(), and rz_regs_prev_handler().

rz_reg_arena_zero()

RZ_API void rz_reg_arena_zero	(	RzReg *	reg,
		RzRegisterType	type
	)

Definition at line 261 of file arena.c.

                                                               {
    rz_return_if_fail(type < RZ_REG_TYPE_LAST || type == RZ_REG_TYPE_ANY);
    if (type >= 0 && type < RZ_REG_TYPE_LAST) {
        RzRegArena *a = reg->regset[type].arena;
        if (!a || !a->bytes) {
            return;
        }
        memset(a->bytes, 0, a->size);
        return;
    }
    int i;
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        RzRegArena *a = reg->regset[i].arena;
        if (a && a->bytes) {
            memset(a->bytes, 0, a->size);
        }
    }
}

References a, i, memset(), reg, RZ_REG_TYPE_ANY, RZ_REG_TYPE_LAST, rz_return_if_fail, and type.

Referenced by rz_core_analysis_types_propagation(), rz_core_link_stroff(), and rz_reg_arenas_zero_handler().

rz_reg_fit_arena()

RZ_API int rz_reg_fit_arena

(

RzReg *

reg

)

Definition at line 135 of file arena.c.

                                        {
    RzRegArena *arena;
    RzListIter *iter;
    RzRegItem *r;
    int size, i, newsize;
 
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        arena = reg->regset[i].arena;
        if (!arena) {
            continue;
        }
        newsize = 0;
        rz_list_foreach (reg->regset[i].regs, iter, r) {
            // XXX: bits2bytes doesnt seems to work fine
            size = BITS2BYTES(r->offset + r->size);
            newsize = RZ_MAX(size, newsize);
        }
        if (newsize < 1) {
            RZ_FREE(arena->bytes);
            arena->size = 0;
        } else {
            ut8 *buf = realloc(arena->bytes, newsize);
            if (buf) {
                arena->size = newsize;
                arena->bytes = buf;
                memset(arena->bytes, 0, arena->size);
            } else {
                arena->bytes = NULL;
                arena->size = 0;
            }
        }
    }
    return true;
}

References rz_reg_set_t::arena, BITS2BYTES, rz_reg_arena_t::bytes, i, memset(), NULL, r, realloc(), reg, RZ_FREE, RZ_MAX, RZ_REG_TYPE_LAST, and rz_reg_arena_t::size.

Referenced by rz_reg_set_profile_string().

rz_reg_get_bytes()

RZ_API ut8* rz_reg_get_bytes	(	RzReg *	reg,
		int	type,
		int *	size
	)

Definition at line 8 of file arena.c.

                                                              {
    RzRegArena *arena;
    int i, sz, osize;
    ut8 *buf, *newbuf;
    if (size) {
        *size = 0;
    }
    if (type == -1) {
        /* serialize ALL register types in a single buffer */
        // owned buffer is returned
        osize = sz = 0;
        buf = malloc(8);
        if (!buf) {
            return NULL;
        }
        for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
            arena = reg->regset[i].arena;
            sz += arena->size;
            newbuf = realloc(buf, sz);
            if (!newbuf) {
                break;
            }
            buf = newbuf;
            memcpy(buf + osize, arena->bytes, arena->size);
            osize = sz;
        }
        if (size) {
            *size = sz;
        }
        return buf;
    }
    if (type < 0 || type > (RZ_REG_TYPE_LAST - 1)) {
        return NULL;
    }
    sz = reg->regset[type].arena->size;
    if (size) {
        *size = sz;
    }
    if (!sz) {
        return NULL;
    }
    buf = malloc(sz);
    if (buf) {
        memcpy(buf, reg->regset[type].arena->bytes, sz);
    }
    return buf;
}

References rz_reg_arena_t::bytes, i, malloc(), memcpy(), NULL, realloc(), reg, RZ_REG_TYPE_LAST, rz_reg_arena_t::size, and type.

Referenced by __reg_read(), backtrace_windows_x64(), rz_debug_execute(), rz_debug_gdb_reg_read(), rz_debug_gdb_reg_write(), rz_debug_qnx_reg_read(), rz_debug_qnx_reg_write(), rz_debug_reg_sync(), and rz_reg_arenas_hexdump_handler().

rz_reg_read_regs()

RZ_API bool rz_reg_read_regs	(	RzReg *	reg,
		ut8 *	buf,
		const int	len
	)

Definition at line 58 of file arena.c.

                                                                  {
    int i, off = 0;
    RzRegArena *arena;
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        if (reg->regset[i].arena) {
            arena = reg->regset[i].arena;
        } else {
            arena = reg->regset[i].arena = RZ_NEW0(RzRegArena);
            if (!arena) {
                return false;
            }
            arena->size = len;
            arena->bytes = calloc(1, len);
            if (!arena->bytes) {
                rz_reg_arena_free(arena);
                return false;
            }
        }
        if (!arena->bytes) {
            arena->size = 0;
            return false;
        }
        memset(arena->bytes, 0, arena->size);
        memcpy(arena->bytes, buf + off,
            RZ_MIN(len - off, arena->size));
        off += arena->size;
        if (off > len) {
            return false;
        }
    }
    return true;
}

References rz_reg_arena_t::bytes, calloc(), i, len, memcpy(), memset(), off, reg, RZ_MIN, RZ_NEW0, rz_reg_arena_free(), RZ_REG_TYPE_LAST, and rz_reg_arena_t::size.

Referenced by rz_debug_execute().

rz_reg_set_bytes()

RZ_API bool rz_reg_set_bytes	(	RzReg *	reg,
		int	type,
		const ut8 *	buf,
		const int	len
	)

Definition at line 92 of file arena.c.

                                                                                  {
    int maxsz, minsz;
    struct rz_reg_set_t *regset;
    RzRegArena *arena;
    if (len < 1 || !buf) {
        return false;
    }
    if (type < 0 || type >= RZ_REG_TYPE_LAST) {
        return false;
    }
    regset = &reg->regset[type];
    arena = regset->arena;
    if (!arena) {
        return false;
    }
    maxsz = RZ_MAX(arena->size, len);
    minsz = RZ_MIN(arena->size, len);
    if ((arena->size != len) || (!arena->bytes)) {
        free(arena->bytes);
        arena->bytes = calloc(1, maxsz);
        if (!arena->bytes) {
            arena->size = 0;
            return false;
        }
        arena->size = maxsz;
    }
    if (arena->size != maxsz) {
        ut8 *tmp = realloc(arena->bytes, maxsz);
        if (!tmp) {
            eprintf("Error resizing arena to %d\n", len);
            return false;
        }
        arena->size = maxsz;
        arena->bytes = tmp;
    }
    if (arena->bytes) {
        memset(arena->bytes, 0, arena->size);
        memcpy(arena->bytes, buf, minsz);
        return true;
    }
    return false;
}

References rz_reg_set_t::arena, rz_reg_arena_t::bytes, calloc(), eprintf, free(), len, memcpy(), memset(), realloc(), reg, RZ_MAX, RZ_MIN, RZ_REG_TYPE_LAST, rz_reg_arena_t::size, autogen_x86imm::tmp, and type.

Referenced by rz_debug_reg_sync(), and rz_reg_arena_set_bytes().