debug.c File Reference

#include <rz_debug.h>
#include <rz_drx.h>
#include <rz_core.h>
#include <rz_windows.h>
#include <signal.h>

Go to the source code of this file.

Macros
#define	DBG_BUF_SIZE   512

Functions
	RZ_LIB_VERSION (rz_debug)
RZ_API RzDebugInfo *	rz_debug_info (RzDebug *dbg, const char *arg)
RZ_API void	rz_debug_info_free (RzDebugInfo *rdi)
RZ_API void	rz_debug_bp_update (RzDebug *dbg)
static int	rz_debug_drx_at (RzDebug *dbg, ut64 addr)
static int	rz_debug_bp_hit (RzDebug *dbg, RzRegItem *pc_ri, ut64 pc, RzBreakpointItem **pb)
static int	rz_debug_bps_enable (RzDebug *dbg)
static int	rz_debug_recoil (RzDebug *dbg, RzDebugRecoilMode rc_mode)
RZ_API RZ_BORROW RzBreakpointItem *	rz_debug_bp_add (RZ_NONNULL RzDebug *dbg, ut64 addr, int hw, bool watch, int rw, RZ_NULLABLE const char *module, st64 m_delta)
static const char *	rz_debug_str_callback (RzNum *userptr, ut64 off, int *ok)
void	free_tracenodes_kv (HtUPKv *kv)
RZ_API RZ_OWN RzDebug *	rz_debug_new (RZ_BORROW RZ_NONNULL RzBreakpointContext *bp_ctx)
RZ_API void	rz_debug_tracenodes_reset (RzDebug *dbg)
RZ_API RzDebug *	rz_debug_free (RzDebug *dbg)
RZ_API int	rz_debug_attach (RzDebug *dbg, int pid)
RZ_API int	rz_debug_stop (RzDebug *dbg)
RZ_API bool	rz_debug_set_arch (RzDebug *dbg, const char *arch, int bits)
RZ_API ut64	rz_debug_execute (RzDebug *dbg, const ut8 *buf, int len, int restore)
RZ_API int	rz_debug_startv (struct rz_debug_t *dbg, int argc, char **argv)
RZ_API int	rz_debug_start (RzDebug *dbg, const char *cmd)
RZ_API int	rz_debug_detach (RzDebug *dbg, int pid)
RZ_API bool	rz_debug_select (RzDebug *dbg, int pid, int tid)
RZ_API const char *	rz_debug_reason_to_string (int type)
RZ_API RzDebugReasonType	rz_debug_stop_reason (RzDebug *dbg)
RZ_API RzDebugReasonType	rz_debug_wait (RzDebug *dbg, RzBreakpointItem **bp)
RZ_API int	rz_debug_step_soft (RzDebug *dbg)
RZ_API int	rz_debug_step_hard (RzDebug *dbg, RzBreakpointItem **pb)
RZ_API int	rz_debug_step (RzDebug *dbg, int steps)
static bool	isStepOverable (ut64 opType)
RZ_API int	rz_debug_step_over (RzDebug *dbg, int steps)
RZ_API bool	rz_debug_goto_cnum (RzDebug *dbg, ut32 cnum)
RZ_API int	rz_debug_step_back (RzDebug *dbg, int steps)
RZ_API int	rz_debug_step_cnum (RzDebug *dbg, int steps)
RZ_API int	rz_debug_continue_kill (RzDebug *dbg, int sig)
RZ_API int	rz_debug_continue (RzDebug *dbg)
RZ_API int	rz_debug_continue_pass_exception (RzDebug *dbg)
RZ_API int	rz_debug_continue_until_nontraced (RzDebug *dbg)
RZ_API int	rz_debug_continue_until_optype (RzDebug *dbg, int type, int over)
static int	rz_debug_continue_until_internal (RzDebug *dbg, ut64 addr, bool block)
RZ_API int	rz_debug_continue_until (RzDebug *dbg, ut64 addr)
RZ_API int	rz_debug_continue_until_nonblock (RzDebug *dbg, ut64 addr)
RZ_API bool	rz_debug_continue_back (RzDebug *dbg)
static int	show_syscall (RzDebug *dbg, const char *sysreg)
RZ_API int	rz_debug_continue_syscalls (RzDebug *dbg, int *sc, int n_sc)
RZ_API int	rz_debug_continue_syscall (RzDebug *dbg, int sc)
RZ_API int	rz_debug_syscall (RzDebug *dbg, int num)
RZ_API bool	rz_debug_can_kill (RzDebug *dbg)
	check whether rz_debug_kill() will not definitely fail (for example because kill is unimplemented by the plugin) More...
RZ_API int	rz_debug_kill (RzDebug *dbg, int pid, int tid, int sig)
RZ_API RzList *	rz_debug_frames (RzDebug *dbg, ut64 at)
RZ_API int	rz_debug_child_fork (RzDebug *dbg)
RZ_API int	rz_debug_child_clone (RzDebug *dbg)
RZ_API bool	rz_debug_is_dead (RzDebug *dbg)
RZ_API int	rz_debug_map_protect (RzDebug *dbg, ut64 addr, int size, int perms)
RZ_API void	rz_debug_drx_list (RzDebug *dbg)
RZ_API int	rz_debug_drx_set (RzDebug *dbg, int idx, ut64 addr, int len, int rwx, int g)
RZ_API int	rz_debug_drx_unset (RzDebug *dbg, int idx)
RZ_API ut64	rz_debug_get_baddr (RzDebug *dbg, const char *file)
RZ_API void	rz_debug_bp_rebase (RzDebug *dbg, ut64 old_base, ut64 new_base)

Macro Definition Documentation

DBG_BUF_SIZE

#define DBG_BUF_SIZE   512

Definition at line 16 of file debug.c.

Function Documentation

free_tracenodes_kv()

void free_tracenodes_kv

(

HtUPKv *

kv

)

Definition at line 355 of file debug.c.

                                    {
    free(kv->value);
}

References free().

Referenced by rz_debug_new(), and rz_debug_tracenodes_reset().

isStepOverable()

static bool isStepOverable ( ut64  opType )

static

Definition at line 1022 of file debug.c.

                                        {
    switch (opType & RZ_ANALYSIS_OP_TYPE_MASK) {
    case RZ_ANALYSIS_OP_TYPE_SWI:
    case RZ_ANALYSIS_OP_TYPE_CALL:
    case RZ_ANALYSIS_OP_TYPE_UCALL:
    case RZ_ANALYSIS_OP_TYPE_RCALL:
        return true;
    }
    return false;
}

References RZ_ANALYSIS_OP_TYPE_CALL, RZ_ANALYSIS_OP_TYPE_MASK, RZ_ANALYSIS_OP_TYPE_RCALL, RZ_ANALYSIS_OP_TYPE_SWI, and RZ_ANALYSIS_OP_TYPE_UCALL.

Referenced by rz_debug_step_over().

rz_debug_attach()

RZ_API int rz_debug_attach	(	RzDebug *	dbg,
		int	pid
	)

Definition at line 445 of file debug.c.

                                                  {
    int ret = false;
    if (dbg && dbg->cur && dbg->cur->attach) {
        ret = dbg->cur->attach(dbg, pid);
        if (ret != -1) {
            dbg->reason.type = RZ_DEBUG_REASON_NONE; // after a successful attach, the process is not dead
            rz_debug_select(dbg, pid, ret); // dbg->pid, dbg->tid);
        }
    }
    return ret;
}

References rz_debug_plugin_t::attach, rz_debug_t::cur, dbg, pid, rz_debug_t::reason, RZ_DEBUG_REASON_NONE, rz_debug_select(), and rz_debug_reason_t::type.

Referenced by cb_dbg_aftersc(), cb_dbg_clone(), cb_dbg_execs(), cb_dbg_forks(), rz_core_debug_attach(), and rz_debug_get_baddr().

rz_debug_bp_add()

RZ_API RZ_BORROW RzBreakpointItem* rz_debug_bp_add	(	RZ_NONNULL RzDebug *	dbg,
		ut64	addr,
		int	hw,
		bool	watch,
		int	rw,
		RZ_NULLABLE const char *	module,
		st64	m_delta
	)

Definition at line 270 of file debug.c.

                                                                                                                                                                 {
    rz_return_val_if_fail(dbg, NULL);
    int bpsz = rz_bp_size_at(dbg->bp, addr);
    RzBreakpointItem *bpi;
    const char *module_name = module;
    RzListIter *iter;
    RzDebugMap *map;
    if (!addr && module) {
        bool detect_module, valid = false;
        int perm;
 
        if (m_delta) {
            detect_module = false;
            RzList *list = rz_debug_modules_list(dbg);
            rz_list_foreach (list, iter, map) {
                if (strstr(map->file, module)) {
                    addr = map->addr + m_delta;
                    module_name = map->file;
                    break;
                }
            }
            rz_list_free(list);
        } else {
            // module holds the address
            addr = (ut64)rz_num_math(dbg->num, module);
            if (!addr) {
                return NULL;
            }
            detect_module = true;
        }
        rz_debug_map_sync(dbg);
        rz_list_foreach (dbg->maps, iter, map) {
            if (addr >= map->addr && addr < map->addr_end) {
                valid = true;
                if (detect_module) {
                    module_name = map->file;
                    m_delta = addr - map->addr;
                }
                perm = ((map->perm & 1) << 2) | (map->perm & 2) | ((map->perm & 4) >> 2);
                if (!(perm & RZ_PERM_X)) {
                    eprintf("WARNING: setting bp within mapped memory without exec perm\n");
                }
                break;
            }
        }
        if (!valid) {
            eprintf("WARNING: module's base addr + delta is not a valid address\n");
            return NULL;
        }
    }
    if (!module) {
        // express db breakpoints as dbm due to ASLR when saving into project
        rz_debug_map_sync(dbg);
        rz_list_foreach (dbg->maps, iter, map) {
            if (addr >= map->addr && addr < map->addr_end) {
                module_name = map->file;
                m_delta = addr - map->addr;
                break;
            }
        }
    }
    if (watch) {
        hw = 1; // XXX
        bpi = rz_bp_watch_add(dbg->bp, addr, bpsz, hw, rw);
    } else {
        bpi = hw
            ? rz_bp_add_hw(dbg->bp, addr, bpsz, RZ_PERM_X)
            : rz_bp_add_sw(dbg->bp, addr, bpsz, RZ_PERM_X);
    }
    if (bpi) {
        if (module_name) {
            bpi->module_name = strdup(module_name);
            bpi->name = rz_str_newf("%s+0x%" PFMT64x, module_name, m_delta);
        }
        bpi->module_delta = m_delta;
    }
    return bpi;
}

References addr, rz_debug_t::bp, dbg, eprintf, list(), map(), rz_debug_t::maps, rz_bp_item_t::module_delta, rz_bp_item_t::module_name, rz_bp_item_t::name, NULL, rz_debug_t::num, PFMT64x, rz_bp_add_hw(), rz_bp_add_sw(), rz_bp_size_at(), rz_bp_watch_add(), rz_debug_map_sync(), rz_debug_modules_list(), rz_list_free(), rz_num_math(), RZ_PERM_X, rz_return_val_if_fail, rz_str_newf(), strdup(), ut64(), and valid.

Referenced by debug_trace_calls(), rz_cmd_debug_add_bp_module_handler(), rz_core_debug_bp_add(), rz_core_debug_bp_add_noreturn_func(), rz_core_debug_breakpoint_toggle(), rz_core_debug_step_over(), rz_core_debug_step_skip(), and rz_w32_add_winmsg_breakpoint().

rz_debug_bp_hit()

static int rz_debug_bp_hit ( RzDebug *  dbg, RzRegItem *  pc_ri, ut64  pc, RzBreakpointItem **  pb  )

static

Definition at line 66 of file debug.c.

                                                                                           {
    RzBreakpointItem *b;
 
    if (!pb) {
        eprintf("BreakpointItem is NULL!\n");
        return false;
    }
    /* initialize the output parameter */
    *pb = NULL;
 
    /* if we are tracing, update the tracing data */
    if (dbg->trace->enabled) {
        rz_debug_trace_pc(dbg, pc);
    }
 
    /* remove all sw breakpoints for now. we'll set them back in stage 2
     *
     * this is necessary because while stopped we don't want any breakpoints in
     * the code messing up our analysis.
     */
    rz_debug_bp_update(dbg);
    if (!rz_bp_restore(dbg->bp, false)) { // unset sw breakpoints
        return false;
    }
 
    /* if we are recoiling, tell rz_debug_step that we ignored a breakpoint
     * event */
    if (!dbg->swstep && dbg->recoil_mode != RZ_DBG_RECOIL_NONE) {
        dbg->reason.bp_addr = 0;
        return true;
    }
 
    /* The MIPS ptrace has a different behaviour */
#if __mips__
    /* see if we really have a breakpoint here... */
    b = rz_bp_get_at(dbg->bp, pc);
    if (!b) { /* we don't. nothing left to do */
        return true;
    }
#else
    /* see if we really have a breakpoint here... */
    if (!dbg->pc_at_bp_set) {
        b = rz_bp_get_ending_at(dbg->bp, pc);
        if (!b) { /* we don't. nothing left to do */
            /* Some targets set pc to breakpoint */
            b = rz_bp_get_at(dbg->bp, pc);
            if (!b) {
                /* handle the case of hw breakpoints - notify the user */
                int drx_reg_idx = rz_debug_drx_at(dbg, pc);
                if (drx_reg_idx != -1) {
                    eprintf("hit hardware breakpoint %d at: %" PFMT64x "\n",
                        drx_reg_idx, pc);
                }
                /* Couldn't find the break point. Nothing more to do... */
                return true;
            } else {
                dbg->pc_at_bp_set = true;
                dbg->pc_at_bp = true;
            }
        } else {
            dbg->pc_at_bp_set = true;
            dbg->pc_at_bp = false;
        }
    }
 
    if (!dbg->pc_at_bp_set) {
        eprintf("failed to determine position of pc after breakpoint");
    }
 
    int pc_off = 0;
    if (dbg->pc_at_bp) {
        b = rz_bp_get_at(dbg->bp, pc);
    } else {
        b = rz_bp_get_ending_at(dbg->bp, pc);
        if (b) {
            pc_off = b->size;
        }
    }
 
    if (!b) {
        return true;
    }
 
    b = rz_bp_get_ending_at(dbg->bp, pc);
    if (!b) { /* we don't. nothing left to do */
        /* Some targets set pc to breakpoint */
        b = rz_bp_get_at(dbg->bp, pc);
        if (!b) {
            return true;
        }
        pc_off = 0;
    }
 
    /* set the pc value back */
    if (pc_off) {
        pc -= pc_off;
        if (!rz_reg_set_value(dbg->reg, pc_ri, pc)) {
            eprintf("failed to set PC!\n");
            return false;
        }
        if (!rz_debug_reg_sync(dbg, RZ_REG_TYPE_GPR, true)) {
            eprintf("cannot set registers!\n");
            return false;
        }
    }
#endif
 
    *pb = b;
 
    /* if we are on a software stepping breakpoint, we hide what is going on... */
    if (b->swstep) {
        dbg->reason.bp_addr = 0;
        return true;
    }
 
    /* setup our stage 2 */
    dbg->reason.bp_addr = b->addr;
 
    /* inform the user of what happened */
    if (dbg->hitinfo) {
        eprintf("hit %spoint at: 0x%" PFMT64x "\n",
            b->trace ? "trace" : "break", pc);
    }
 
    /* now that we've cleaned up after the breakpoint, call the other
     * potential breakpoint handlers
     */
    if (dbg->corebind.core && dbg->corebind.bphit) {
        dbg->corebind.bphit(dbg->corebind.core, b);
    }
    return true;
}

References b, rz_debug_t::bp, rz_debug_reason_t::bp_addr, rz_core_bind_t::bphit, rz_core_bind_t::core, rz_debug_t::corebind, dbg, rz_debug_trace_t::enabled, eprintf, rz_debug_t::hitinfo, NULL, pc, rz_debug_t::pc_at_bp, rz_debug_t::pc_at_bp_set, PFMT64x, rz_debug_t::reason, rz_debug_t::recoil_mode, rz_debug_t::reg, rz_bp_get_at(), rz_bp_get_ending_at(), rz_bp_restore(), RZ_DBG_RECOIL_NONE, rz_debug_bp_update(), rz_debug_drx_at(), rz_debug_reg_sync(), rz_debug_trace_pc(), rz_reg_set_value(), RZ_REG_TYPE_GPR, rz_debug_t::swstep, and rz_debug_t::trace.

Referenced by rz_debug_wait().

rz_debug_bp_rebase()

RZ_API void rz_debug_bp_rebase	(	RzDebug *	dbg,
		ut64	old_base,
		ut64	new_base
	)

Definition at line 1737 of file debug.c.

                                                                           {
    RzBreakpointItem *bp;
    RzListIter *iter;
    ut64 diff = new_base - old_base;
    // update bp->baddr
    dbg->bp->baddr = new_base;
 
    // update bp's address
    rz_list_foreach (dbg->bp->bps, iter, bp) {
        bp->addr += diff;
        bp->delta = bp->addr - dbg->bp->baddr;
    }
}

References rz_bp_item_t::addr, rz_bp_t::baddr, rz_debug_t::bp, rz_bp_t::bps, dbg, rz_bp_item_t::delta, and ut64().

Referenced by __rebase_everything(), and rebase_helper().

rz_debug_bp_update()

RZ_API void rz_debug_bp_update

(

RzDebug *

dbg

)

Definition at line 39 of file debug.c.

                                             {
    /* update all bp->addr if they are named bps */
    RzBreakpointItem *bp;
    RzListIter *iter;
    rz_list_foreach (dbg->bp->bps, iter, bp) {
        if (bp->expr) {
            bp->addr = dbg->corebind.numGet(dbg->corebind.core, bp->expr);
        }
    }
}

References rz_bp_item_t::addr, rz_debug_t::bp, rz_bp_t::bps, rz_core_bind_t::core, rz_debug_t::corebind, dbg, rz_bp_item_t::expr, and rz_core_bind_t::numGet.

Referenced by linux_remove_fork_bps(), rz_debug_bp_hit(), and rz_debug_continue_kill().

rz_debug_bps_enable()

static int rz_debug_bps_enable ( RzDebug *  dbg )

static

Definition at line 200 of file debug.c.

                                             {
    /* restore all sw breakpoints. we are about to step/continue so these need
     * to be in place. */
    if (!rz_bp_restore(dbg->bp, true)) {
        return false;
    }
    /* done recoiling... */
    dbg->recoil_mode = RZ_DBG_RECOIL_NONE;
    return true;
}

References rz_debug_t::bp, dbg, rz_debug_t::recoil_mode, rz_bp_restore(), and RZ_DBG_RECOIL_NONE.

Referenced by rz_debug_recoil().

rz_debug_can_kill()

RZ_API bool rz_debug_can_kill

(

RzDebug *

dbg

)

check whether rz_debug_kill() will not definitely fail (for example because kill is unimplemented by the plugin)

Definition at line 1594 of file debug.c.

                                            {
    return !rz_debug_is_dead(dbg) && dbg->cur && dbg->cur->kill;
}

References rz_debug_t::cur, dbg, rz_debug_plugin_t::kill, and rz_debug_is_dead().

Referenced by rz_main_rizin().

rz_debug_child_clone()

RZ_API int rz_debug_child_clone

(

RzDebug *

dbg

)

Definition at line 1626 of file debug.c.

                                              {
    // if (dbg && dbg->cur && dbg->cur->frames)
    // return dbg->cur->frames (dbg);
    return 0;
}

Referenced by cmd_debug_pid().

rz_debug_child_fork()

RZ_API int rz_debug_child_fork

(

RzDebug *

dbg

)

Definition at line 1620 of file debug.c.

                                             {
    // if (dbg && dbg->cur && dbg->cur->frames)
    // return dbg->cur->frames (dbg);
    return 0;
}

Referenced by cmd_debug_pid().

rz_debug_continue()

RZ_API int rz_debug_continue

(

RzDebug *

dbg

)

Definition at line 1332 of file debug.c.

                                           {
    return rz_debug_continue_kill(dbg, 0); // dbg->reason.signum);
}

References dbg, and rz_debug_continue_kill().

Referenced by cmd_debug_backtrace(), rz_core_debug_continue(), rz_core_debug_continue_until(), rz_core_file_reopen(), rz_debug_continue_until_internal(), rz_debug_execute(), rz_debug_step_soft(), and w32_attach().

rz_debug_continue_back()

RZ_API bool rz_debug_continue_back

(

RzDebug *

dbg

)

Definition at line 1442 of file debug.c.

                                                 {
    int cnum;
    bool has_bp = false;
 
    RzRegItem *ripc = rz_reg_get(dbg->reg, dbg->reg->name[RZ_REG_NAME_PC], RZ_REG_TYPE_GPR);
    RzVector *vreg = ht_up_find(dbg->session->registers, ripc->offset | (ripc->arena << 16), NULL);
    if (!vreg) {
        eprintf("Error: cannot find PC change vector");
        return false;
    }
    RzDebugChangeReg *reg;
    rz_vector_foreach_prev(vreg, reg) {
        if (reg->cnum >= dbg->session->cnum) {
            continue;
        }
        has_bp = rz_bp_get_in(dbg->bp, reg->data, RZ_PERM_X) != NULL;
        if (has_bp) {
            cnum = reg->cnum;
            eprintf("hit breakpoint at: 0x%" PFMT64x " cnum: %d\n", reg->data, reg->cnum);
            break;
        }
    }
 
    if (has_bp) {
        rz_debug_goto_cnum(dbg, cnum);
    } else {
        if (dbg->session->maxcnum > 0) {
            rz_debug_goto_cnum(dbg, 0);
        }
    }
 
    return true;
}

References rz_reg_item_t::arena, rz_debug_t::bp, rz_debug_session_t::cnum, dbg, eprintf, rz_debug_session_t::maxcnum, rz_reg_t::name, NULL, rz_reg_item_t::offset, PFMT64x, reg, rz_debug_t::reg, rz_debug_session_t::registers, rz_bp_get_in(), rz_debug_goto_cnum(), RZ_PERM_X, rz_reg_get(), RZ_REG_NAME_PC, RZ_REG_TYPE_GPR, rz_vector_foreach_prev, and rz_debug_t::session.

Referenced by rz_cmd_debug_continue_back_handler().

rz_debug_continue_kill()

RZ_API int rz_debug_continue_kill	(	RzDebug *	dbg,
		int	sig
	)

Definition at line 1141 of file debug.c.

                                                         {
    RzDebugReasonType reason = RZ_DEBUG_REASON_NONE;
    int ret = 0;
    RzBreakpointItem *bp = NULL;
 
    if (!dbg) {
        return 0;
    }
 
    // If the debugger is not at the end of the changes
    // Go to the end or the next breakpoint in the changes
    if (dbg->session && dbg->session->cnum != dbg->session->maxcnum) {
        bool has_bp = false;
        RzRegItem *ripc = rz_reg_get(dbg->reg, dbg->reg->name[RZ_REG_NAME_PC], RZ_REG_TYPE_GPR);
        RzVector *vreg = ht_up_find(dbg->session->registers, ripc->offset | (ripc->arena << 16), NULL);
        RzDebugChangeReg *reg;
        rz_vector_foreach_prev(vreg, reg) {
            if (reg->cnum <= dbg->session->cnum) {
                continue;
            }
            has_bp = rz_bp_get_in(dbg->bp, reg->data, RZ_PERM_X) != NULL;
            if (has_bp) {
                eprintf("hit breakpoint at: 0x%" PFMT64x " cnum: %d\n", reg->data, reg->cnum);
                rz_debug_goto_cnum(dbg, reg->cnum);
                return dbg->tid;
            }
        }
 
        rz_debug_goto_cnum(dbg, dbg->session->maxcnum);
        return dbg->tid;
    }
 
repeat:
    if (rz_debug_is_dead(dbg)) {
        return 0;
    }
    if (dbg->session && dbg->trace_continue) {
        while (!rz_cons_is_breaked()) {
            if (rz_debug_step(dbg, 1) != 1) {
                break;
            }
            if (dbg->session->reasontype != RZ_DEBUG_REASON_STEP) {
                break;
            }
        }
        reason = dbg->session->reasontype;
        bp = dbg->session->bp;
    } else if (dbg->cur && dbg->cur->cont) {
        /* handle the stage-2 of breakpoints */
        if (!rz_debug_recoil(dbg, RZ_DBG_RECOIL_CONTINUE)) {
            return 0;
        }
        /* tell the inferior to go! */
        ret = dbg->cur->cont(dbg, dbg->pid, dbg->tid, sig);
        // XXX(jjd): why? //dbg->reason.signum = 0;
        reason = rz_debug_wait(dbg, &bp);
    } else {
        return 0;
    }
 
    if (dbg->corebind.core) {
        RzCore *core = (RzCore *)dbg->corebind.core;
        RzNum *num = core->num;
        if (reason == RZ_DEBUG_REASON_COND) {
            if (bp && bp->cond && dbg->corebind.cmd) {
                dbg->corebind.cmd(dbg->corebind.core, bp->cond);
            }
            if (num->value) {
                goto repeat;
            }
        }
    }
    if (reason == RZ_DEBUG_REASON_BREAKPOINT &&
        ((bp && !bp->enabled) || (!bp && !rz_cons_is_breaked() && dbg->corebind.core && dbg->corebind.cfggeti(dbg->corebind.core, "dbg.bpsysign")))) {
        goto repeat;
    }
 
#if __linux__
    if (reason == RZ_DEBUG_REASON_NEW_PID && dbg->follow_child) {
#if DEBUGGER
        static bool (*linux_attach_new_process)(RzDebug * dbg, int pid) = NULL;
        if (!linux_attach_new_process) {
            linux_attach_new_process = rz_lib_dl_sym(NULL, "linux_attach_new_process");
        }
        if (linux_attach_new_process) {
            linux_attach_new_process(dbg, dbg->forked_pid);
        }
#endif
        goto repeat;
    }
 
    if (reason == RZ_DEBUG_REASON_NEW_TID) {
        ret = dbg->tid;
        if (!dbg->trace_clone) {
            goto repeat;
        }
    }
 
    if (reason == RZ_DEBUG_REASON_EXIT_TID) {
        goto repeat;
    }
#endif
    if (reason != RZ_DEBUG_REASON_DEAD) {
        ret = dbg->tid;
    }
#if __WINDOWS__
    if (reason == RZ_DEBUG_REASON_NEW_LIB ||
        reason == RZ_DEBUG_REASON_EXIT_LIB ||
        reason == RZ_DEBUG_REASON_NEW_TID ||
        reason == RZ_DEBUG_REASON_NONE ||
        reason == RZ_DEBUG_REASON_EXIT_TID) {
        goto repeat;
    }
#endif
    if (reason == RZ_DEBUG_REASON_EXIT_PID) {
#if __WINDOWS__
        dbg->pid = -1;
#elif __linux__
        rz_debug_bp_update(dbg);
        rz_bp_restore(dbg->bp, false); // (vdf) there has got to be a better way
#endif
    }
 
    /* if continuing killed the inferior, we won't be able to get
     * the registers.. */
    if (reason == RZ_DEBUG_REASON_DEAD || rz_debug_is_dead(dbg)) {
        return 0;
    }
 
    /* if we hit a tracing breakpoint, we need to continue in
     * whatever mode the user desired. */
    if (reason == RZ_DEBUG_REASON_TRACEPOINT) {
        rz_debug_step(dbg, 1);
        goto repeat;
    }
 
    /* choose the thread that was returned from the continue function */
    // XXX(jjd): there must be a cleaner way to do this...
    if (ret != dbg->tid) {
        rz_debug_select(dbg, dbg->pid, ret);
    }
    sig = 0; // clear continuation after signal if needed
 
    /* handle general signals here based on the return from the wait
     * function */
    if (dbg->reason.signum != -1) {
        int what = rz_debug_signal_what(dbg, dbg->reason.signum);
        if (what & RZ_DBG_SIGNAL_CONT) {
            sig = dbg->reason.signum;
            eprintf("Continue into the signal %d handler\n", sig);
            goto repeat;
        } else if (what & RZ_DBG_SIGNAL_SKIP) {
            // skip signal. requires skipping one instruction
            ut8 buf[64];
            RzAnalysisOp op = { 0 };
            ut64 pc = rz_debug_reg_get(dbg, "PC");
            dbg->iob.read_at(dbg->iob.io, pc, buf, sizeof(buf));
            rz_analysis_op(dbg->analysis, &op, pc, buf, sizeof(buf), RZ_ANALYSIS_OP_MASK_BASIC);
            if (op.size > 0) {
                const char *signame = rz_signal_to_string(dbg->reason.signum);
                rz_debug_reg_set(dbg, "PC", pc + op.size);
                eprintf("Skip signal %d handler %s\n",
                    dbg->reason.signum, signame);
                goto repeat;
            } else {
                ut64 pc = rz_debug_reg_get(dbg, "PC");
                eprintf("Stalled with an exception at 0x%08" PFMT64x "\n", pc);
            }
        }
    }
#if __WINDOWS__
    rz_cons_break_pop();
#endif
 
    // Unset breakpoints before leaving
    if (reason != RZ_DEBUG_REASON_BREAKPOINT) {
        rz_bp_restore(dbg->bp, false);
    }
 
    // Add a checkpoint at stops
    if (dbg->session && !dbg->trace_continue) {
        dbg->session->cnum++;
        dbg->session->maxcnum++;
        rz_debug_add_checkpoint(dbg);
    }
 
    return ret;
}

References rz_debug_t::analysis, rz_reg_item_t::arena, bool, rz_debug_session_t::bp, rz_debug_t::bp, rz_core_bind_t::cfggeti, rz_core_bind_t::cmd, rz_debug_session_t::cnum, rz_bp_item_t::cond, rz_debug_plugin_t::cont, rz_core_bind_t::core, rz_debug_t::corebind, rz_debug_t::cur, dbg, rz_bp_item_t::enabled, eprintf, rz_debug_t::follow_child, rz_debug_t::forked_pid, if(), rz_io_bind_t::io, rz_debug_t::iob, linux_attach_new_process(), rz_debug_session_t::maxcnum, rz_reg_t::name, NULL, rz_core_t::num, num, rz_reg_item_t::offset, pc, PFMT64x, rz_debug_t::pid, pid, rz_io_bind_t::read_at, rz_debug_t::reason, rz_debug_session_t::reasontype, reg, rz_debug_t::reg, rz_debug_session_t::registers, repeat(), rz_analysis_op(), RZ_ANALYSIS_OP_MASK_BASIC, rz_bp_get_in(), rz_bp_restore(), rz_cons_break_pop(), rz_cons_is_breaked(), RZ_DBG_RECOIL_CONTINUE, RZ_DBG_SIGNAL_CONT, RZ_DBG_SIGNAL_SKIP, rz_debug_add_checkpoint(), rz_debug_bp_update(), rz_debug_goto_cnum(), rz_debug_is_dead(), RZ_DEBUG_REASON_BREAKPOINT, RZ_DEBUG_REASON_COND, RZ_DEBUG_REASON_DEAD, RZ_DEBUG_REASON_EXIT_LIB, RZ_DEBUG_REASON_EXIT_PID, RZ_DEBUG_REASON_EXIT_TID, RZ_DEBUG_REASON_NEW_LIB, RZ_DEBUG_REASON_NEW_PID, RZ_DEBUG_REASON_NEW_TID, RZ_DEBUG_REASON_NONE, RZ_DEBUG_REASON_STEP, RZ_DEBUG_REASON_TRACEPOINT, rz_debug_recoil(), rz_debug_reg_get(), rz_debug_reg_set(), rz_debug_select(), rz_debug_signal_what(), rz_debug_step(), rz_debug_wait(), rz_lib_dl_sym(), RZ_PERM_X, rz_reg_get(), RZ_REG_NAME_PC, RZ_REG_TYPE_GPR, rz_signal_to_string(), rz_vector_foreach_prev, rz_debug_t::session, rz_debug_reason_t::signum, rz_debug_t::tid, rz_debug_t::trace_clone, rz_debug_t::trace_continue, and ut64().

Referenced by rz_cmd_debug_continue_send_signal_handler(), rz_debug_continue(), and rz_debug_continue_pass_exception().

rz_debug_continue_pass_exception()

RZ_API int rz_debug_continue_pass_exception

(

RzDebug *

dbg

)

Definition at line 1336 of file debug.c.

                                                          {
    return rz_debug_continue_kill(dbg, dbg->reason.signum);
}

References dbg, rz_debug_t::reason, rz_debug_continue_kill(), and rz_debug_reason_t::signum.

Referenced by rz_cmd_debug_continue_exception_handler().

rz_debug_continue_syscall()

RZ_API int rz_debug_continue_syscall	(	RzDebug *	dbg,
		int	sc
	)

Definition at line 1578 of file debug.c.

                                                           {
    return rz_debug_continue_syscalls(dbg, &sc, 1);
}

References dbg, rz_debug_continue_syscalls(), and sc.

rz_debug_continue_syscalls()

RZ_API int rz_debug_continue_syscalls	(	RzDebug *	dbg,
		int *	sc,
		int	n_sc
	)

Definition at line 1507 of file debug.c.

                                                                       {
    int i, reg, ret = false;
    if (!dbg || !dbg->cur || rz_debug_is_dead(dbg)) {
        return false;
    }
    if (!dbg->cur->contsc) {
        /* user-level syscall tracing */
        rz_debug_continue_until_optype(dbg, RZ_ANALYSIS_OP_TYPE_SWI, 0);
        return show_syscall(dbg, "A0");
    }
 
    if (!rz_debug_reg_sync(dbg, RZ_REG_TYPE_GPR, false)) {
        eprintf("--> cannot read registers\n");
        return -1;
    }
 
    if (!rz_reg_get_by_role(dbg->reg, RZ_REG_NAME_SN)) {
        eprintf("Cannot find 'sn' register for current arch-os.\n");
        return -1;
    }
    for (;;) {
        RzDebugReasonType reason;
 
        if (rz_cons_singleton()->context->breaked) {
            break;
        }
#if __linux__
        // step is needed to avoid dupped contsc results
        /* XXX(jjd): actually one stop is before the syscall, the other is
         * after.  this allows you to inspect the arguments before and the
         * return value after... */
        rz_debug_step(dbg, 1);
#endif
        dbg->cur->contsc(dbg, dbg->pid, 0); // TODO handle return value
        // wait until continuation
        reason = rz_debug_wait(dbg, NULL);
        if (reason == RZ_DEBUG_REASON_DEAD || rz_debug_is_dead(dbg)) {
            break;
        }
#if 0
        if (reason != RZ_DEBUG_REASON_STEP) {
            eprintf ("astep\n");
            break;
        }
#endif
        if (!rz_debug_reg_sync(dbg, RZ_REG_TYPE_GPR, false)) {
            eprintf("--> cannot sync regs, process is probably dead\n");
            return -1;
        }
        reg = show_syscall(dbg, "SN");
 
        if (dbg->corebind.core && dbg->corebind.syshit) {
            dbg->corebind.syshit(dbg->corebind.core);
        }
 
        if (n_sc == -1) {
            continue;
        }
        if (n_sc == 0) {
            break;
        }
        for (i = 0; i < n_sc; i++) {
            if (sc[i] == reg) {
                return reg;
            }
        }
        // TODO: must use rz_core_cmd(as)..import code from rcore
    }
    return ret;
}

References rz_debug_plugin_t::contsc, rz_core_bind_t::core, rz_debug_t::corebind, rz_debug_t::cur, dbg, eprintf, i, NULL, rz_debug_t::pid, reg, rz_debug_t::reg, RZ_ANALYSIS_OP_TYPE_SWI, rz_cons_singleton(), rz_debug_continue_until_optype(), rz_debug_is_dead(), RZ_DEBUG_REASON_DEAD, RZ_DEBUG_REASON_STEP, rz_debug_reg_sync(), rz_debug_step(), rz_debug_wait(), rz_reg_get_by_role(), RZ_REG_NAME_SN, RZ_REG_TYPE_GPR, sc, show_syscall(), and rz_core_bind_t::syshit.

Referenced by cmd_debug_cont_syscall(), and rz_debug_continue_syscall().

rz_debug_continue_until()

RZ_API int rz_debug_continue_until	(	RzDebug *	dbg,
		ut64	addr
	)

Definition at line 1434 of file debug.c.

                                                            {
    return rz_debug_continue_until_internal(dbg, addr, true);
}

References addr, dbg, and rz_debug_continue_until_internal().

Referenced by do_debug_trace_calls(), and rz_debug_step_over().

rz_debug_continue_until_internal()

static int rz_debug_continue_until_internal ( RzDebug *  dbg, ut64  addr, bool  block  )

static

Definition at line 1402 of file debug.c.

                                                                                 {
    if (rz_debug_is_dead(dbg)) {
        return false;
    }
    // Check if there was another breakpoint set at addr
    bool has_bp = rz_bp_get_in(dbg->bp, addr, RZ_PERM_X) != NULL;
    if (!has_bp) {
        rz_bp_add_sw(dbg->bp, addr, 0, RZ_PERM_X);
    }
 
    // Continue until the bp is reached
    dbg->reason.type = 0;
    for (;;) {
        if (rz_debug_is_dead(dbg) || dbg->reason.type) {
            break;
        }
        ut64 pc = rz_debug_reg_get(dbg, dbg->reg->name[RZ_REG_NAME_PC]);
        if (pc == addr) {
            break;
        }
        if (block && rz_bp_get_at(dbg->bp, pc)) {
            break;
        }
        rz_debug_continue(dbg);
    }
    // Clean up if needed
    if (!has_bp) {
        rz_bp_del(dbg->bp, addr);
    }
    return true;
}

References addr, rz_debug_t::bp, dbg, rz_reg_t::name, NULL, pc, rz_debug_t::reason, rz_debug_t::reg, rz_bp_add_sw(), rz_bp_del(), rz_bp_get_at(), rz_bp_get_in(), rz_debug_continue(), rz_debug_is_dead(), rz_debug_reg_get(), RZ_PERM_X, RZ_REG_NAME_PC, rz_debug_reason_t::type, and ut64().

Referenced by rz_debug_continue_until(), and rz_debug_continue_until_nonblock().

rz_debug_continue_until_nonblock()

RZ_API int rz_debug_continue_until_nonblock	(	RzDebug *	dbg,
		ut64	addr
	)

Definition at line 1438 of file debug.c.

                                                                     {
    return rz_debug_continue_until_internal(dbg, addr, false);
}

References addr, dbg, and rz_debug_continue_until_internal().

rz_debug_continue_until_nontraced()

RZ_API int rz_debug_continue_until_nontraced

(

RzDebug *

dbg

)

Definition at line 1340 of file debug.c.

                                                           {
    eprintf("TODO\n");
    return false;
}

References eprintf.

rz_debug_continue_until_optype()

RZ_API int rz_debug_continue_until_optype	(	RzDebug *	dbg,
		int	type,
		int	over
	)

Definition at line 1345 of file debug.c.

                                                                            {
    int ret, n = 0;
    ut64 pc, buf_pc = 0;
    RzAnalysisOp op;
    ut8 buf[DBG_BUF_SIZE];
 
    if (rz_debug_is_dead(dbg)) {
        return false;
    }
 
    if (!dbg->analysis || !dbg->reg) {
        eprintf("Undefined pointer at dbg->analysis\n");
        return false;
    }
 
    rz_debug_step(dbg, 1);
    rz_debug_reg_sync(dbg, RZ_REG_TYPE_GPR, false);
 
    // Initial refill
    buf_pc = rz_debug_reg_get(dbg, dbg->reg->name[RZ_REG_NAME_PC]);
    dbg->iob.read_at(dbg->iob.io, buf_pc, buf, sizeof(buf));
 
    // step first, we don't want to check current optype
    for (;;) {
        if (!rz_debug_reg_sync(dbg, RZ_REG_TYPE_GPR, false)) {
            break;
        }
 
        pc = rz_debug_reg_get(dbg, dbg->reg->name[RZ_REG_NAME_PC]);
        // Try to keep the buffer full
        if (pc - buf_pc > sizeof(buf)) {
            buf_pc = pc;
            dbg->iob.read_at(dbg->iob.io, buf_pc, buf, sizeof(buf));
        }
        // Analyze the opcode
        if (rz_analysis_op(dbg->analysis, &op, pc, buf + (pc - buf_pc), sizeof(buf) - (pc - buf_pc), RZ_ANALYSIS_OP_MASK_BASIC) < 1) {
            eprintf("Decode error at %" PFMT64x "\n", pc);
            return false;
        }
        if (op.type == type) {
            break;
        }
        // Step over and repeat
        ret = over
            ? rz_debug_step_over(dbg, 1)
            : rz_debug_step(dbg, 1);
 
        if (!ret) {
            eprintf("rz_debug_step: failed\n");
            break;
        }
        n++;
    }
 
    return n;
}

References rz_debug_t::analysis, dbg, DBG_BUF_SIZE, eprintf, rz_io_bind_t::io, rz_debug_t::iob, n, rz_reg_t::name, op, pc, PFMT64x, rz_io_bind_t::read_at, rz_debug_t::reg, rz_analysis_op(), RZ_ANALYSIS_OP_MASK_BASIC, rz_debug_is_dead(), rz_debug_reg_get(), rz_debug_reg_sync(), rz_debug_step(), rz_debug_step_over(), RZ_REG_NAME_PC, RZ_REG_TYPE_GPR, type, and ut64().

Referenced by rz_cmd_debug_continue_call_handler(), rz_cmd_debug_continue_ret_handler(), rz_cmd_debug_continue_unknown_call_handler(), rz_core_debug_single_step_over(), and rz_debug_continue_syscalls().

rz_debug_detach()

RZ_API int rz_debug_detach	(	RzDebug *	dbg,
		int	pid
	)

Definition at line 583 of file debug.c.

                                                  {
    int ret = 0;
    if (dbg->cur && dbg->cur->detach) {
        ret = dbg->cur->detach(dbg, pid);
        if (dbg->pid == pid) {
            dbg->pid = -1;
            dbg->tid = -1;
        }
    }
    return ret;
}

References rz_debug_t::cur, dbg, rz_debug_plugin_t::detach, rz_debug_t::pid, pid, and rz_debug_t::tid.

Referenced by cmd_debug_pid(), rz_core_debug_process_close(), rz_core_file_reopen(), and rz_main_rizin().

rz_debug_drx_at()

static int rz_debug_drx_at ( RzDebug *  dbg, ut64  addr  )

static

Definition at line 50 of file debug.c.

                                                    {
    if (dbg && dbg->cur && dbg->cur->drx) {
        return dbg->cur->drx(dbg, 0, addr, 0, 0, 0, DRX_API_GET_BP);
    }
    return -1;
}

References addr, rz_debug_t::cur, dbg, rz_debug_plugin_t::drx, and DRX_API_GET_BP.

Referenced by rz_debug_bp_hit().

rz_debug_drx_list()

RZ_API void rz_debug_drx_list

(

RzDebug *

dbg

)

Definition at line 1662 of file debug.c.

                                            {
    if (dbg && dbg->cur && dbg->cur->drx) {
        dbg->cur->drx(dbg, 0, 0, 0, 0, 0, DRX_API_LIST);
    }
}

References rz_debug_t::cur, dbg, rz_debug_plugin_t::drx, and DRX_API_LIST.

Referenced by rz_debug_drx_handler().

rz_debug_drx_set()

RZ_API int rz_debug_drx_set	(	RzDebug *	dbg,
		int	idx,
		ut64	addr,
		int	len,
		int	rwx,
		int	g
	)

Definition at line 1668 of file debug.c.

                                                                                       {
    if (dbg && dbg->cur && dbg->cur->drx) {
        return dbg->cur->drx(dbg, idx, addr, len, rwx, g, DRX_API_SET_BP);
    }
    return false;
}

References addr, rz_debug_t::cur, dbg, rz_debug_plugin_t::drx, DRX_API_SET_BP, g, setup::idx, and len.

Referenced by drx_add(), and rz_debug_drx_handler().

rz_debug_drx_unset()

RZ_API int rz_debug_drx_unset	(	RzDebug *	dbg,
		int	idx
	)

Definition at line 1675 of file debug.c.

                                                     {
    if (dbg && dbg->cur && dbg->cur->drx) {
        return dbg->cur->drx(dbg, idx, 0, -1, 0, 0, DRX_API_REMOVE_BP);
    }
    return false;
}

References rz_debug_t::cur, dbg, rz_debug_plugin_t::drx, DRX_API_REMOVE_BP, and setup::idx.

Referenced by drx_del(), linux_remove_fork_bps(), and rz_debug_drx_unset_handler().

rz_debug_execute()

RZ_API ut64 rz_debug_execute	(	RzDebug *	dbg,
		const ut8 *	buf,
		int	len,
		int	restore
	)

Definition at line 510 of file debug.c.

                                                                                 {
    int orig_sz;
    ut8 stackbackup[4096];
    ut8 *backup, *orig = NULL;
    RzRegItem *ri, *risp, *ripc;
    ut64 rsp, rpc, ra0 = 0LL;
    if (rz_debug_is_dead(dbg)) {
        return false;
    }
    ripc = rz_reg_get(dbg->reg, dbg->reg->name[RZ_REG_NAME_PC], RZ_REG_TYPE_GPR);
    risp = rz_reg_get(dbg->reg, dbg->reg->name[RZ_REG_NAME_SP], RZ_REG_TYPE_GPR);
    if (ripc) {
        rz_debug_reg_sync(dbg, RZ_REG_TYPE_GPR, false);
        orig = rz_reg_get_bytes(dbg->reg, RZ_REG_TYPE_ANY, &orig_sz);
        if (!orig) {
            eprintf("Cannot get register arena bytes\n");
            return 0LL;
        }
        rpc = rz_reg_get_value(dbg->reg, ripc);
        rsp = rz_reg_get_value(dbg->reg, risp);
 
        backup = malloc(len);
        if (!backup) {
            free(orig);
            return 0LL;
        }
        dbg->iob.read_at(dbg->iob.io, rpc, backup, len);
        dbg->iob.read_at(dbg->iob.io, rsp, stackbackup, len);
 
        rz_bp_add_sw(dbg->bp, rpc + len, 0, RZ_PERM_X);
 
        /* execute code here */
        dbg->iob.write_at(dbg->iob.io, rpc, buf, len);
        // rz_bp_add_sw (dbg->bp, rpc+len, 4, RZ_PERM_X);
        rz_debug_continue(dbg);
        // rz_bp_del (dbg->bp, rpc+len);
        /* TODO: check if stopped in breakpoint or not */
 
        rz_bp_del(dbg->bp, rpc + len);
        dbg->iob.write_at(dbg->iob.io, rpc, backup, len);
        if (restore) {
            dbg->iob.write_at(dbg->iob.io, rsp, stackbackup, len);
        }
 
        rz_debug_reg_sync(dbg, RZ_REG_TYPE_GPR, false);
        ri = rz_reg_get(dbg->reg, dbg->reg->name[RZ_REG_NAME_A0], RZ_REG_TYPE_GPR);
        ra0 = rz_reg_get_value(dbg->reg, ri);
        if (restore) {
            rz_reg_read_regs(dbg->reg, orig, orig_sz);
        } else {
            rz_reg_set_value(dbg->reg, ripc, rpc);
        }
        rz_debug_reg_sync(dbg, RZ_REG_TYPE_GPR, true);
        free(backup);
        free(orig);
        eprintf("ra0=0x%08" PFMT64x "\n", ra0);
    } else {
        eprintf("rz_debug_execute: Cannot get program counter\n");
    }
    return (ra0);
}

References rz_debug_t::bp, dbg, eprintf, free(), rz_io_bind_t::io, rz_debug_t::iob, len, malloc(), rz_reg_t::name, NULL, PFMT64x, rz_io_bind_t::read_at, rz_debug_t::reg, rz_bp_add_sw(), rz_bp_del(), rz_debug_continue(), rz_debug_is_dead(), rz_debug_reg_sync(), RZ_PERM_X, rz_reg_get(), rz_reg_get_bytes(), rz_reg_get_value(), RZ_REG_NAME_A0, RZ_REG_NAME_PC, RZ_REG_NAME_SP, rz_reg_read_regs(), rz_reg_set_value(), RZ_REG_TYPE_ANY, RZ_REG_TYPE_GPR, ut64(), and rz_io_bind_t::write_at.

Referenced by rz_cmd_debug().

rz_debug_frames()

RZ_API RzList* rz_debug_frames	(	RzDebug *	dbg,
		ut64	at
	)

Definition at line 1612 of file debug.c.

                                                      {
    if (dbg && dbg->cur && dbg->cur->frames) {
        return dbg->cur->frames(dbg, at);
    }
    return NULL;
}

References rz_debug_t::cur, dbg, rz_debug_plugin_t::frames, and NULL.

Referenced by iter_dbt_commands(), rz_cmd_debug_display_bt_ascii_handler(), rz_cmd_debug_display_bt_local_vars_handler(), rz_cmd_debug_display_bt_oneline_handler(), rz_core_cmd_foreach(), and rz_core_debug_backtraces().

rz_debug_free()

RZ_API RzDebug* rz_debug_free

(

RzDebug *

dbg

)

Definition at line 416 of file debug.c.

                                            {
    if (dbg) {
        rz_hash_free(dbg->hash);
        rz_bp_free(dbg->bp);
        free(dbg->snap_path);
        rz_list_free(dbg->maps);
        rz_list_free(dbg->maps_user);
        rz_list_free(dbg->threads);
        rz_num_free(dbg->num);
        sdb_free(dbg->sgnls);
        rz_tree_free(dbg->tree);
        ht_up_free(dbg->tracenodes);
        rz_list_free(dbg->plugins);
        rz_list_free(dbg->call_frames);
        free(dbg->btalgo);
        rz_debug_trace_free(dbg->trace);
        rz_debug_session_free(dbg->session);
        rz_analysis_op_free(dbg->cur_op);
        dbg->trace = NULL;
        rz_egg_free(dbg->egg);
        rz_reg_free(dbg->reg);
        free(dbg->arch);
        free(dbg->glob_libs);
        free(dbg->glob_unlibs);
        free(dbg);
    }
    return NULL;
}

References rz_debug_t::arch, rz_debug_t::bp, rz_debug_t::btalgo, rz_debug_t::call_frames, rz_debug_t::cur_op, dbg, rz_debug_t::egg, free(), rz_debug_t::glob_libs, rz_debug_t::glob_unlibs, rz_debug_t::hash, rz_debug_t::maps, rz_debug_t::maps_user, NULL, rz_debug_t::num, rz_debug_t::plugins, rz_debug_t::reg, rz_analysis_op_free(), rz_bp_free(), rz_debug_session_free(), rz_debug_trace_free(), rz_egg_free(), rz_hash_free(), rz_list_free(), rz_num_free(), rz_reg_free(), rz_tree_free(), sdb_free(), rz_debug_t::session, rz_debug_t::sgnls, rz_debug_t::snap_path, rz_debug_t::threads, rz_debug_t::trace, rz_debug_t::tracenodes, and rz_debug_t::tree.

Referenced by rz_core_fini().

rz_debug_get_baddr()

RZ_API ut64 rz_debug_get_baddr	(	RzDebug *	dbg,
		const char *	file
	)

Definition at line 1682 of file debug.c.

                                                               {
    if (!dbg || !dbg->iob.io || !dbg->iob.io->desc) {
        return 0LL;
    }
    if (!strcmp(dbg->iob.io->desc->plugin->name, "gdb")) { // this is very bad
        // Tell gdb that we want baddr, not full mem map
        dbg->iob.system(dbg->iob.io, "baddr");
    }
    int pid = rz_io_desc_get_pid(dbg->iob.io->desc);
    int tid = rz_io_desc_get_tid(dbg->iob.io->desc);
    if (pid < 0 || tid < 0) {
        return 0LL;
    }
    if (rz_debug_attach(dbg, pid) == -1) {
        return 0LL;
    }
#if __WINDOWS__
    ut64 base;
    bool ret = rz_io_desc_get_base(dbg->iob.io->desc, &base);
    if (ret) {
        return base;
    }
#endif
    RzListIter *iter;
    RzDebugMap *map;
    rz_debug_select(dbg, pid, tid);
    rz_debug_map_sync(dbg);
    char *abspath = rz_sys_pid_to_path(pid);
#if !__WINDOWS__
    if (!abspath) {
        abspath = rz_file_abspath(file);
    }
#endif
    if (!abspath) {
        abspath = strdup(file);
    }
    if (abspath) {
        rz_list_foreach (dbg->maps, iter, map) {
            if (!strcmp(abspath, map->name)) {
                free(abspath);
                return map->addr;
            }
        }
        free(abspath);
    }
    // fallback resolution (osx/w32?)
    // we assume maps to be loaded in order, so lower addresses come first
    rz_list_foreach (dbg->maps, iter, map) {
        if (map->perm == 5) { // r-x
            return map->addr;
        }
    }
    return 0LL;
}

References dbg, rz_io_t::desc, free(), rz_io_bind_t::io, rz_debug_t::iob, map(), rz_debug_t::maps, rz_io_plugin_t::name, pid, rz_io_desc_t::plugin, rz_debug_attach(), rz_debug_map_sync(), rz_debug_select(), rz_file_abspath(), rz_io_desc_get_base(), rz_io_desc_get_pid(), rz_io_desc_get_tid(), rz_sys_pid_to_path(), strdup(), rz_io_bind_t::system, and ut64().

Referenced by num_callback(), rz_cmd_debug(), rz_core_file_reopen(), rz_core_file_reopen_remote_debug(), rz_core_rtr_gdb_cb(), and rz_main_rizin().

rz_debug_goto_cnum()

RZ_API bool rz_debug_goto_cnum	(	RzDebug *	dbg,
		ut32	cnum
	)

Definition at line 1110 of file debug.c.

                                                        {
    if (cnum > dbg->session->maxcnum) {
        eprintf("Error: out of cnum range\n");
        return false;
    }
    dbg->session->cnum = cnum;
    rz_debug_session_restore_reg_mem(dbg, cnum);
 
    return true;
}

References rz_debug_session_t::cnum, dbg, eprintf, rz_debug_session_t::maxcnum, rz_debug_session_restore_reg_mem(), and rz_debug_t::session.

Referenced by rz_debug_continue_back(), rz_debug_continue_kill(), rz_debug_step_back(), and rz_debug_step_cnum().

rz_debug_info()

RZ_API RzDebugInfo* rz_debug_info	(	RzDebug *	dbg,
		const char *	arg
	)

Definition at line 18 of file debug.c.

                                                                 {
    if (!dbg || !dbg->cur || !dbg->cur->info) {
        return NULL;
    }
    if (dbg->pid < 0) {
        return NULL;
    }
    return dbg->cur->info(dbg, arg);
}

References rz_debug_t::cur, dbg, rz_debug_plugin_t::info, NULL, and rz_debug_t::pid.

Referenced by rz_cmd_debug().

rz_debug_info_free()

RZ_API void rz_debug_info_free

(

RzDebugInfo *

rdi

)

Definition at line 28 of file debug.c.

                                                 {
    if (rdi) {
        free(rdi->cwd);
        free(rdi->exe);
        free(rdi->cmdline);
        free(rdi->libname);
        free(rdi->usr);
        free(rdi);
    }
}

References free(), and rdi.

Referenced by rz_cmd_debug().

rz_debug_is_dead()

RZ_API bool rz_debug_is_dead

(

RzDebug *

dbg

)

Definition at line 1632 of file debug.c.

                                           {
    if (!dbg->cur) {
        return false;
    }
    // workaround for debug.io.. should be generic
    if (!strcmp(dbg->cur->name, "io")) {
        return false;
    }
    bool is_dead = (dbg->pid == -1 && strncmp(dbg->cur->name, "gdb", 3)) || (dbg->reason.type == RZ_DEBUG_REASON_DEAD);
    if (dbg->pid > 0 && dbg->cur && dbg->cur->kill) {
        is_dead = !dbg->cur->kill(dbg, dbg->pid, false, 0);
    }
#if 0
    if (!is_dead && dbg->cur && dbg->cur->kill) {
        is_dead = !dbg->cur->kill (dbg, dbg->pid, false, 0);
    }
#endif
    if (is_dead) {
        dbg->reason.type = RZ_DEBUG_REASON_DEAD;
    }
    return is_dead;
}

References rz_debug_t::cur, dbg, rz_debug_plugin_t::kill, rz_debug_plugin_t::name, rz_debug_t::pid, rz_debug_t::reason, RZ_DEBUG_REASON_DEAD, and rz_debug_reason_t::type.

Referenced by debug_trace_calls(), do_debug_trace_calls(), rz_cmd_debug_start_trace_session_handler(), rz_cmd_debug_step_cond_handler(), rz_core_debug_continue_until(), rz_core_debug_map_update_flags(), rz_core_debug_step_until_frame(), rz_core_file_reopen(), rz_debug_can_kill(), rz_debug_continue_kill(), rz_debug_continue_syscalls(), rz_debug_continue_until_internal(), rz_debug_continue_until_optype(), rz_debug_execute(), rz_debug_kill(), rz_debug_reg_sync(), rz_debug_step(), rz_debug_step_hard(), rz_debug_step_over(), rz_debug_step_soft(), rz_debug_wait(), step_until(), step_until_esil(), step_until_flag(), step_until_inst(), and step_until_optype().

rz_debug_kill()

RZ_API int rz_debug_kill	(	RzDebug *	dbg,
		int	pid,
		int	tid,
		int	sig
	)

Definition at line 1598 of file debug.c.

                                                                  {
    if (rz_debug_is_dead(dbg)) {
        return false;
    }
    if (dbg->cur && dbg->cur->kill) {
        if (pid > 0) {
            return dbg->cur->kill(dbg, pid, tid, sig);
        }
        return -1;
    }
    eprintf("Backend does not implement kill()\n");
    return false;
}

References rz_debug_t::cur, dbg, eprintf, rz_debug_plugin_t::kill, pid, and rz_debug_is_dead().

Referenced by cmd_debug_pid(), rz_cmd_debug(), rz_core_debug_kill(), rz_core_debug_process_close(), rz_core_file_reopen(), and rz_main_rizin().

rz_debug_map_protect()

RZ_API int rz_debug_map_protect	(	RzDebug *	dbg,
		ut64	addr,
		int	size,
		int	perms
	)

Definition at line 1655 of file debug.c.

                                                                              {
    if (dbg && dbg->cur && dbg->cur->map_protect) {
        return dbg->cur->map_protect(dbg, addr, size, perms);
    }
    return false;
}

References addr, rz_debug_t::cur, dbg, and rz_debug_plugin_t::map_protect.

Referenced by rz_debug_memory_permission_handler().

rz_debug_new()

RZ_API RZ_OWN RzDebug* rz_debug_new

(

RZ_BORROW RZ_NONNULL RzBreakpointContext *

bp_ctx

)

Definition at line 359 of file debug.c.

                                                                                      {
    rz_return_val_if_fail(bp_ctx, NULL);
    RzDebug *dbg = RZ_NEW0(RzDebug);
    if (!dbg) {
        return NULL;
    }
    // RZ_SYS_ARCH
    dbg->arch = strdup(RZ_SYS_ARCH);
    dbg->bits = RZ_SYS_BITS;
    dbg->trace_forks = 1;
    dbg->forked_pid = -1;
    dbg->main_pid = -1;
    dbg->n_threads = 0;
    dbg->trace_clone = 0;
    dbg->egg = rz_egg_new();
    rz_egg_setup(dbg->egg, RZ_SYS_ARCH, RZ_SYS_BITS, RZ_SYS_ENDIAN, RZ_SYS_OS);
    dbg->trace_aftersyscall = true;
    dbg->follow_child = false;
    RZ_FREE(dbg->btalgo);
    dbg->trace_execs = 0;
    dbg->analysis = NULL;
    dbg->pid = -1;
    dbg->tid = -1;
    dbg->tree = rz_tree_new();
    dbg->tracenodes = ht_up_new(NULL, free_tracenodes_kv, NULL);
    dbg->swstep = 0;
    dbg->stop_all_threads = false;
    dbg->trace = rz_debug_trace_new();
    dbg->cb_printf = (void *)printf;
    dbg->reg = rz_reg_new();
    dbg->num = rz_num_new(rz_debug_num_callback, rz_debug_str_callback, dbg);
    dbg->cur = NULL;
    dbg->plugin_data = NULL;
    dbg->threads = NULL;
    dbg->hitinfo = 1;
    /* TODO: needs a redesign? */
    dbg->maps = rz_debug_map_list_new();
    dbg->maps_user = rz_debug_map_list_new();
    dbg->q_regs = NULL;
    dbg->call_frames = NULL;
    dbg->main_arena_resolved = false;
    dbg->glibc_version = 231; /* default version ubuntu 20 */
    rz_debug_signal_init(dbg);
    dbg->bp = rz_bp_new(bp_ctx);
    rz_debug_plugin_init(dbg);
    dbg->bp->iob.init = false;
    dbg->bp->baddr = 0;
    dbg->nt_x86_xstate_supported = true;
    dbg->hash = rz_hash_new();
    return dbg;
}

References rz_debug_t::analysis, rz_debug_t::arch, rz_bp_t::baddr, rz_debug_t::bits, rz_debug_t::bp, rz_debug_t::btalgo, rz_debug_t::call_frames, rz_debug_t::cb_printf, rz_debug_t::cur, dbg, rz_debug_t::egg, rz_debug_t::follow_child, rz_debug_t::forked_pid, free_tracenodes_kv(), rz_debug_t::glibc_version, rz_debug_t::hash, rz_debug_t::hitinfo, rz_io_bind_t::init, rz_bp_t::iob, rz_debug_t::main_arena_resolved, rz_debug_t::main_pid, rz_debug_t::maps, rz_debug_t::maps_user, rz_debug_t::n_threads, rz_debug_t::nt_x86_xstate_supported, NULL, rz_debug_t::num, rz_debug_t::pid, rz_debug_t::plugin_data, printf(), rz_debug_t::q_regs, rz_debug_t::reg, rz_bp_new(), rz_debug_map_list_new(), rz_debug_num_callback(), rz_debug_plugin_init(), rz_debug_signal_init(), rz_debug_str_callback(), rz_debug_trace_new(), rz_egg_new(), rz_egg_setup(), RZ_FREE, rz_hash_new(), RZ_NEW0, rz_num_new(), rz_reg_new(), rz_return_val_if_fail, RZ_SYS_ARCH, RZ_SYS_BITS, RZ_SYS_ENDIAN, RZ_SYS_OS, rz_tree_new(), rz_debug_t::stop_all_threads, strdup(), rz_debug_t::swstep, rz_debug_t::threads, rz_debug_t::tid, rz_debug_t::trace, rz_debug_t::trace_aftersyscall, rz_debug_t::trace_clone, rz_debug_t::trace_execs, rz_debug_t::trace_forks, rz_debug_t::tracenodes, and rz_debug_t::tree.

Referenced by rz_core_init().

rz_debug_reason_to_string()

RZ_API const char* rz_debug_reason_to_string

(

int

type

)

Definition at line 639 of file debug.c.

                                                       {
    switch (type) {
    case RZ_DEBUG_REASON_DEAD: return "dead";
    case RZ_DEBUG_REASON_ABORT: return "abort";
    case RZ_DEBUG_REASON_SEGFAULT: return "segfault";
    case RZ_DEBUG_REASON_NONE: return "none";
    case RZ_DEBUG_REASON_SIGNAL: return "signal";
    case RZ_DEBUG_REASON_BREAKPOINT: return "breakpoint";
    case RZ_DEBUG_REASON_TRACEPOINT: return "tracepoint";
    case RZ_DEBUG_REASON_READERR: return "read-error";
    case RZ_DEBUG_REASON_WRITERR: return "write-error";
    case RZ_DEBUG_REASON_DIVBYZERO: return "div-by-zero";
    case RZ_DEBUG_REASON_ILLEGAL: return "illegal";
    case RZ_DEBUG_REASON_UNKNOWN: return "unknown";
    case RZ_DEBUG_REASON_ERROR: return "error";
    case RZ_DEBUG_REASON_NEW_PID: return "new-pid";
    case RZ_DEBUG_REASON_NEW_TID: return "new-tid";
    case RZ_DEBUG_REASON_NEW_LIB: return "new-lib";
    case RZ_DEBUG_REASON_EXIT_PID: return "exit-pid";
    case RZ_DEBUG_REASON_EXIT_TID: return "exit-tid";
    case RZ_DEBUG_REASON_EXIT_LIB: return "exit-lib";
    case RZ_DEBUG_REASON_TRAP: return "trap";
    case RZ_DEBUG_REASON_SWI: return "software-interrupt";
    case RZ_DEBUG_REASON_INT: return "interrupt";
    case RZ_DEBUG_REASON_FPU: return "fpu";
    case RZ_DEBUG_REASON_STEP: return "step";
    case RZ_DEBUG_REASON_USERSUSP: return "suspended-by-user";
    }
    return "unhandled";
}

References RZ_DEBUG_REASON_ABORT, RZ_DEBUG_REASON_BREAKPOINT, RZ_DEBUG_REASON_DEAD, RZ_DEBUG_REASON_DIVBYZERO, RZ_DEBUG_REASON_ERROR, RZ_DEBUG_REASON_EXIT_LIB, RZ_DEBUG_REASON_EXIT_PID, RZ_DEBUG_REASON_EXIT_TID, RZ_DEBUG_REASON_FPU, RZ_DEBUG_REASON_ILLEGAL, RZ_DEBUG_REASON_INT, RZ_DEBUG_REASON_NEW_LIB, RZ_DEBUG_REASON_NEW_PID, RZ_DEBUG_REASON_NEW_TID, RZ_DEBUG_REASON_NONE, RZ_DEBUG_REASON_READERR, RZ_DEBUG_REASON_SEGFAULT, RZ_DEBUG_REASON_SIGNAL, RZ_DEBUG_REASON_STEP, RZ_DEBUG_REASON_SWI, RZ_DEBUG_REASON_TRACEPOINT, RZ_DEBUG_REASON_TRAP, RZ_DEBUG_REASON_UNKNOWN, RZ_DEBUG_REASON_USERSUSP, RZ_DEBUG_REASON_WRITERR, and type.

Referenced by rz_cmd_debug().

rz_debug_recoil()

static int rz_debug_recoil ( RzDebug *  dbg, RzDebugRecoilMode  rc_mode  )

static

Definition at line 223 of file debug.c.

                                                                    {
    /* if bp_addr is not set, we must not have actually hit a breakpoint */
    if (!dbg->reason.bp_addr) {
        return rz_debug_bps_enable(dbg);
    }
 
    /* don't do anything if we already are recoiling */
    if (dbg->recoil_mode != RZ_DBG_RECOIL_NONE) {
        /* the first time recoil is called with swstep, we just need to
         * look up the bp and step past it.
         * the second time it's called, the new sw breakpoint should exist
         * so we just restore all except what we originally hit and reset.
         */
        if (dbg->swstep) {
            if (!rz_bp_restore_except(dbg->bp, true, dbg->reason.bp_addr)) {
                return false;
            }
            return true;
        }
 
        /* otherwise, avoid recursion */
        return true;
    }
 
    /* we have entered recoil! */
    dbg->recoil_mode = rc_mode;
 
    /* step over the place with the breakpoint and let the caller resume */
    if (rz_debug_step(dbg, 1) != 1) {
        return false;
    }
 
    /* when stepping away from a breakpoint during recoil in stepping mode,
     * the rz_debug_bp_hit function tells us that it was called
     * innapropriately by setting bp_addr back to zero. however, recoil_mode
     * is still set. we use this condition to know not to proceed but
     * pretend as if we had.
     */
    if (!dbg->reason.bp_addr && dbg->recoil_mode == RZ_DBG_RECOIL_STEP) {
        return true;
    }
    dbg->reason.bp_addr = 0;
 
    return rz_debug_bps_enable(dbg);
}

References rz_debug_t::bp, rz_debug_reason_t::bp_addr, dbg, rz_debug_t::reason, rz_debug_t::recoil_mode, rz_bp_restore_except(), RZ_DBG_RECOIL_NONE, RZ_DBG_RECOIL_STEP, rz_debug_bps_enable(), rz_debug_step(), and rz_debug_t::swstep.

Referenced by rz_debug_continue_kill(), and rz_debug_step_hard().

rz_debug_select()

RZ_API bool rz_debug_select	(	RzDebug *	dbg,
		int	pid,
		int	tid
	)

Definition at line 595 of file debug.c.

                                                            {
    ut64 pc = 0;
    int prev_pid = dbg->pid;
    int prev_tid = dbg->tid;
 
    if (pid < 0) {
        return false;
    }
    if (tid < 0) {
        tid = pid;
    }
 
    if ((pid != dbg->pid || tid != dbg->tid) && dbg->verbose) {
        eprintf("= attach %d %d\n", pid, tid);
    }
 
    if (dbg->cur && dbg->cur->select && !dbg->cur->select(dbg, pid, tid)) {
        return false;
    }
 
    // Don't change the pid/tid if the plugin already modified it due to internal constraints
    if (dbg->pid == prev_pid) {
        dbg->pid = pid;
    }
    if (dbg->tid == prev_tid) {
        dbg->tid = tid;
    }
 
    rz_io_system(dbg->iob.io, sdb_fmt("pid %d", dbg->tid));
 
    // Synchronize with the current thread's data
    if (dbg->corebind.core) {
        RzCore *core = (RzCore *)dbg->corebind.core;
 
        rz_reg_arena_swap(core->dbg->reg, true);
        rz_debug_reg_sync(dbg, RZ_REG_TYPE_ANY, false);
 
        pc = rz_debug_reg_get(dbg, "PC");
        core->offset = pc;
    }
 
    return true;
}

References rz_core_bind_t::core, rz_debug_t::corebind, rz_debug_t::cur, dbg, rz_core_t::dbg, eprintf, rz_io_bind_t::io, rz_debug_t::iob, rz_core_t::offset, pc, rz_debug_t::pid, pid, rz_debug_t::reg, rz_debug_reg_get(), rz_debug_reg_sync(), rz_io_system(), rz_reg_arena_swap(), RZ_REG_TYPE_ANY, sdb_fmt(), rz_debug_plugin_t::select, rz_debug_t::tid, ut64(), and rz_debug_t::verbose.

Referenced by cb_cfgdebug(), cmd_debug_pid(), core_file_do_load_for_debug(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), linux_attach_new_process(), linux_handle_signals(), linux_remove_fork_bps(), rz_cmd_debug_continue_execution_handler(), rz_cmd_debug_continue_send_signal_handler(), rz_core_cmd_foreach(), rz_core_debug_attach(), rz_core_file_reopen(), rz_core_setup_debugger(), rz_debug_attach(), rz_debug_continue_kill(), rz_debug_get_baddr(), and w32_attach_new_process().

rz_debug_set_arch()

RZ_API bool rz_debug_set_arch	(	RzDebug *	dbg,
		const char *	arch,
		int	bits
	)

Definition at line 465 of file debug.c.

                                                                        {
    if (arch && dbg && dbg->cur) {
        switch (bits) {
        case 16:
            if (dbg->cur->bits & RZ_SYS_BITS_16) {
                dbg->bits = RZ_SYS_BITS_16;
            }
            break;
        case 27:
            if (dbg->cur->bits == 27) {
                dbg->bits = 27;
            }
            break;
        case 32:
            if (dbg->cur->bits & RZ_SYS_BITS_32) {
                dbg->bits = RZ_SYS_BITS_32;
            }
            break;
        case 64:
            dbg->bits = RZ_SYS_BITS_64;
            break;
        }
        if (!dbg->cur->bits) {
            dbg->bits = dbg->cur->bits;
        } else if (!(dbg->cur->bits & dbg->bits)) {
            dbg->bits = dbg->cur->bits & RZ_SYS_BITS_64;
            if (!dbg->bits) {
                dbg->bits = dbg->cur->bits & RZ_SYS_BITS_32;
            }
            if (!dbg->bits) {
                dbg->bits = RZ_SYS_BITS_32;
            }
        }
        free(dbg->arch);
        dbg->arch = strdup(arch);
        return true;
    }
    return false;
}

References rz_debug_t::arch, arch, rz_debug_t::bits, rz_debug_plugin_t::bits, bits(), rz_debug_t::cur, dbg, free(), RZ_SYS_BITS_16, RZ_SYS_BITS_32, RZ_SYS_BITS_64, and strdup().

Referenced by cb_asmarch(), cb_asmbits(), and rz_debug_use().

rz_debug_start()

RZ_API int rz_debug_start	(	RzDebug *	dbg,
		const char *	cmd
	)

Definition at line 577 of file debug.c.

                                                         {
    /* TODO: this argc/argv parser is done in rz_io */
    // TODO: parse cmd and generate argc and argv
    return false;
}

rz_debug_startv()

RZ_API int rz_debug_startv	(	struct rz_debug_t *	dbg,
		int	argc,
		char **	argv
	)

Definition at line 572 of file debug.c.

                                                                          {
    /* TODO : rz_debug_startv unimplemented */
    return false;
}

rz_debug_step()

RZ_API int rz_debug_step	(	RzDebug *	dbg,
		int	steps
	)

Definition at line 962 of file debug.c.

                                                  {
    RzBreakpointItem *bp = NULL;
    int ret, steps_taken = 0;
 
    /* who calls this without giving a positive number? */
    if (steps < 1) {
        steps = 1;
    }
 
    if (!dbg || !dbg->cur) {
        return steps_taken;
    }
 
    if (rz_debug_is_dead(dbg)) {
        return steps_taken;
    }
 
    dbg->reason.type = RZ_DEBUG_REASON_STEP;
 
    if (dbg->session) {
        if (dbg->session->cnum != dbg->session->maxcnum) {
            steps_taken = rz_debug_step_cnum(dbg, steps);
        }
    }
 
    for (; steps_taken < steps; steps_taken++) {
        if (dbg->session && dbg->recoil_mode == RZ_DBG_RECOIL_NONE) {
            dbg->session->cnum++;
            dbg->session->maxcnum++;
            dbg->session->bp = 0;
            if (!rz_debug_trace_ins_before(dbg)) {
                eprintf("trace_ins_before: failed\n");
            }
        }
 
        if (dbg->swstep) {
            ret = rz_debug_step_soft(dbg);
        } else {
            ret = rz_debug_step_hard(dbg, &bp);
        }
        if (!ret) {
            eprintf("Stepping failed!\n");
            return steps_taken;
        }
 
        if (dbg->session && dbg->recoil_mode == RZ_DBG_RECOIL_NONE) {
            if (!rz_debug_trace_ins_after(dbg)) {
                eprintf("trace_ins_after: failed\n");
            }
            dbg->session->reasontype = dbg->reason.type;
            dbg->session->bp = bp;
        }
 
        dbg->steps++;
        dbg->reason.type = RZ_DEBUG_REASON_STEP;
    }
 
    return steps_taken;
}

References rz_debug_session_t::bp, rz_debug_session_t::cnum, rz_debug_t::cur, dbg, eprintf, rz_debug_session_t::maxcnum, NULL, rz_debug_t::reason, rz_debug_session_t::reasontype, rz_debug_t::recoil_mode, RZ_DBG_RECOIL_NONE, rz_debug_is_dead(), RZ_DEBUG_REASON_STEP, rz_debug_step_cnum(), rz_debug_step_hard(), rz_debug_step_soft(), rz_debug_trace_ins_after(), rz_debug_trace_ins_before(), rz_debug_t::session, rz_debug_t::steps, rz_debug_t::swstep, and rz_debug_reason_t::type.

Referenced by cmd_dcu(), do_debug_trace_calls(), rz_cmd_debug_continue_mapped_io_handler(), rz_cmd_debug_step_cond_handler(), rz_cmd_debug_step_prog_handler(), rz_core_debug_continue_until(), rz_core_debug_step_one(), rz_debug_continue_kill(), rz_debug_continue_syscalls(), rz_debug_continue_until_optype(), rz_debug_esil_stepi(), rz_debug_recoil(), rz_debug_step_over(), step_line(), step_until(), step_until_esil(), step_until_flag(), step_until_inst(), and step_until_optype().

rz_debug_step_back()

RZ_API int rz_debug_step_back	(	RzDebug *	dbg,
		int	steps
	)

Definition at line 1121 of file debug.c.

                                                       {
    if (steps > dbg->session->cnum) {
        steps = dbg->session->cnum;
    }
    if (!rz_debug_goto_cnum(dbg, dbg->session->cnum - steps)) {
        return -1;
    }
    return steps;
}

References rz_debug_session_t::cnum, dbg, rz_debug_goto_cnum(), and rz_debug_t::session.

Referenced by rz_core_debug_step_back().

rz_debug_step_cnum()

RZ_API int rz_debug_step_cnum	(	RzDebug *	dbg,
		int	steps
	)

Definition at line 1131 of file debug.c.

                                                       {
    if (steps > dbg->session->maxcnum - dbg->session->cnum) {
        steps = dbg->session->maxcnum - dbg->session->cnum;
    }
 
    rz_debug_goto_cnum(dbg, dbg->session->cnum + steps);
 
    return steps;
}

References rz_debug_session_t::cnum, dbg, rz_debug_session_t::maxcnum, rz_debug_goto_cnum(), and rz_debug_t::session.

Referenced by rz_debug_step().

rz_debug_step_hard()

RZ_API int rz_debug_step_hard	(	RzDebug *	dbg,
		RzBreakpointItem **	pb
	)

Definition at line 909 of file debug.c.

                                                                   {
    RzDebugReasonType reason;
 
    dbg->reason.type = RZ_DEBUG_REASON_STEP;
    if (rz_debug_is_dead(dbg)) {
        return false;
    }
 
    /* only handle recoils when not already in recoil mode. */
    if (dbg->recoil_mode == RZ_DBG_RECOIL_NONE) {
        /* handle the stage-2 of breakpoints */
        if (!rz_debug_recoil(dbg, RZ_DBG_RECOIL_STEP)) {
            return false;
        }
 
        /* recoil already stepped once, so we don't step again. */
        if (dbg->recoil_mode == RZ_DBG_RECOIL_STEP) {
            dbg->recoil_mode = RZ_DBG_RECOIL_NONE;
            return true;
        }
    }
 
    if (!dbg->cur->step(dbg)) {
        return false;
    }
 
#if __linux__
    // Turn off continue_all_threads to make sure linux_dbg_wait
    // only waits for one target for a single-step or breakpoint trap
    bool prev_continue = dbg->continue_all_threads;
    dbg->continue_all_threads = false;
#endif
    reason = rz_debug_wait(dbg, pb);
#if __linux__
    dbg->continue_all_threads = prev_continue;
#endif
 
    if (reason == RZ_DEBUG_REASON_DEAD || rz_debug_is_dead(dbg)) {
        return false;
    }
    // Unset breakpoints before leaving
    if (reason != RZ_DEBUG_REASON_BREAKPOINT &&
        reason != RZ_DEBUG_REASON_COND &&
        reason != RZ_DEBUG_REASON_TRACEPOINT) {
        rz_bp_restore(dbg->bp, false);
    }
    /* TODO: handle better */
    if (reason == RZ_DEBUG_REASON_ERROR) {
        return false;
    }
    return true;
}

References rz_debug_t::bp, rz_debug_t::continue_all_threads, rz_debug_t::cur, dbg, rz_debug_t::reason, rz_debug_t::recoil_mode, rz_bp_restore(), RZ_DBG_RECOIL_NONE, RZ_DBG_RECOIL_STEP, rz_debug_is_dead(), RZ_DEBUG_REASON_BREAKPOINT, RZ_DEBUG_REASON_COND, RZ_DEBUG_REASON_DEAD, RZ_DEBUG_REASON_ERROR, RZ_DEBUG_REASON_STEP, RZ_DEBUG_REASON_TRACEPOINT, rz_debug_recoil(), rz_debug_wait(), rz_debug_plugin_t::step, and rz_debug_reason_t::type.

Referenced by rz_debug_step().

rz_debug_step_over()

RZ_API int rz_debug_step_over	(	RzDebug *	dbg,
		int	steps
	)

Definition at line 1033 of file debug.c.

                                                       {
    RzAnalysisOp op;
    ut64 buf_pc, pc, ins_size;
    ut8 buf[DBG_BUF_SIZE];
    int steps_taken = 0;
 
    if (rz_debug_is_dead(dbg)) {
        return steps_taken;
    }
 
    if (steps < 1) {
        steps = 1;
    }
 
    if (dbg->cur && dbg->cur->step_over) {
        for (; steps_taken < steps; steps_taken++) {
            if (dbg->session && dbg->recoil_mode == RZ_DBG_RECOIL_NONE) {
                dbg->session->cnum++;
                dbg->session->maxcnum++;
                rz_debug_trace_ins_before(dbg);
            }
            if (!dbg->cur->step_over(dbg)) {
                return steps_taken;
            }
            if (dbg->session && dbg->recoil_mode == RZ_DBG_RECOIL_NONE) {
                rz_debug_trace_ins_after(dbg);
            }
        }
        return steps_taken;
    }
 
    if (!dbg->analysis || !dbg->reg) {
        return steps_taken;
    }
 
    // Initial refill
    buf_pc = rz_debug_reg_get(dbg, dbg->reg->name[RZ_REG_NAME_PC]);
    dbg->iob.read_at(dbg->iob.io, buf_pc, buf, sizeof(buf));
 
    for (; steps_taken < steps; steps_taken++) {
        pc = rz_debug_reg_get(dbg, dbg->reg->name[RZ_REG_NAME_PC]);
        // Try to keep the buffer full
        if (pc - buf_pc > sizeof(buf)) {
            buf_pc = pc;
            dbg->iob.read_at(dbg->iob.io, buf_pc, buf, sizeof(buf));
        }
        // Analyze the opcode
        if (rz_analysis_op(dbg->analysis, &op, pc, buf + (pc - buf_pc), sizeof(buf) - (pc - buf_pc), RZ_ANALYSIS_OP_MASK_BASIC) < 1) {
            eprintf("debug-step-over: Decode error at %" PFMT64x "\n", pc);
            return steps_taken;
        }
        if (op.fail == -1) {
            ins_size = pc + op.size;
        } else {
            // Use op.fail here instead of pc+op.size to enforce analysis backends to fill in this field
            ins_size = op.fail;
        }
        // Skip over all the subroutine calls
        if (isStepOverable(op.type)) {
            if (!rz_debug_continue_until(dbg, ins_size)) {
                eprintf("Could not step over call @ 0x%" PFMT64x "\n", pc);
                return steps_taken;
            }
        } else if ((op.prefix & (RZ_ANALYSIS_OP_PREFIX_REP | RZ_ANALYSIS_OP_PREFIX_REPNE | RZ_ANALYSIS_OP_PREFIX_LOCK))) {
            // eprintf ("REP: skip to next instruction...\n");
            if (!rz_debug_continue_until(dbg, ins_size)) {
                eprintf("step over failed over rep\n");
                return steps_taken;
            }
        } else {
            rz_debug_step(dbg, 1);
        }
    }
 
    return steps_taken;
}

References rz_debug_t::analysis, rz_debug_session_t::cnum, rz_debug_t::cur, dbg, DBG_BUF_SIZE, eprintf, rz_io_bind_t::io, rz_debug_t::iob, isStepOverable(), rz_debug_session_t::maxcnum, rz_reg_t::name, op, pc, PFMT64x, rz_io_bind_t::read_at, rz_debug_t::recoil_mode, rz_debug_t::reg, rz_analysis_op(), RZ_ANALYSIS_OP_MASK_BASIC, RZ_ANALYSIS_OP_PREFIX_LOCK, RZ_ANALYSIS_OP_PREFIX_REP, RZ_ANALYSIS_OP_PREFIX_REPNE, RZ_DBG_RECOIL_NONE, rz_debug_continue_until(), rz_debug_is_dead(), rz_debug_reg_get(), rz_debug_step(), rz_debug_trace_ins_after(), rz_debug_trace_ins_before(), RZ_REG_NAME_PC, rz_debug_t::session, rz_debug_plugin_t::step_over, and ut64().

Referenced by rz_cmd_debug_step_prog_handler(), rz_core_debug_step_over(), rz_core_debug_step_until_frame(), rz_debug_continue_until_optype(), and step_until_inst().

rz_debug_step_soft()

RZ_API int rz_debug_step_soft

(

RzDebug *

dbg

)

Definition at line 787 of file debug.c.

                                            {
    ut8 buf[32];
    ut64 pc, sp, r;
    ut64 next[2];
    RzAnalysisOp op;
    int br, i, ret;
    union {
        ut64 r64;
        ut32 r32[2];
    } sp_top;
    union {
        ut64 r64;
        ut32 r32[2];
    } memval;
 
    if (dbg->recoil_mode == RZ_DBG_RECOIL_NONE) {
        dbg->recoil_mode = RZ_DBG_RECOIL_STEP;
    }
 
    if (rz_debug_is_dead(dbg)) {
        return false;
    }
 
    const bool has_lr_reg = rz_reg_get_name(dbg->reg, RZ_REG_NAME_LR);
    const bool arch_ret_is_pop = !strcmp(dbg->arch, "arm") && dbg->bits <= RZ_SYS_BITS_32;
 
    pc = rz_debug_reg_get(dbg, dbg->reg->name[RZ_REG_NAME_PC]);
    sp = rz_debug_reg_get(dbg, dbg->reg->name[RZ_REG_NAME_SP]);
 
    if (!dbg->iob.read_at) {
        return false;
    }
    if (!dbg->iob.read_at(dbg->iob.io, pc, buf, sizeof(buf))) {
        return false;
    }
    if (rz_analysis_op(dbg->analysis, &op, pc, buf, sizeof(buf), RZ_ANALYSIS_OP_MASK_BASIC) < 1) {
        return false;
    }
    if (op.type == RZ_ANALYSIS_OP_TYPE_ILL) {
        return false;
    }
    switch (op.type) {
    case RZ_ANALYSIS_OP_TYPE_RET:
        if (arch_ret_is_pop && op.stackop == RZ_ANALYSIS_STACK_INC) {
            dbg->iob.read_at(dbg->iob.io, sp - op.stackptr - 4, (ut8 *)&sp_top, 4);
            next[0] = sp_top.r32[0];
        } else if (has_lr_reg) {
            next[0] = rz_debug_reg_get(dbg, dbg->reg->name[RZ_REG_NAME_LR]);
        } else {
            dbg->iob.read_at(dbg->iob.io, sp, (ut8 *)&sp_top, 8);
            next[0] = (dbg->bits <= RZ_SYS_BITS_32) ? sp_top.r32[0] : sp_top.r64;
        }
        br = 1;
        break;
    case RZ_ANALYSIS_OP_TYPE_CJMP:
    case RZ_ANALYSIS_OP_TYPE_CCALL:
        next[0] = op.jump;
        next[1] = op.fail;
        br = 2;
        break;
    case RZ_ANALYSIS_OP_TYPE_CALL:
    case RZ_ANALYSIS_OP_TYPE_JMP:
        next[0] = op.jump;
        br = 1;
        break;
    case RZ_ANALYSIS_OP_TYPE_RJMP:
    case RZ_ANALYSIS_OP_TYPE_RCALL:
        r = rz_debug_reg_get(dbg, op.reg);
        next[0] = r;
        br = 1;
        break;
    case RZ_ANALYSIS_OP_TYPE_IRCALL:
    case RZ_ANALYSIS_OP_TYPE_IRJMP:
        r = rz_debug_reg_get(dbg, op.reg);
        if (!dbg->iob.read_at(dbg->iob.io, r, (ut8 *)&memval, 8)) {
            next[0] = op.addr + op.size;
        } else {
            next[0] = (dbg->bits <= RZ_SYS_BITS_32) ? memval.r32[0] : memval.r64;
        }
        br = 1;
        break;
    case RZ_ANALYSIS_OP_TYPE_UJMP:
    case RZ_ANALYSIS_OP_TYPE_UCALL:
    case RZ_ANALYSIS_OP_TYPE_MJMP:
        if (op.ireg) {
            r = rz_debug_reg_get(dbg, op.ireg);
        } else {
            r = 0;
        }
        if (!dbg->iob.read_at(dbg->iob.io, r * op.scale + op.disp, (ut8 *)&memval, 8)) {
            next[0] = op.addr + op.size;
        } else {
            next[0] = (dbg->bits <= RZ_SYS_BITS_32) ? memval.r32[0] : memval.r64;
        }
        br = 1;
        break;
    default:
        next[0] = op.addr + op.size;
        br = 1;
        break;
    }
 
    const int align = rz_analysis_archinfo(dbg->analysis, RZ_ANALYSIS_ARCHINFO_ALIGN);
    for (i = 0; i < br; i++) {
        if (align > 1) {
            next[i] = next[i] - (next[i] % align);
        }
        RzBreakpointItem *bpi = rz_bp_add_sw(dbg->bp, next[i], 0, RZ_PERM_X);
        if (bpi) {
            bpi->swstep = true;
        }
    }
 
    ret = rz_debug_continue(dbg);
 
    for (i = 0; i < br; i++) {
        rz_bp_del(dbg->bp, next[i]);
    }
 
    return ret;
}

References rz_debug_t::analysis, rz_debug_t::arch, rz_debug_t::bits, rz_debug_t::bp, br, dbg, i, rz_io_bind_t::io, rz_debug_t::iob, rz_reg_t::name, op, pc, r, rz_io_bind_t::read_at, rz_debug_t::recoil_mode, rz_debug_t::reg, rz_analysis_archinfo(), RZ_ANALYSIS_ARCHINFO_ALIGN, rz_analysis_op(), RZ_ANALYSIS_OP_MASK_BASIC, RZ_ANALYSIS_OP_TYPE_CALL, RZ_ANALYSIS_OP_TYPE_CCALL, RZ_ANALYSIS_OP_TYPE_CJMP, RZ_ANALYSIS_OP_TYPE_ILL, RZ_ANALYSIS_OP_TYPE_IRCALL, RZ_ANALYSIS_OP_TYPE_IRJMP, RZ_ANALYSIS_OP_TYPE_JMP, RZ_ANALYSIS_OP_TYPE_MJMP, RZ_ANALYSIS_OP_TYPE_RCALL, RZ_ANALYSIS_OP_TYPE_RET, RZ_ANALYSIS_OP_TYPE_RJMP, RZ_ANALYSIS_OP_TYPE_UCALL, RZ_ANALYSIS_OP_TYPE_UJMP, RZ_ANALYSIS_STACK_INC, rz_bp_add_sw(), rz_bp_del(), RZ_DBG_RECOIL_NONE, RZ_DBG_RECOIL_STEP, rz_debug_continue(), rz_debug_is_dead(), rz_debug_reg_get(), RZ_PERM_X, rz_reg_get_name(), RZ_REG_NAME_LR, RZ_REG_NAME_PC, RZ_REG_NAME_SP, RZ_SYS_BITS_32, sp, rz_bp_item_t::swstep, and ut64().

Referenced by rz_debug_step().

rz_debug_stop()

RZ_API int rz_debug_stop

(

RzDebug *

dbg

)

Definition at line 458 of file debug.c.

                                       {
    if (dbg && dbg->cur && dbg->cur->stop) {
        return dbg->cur->stop(dbg);
    }
    return false;
}

References rz_debug_t::cur, dbg, and rz_debug_plugin_t::stop.

Referenced by rz_core_static_debug_stop(), and rz_debug_wait().

rz_debug_stop_reason()

RZ_API RzDebugReasonType rz_debug_stop_reason

(

RzDebug *

dbg

)

Definition at line 670 of file debug.c.

                                                            {
    // TODO: return reason to stop debugging
    // - new process
    // - trap instruction
    // - illegal instruction
    // - fpu exception
    // return dbg->reason
    return dbg->reason.type;
}

References dbg, rz_debug_t::reason, and rz_debug_reason_t::type.

Referenced by rz_cmd_debug().

rz_debug_str_callback()

static const char* rz_debug_str_callback ( RzNum *  userptr, ut64  off, int *  ok  )

static

Definition at line 349 of file debug.c.

                                                                            {
    // RzDebug *dbg = (RzDebug *)userptr;
    eprintf("rz_debug_str_callback has been called. this should not happen\n");
    return NULL;
}

References eprintf, and NULL.

Referenced by rz_debug_new().

rz_debug_syscall()

RZ_API int rz_debug_syscall	(	RzDebug *	dbg,
		int	num
	)

Definition at line 1583 of file debug.c.

                                                   {
    bool ret = true;
    if (dbg->cur->contsc) {
        ret = dbg->cur->contsc(dbg, dbg->pid, num);
    }
    eprintf("TODO: show syscall information\n");
    /* rz_testc task? ala inject? */
    return (int)ret;
}

References rz_debug_plugin_t::contsc, rz_debug_t::cur, dbg, eprintf, num, and rz_debug_t::pid.

rz_debug_tracenodes_reset()

RZ_API void rz_debug_tracenodes_reset

(

RzDebug *

dbg

)

Definition at line 411 of file debug.c.

                                                    {
    ht_up_free(dbg->tracenodes);
    dbg->tracenodes = ht_up_new(NULL, free_tracenodes_kv, NULL);
}

References dbg, free_tracenodes_kv(), NULL, and rz_debug_t::tracenodes.

Referenced by rz_cmd_debug_traces_reset_handler().

rz_debug_wait()

RZ_API RzDebugReasonType rz_debug_wait	(	RzDebug *	dbg,
		RzBreakpointItem **	bp
	)

Definition at line 685 of file debug.c.

                                                                            {
    RzDebugReasonType reason = RZ_DEBUG_REASON_ERROR;
    if (!dbg) {
        return reason;
    }
 
    if (bp) {
        *bp = NULL;
    }
    /* default to unknown */
    dbg->reason.type = RZ_DEBUG_REASON_UNKNOWN;
    if (rz_debug_is_dead(dbg)) {
        return RZ_DEBUG_REASON_DEAD;
    }
 
    /* if our debugger plugin has wait */
    if (dbg->cur && dbg->cur->wait) {
        reason = dbg->cur->wait(dbg, dbg->pid);
        if (reason == RZ_DEBUG_REASON_DEAD) {
            eprintf("\n==> Process finished\n\n");
            RzEventDebugProcessFinished event = {
                .pid = dbg->pid
            };
            rz_event_send(dbg->ev, RZ_EVENT_DEBUG_PROCESS_FINISHED, &event);
            // XXX(jjd): TODO: handle fallback or something else
            // rz_debug_select (dbg, -1, -1);
            return RZ_DEBUG_REASON_DEAD;
        }
 
#if __linux__
        // Letting other threads running will cause ptrace commands to fail
        // when writing to the same process memory to set/unset breakpoints
        // and is problematic in Linux.
        if (dbg->continue_all_threads) {
            rz_debug_stop(dbg);
        }
#endif
 
        /* propagate errors from the plugin */
        if (reason == RZ_DEBUG_REASON_ERROR) {
            return RZ_DEBUG_REASON_ERROR;
        }
 
        /* read general purpose registers */
        if (!rz_debug_reg_sync(dbg, RZ_REG_TYPE_GPR, false)) {
            return RZ_DEBUG_REASON_ERROR;
        }
 
        bool libs_bp = (dbg->glob_libs || dbg->glob_unlibs) ? true : false;
        /* if the underlying stop reason is a breakpoint, call the handlers */
        if (reason == RZ_DEBUG_REASON_BREAKPOINT ||
            reason == RZ_DEBUG_REASON_STEP ||
            (libs_bp && ((reason == RZ_DEBUG_REASON_NEW_LIB) || (reason == RZ_DEBUG_REASON_EXIT_LIB)))) {
            RzRegItem *pc_ri;
            RzBreakpointItem *b = NULL;
            ut64 pc;
 
            /* get the program coounter */
            pc_ri = rz_reg_get(dbg->reg, dbg->reg->name[RZ_REG_NAME_PC], -1);
            if (!pc_ri) { /* couldn't find PC?! */
                eprintf("Couldn't find PC!\n");
                return RZ_DEBUG_REASON_ERROR;
            }
 
            /* get the value */
            pc = rz_reg_get_value(dbg->reg, pc_ri);
 
            if (!rz_debug_bp_hit(dbg, pc_ri, pc, &b)) {
                return RZ_DEBUG_REASON_ERROR;
            }
 
            if (bp) {
                *bp = b;
            }
 
            if (b && reason == RZ_DEBUG_REASON_STEP) {
                reason = RZ_DEBUG_REASON_BREAKPOINT;
            }
            /* if we hit a tracing breakpoint, we need to continue in
             * whatever mode the user desired. */
            if (dbg->corebind.core && b && b->cond) {
                reason = RZ_DEBUG_REASON_COND;
            }
            if (b && b->trace) {
                reason = RZ_DEBUG_REASON_TRACEPOINT;
            }
        }
 
        dbg->reason.type = reason;
        if (reason == RZ_DEBUG_REASON_SIGNAL && dbg->reason.signum != -1) {
            /* handle signal on continuations here */
            int what = rz_debug_signal_what(dbg, dbg->reason.signum);
            const char *name = rz_signal_to_string(dbg->reason.signum);
            if (name && strcmp("SIGTRAP", name)) {
                rz_cons_printf("[+] signal %d aka %s received %d\n",
                    dbg->reason.signum, name, what);
            }
        }
    }
    return reason;
}

References b, rz_debug_t::continue_all_threads, rz_core_bind_t::core, rz_debug_t::corebind, rz_debug_t::cur, dbg, eprintf, rz_debug_t::ev, rz_debug_t::glob_libs, rz_debug_t::glob_unlibs, rz_reg_t::name, NULL, pc, rz_debug_t::pid, rz_event_debug_process_finished_t::pid, rz_debug_t::reason, rz_debug_t::reg, rz_cons_printf(), rz_debug_bp_hit(), rz_debug_is_dead(), RZ_DEBUG_REASON_BREAKPOINT, RZ_DEBUG_REASON_COND, RZ_DEBUG_REASON_DEAD, RZ_DEBUG_REASON_ERROR, RZ_DEBUG_REASON_EXIT_LIB, RZ_DEBUG_REASON_NEW_LIB, RZ_DEBUG_REASON_SIGNAL, RZ_DEBUG_REASON_STEP, RZ_DEBUG_REASON_TRACEPOINT, RZ_DEBUG_REASON_UNKNOWN, rz_debug_reg_sync(), rz_debug_signal_what(), rz_debug_stop(), RZ_EVENT_DEBUG_PROCESS_FINISHED, rz_event_send(), rz_reg_get(), rz_reg_get_value(), RZ_REG_NAME_PC, RZ_REG_TYPE_GPR, rz_signal_to_string(), rz_debug_reason_t::signum, rz_debug_reason_t::type, ut64(), and rz_debug_plugin_t::wait.

Referenced by rz_debug_continue_kill(), rz_debug_continue_syscalls(), and rz_debug_step_hard().

RZ_LIB_VERSION()

RZ_LIB_VERSION

(

rz_debug

)

show_syscall()

static int show_syscall ( RzDebug *  dbg, const char *  sysreg  )

static

Definition at line 1476 of file debug.c.

                                                          {
    const char *sysname;
    char regname[32];
    int reg, i, args;
    RzSyscallItem *si;
    reg = (int)rz_debug_reg_get(dbg, sysreg);
    si = rz_syscall_get(dbg->analysis->syscall, reg, -1);
    if (si) {
        sysname = si->name ? si->name : "unknown";
        args = si->args;
    } else {
        sysname = "unknown";
        args = 3;
    }
    eprintf("--> %s 0x%08" PFMT64x " syscall %d %s (", sysreg,
        rz_debug_reg_get(dbg, "PC"), reg, sysname);
    for (i = 0; i < args; i++) {
        ut64 val;
        snprintf(regname, sizeof(regname) - 1, "A%d", i);
        val = rz_debug_reg_get(dbg, regname);
        if (((st64)val < 0) && ((st64)val > -0xffff)) {
            eprintf("%" PFMT64d "%s", val, (i + 1 == args) ? "" : " ");
        } else {
            eprintf("0x%" PFMT64x "%s", val, (i + 1 == args) ? "" : " ");
        }
    }
    eprintf(")\n");
    rz_syscall_item_free(si);
    return reg;
}

References rz_debug_t::analysis, args, dbg, eprintf, i, int, PFMT64d, PFMT64x, reg, regname(), rz_debug_reg_get(), rz_syscall_get(), rz_syscall_item_free(), si, snprintf, st64, rz_analysis_t::syscall, ut64(), and val.

Referenced by rz_debug_continue_syscalls().