esil_trace.c File Reference

#include <rz_analysis.h>

Go to the source code of this file.

Macros
#define	CMP_REG_CHANGE(x, y)   ((x) - ((RzAnalysisEsilRegChange *)(y))->idx)
#define	CMP_MEM_CHANGE(x, y)   ((x) - ((RzAnalysisEsilMemChange *)(y))->idx)

Functions
static bool	esil_add_mem_trace (RzAnalysisEsilTrace *etrace, RzILTraceMemOp *mem)
static bool	esil_add_reg_trace (RzAnalysisEsilTrace *etrace, RzILTraceRegOp *reg)
static void	htup_vector_free (HtUPKv *kv)
RZ_API RzAnalysisEsilTrace *	rz_analysis_esil_trace_new (RzAnalysisEsil *esil)
RZ_API void	rz_analysis_esil_trace_free (RzAnalysisEsilTrace *trace)
static void	add_reg_change (RzAnalysisEsilTrace *trace, int idx, RzRegItem *ri, ut64 data)
static void	add_mem_change (RzAnalysisEsilTrace *trace, int idx, ut64 addr, ut8 data)
static int	trace_hook_reg_read (RzAnalysisEsil *esil, const char *name, ut64 *res, int *size)
static int	trace_hook_reg_write (RzAnalysisEsil *esil, const char *name, ut64 *val)
static int	trace_hook_mem_read (RzAnalysisEsil *esil, ut64 addr, ut8 *buf, int len)
static int	trace_hook_mem_write (RzAnalysisEsil *esil, ut64 addr, const ut8 *buf, int len)
RZ_API RZ_BORROW RzILTraceInstruction *	rz_analysis_esil_get_instruction_trace (RZ_NONNULL RzAnalysisEsilTrace *etrace, int idx)
RZ_API void	rz_analysis_esil_trace_op (RzAnalysisEsil *esil, RZ_NONNULL RzAnalysisOp *op)
static bool	restore_memory_cb (void *user, const ut64 key, const void *value)
static bool	restore_register (RzAnalysisEsil *esil, RzRegItem *ri, int idx)
RZ_API void	rz_analysis_esil_trace_restore (RzAnalysisEsil *esil, int idx)
static void	print_instruction_ops (RzILTraceInstruction *instruction, int idx, RzILTraceInsOp focus)
static void	print_instruction_trace (RzILTraceInstruction *instruction, int idx)
RZ_API void	rz_analysis_esil_trace_list (RzAnalysisEsil *esil)
RZ_API void	rz_analysis_esil_trace_show (RzAnalysisEsil *esil, int idx)

Variables
static int	ocbs_set = false
static RzAnalysisEsilCallbacks	ocbs = { 0 }

Macro Definition Documentation

CMP_MEM_CHANGE

#define CMP_MEM_CHANGE	(		x,
			y
	)		((x) - ((RzAnalysisEsilMemChange *)(y))->idx)

Definition at line 8 of file esil_trace.c.

CMP_REG_CHANGE

#define CMP_REG_CHANGE	(		x,
			y
	)		((x) - ((RzAnalysisEsilRegChange *)(y))->idx)

Definition at line 7 of file esil_trace.c.

Function Documentation

add_mem_change()

static void add_mem_change ( RzAnalysisEsilTrace *  trace, int  idx, ut64  addr, ut8  data  )

static

Definition at line 110 of file esil_trace.c.

                                                                                     {
    RzVector *vmem = ht_up_find(trace->memory, addr, NULL);
    if (!vmem) {
        vmem = rz_vector_new(sizeof(RzAnalysisEsilMemChange), NULL, NULL);
        if (!vmem) {
            RZ_LOG_ERROR("Creating a memory vector.\n");
            return;
        }
        ht_up_insert(trace->memory, addr, vmem);
    }
    RzAnalysisEsilMemChange mem = { idx, data };
    rz_vector_push(vmem, &mem);
}

References addr, setup::idx, mem, rz_analysis_esil_trace_t::memory, NULL, RZ_LOG_ERROR, rz_vector_new(), and rz_vector_push().

Referenced by trace_hook_mem_write().

add_reg_change()

static void add_reg_change ( RzAnalysisEsilTrace *  trace, int  idx, RzRegItem *  ri, ut64  data  )

static

Definition at line 95 of file esil_trace.c.

                                                                                          {
    ut64 addr = ri->offset | (ri->arena << 16);
    RzVector *vreg = ht_up_find(trace->registers, addr, NULL);
    if (!vreg) {
        vreg = rz_vector_new(sizeof(RzAnalysisEsilRegChange), NULL, NULL);
        if (!vreg) {
            RZ_LOG_ERROR("Creating a register vector.\n");
            return;
        }
        ht_up_insert(trace->registers, addr, vreg);
    }
    RzAnalysisEsilRegChange reg = { idx, data };
    rz_vector_push(vreg, &reg);
}

References addr, rz_reg_item_t::arena, setup::idx, NULL, rz_reg_item_t::offset, reg, rz_analysis_esil_trace_t::registers, RZ_LOG_ERROR, rz_vector_new(), rz_vector_push(), and ut64().

Referenced by rz_analysis_esil_trace_op(), and trace_hook_reg_write().

esil_add_mem_trace()

static bool esil_add_mem_trace ( RzAnalysisEsilTrace *  etrace, RzILTraceMemOp *  mem  )

inlinestatic

Definition at line 14 of file esil_trace.c.

                                                                                        {
    RzILTraceInstruction *instr_trace = rz_analysis_esil_get_instruction_trace(etrace, etrace->idx);
    return rz_analysis_il_trace_add_mem(instr_trace, mem);
}

References rz_analysis_esil_trace_t::idx, mem, rz_analysis_esil_get_instruction_trace(), and rz_analysis_il_trace_add_mem().

Referenced by trace_hook_mem_read(), and trace_hook_mem_write().

esil_add_reg_trace()

static bool esil_add_reg_trace ( RzAnalysisEsilTrace *  etrace, RzILTraceRegOp *  reg  )

inlinestatic

Definition at line 19 of file esil_trace.c.

                                                                                        {
    RzILTraceInstruction *instr_trace = rz_analysis_esil_get_instruction_trace(etrace, etrace->idx);
    return rz_analysis_il_trace_add_reg(instr_trace, reg);
}

References rz_analysis_esil_trace_t::idx, reg, rz_analysis_esil_get_instruction_trace(), and rz_analysis_il_trace_add_reg().

Referenced by trace_hook_reg_read(), and trace_hook_reg_write().

htup_vector_free()

static void htup_vector_free ( HtUPKv *  kv )

static

Definition at line 24 of file esil_trace.c.

                                         {
    rz_vector_free(kv->value);
}

References rz_vector_free().

Referenced by rz_analysis_esil_trace_new().

print_instruction_ops()

static void print_instruction_ops ( RzILTraceInstruction *  instruction, int  idx, RzILTraceInsOp  focus  )

static

Definition at line 375 of file esil_trace.c.

                                                                                                    {
    bool reg = focus == RZ_IL_TRACE_INS_HAS_REG_R || focus == RZ_IL_TRACE_INS_HAS_REG_W;
    bool read = focus == RZ_IL_TRACE_INS_HAS_REG_R || focus == RZ_IL_TRACE_INS_HAS_MEM_R;
    const char *direction = read ? "read" : "write";
    void **it;
    bool first = true;
 
    if (reg) {
        RzPVector *ops = read ? instruction->read_reg_ops : instruction->write_reg_ops;
        if (!rz_pvector_empty(ops)) {
            rz_cons_printf("%d.reg.%s=", idx, direction);
            rz_pvector_foreach (ops, it) {
                RzILTraceRegOp *op = (RzILTraceRegOp *)*it;
                first ? (first = false) : rz_cons_print(",");
                rz_cons_printf("%s", op->reg_name);
            }
            rz_cons_newline();
        }
        rz_pvector_foreach (ops, it) {
            RzILTraceRegOp *op = (RzILTraceRegOp *)*it;
            rz_cons_printf("%d.reg.%s.%s=%s%" PFMT64x "\n", idx, direction,
                op->reg_name, op->value < 10 ? "" : "0x", op->value);
        }
    } else {
        RzPVector *ops = read ? instruction->read_mem_ops : instruction->write_mem_ops;
        if (!rz_pvector_empty(ops)) {
            rz_cons_printf("%d.mem.%s=", idx, direction);
            rz_pvector_foreach (ops, it) {
                RzILTraceMemOp *op = (RzILTraceMemOp *)*it;
                first ? (first = false) : rz_cons_print(",");
                rz_cons_printf("0x%" PFMT64x, op->addr);
            }
            rz_cons_newline();
        }
        rz_pvector_foreach (ops, it) {
            RzILTraceMemOp *op = (RzILTraceMemOp *)*it;
            char hexstr[sizeof(op->data_buf) * 2 + 1];
            rz_hex_bin2str(op->data_buf, RZ_MIN(sizeof(op->data_buf), op->data_len), hexstr);
            rz_cons_printf("%d.mem.%s.data.0x%" PFMT64x "=%s\n", idx, direction, op->addr, hexstr);
        }
    }
}

References setup::idx, ops, PFMT64x, read(), reg, rz_cons_newline(), rz_cons_printf(), rz_hex_bin2str(), RZ_MIN, rz_pvector_empty(), and rz_pvector_foreach.

Referenced by print_instruction_trace().

print_instruction_trace()

static void print_instruction_trace ( RzILTraceInstruction *  instruction, int  idx  )

static

Definition at line 418 of file esil_trace.c.

                                                                                {
    rz_cons_printf("%d.addr=0x%" PFMT64x "\n", idx, instruction->addr);
 
    // IL ops within an instruction are printed in the order reg read, mem
    // read, reg write, mem write that is partially based on x86 PUSH. This
    // print order MAY NOT be the same as the actual ops order.
    print_instruction_ops(instruction, idx, RZ_IL_TRACE_INS_HAS_REG_R);
    print_instruction_ops(instruction, idx, RZ_IL_TRACE_INS_HAS_MEM_R);
    print_instruction_ops(instruction, idx, RZ_IL_TRACE_INS_HAS_REG_W);
    print_instruction_ops(instruction, idx, RZ_IL_TRACE_INS_HAS_MEM_W);
}

References setup::idx, PFMT64x, print_instruction_ops(), and rz_cons_printf().

Referenced by rz_analysis_esil_trace_list(), and rz_analysis_esil_trace_show().

restore_memory_cb()

static bool restore_memory_cb ( void *  user, const ut64  key, const void *  value  )

static

Definition at line 321 of file esil_trace.c.

                                                                             {
    size_t index;
    RzAnalysisEsil *esil = user;
    RzVector *vmem = (RzVector *)value;
 
    rz_vector_upper_bound(vmem, esil->trace->idx, index, CMP_MEM_CHANGE);
    if (index > 0 && index <= vmem->len) {
        RzAnalysisEsilMemChange *c = rz_vector_index_ptr(vmem, index - 1);
        esil->analysis->iob.write_at(esil->analysis->iob.io, key, &c->data, 1);
    }
    return true;
}

References rz_analysis_esil_t::analysis, c, CMP_MEM_CHANGE, rz_analysis_esil_trace_t::idx, rz_io_bind_t::io, rz_analysis_t::iob, key, len, rz_vector_index_ptr(), rz_vector_upper_bound, rz_analysis_esil_t::trace, value, and rz_io_bind_t::write_at.

Referenced by rz_analysis_esil_trace_restore().

restore_register()

static bool restore_register ( RzAnalysisEsil *  esil, RzRegItem *  ri, int  idx  )

static

Definition at line 334 of file esil_trace.c.

                                                                           {
    size_t index;
    RzVector *vreg = ht_up_find(esil->trace->registers, ri->offset | (ri->arena << 16), NULL);
    if (vreg) {
        rz_vector_upper_bound(vreg, idx, index, CMP_REG_CHANGE);
        if (index > 0 && index <= vreg->len) {
            RzAnalysisEsilRegChange *c = rz_vector_index_ptr(vreg, index - 1);
            rz_reg_set_value(esil->analysis->reg, ri, c->data);
        }
    }
    return true;
}

References rz_analysis_esil_t::analysis, rz_reg_item_t::arena, c, CMP_REG_CHANGE, setup::idx, len, NULL, rz_reg_item_t::offset, rz_analysis_t::reg, rz_analysis_esil_trace_t::registers, rz_reg_set_value(), rz_vector_index_ptr(), rz_vector_upper_bound, and rz_analysis_esil_t::trace.

Referenced by rz_analysis_esil_trace_restore().

rz_analysis_esil_get_instruction_trace()

RZ_API RZ_BORROW RzILTraceInstruction* rz_analysis_esil_get_instruction_trace	(	RZ_NONNULL RzAnalysisEsilTrace *	etrace,
		int	idx
	)

Get instruction trace from ESIL trace by index

Parameters

etrace	RzAnalysisEsilTrace *, ESIL trace
idx	int, index of instruction

Returns

RzILTraceInstruction *, instruction trace at index

Definition at line 263 of file esil_trace.c.

                                                                                                                               {
    rz_return_val_if_fail(etrace, NULL);
    if (idx < 0 || idx >= rz_pvector_len(etrace->instructions)) {
        return NULL;
    }
    return rz_pvector_at(etrace->instructions, idx);
}

References setup::idx, NULL, rz_pvector_at(), rz_pvector_len(), and rz_return_val_if_fail.

Referenced by esil_add_mem_trace(), esil_add_reg_trace(), get_addr(), handle_stack_canary(), propagate_types_among_used_variables(), rz_analysis_esil_trace_show(), and type_match().

rz_analysis_esil_trace_free()

RZ_API void rz_analysis_esil_trace_free

(

RzAnalysisEsilTrace *

trace

)

Definition at line 79 of file esil_trace.c.

                                                                    {
    if (!trace) {
        return;
    }
    size_t i;
    ht_up_free(trace->registers);
    ht_up_free(trace->memory);
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        rz_reg_arena_free(trace->arena[i]);
    }
    free(trace->stack_data);
    rz_pvector_free(trace->instructions);
    trace->instructions = NULL;
    RZ_FREE(trace);
}

References rz_analysis_esil_trace_t::arena, free(), i, rz_analysis_esil_trace_t::instructions, rz_analysis_esil_trace_t::memory, NULL, rz_analysis_esil_trace_t::registers, RZ_FREE, rz_pvector_free(), rz_reg_arena_free(), RZ_REG_TYPE_LAST, and rz_analysis_esil_trace_t::stack_data.

Referenced by analysis_emul_restore(), rz_analysis_esil_free(), rz_analysis_esil_trace_new(), rz_analysis_rzil_trace_new(), and rz_core_analysis_esil_trace_stop().

rz_analysis_esil_trace_list()

RZ_API void rz_analysis_esil_trace_list

(

RzAnalysisEsil *

esil

)

List all traces

Parameters

esil	RzAnalysisEsil *, ESIL instance

Definition at line 434 of file esil_trace.c.

                                                              {
    rz_return_if_fail(esil);
    if (!esil->trace) {
        return;
    }
 
    RzILTraceInstruction *instruction_trace;
    int idx = 0;
    void **iter;
    rz_pvector_foreach (esil->trace->instructions, iter) {
        instruction_trace = *iter;
        print_instruction_trace(instruction_trace, idx);
        idx++;
    }
    rz_cons_printf("idx=%d\n", idx - 1);
}

References setup::idx, rz_analysis_esil_trace_t::instructions, print_instruction_trace(), rz_cons_printf(), rz_pvector_foreach, rz_return_if_fail, and rz_analysis_esil_t::trace.

Referenced by rz_cmd_debug_trace_esils_handler().

rz_analysis_esil_trace_new()

RZ_API RzAnalysisEsilTrace* rz_analysis_esil_trace_new

(

RzAnalysisEsil *

esil

)

Definition at line 28 of file esil_trace.c.

                                                                             {
    rz_return_val_if_fail(esil && esil->stack_addr && esil->stack_size, NULL);
    size_t i;
    RzAnalysisEsilTrace *trace = RZ_NEW0(RzAnalysisEsilTrace);
    if (!trace) {
        return NULL;
    }
    trace->registers = ht_up_new(NULL, htup_vector_free, NULL);
    if (!trace->registers) {
        RZ_LOG_ERROR("esil: Cannot allocate hashmap for trace registers\n");
        goto error;
    }
    trace->memory = ht_up_new(NULL, htup_vector_free, NULL);
    if (!trace->memory) {
        RZ_LOG_ERROR("esil: Cannot allocate hashmap for trace memory\n");
        goto error;
    }
    trace->instructions = rz_pvector_new((RzPVectorFree)rz_analysis_il_trace_instruction_free);
    if (!trace->instructions) {
        RZ_LOG_ERROR("esil: Cannot allocate vector for trace instructions\n");
        goto error;
    }
    // Save initial ESIL stack memory
    trace->stack_addr = esil->stack_addr;
    trace->stack_size = esil->stack_size;
    trace->stack_data = malloc(esil->stack_size);
    if (!trace->stack_data) {
        RZ_LOG_ERROR("esil: Cannot allocate stack for trace\n");
        goto error;
    }
    esil->analysis->iob.read_at(esil->analysis->iob.io, trace->stack_addr,
        trace->stack_data, trace->stack_size);
    // Save initial registers arenas
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        RzRegArena *a = esil->analysis->reg->regset[i].arena;
        RzRegArena *b = rz_reg_arena_new(a->size);
        if (!b) {
            RZ_LOG_ERROR("esil: Cannot allocate register arena for trace\n");
            goto error;
        }
        if (b->bytes && a->bytes && b->size > 0) {
            memcpy(b->bytes, a->bytes, b->size);
        }
        trace->arena[i] = b;
    }
    return trace;
error:
    rz_analysis_esil_trace_free(trace);
    return NULL;
}

References a, rz_analysis_esil_t::analysis, rz_analysis_esil_trace_t::arena, rz_reg_set_t::arena, b, error(), htup_vector_free(), i, rz_analysis_esil_trace_t::instructions, rz_io_bind_t::io, rz_analysis_t::iob, malloc(), memcpy(), rz_analysis_esil_trace_t::memory, NULL, rz_io_bind_t::read_at, rz_analysis_t::reg, rz_analysis_esil_trace_t::registers, rz_reg_t::regset, rz_analysis_esil_trace_free(), rz_analysis_il_trace_instruction_free(), RZ_LOG_ERROR, RZ_NEW0, rz_pvector_new(), rz_reg_arena_new(), RZ_REG_TYPE_LAST, rz_return_val_if_fail, rz_analysis_esil_trace_t::stack_addr, rz_analysis_esil_t::stack_addr, rz_analysis_esil_trace_t::stack_data, rz_analysis_esil_trace_t::stack_size, and rz_analysis_esil_t::stack_size.

Referenced by analysis_emul_init(), rz_analysis_esil_trace_op(), and rz_core_analysis_esil_trace_start().

rz_analysis_esil_trace_op()

RZ_API void rz_analysis_esil_trace_op	(	RzAnalysisEsil *	esil,
		RZ_NONNULL RzAnalysisOp *	op
	)

Definition at line 271 of file esil_trace.c.

                                                                                         {
    rz_return_if_fail(esil && op);
    const char *expr = rz_strbuf_get(&op->esil);
    if (RZ_STR_ISEMPTY(expr)) {
        // do nothing
        return;
    }
    if (!esil->trace) {
        esil->trace = rz_analysis_esil_trace_new(esil);
        if (!esil->trace) {
            return;
        }
    }
    /* restore from trace when `idx` is not at the end */
    if (esil->trace->idx != esil->trace->end_idx) {
        rz_analysis_esil_trace_restore(esil, esil->trace->idx + 1);
        return;
    }
    /* save old callbacks */
    int esil_verbose = esil->verbose;
    if (ocbs_set) {
        RZ_LOG_ERROR("esil: Cannot call recursively\n");
    }
    ocbs = esil->cb;
    ocbs_set = true;
 
    RzILTraceInstruction *instruction = rz_analysis_il_trace_instruction_new(op->addr);
    rz_pvector_push(esil->trace->instructions, instruction);
 
    RzRegItem *pc_ri = rz_reg_get(esil->analysis->reg, "PC", -1);
    add_reg_change(esil->trace, esil->trace->idx, pc_ri, op->addr);
    /* set hooks */
    esil->verbose = 0;
    esil->cb.hook_reg_read = trace_hook_reg_read;
    esil->cb.hook_reg_write = trace_hook_reg_write;
    esil->cb.hook_mem_read = trace_hook_mem_read;
    esil->cb.hook_mem_write = trace_hook_mem_write;
 
    /* evaluate esil expression */
    rz_analysis_esil_parse(esil, expr);
    rz_analysis_esil_stack_free(esil);
    /* restore hooks */
    esil->cb = ocbs;
    ocbs_set = false;
    esil->verbose = esil_verbose;
    /* increment idx */
    esil->trace->idx++;
    esil->trace->end_idx++;
}

References add_reg_change(), rz_analysis_esil_t::analysis, rz_analysis_esil_t::cb, rz_analysis_esil_trace_t::end_idx, expr(), rz_analysis_esil_callbacks_t::hook_mem_read, rz_analysis_esil_callbacks_t::hook_mem_write, rz_analysis_esil_callbacks_t::hook_reg_read, rz_analysis_esil_callbacks_t::hook_reg_write, rz_analysis_esil_trace_t::idx, rz_analysis_esil_trace_t::instructions, ocbs, ocbs_set, rz_analysis_t::reg, rz_analysis_esil_parse(), rz_analysis_esil_stack_free(), rz_analysis_esil_trace_new(), rz_analysis_esil_trace_restore(), rz_analysis_il_trace_instruction_new(), RZ_LOG_ERROR, rz_pvector_push(), rz_reg_get(), rz_return_if_fail, RZ_STR_ISEMPTY, rz_strbuf_get(), rz_analysis_esil_t::trace, trace_hook_mem_read(), trace_hook_mem_write(), trace_hook_reg_read(), trace_hook_reg_write(), and rz_analysis_esil_t::verbose.

Referenced by rz_cmd_debug_traces_esil_i_handler(), and rz_debug_trace_op().

rz_analysis_esil_trace_restore()

RZ_API void rz_analysis_esil_trace_restore	(	RzAnalysisEsil *	esil,
		int	idx
	)

Definition at line 347 of file esil_trace.c.

                                                                          {
    rz_return_if_fail(esil);
    size_t i;
    RzAnalysisEsilTrace *trace = esil->trace;
    // Restore initial state when going backward
    if (idx < esil->trace->idx) {
        // Restore initial registers value
        for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
            RzRegArena *a = esil->analysis->reg->regset[i].arena;
            RzRegArena *b = trace->arena[i];
            if (a && b) {
                memcpy(a->bytes, b->bytes, a->size);
            }
        }
        // Restore initial stack memory
        esil->analysis->iob.write_at(esil->analysis->iob.io, trace->stack_addr,
            trace->stack_data, trace->stack_size);
    }
    // Apply latest changes to registers and memory
    esil->trace->idx = idx;
    RzListIter *iter;
    RzRegItem *ri;
    rz_list_foreach (esil->analysis->reg->allregs, iter, ri) {
        restore_register(esil, ri, idx);
    }
    ht_up_foreach(trace->memory, restore_memory_cb, esil);
}

References a, rz_reg_t::allregs, rz_analysis_esil_t::analysis, rz_analysis_esil_trace_t::arena, rz_reg_set_t::arena, b, i, rz_analysis_esil_trace_t::idx, setup::idx, rz_io_bind_t::io, rz_analysis_t::iob, memcpy(), rz_analysis_esil_trace_t::memory, rz_analysis_t::reg, rz_reg_t::regset, restore_memory_cb(), restore_register(), RZ_REG_TYPE_LAST, rz_return_if_fail, rz_analysis_esil_trace_t::stack_addr, rz_analysis_esil_trace_t::stack_data, rz_analysis_esil_trace_t::stack_size, rz_analysis_esil_t::trace, and rz_io_bind_t::write_at.

Referenced by rz_analysis_esil_trace_op(), rz_core_esil_continue_back(), and rz_core_esil_step_back().

rz_analysis_esil_trace_show()

RZ_API void rz_analysis_esil_trace_show	(	RzAnalysisEsil *	esil,
		int	idx
	)

Display an ESIL trace at index idx

Parameters

esil	RzAnalysisEsil *, ESIL instance
idx	int, index of trace

Definition at line 456 of file esil_trace.c.

                                                                       {
    rz_return_if_fail(esil);
    if (!esil->trace) {
        return;
    }
 
    RzILTraceInstruction *instruction = rz_analysis_esil_get_instruction_trace(esil->trace, idx);
    if (!instruction) {
        RZ_LOG_ERROR("Invalid trace id : %d\n", idx);
        return;
    }
 
    print_instruction_trace(instruction, idx);
}

References setup::idx, print_instruction_trace(), rz_analysis_esil_get_instruction_trace(), RZ_LOG_ERROR, rz_return_if_fail, and rz_analysis_esil_t::trace.

Referenced by rz_cmd_debug_trace_esil_handler().

trace_hook_mem_read()

static int trace_hook_mem_read ( RzAnalysisEsil *  esil, ut64  addr, ut8 *  buf, int  len  )

static

Definition at line 183 of file esil_trace.c.

                                                                                   {
    int ret = 0;
    if (esil->cb.mem_read) {
        ret = esil->cb.mem_read(esil, addr, buf, len);
    }
 
    // Trace memory read behavior
    RzILTraceMemOp *mem_read = RZ_NEW0(RzILTraceMemOp);
    if (!mem_read) {
        RZ_LOG_ERROR("fail to init memory read trace\n");
        return 0;
    }
 
    if (len > sizeof(mem_read->data_buf)) {
        RZ_LOG_ERROR("read memory more than 32 bytes, cannot trace\n");
        RZ_FREE(mem_read);
        return 0;
    }
 
    rz_mem_copy(mem_read->data_buf, sizeof(mem_read->data_buf), buf, len);
    mem_read->data_len = len;
    mem_read->behavior = RZ_IL_TRACE_OP_READ;
    mem_read->addr = addr;
    if (!esil_add_mem_trace(esil->trace, mem_read)) {
        RZ_FREE(mem_read);
    }
 
    if (ocbs.hook_mem_read) {
        RzAnalysisEsilCallbacks cbs = esil->cb;
        esil->cb = ocbs;
        ret = ocbs.hook_mem_read(esil, addr, buf, len);
        esil->cb = cbs;
    }
    return ret;
}

References addr, rz_analysis_esil_t::cb, esil_add_mem_trace(), rz_analysis_esil_callbacks_t::hook_mem_read, len, mem_read(), rz_analysis_esil_callbacks_t::mem_read, ocbs, RZ_FREE, RZ_LOG_ERROR, rz_mem_copy(), RZ_NEW0, and rz_analysis_esil_t::trace.

Referenced by rz_analysis_esil_trace_op().

trace_hook_mem_write()

static int trace_hook_mem_write ( RzAnalysisEsil *  esil, ut64  addr, const ut8 *  buf, int  len  )

static

Definition at line 219 of file esil_trace.c.

                                                                                          {
    size_t i;
    int ret = 0;
 
    // Trace memory read behavior
    RzILTraceMemOp *mem_write = RZ_NEW0(RzILTraceMemOp);
    if (!mem_write) {
        RZ_LOG_ERROR("fail to init memory write trace\n");
        return 0;
    }
 
    if (len > sizeof(mem_write->data_buf)) {
        RZ_LOG_ERROR("write memory more than 32 bytes, cannot trace\n");
        RZ_FREE(mem_write);
        return 0;
    }
 
    rz_mem_copy(mem_write->data_buf, sizeof(mem_write->data_buf), buf, len);
    mem_write->data_len = len;
    mem_write->behavior = RZ_IL_TRACE_OP_WRITE;
    mem_write->addr = addr;
    if (!esil_add_mem_trace(esil->trace, mem_write)) {
        RZ_FREE(mem_write);
    }
 
    for (i = 0; i < len; i++) {
        add_mem_change(esil->trace, esil->trace->idx + 1, addr + i, buf[i]);
    }
 
    if (ocbs.hook_mem_write) {
        RzAnalysisEsilCallbacks cbs = esil->cb;
        esil->cb = ocbs;
        ret = ocbs.hook_mem_write(esil, addr, buf, len);
        esil->cb = cbs;
    }
    return ret;
}

References add_mem_change(), addr, rz_analysis_esil_t::cb, esil_add_mem_trace(), rz_analysis_esil_callbacks_t::hook_mem_write, i, rz_analysis_esil_trace_t::idx, len, mem_write(), ocbs, RZ_FREE, RZ_LOG_ERROR, rz_mem_copy(), RZ_NEW0, and rz_analysis_esil_t::trace.

Referenced by rz_analysis_esil_trace_op().

trace_hook_reg_read()

static int trace_hook_reg_read ( RzAnalysisEsil *  esil, const char *  name, ut64 *  res, int *  size  )

static

Definition at line 124 of file esil_trace.c.

                                                                                             {
    int ret = 0;
    if (*name == '0') {
        // RZ_LOG_WARN("Register not found in profile\n");
        return 0;
    }
    if (ocbs.hook_reg_read) {
        RzAnalysisEsilCallbacks cbs = esil->cb;
        esil->cb = ocbs;
        ret = ocbs.hook_reg_read(esil, name, res, size);
        esil->cb = cbs;
    }
    if (!ret && esil->cb.reg_read) {
        ret = esil->cb.reg_read(esil, name, res, size);
    }
    if (ret) {
        // Trace reg read behavior
        RzILTraceRegOp *reg_read = RZ_NEW0(RzILTraceRegOp);
        if (!reg_read) {
            RZ_LOG_ERROR("failed to init reg read trace\n");
            return 0;
        }
        reg_read->reg_name = rz_str_constpool_get(&esil->analysis->constpool, name);
        reg_read->behavior = RZ_IL_TRACE_OP_READ;
        reg_read->value = *res;
        if (!esil_add_reg_trace(esil->trace, reg_read)) {
            RZ_FREE(reg_read);
        }
    }
    return ret;
}

References rz_analysis_esil_t::analysis, rz_analysis_esil_t::cb, rz_analysis_t::constpool, esil_add_reg_trace(), rz_analysis_esil_callbacks_t::hook_reg_read, ocbs, rz_analysis_esil_callbacks_t::reg_read, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_str_constpool_get(), and rz_analysis_esil_t::trace.

Referenced by rz_analysis_esil_trace_op().

trace_hook_reg_write()

static int trace_hook_reg_write ( RzAnalysisEsil *  esil, const char *  name, ut64 *  val  )

static

Definition at line 156 of file esil_trace.c.

                                                                                   {
    int ret = 0;
 
    // add reg write to trace
    RzILTraceRegOp *reg_write = RZ_NEW0(RzILTraceRegOp);
    if (!reg_write) {
        RZ_LOG_ERROR("failed to init reg write\n");
        return ret;
    }
    reg_write->reg_name = rz_str_constpool_get(&esil->analysis->constpool, name);
    reg_write->behavior = RZ_IL_TRACE_OP_WRITE;
    reg_write->value = *val;
    if (!esil_add_reg_trace(esil->trace, reg_write)) {
        RZ_FREE(reg_write);
    }
 
    RzRegItem *ri = rz_reg_get(esil->analysis->reg, name, -1);
    add_reg_change(esil->trace, esil->trace->idx + 1, ri, *val);
    if (ocbs.hook_reg_write) {
        RzAnalysisEsilCallbacks cbs = esil->cb;
        esil->cb = ocbs;
        ret = ocbs.hook_reg_write(esil, name, val);
        esil->cb = cbs;
    }
    return ret;
}

References add_reg_change(), rz_analysis_esil_t::analysis, rz_analysis_esil_t::cb, rz_analysis_t::constpool, esil_add_reg_trace(), rz_analysis_esil_callbacks_t::hook_reg_write, rz_analysis_esil_trace_t::idx, ocbs, rz_analysis_t::reg, RZ_FREE, RZ_LOG_ERROR, RZ_NEW0, rz_reg_get(), rz_str_constpool_get(), rz_analysis_esil_t::trace, and val.

Referenced by rz_analysis_esil_trace_op().

Variable Documentation

ocbs

RzAnalysisEsilCallbacks ocbs = { 0 }

static

Definition at line 11 of file esil_trace.c.

Referenced by esil_i8051_init(), rz_analysis_esil_trace_op(), trace_hook_mem_read(), trace_hook_mem_write(), trace_hook_reg_read(), and trace_hook_reg_write().

ocbs_set

int ocbs_set = false

static

Definition at line 10 of file esil_trace.c.

Referenced by rz_analysis_esil_trace_op().