trace.c File Reference

#include <rz_debug.h>

Go to the source code of this file.

Functions
RZ_API RzDebugTrace *	rz_debug_trace_new (void)
RZ_API void	rz_debug_trace_free (RzDebugTrace *trace)
RZ_API int	rz_debug_trace_tag (RzDebug *dbg, int tag)
RZ_API bool	rz_debug_trace_ins_before (RzDebug *dbg)
RZ_API bool	rz_debug_trace_ins_after (RzDebug *dbg)
RZ_API int	rz_debug_trace_pc (RzDebug *dbg, ut64 pc)
RZ_API void	rz_debug_trace_op (RzDebug *dbg, RzAnalysisOp *op)
RZ_API void	rz_debug_trace_at (RzDebug *dbg, const char *str)
RZ_API RzDebugTracepoint *	rz_debug_trace_get (RzDebug *dbg, ut64 addr)
static int	cmpaddr (const void *_a, const void *_b)
RZ_API RZ_OWN RzList *	rz_debug_traces_info (RzDebug *dbg, ut64 offset)
static int	rz_debug_trace_is_traceable (RzDebug *dbg, ut64 addr)
RZ_API RzDebugTracepoint *	rz_debug_trace_add (RzDebug *dbg, ut64 addr, int size)
RZ_API void	rz_debug_trace_reset (RzDebug *dbg)

Function Documentation

cmpaddr()

static int cmpaddr ( const void *  _a, const void *  _b  )

static

Definition at line 206 of file trace.c.

                                                   {
    const RzListInfo *a = _a, *b = _b;
    return (rz_itv_begin(a->pitv) > rz_itv_begin(b->pitv)) ? 1 : (rz_itv_begin(a->pitv) < rz_itv_begin(b->pitv)) ? -1
                                                             : 0;
}

References a, b, and rz_itv_begin().

Referenced by rz_debug_traces_info().

rz_debug_trace_add()

RZ_API RzDebugTracepoint* rz_debug_trace_add	(	RzDebug *	dbg,
		ut64	addr,
		int	size
	)

Definition at line 261 of file trace.c.

                                                                                {
    RzDebugTracepoint *tp;
    int tag = dbg->trace->tag;
    if (!rz_debug_trace_is_traceable(dbg, addr)) {
        return NULL;
    }
    rz_analysis_trace_bb(dbg->analysis, addr);
    tp = RZ_NEW0(RzDebugTracepoint);
    if (!tp) {
        return NULL;
    }
    tp->stamp = rz_time_now();
    tp->addr = addr;
    tp->tags = tag;
    tp->size = size;
    tp->count = ++dbg->trace->count;
    tp->times = 1;
    rz_list_append(dbg->trace->traces, tp);
    ht_pp_update(dbg->trace->ht,
        sdb_fmt("trace.%d.%" PFMT64x, tag, addr), tp);
    return tp;
}

References addr, rz_debug_tracepoint_t::addr, rz_debug_t::analysis, rz_debug_trace_t::count, rz_debug_tracepoint_t::count, dbg, rz_debug_trace_t::ht, NULL, PFMT64x, rz_analysis_trace_bb(), rz_debug_trace_is_traceable(), rz_list_append(), RZ_NEW0, rz_time_now(), sdb_fmt(), rz_debug_tracepoint_t::size, rz_debug_tracepoint_t::stamp, rz_debug_trace_t::tag, test-lz4-versions::tag, rz_debug_tracepoint_t::tags, rz_debug_tracepoint_t::times, rz_debug_t::trace, and rz_debug_trace_t::traces.

Referenced by rz_cmd_debug_trace_add_addrs_handler(), rz_cmd_debug_trace_add_handler(), and rz_debug_trace_op().

rz_debug_trace_at()

RZ_API void rz_debug_trace_at	(	RzDebug *	dbg,
		const char *	str
	)

Definition at line 194 of file trace.c.

                                                             {
    // TODO: parse offsets and so use ut64 instead of strstr()
    free(dbg->trace->addresses);
    dbg->trace->addresses = (str && *str) ? strdup(str) : NULL;
}

References rz_debug_trace_t::addresses, dbg, free(), NULL, cmd_descs_generate::str, strdup(), and rz_debug_t::trace.

Referenced by rz_cmd_debug_trace_addr().

rz_debug_trace_free()

RZ_API void rz_debug_trace_free

(

RzDebugTrace *

trace

)

Definition at line 29 of file trace.c.

                                                     {
    if (!trace) {
        return;
    }
    rz_list_purge(trace->traces);
    free(trace->traces);
    ht_pp_free(trace->ht);
    RZ_FREE(trace);
}

References free(), rz_debug_trace_t::ht, RZ_FREE, rz_list_purge(), and rz_debug_trace_t::traces.

Referenced by analysis_emul_restore(), rz_cmd_debug_traces_reset_handler(), rz_debug_free(), and rz_debug_trace_new().

rz_debug_trace_get()

RZ_API RzDebugTracepoint* rz_debug_trace_get	(	RzDebug *	dbg,
		ut64	addr
	)

Definition at line 200 of file trace.c.

                                                                      {
    int tag = dbg->trace->tag;
    return ht_pp_find(dbg->trace->ht,
        sdb_fmt("trace.%d.%" PFMT64x, tag, addr), NULL);
}

References addr, dbg, rz_debug_trace_t::ht, NULL, PFMT64x, sdb_fmt(), rz_debug_trace_t::tag, test-lz4-versions::tag, and rz_debug_t::trace.

Referenced by bb_info_print(), core_analysis_graph_construct_nodes(), ds_print_offset(), ds_print_trace(), fold_asm_trace(), graph_construct_nodes(), and rz_cmd_debug_trace_handler().

rz_debug_trace_ins_after()

RZ_API bool rz_debug_trace_ins_after

(

RzDebug *

dbg

)

Definition at line 110 of file trace.c.

                                                   {
    rz_return_val_if_fail(dbg->cur_op, false);
    RzListIter *it;
    RzAnalysisValue *val;
 
    // Add reg/mem write change
    rz_debug_reg_sync(dbg, RZ_REG_TYPE_ANY, false);
    rz_list_foreach (dbg->cur_op->access, it, val) {
        if (!(val->access & RZ_ANALYSIS_ACC_W)) {
            continue;
        }
 
        switch (val->type) {
        case RZ_ANALYSIS_VAL_REG: {
            if (!val->reg) {
                RZ_LOG_ERROR("invalid register, unable to trace register state\n");
                continue;
            }
            ut64 data = rz_reg_get_value(dbg->reg, val->reg);
 
            // add reg write
            rz_debug_session_add_reg_change(dbg->session, val->reg->arena, val->reg->offset, data);
            break;
        }
        case RZ_ANALYSIS_VAL_MEM: {
            ut8 buf[32] = { 0 };
            if (!dbg->iob.read_at(dbg->iob.io, val->base, buf, val->memref)) {
                eprintf("Error reading memory at 0x%" PFMT64x "\n", val->base);
                break;
            }
 
            // add mem write
            size_t i;
            for (i = 0; i < val->memref; i++) {
                rz_debug_session_add_mem_change(dbg->session, val->base + i, buf[i]);
            }
            break;
        }
        default:
            break;
        }
    }
    rz_analysis_op_free(dbg->cur_op);
    dbg->cur_op = NULL;
    return true;
}

References rz_analysis_op_t::access, rz_debug_t::cur_op, dbg, eprintf, i, rz_io_bind_t::io, rz_debug_t::iob, NULL, PFMT64x, rz_io_bind_t::read_at, rz_debug_t::reg, RZ_ANALYSIS_ACC_W, rz_analysis_op_free(), RZ_ANALYSIS_VAL_MEM, RZ_ANALYSIS_VAL_REG, rz_debug_reg_sync(), rz_debug_session_add_mem_change(), rz_debug_session_add_reg_change(), RZ_LOG_ERROR, rz_reg_get_value(), RZ_REG_TYPE_ANY, rz_return_val_if_fail, rz_debug_t::session, ut64(), and val.

Referenced by rz_debug_step(), and rz_debug_step_over().

rz_debug_trace_ins_before()

RZ_API bool rz_debug_trace_ins_before

(

RzDebug *

dbg

)

Definition at line 46 of file trace.c.

                                                    {
    RzListIter *it, *it_tmp;
    RzAnalysisValue *val;
    ut8 buf_pc[32];
 
    // Analyze current instruction
    ut64 pc = rz_debug_reg_get(dbg, dbg->reg->name[RZ_REG_NAME_PC]);
    if (!dbg->iob.read_at) {
        return false;
    }
    if (!dbg->iob.read_at(dbg->iob.io, pc, buf_pc, sizeof(buf_pc))) {
        return false;
    }
    dbg->cur_op = RZ_NEW0(RzAnalysisOp);
    if (!dbg->cur_op) {
        return false;
    }
    if (rz_analysis_op(dbg->analysis, dbg->cur_op, pc, buf_pc, sizeof(buf_pc), RZ_ANALYSIS_OP_MASK_VAL) < 1) {
        rz_analysis_op_free(dbg->cur_op);
        dbg->cur_op = NULL;
        return false;
    }
 
    // resolve mem write address
    rz_list_foreach_safe (dbg->cur_op->access, it, it_tmp, val) {
        switch (val->type) {
        case RZ_ANALYSIS_VAL_REG:
            if (!(val->access & RZ_ANALYSIS_ACC_W)) {
                rz_list_delete(dbg->cur_op->access, it);
            }
            break;
        case RZ_ANALYSIS_VAL_MEM:
            if (val->memref > 32) {
                eprintf("Error: adding changes to %d bytes in memory.\n", val->memref);
                rz_list_delete(dbg->cur_op->access, it);
                break;
            }
 
            if (val->access & RZ_ANALYSIS_ACC_W) {
                // resolve memory address
                ut64 addr = 0;
                addr += val->delta;
                if (val->seg) {
                    addr += rz_reg_get_value(dbg->reg, val->seg);
                }
                if (val->reg) {
                    addr += rz_reg_get_value(dbg->reg, val->reg);
                }
                if (val->regdelta) {
                    int mul = val->mul ? val->mul : 1;
                    addr += mul * rz_reg_get_value(dbg->reg, val->regdelta);
                }
                // resolve address into base for ins_after
                val->base = addr;
            } else {
                rz_list_delete(dbg->cur_op->access, it);
            }
        default:
            break;
        }
    }
    return true;
}

References rz_analysis_op_t::access, addr, rz_debug_t::analysis, rz_debug_t::cur_op, dbg, eprintf, rz_io_bind_t::io, rz_debug_t::iob, mul(), rz_reg_t::name, NULL, pc, rz_io_bind_t::read_at, rz_debug_t::reg, RZ_ANALYSIS_ACC_W, rz_analysis_op(), rz_analysis_op_free(), RZ_ANALYSIS_OP_MASK_VAL, RZ_ANALYSIS_VAL_MEM, RZ_ANALYSIS_VAL_REG, rz_debug_reg_get(), rz_list_delete(), RZ_NEW0, rz_reg_get_value(), RZ_REG_NAME_PC, ut64(), and val.

Referenced by rz_debug_step(), and rz_debug_step_over().

rz_debug_trace_is_traceable()

static int rz_debug_trace_is_traceable ( RzDebug *  dbg, ut64  addr  )

static

Definition at line 250 of file trace.c.

                                                                {
    if (dbg->trace->addresses) {
        char addr_str[32];
        snprintf(addr_str, sizeof(addr_str), "0x%08" PFMT64x, addr);
        if (!strstr(dbg->trace->addresses, addr_str)) {
            return false;
        }
    }
    return true;
}

References addr, rz_debug_trace_t::addresses, dbg, PFMT64x, snprintf, and rz_debug_t::trace.

Referenced by rz_debug_trace_add().

rz_debug_trace_new()

RZ_API RzDebugTrace* rz_debug_trace_new

(

void

)

Definition at line 7 of file trace.c.

                                              {
    RzDebugTrace *t = RZ_NEW0(RzDebugTrace);
    if (!t) {
        return NULL;
    }
    t->tag = 1; // UT32_MAX;
    t->addresses = NULL;
    t->enabled = false;
    t->traces = rz_list_new();
    if (!t->traces) {
        rz_debug_trace_free(t);
        return NULL;
    }
    t->traces->free = free;
    t->ht = ht_pp_new0();
    if (!t->ht) {
        rz_debug_trace_free(t);
        return NULL;
    }
    return t;
}

References rz_debug_trace_t::addresses, rz_debug_trace_t::enabled, rz_list_t::free, free(), rz_debug_trace_t::ht, NULL, rz_debug_trace_free(), rz_list_new(), RZ_NEW0, rz_debug_trace_t::tag, and rz_debug_trace_t::traces.

Referenced by analysis_emul_init(), rz_cmd_debug_traces_reset_handler(), and rz_debug_new().

rz_debug_trace_op()

RZ_API void rz_debug_trace_op	(	RzDebug *	dbg,
		RzAnalysisOp *	op
	)

Definition at line 177 of file trace.c.

                                                              {
    static ut64 oldpc = UT64_MAX; // Must trace the previously traced instruction
    if (dbg->trace->enabled) {
        if (dbg->analysis->esil) {
            rz_analysis_esil_trace_op(dbg->analysis->esil, op);
        } else {
            if (dbg->verbose) {
                eprintf("Run aeim to get dbg->analysis->esil initialized\n");
            }
        }
    }
    if (oldpc != UT64_MAX) {
        rz_debug_trace_add(dbg, oldpc, op->size); // XXX review what this line really do
    }
    oldpc = op->addr;
}

References rz_debug_t::analysis, dbg, rz_debug_trace_t::enabled, eprintf, rz_analysis_t::esil, rz_analysis_esil_trace_op(), rz_debug_trace_add(), rz_debug_t::trace, ut64(), UT64_MAX, and rz_debug_t::verbose.

Referenced by rz_core_esil_step(), and rz_debug_trace_pc().

rz_debug_trace_pc()

RZ_API int rz_debug_trace_pc	(	RzDebug *	dbg,
		ut64	pc
	)

Definition at line 160 of file trace.c.

                                                    {
    ut8 buf[32];
    RzAnalysisOp op = { 0 };
    if (!dbg->iob.is_valid_offset(dbg->iob.io, pc, 0)) {
        eprintf("trace_pc: cannot read memory at 0x%" PFMT64x "\n", pc);
        return false;
    }
    (void)dbg->iob.read_at(dbg->iob.io, pc, buf, sizeof(buf));
    if (rz_analysis_op(dbg->analysis, &op, pc, buf, sizeof(buf), RZ_ANALYSIS_OP_MASK_ESIL) < 1) {
        eprintf("trace_pc: cannot get opcode size at 0x%" PFMT64x "\n", pc);
        return false;
    }
    rz_debug_trace_op(dbg, &op);
    rz_analysis_op_fini(&op);
    return true;
}

References rz_debug_t::analysis, dbg, eprintf, rz_io_bind_t::io, rz_debug_t::iob, rz_io_bind_t::is_valid_offset, pc, PFMT64x, rz_io_bind_t::read_at, rz_analysis_op(), rz_analysis_op_fini(), RZ_ANALYSIS_OP_MASK_ESIL, and rz_debug_trace_op().

Referenced by rz_core_debug_step_one(), and rz_debug_bp_hit().

rz_debug_trace_reset()

RZ_API void rz_debug_trace_reset

(

RzDebug *

dbg

)

Definition at line 284 of file trace.c.

                                               {
    RzDebugTrace *t = dbg->trace;
    rz_list_purge(t->traces);
    ht_pp_free(t->ht);
    t->ht = ht_pp_new0();
    t->traces = rz_list_new();
    t->traces->free = free;
}

References dbg, rz_list_t::free, free(), rz_debug_trace_t::ht, rz_list_new(), rz_list_purge(), rz_debug_t::trace, and rz_debug_trace_t::traces.

rz_debug_trace_tag()

RZ_API int rz_debug_trace_tag	(	RzDebug *	dbg,
		int	tag
	)

Definition at line 41 of file trace.c.

                                                     {
    // if (tag>0 && tag<31) core->dbg->trace->tag = 1<<(sz-1);
    return (dbg->trace->tag = (tag > 0) ? tag : UT32_MAX);
}

References dbg, rz_debug_trace_t::tag, test-lz4-versions::tag, rz_debug_t::trace, and UT32_MAX.

Referenced by rz_cmd_debug_trace_tag_handler().

rz_debug_traces_info()

RZ_API RZ_OWN RzList* rz_debug_traces_info	(	RzDebug *	dbg,
		ut64	offset
	)

Definition at line 218 of file trace.c.

                                                                      {
    rz_return_val_if_fail(dbg, NULL);
    int tag = dbg->trace->tag;
    RzListIter *iter;
    RzList *info_list = rz_list_new();
    if (!info_list) {
        return NULL;
    }
 
    RzDebugTracepoint *trace;
    rz_list_foreach (dbg->trace->traces, iter, trace) {
        if (trace->tag && !(tag & trace->tag)) {
            continue;
        }
        RzListInfo *info = RZ_NEW0(RzListInfo);
        if (!info) {
            rz_list_free(info_list);
            return NULL;
        }
        info->pitv = (RzInterval){ trace->addr, trace->size };
        info->vitv = info->pitv;
        info->perm = -1;
        info->name = rz_str_newf("%d", trace->times);
        info->extra = rz_str_newf("%d", trace->count);
        rz_list_append(info_list, info);
    }
 
    rz_list_sort(info_list, cmpaddr);
    return info_list;
}

References rz_debug_tracepoint_t::addr, cmpaddr(), rz_debug_tracepoint_t::count, dbg, info(), NULL, rz_list_append(), rz_list_free(), rz_list_new(), rz_list_sort(), RZ_NEW0, rz_return_val_if_fail, rz_str_newf(), rz_debug_tracepoint_t::size, rz_debug_trace_t::tag, rz_debug_tracepoint_t::tag, test-lz4-versions::tag, rz_debug_tracepoint_t::times, rz_debug_t::trace, and rz_debug_trace_t::traces.

Referenced by rz_debug_traces_ascii().