cdebug.c File Reference

#include <rz_core.h>
#include <rz_debug.h>
#include "core_private.h"

Go to the source code of this file.

Macros
#define	SIGKILL   9

Functions
RZ_API bool	rz_core_is_debug (RzCore *core)
	Check whether the core is in debug mode (equivalent to cfg.debug) More...
static bool	is_x86_call (RzDebug *dbg, ut64 addr)
static bool	is_x86_ret (RzDebug *dbg, ut64 addr)
RZ_API bool	rz_core_debug_step_one (RzCore *core, int times)
RZ_IPI void	rz_core_debug_continue (RzCore *core)
RZ_API bool	rz_core_debug_continue_until (RzCore *core, ut64 addr, ut64 to)
RZ_IPI void	rz_core_debug_sync_bits (RzCore *core)
RZ_IPI void	rz_core_debug_single_step_in (RzCore *core)
RZ_IPI void	rz_core_debug_single_step_over (RzCore *core)
RZ_API void	rz_core_debug_breakpoint_toggle (RZ_NONNULL RzCore *core, ut64 addr)
	Toggle breakpoint. More...
RZ_API void	rz_core_debug_bp_add_noreturn_func (RzCore *core)
	Put a breakpoint into every no-return function. More...
RZ_IPI void	rz_core_debug_attach (RzCore *core, int pid)
RZ_API RzCmdStatus	rz_core_debug_plugin_print (RzDebug *dbg, RzDebugPlugin *plugin, RzCmdStateOutput *state, int count, char *spaces)
RZ_API RzCmdStatus	rz_core_debug_plugins_print (RzCore *core, RzCmdStateOutput *state)
RZ_IPI void	rz_core_debug_print_status (RzCore *core)
static void	print_debug_map_json (RzDebugMap *map, PJ *pj)
static void	print_debug_map_line (RzDebug *dbg, RzDebugMap *map, ut64 addr, RzOutputMode mode)
static void	apply_maps_as_flags (RzCore *core, RzList *maps, bool print_only)
RZ_API void	rz_core_debug_map_update_flags (RzCore *core)
RZ_API void	rz_core_debug_map_print (RzCore *core, ut64 addr, RzCmdStateOutput *state)
static int	cmp (const void *a, const void *b)
static int	findMinMax (RzList *maps, ut64 *min, ut64 *max, int skip, int width)
	Find the min and max addresses in an RzList of maps. More...
static void	print_debug_maps_ascii_art (RzDebug *dbg, RzList *maps, ut64 addr, int colors)
RZ_API void	rz_debug_map_list_visual (RzDebug *dbg, ut64 addr, const char *input, int colors)
RZ_API void	rz_debug_trace_print (RzDebug *dbg, RzCmdStateOutput *state, ut64 offset)
RZ_API void	rz_debug_traces_ascii (RzDebug *dbg, ut64 offset)
RZ_API bool	rz_core_debug_process_close (RzCore *core)
	Close debug process (Kill debugee and all child processes) More...
RZ_API bool	rz_core_debug_step_until_frame (RzCore *core)
	Step until end of frame. More...
RZ_API bool	rz_core_debug_step_back (RzCore *core, int steps)
	Step back. More...
RZ_API bool	rz_core_debug_step_over (RzCore *core, int steps)
	Step over. More...
RZ_API bool	rz_core_debug_step_skip (RzCore *core, int times)
	Skip operations. More...
RZ_API void	rz_backtrace_free (RZ_NULLABLE RzBacktrace *bt)
static void	get_backtrace_info (RzCore *core, RzDebugFrame *frame, ut64 addr, char **flagdesc, char **flagdesc2, char **pcstr, char **spstr)
RZ_API RZ_OWN RzList *	rz_core_debug_backtraces (RzCore *core)
	Get backtraces based on dbg.btdepth and dbg.btalgo. More...

Macro Definition Documentation

SIGKILL

#define SIGKILL   9

Function Documentation

apply_maps_as_flags()

static void apply_maps_as_flags ( RzCore *  core, RzList *  maps, bool  print_only  )

static

Definition at line 437 of file cdebug.c.

                                                                               {
    RzListIter *iter;
    RzDebugMap *map;
    rz_list_foreach (maps, iter, map) {
        char *name = (map->name && *map->name)
            ? rz_str_newf("%s.%s", map->name, rz_str_rwx_i(map->perm))
            : rz_str_newf("%08" PFMT64x ".%s", map->addr, rz_str_rwx_i(map->perm));
        if (!name) {
            continue;
        }
        rz_name_filter(name, 0, true);
        ut64 size = map->addr_end - map->addr;
        if (print_only) {
            rz_cons_printf("f+ map.%s 0x%08" PFMT64x " @ 0x%08" PFMT64x "\n",
                name, size, map->addr);
        } else {
            rz_flag_set_next(core->flags, name, map->addr, size);
        }
        free(name);
    }
}

References rz_core_t::flags, free(), map(), maps(), PFMT64x, rz_cons_printf(), rz_flag_set_next(), rz_name_filter(), rz_str_newf(), rz_str_rwx_i(), and ut64().

Referenced by rz_core_debug_map_print(), and rz_core_debug_map_update_flags().

cmp()

static int cmp ( const void *  a, const void *  b  )

static

Definition at line 530 of file cdebug.c.

                                             {
    RzDebugMap *ma = (RzDebugMap *)a;
    RzDebugMap *mb = (RzDebugMap *)b;
    return ma->addr - mb->addr;
}

References a, rz_debug_map_t::addr, and b.

Referenced by print_debug_maps_ascii_art().

findMinMax()

static int findMinMax ( RzList *  maps, ut64 *  min, ut64 *  max, int  skip, int  width  )

static

Find the min and max addresses in an RzList of maps.

Parameters

maps	RzList of maps that will be searched through
min	Pointer to a ut64 that the min will be stored in
max	Pointer to a ut64 that the max will be stored in
skip	How many maps to skip at the start of iteration
width	Divisor for the return value

Returns

(max-min)/width

Used to determine the min & max addresses of maps and scale the ascii bar to the width of the terminal

Definition at line 548 of file cdebug.c.

                                                                               {
    RzDebugMap *map;
    RzListIter *iter;
    *min = UT64_MAX;
    *max = 0;
    rz_list_foreach (maps, iter, map) {
        if (skip > 0) {
            skip--;
            continue;
        }
        if (map->addr < *min) {
            *min = map->addr;
        }
        if (map->addr_end > *max) {
            *max = map->addr_end;
        }
    }
    return (int)(*max - *min) / width;
}

References map(), maps(), max, min, skip(), UT64_MAX, and width.

Referenced by print_debug_maps_ascii_art().

get_backtrace_info()

static void get_backtrace_info ( RzCore *  core, RzDebugFrame *  frame, ut64  addr, char **  flagdesc, char **  flagdesc2, char **  pcstr, char **  spstr  )

static

Definition at line 866 of file cdebug.c.

                                                                   {
    RzFlagItem *f = rz_flag_get_at(core->flags, frame->addr, true);
    *flagdesc = NULL;
    *flagdesc2 = NULL;
    if (f) {
        if (f->offset != addr) {
            int delta = (int)(frame->addr - f->offset);
            if (delta > 0) {
                *flagdesc = rz_str_newf("%s+%d", f->name, delta);
            } else if (delta < 0) {
                *flagdesc = rz_str_newf("%s%d", f->name, delta);
            } else {
                *flagdesc = rz_str_newf("%s", f->name);
            }
        } else {
            *flagdesc = rz_str_newf("%s", f->name);
        }
        if (!strchr(f->name, '.')) {
            f = rz_flag_get_at(core->flags, frame->addr - 1, true);
        }
        if (f) {
            if (f->offset != addr) {
                int delta = (int)(frame->addr - 1 - f->offset);
                if (delta > 0) {
                    *flagdesc2 = rz_str_newf("%s+%d", f->name, delta + 1);
                } else if (delta < 0) {
                    *flagdesc2 = rz_str_newf("%s%d", f->name, delta + 1);
                } else {
                    *flagdesc2 = rz_str_newf("%s+1", f->name);
                }
            } else {
                *flagdesc2 = rz_str_newf("%s", f->name);
            }
        }
    }
    if (!rz_str_cmp(*flagdesc, *flagdesc2, -1)) {
        free(*flagdesc2);
        *flagdesc2 = NULL;
    }
    if (!(pcstr && spstr)) {
        return;
    }
    if (core->dbg->bits & RZ_SYS_BITS_64) {
        *pcstr = rz_str_newf("0x%-16" PFMT64x, frame->addr);
        *spstr = rz_str_newf("0x%-16" PFMT64x, frame->sp);
    } else if (core->dbg->bits & RZ_SYS_BITS_32) {
        *pcstr = rz_str_newf("0x%-8" PFMT64x, frame->addr);
        *spstr = rz_str_newf("0x%-8" PFMT64x, frame->sp);
    } else {
        *pcstr = rz_str_newf("0x%" PFMT64x, frame->addr);
        *spstr = rz_str_newf("0x%" PFMT64x, frame->sp);
    }
}

References addr, rz_debug_frame_t::addr, rz_debug_t::bits, rz_core_t::dbg, delta, f, rz_core_t::flags, free(), int, NULL, PFMT64x, rz_flag_get_at(), rz_str_cmp(), rz_str_newf(), RZ_SYS_BITS_32, RZ_SYS_BITS_64, and rz_debug_frame_t::sp.

Referenced by rz_core_debug_backtraces().

is_x86_call()

static bool is_x86_call ( RzDebug *  dbg, ut64  addr  )

static

Definition at line 17 of file cdebug.c.

                                                 {
    ut8 buf[3];
    ut8 *op = buf;
    (void)dbg->iob.read_at(dbg->iob.io, addr, buf, RZ_ARRAY_SIZE(buf));
    switch (buf[0]) { /* Segment override prefixes */
    case 0x65:
    case 0x64:
    case 0x26:
    case 0x3e:
    case 0x36:
    case 0x2e:
        op++;
    }
    if (op[0] == 0xe8) {
        return true;
    }
    if (op[0] == 0xff /* bits 4-5 (from right) of next byte must be 01 */
        && (op[1] & 0x30) == 0x10) {
        return true;
    }
    /* ... */
    return false;
}

References addr, dbg, rz_io_bind_t::io, rz_debug_t::iob, rz_io_bind_t::read_at, and RZ_ARRAY_SIZE.

Referenced by rz_core_debug_continue_until().

is_x86_ret()

static bool is_x86_ret ( RzDebug *  dbg, ut64  addr  )

static

Definition at line 41 of file cdebug.c.

                                                {
    ut8 buf[1];
    (void)dbg->iob.read_at(dbg->iob.io, addr, buf, RZ_ARRAY_SIZE(buf));
    switch (buf[0]) {
    case 0xc3:
    case 0xcb:
    case 0xc2:
    case 0xca:
        return true;
    default:
        return false;
    }
    /* Possibly incomplete with regard to instruction prefixes */
}

References addr, dbg, rz_io_bind_t::io, rz_debug_t::iob, rz_io_bind_t::read_at, and RZ_ARRAY_SIZE.

Referenced by rz_core_debug_continue_until().

print_debug_map_json()

static void print_debug_map_json ( RzDebugMap *  map, PJ *  pj  )

static

Definition at line 371 of file cdebug.c.

                                                          {
    pj_o(pj);
    if (map->name && *map->name) {
        pj_ks(pj, "name", map->name);
    }
    if (map->file && *map->file) {
        pj_ks(pj, "file", map->file);
    }
    pj_kn(pj, "addr", map->addr);
    pj_kn(pj, "addr_end", map->addr_end);
    pj_ks(pj, "type", map->user ? "u" : "s");
    pj_ks(pj, "perm", rz_str_rwx_i(map->perm));
    pj_end(pj);
}

References map(), pj_end(), pj_kn(), pj_ks(), pj_o(), and rz_str_rwx_i().

Referenced by rz_core_debug_map_print().

print_debug_map_line()

static void print_debug_map_line ( RzDebug *  dbg, RzDebugMap *  map, ut64  addr, RzOutputMode  mode  )

static

Definition at line 387 of file cdebug.c.

                                                                                              {
    char humansz[8];
    if (mode == RZ_OUTPUT_MODE_QUIET) { // "dmq"
        char *name = (map->name && *map->name)
            ? rz_str_newf("%s.%s", map->name, rz_str_rwx_i(map->perm))
            : rz_str_newf("%08" PFMT64x ".%s", map->addr, rz_str_rwx_i(map->perm));
        rz_name_filter(name, 0, true);
        rz_num_units(humansz, sizeof(humansz), map->addr_end - map->addr);
        rz_cons_printf("0x%016" PFMT64x " - 0x%016" PFMT64x " %6s %5s %s\n",
            map->addr,
            map->addr_end,
            humansz,
            rz_str_rwx_i(map->perm),
            name);
        free(name);
    } else {
        const char *fmtstr = dbg->bits & RZ_SYS_BITS_64
            ? "0x%016" PFMT64x " - 0x%016" PFMT64x " %c %s %6s %c %s %s %s%s%s\n"
            : "0x%08" PFMT64x " - 0x%08" PFMT64x " %c %s %6s %c %s %s %s%s%s\n";
        const char *type = map->shared ? "sys" : "usr";
        const char *flagname = dbg->corebind.getName
            ? dbg->corebind.getName(dbg->corebind.core, map->addr)
            : NULL;
        if (!flagname) {
            flagname = "";
        } else if (map->name) {
            char *filtered_name = strdup(map->name);
            rz_name_filter(filtered_name, 0, true);
            if (!strncmp(flagname, "map.", 4) &&
                !strcmp(flagname + 4, filtered_name)) {
                flagname = "";
            }
            free(filtered_name);
        }
        rz_num_units(humansz, sizeof(humansz), map->size);
        rz_cons_printf(fmtstr,
            map->addr,
            map->addr_end,
            (addr >= map->addr && addr < map->addr_end) ? '*' : '-',
            type,
            humansz,
            map->user ? 'u' : 's',
            rz_str_rwx_i(map->perm),
            map->name ? map->name : "?",
            map->file ? map->file : "?",
            *flagname ? " ; " : "",
            flagname);
    }
}

References addr, rz_debug_t::bits, rz_core_bind_t::core, rz_debug_t::corebind, dbg, free(), rz_core_bind_t::getName, map(), NULL, PFMT64x, rz_cons_printf(), rz_name_filter(), rz_num_units(), RZ_OUTPUT_MODE_QUIET, rz_str_newf(), rz_str_rwx_i(), RZ_SYS_BITS_64, strdup(), and type.

Referenced by rz_core_debug_map_print().

print_debug_maps_ascii_art()

static void print_debug_maps_ascii_art ( RzDebug *  dbg, RzList *  maps, ut64  addr, int  colors  )

static

Definition at line 568 of file cdebug.c.

                                                                                          {
    ut64 mul; // The amount of address space a single console column will represent in bar graph
    ut64 min = -1, max = 0;
    int width = rz_cons_get_size(NULL) - 90;
    RzListIter *iter;
    RzDebugMap *map;
    RzConsPrintablePalette *pal = &rz_cons_singleton()->context->pal;
    if (width < 1) {
        width = 30;
    }
    rz_list_sort(maps, cmp);
    mul = findMinMax(maps, &min, &max, 0, width);
    ut64 last = min;
    if (min != -1 && mul != 0) {
        const char *color_prefix = ""; // Color escape code prefixed to string (address coloring)
        const char *color_suffix = ""; // Color escape code appended to end of string
        const char *fmtstr;
        char humansz[8]; // Holds the human formatted size string [124K]
        int skip = 0; // Number of maps to skip when re-calculating the minmax
        rz_list_foreach (maps, iter, map) {
            rz_num_units(humansz, sizeof(humansz), map->size); // Convert map size to human readable string
            if (colors) {
                color_suffix = Color_RESET;
                if ((map->perm & 2) && (map->perm & 1)) { // Writable & Executable
                    color_prefix = pal->widget_sel;
                } else if (map->perm & 2) { // Writable
                    color_prefix = pal->graph_false;
                } else if (map->perm & 1) { // Executable
                    color_prefix = pal->graph_true;
                } else {
                    color_prefix = "";
                    color_suffix = "";
                }
            } else {
                color_prefix = "";
                color_suffix = "";
            }
            if ((map->addr - last) > UT32_MAX) { // TODO: Comment what this is for
                mul = findMinMax(maps, &min, &max, skip, width); //  Recalculate minmax
            }
            skip++;
            fmtstr = dbg->bits & RZ_SYS_BITS_64 // Prefix formatting string (before bar)
                ? "map %4.8s %c %s0x%016" PFMT64x "%s |"
                : "map %4.8s %c %s0x%08" PFMT64x "%s |";
            rz_cons_printf(fmtstr, humansz,
                (addr >= map->addr &&
                    addr < map->addr_end)
                    ? '*'
                    : '-',
                color_prefix, map->addr, color_suffix); // * indicates map is within our current sought offset
            int col;
            for (col = 0; col < width; col++) { // Iterate over the available width/columns for bar graph
                ut64 pos = min + (col * mul); // Current address space to check
                ut64 npos = min + ((col + 1) * mul); // Next address space to check
                if (map->addr < npos && map->addr_end > pos) {
                    rz_cons_printf("#"); // TODO: Comment what a # represents
                } else {
                    rz_cons_printf("-");
                }
            }
            fmtstr = dbg->bits & RZ_SYS_BITS_64 ? // Suffix formatting string (after bar)
                "| %s0x%016" PFMT64x "%s %s %s\n"
                                : "| %s0x%08" PFMT64x "%s %s %s\n";
            rz_cons_printf(fmtstr, color_prefix, map->addr_end, color_suffix,
                rz_str_rwx_i(map->perm), map->name);
            last = map->addr;
        }
    }
}

References addr, rz_debug_t::bits, cmp(), Color_RESET, colors, rz_cons_t::context, dbg, findMinMax(), rz_cons_printable_palette_t::graph_false, rz_cons_printable_palette_t::graph_true, map(), maps(), max, min, mul(), NULL, rz_cons_context_t::pal, PFMT64x, pos, rz_cons_get_size(), rz_cons_printf(), rz_cons_singleton(), rz_list_sort(), rz_num_units(), rz_str_rwx_i(), RZ_SYS_BITS_64, skip(), UT32_MAX, ut64(), rz_cons_printable_palette_t::widget_sel, and width.

Referenced by rz_debug_map_list_visual().

rz_backtrace_free()

RZ_API void rz_backtrace_free

(

RZ_NULLABLE RzBacktrace *

bt

)

Definition at line 853 of file cdebug.c.

                                                           {
    if (!bt) {
        return;
    }
    free(bt->frame);
    free(bt->desc);
    free(bt->pcstr);
    free(bt->spstr);
    free(bt->flagdesc);
    free(bt->flagdesc2);
    free(bt);
}

References free().

Referenced by rz_core_debug_backtraces().

rz_core_debug_attach()

RZ_IPI void rz_core_debug_attach	(	RzCore *	core,
		int	pid
	)

Definition at line 284 of file cdebug.c.

                                                        {
    char buf[20];
 
    rz_debug_reg_profile_sync(core->dbg);
    if (pid > 0) {
        rz_debug_attach(core->dbg, pid);
    } else {
        if (core->file && core->io) {
            rz_debug_attach(core->dbg, rz_io_fd_get_pid(core->io, core->file->fd));
        }
    }
    rz_debug_select(core->dbg, core->dbg->pid, core->dbg->tid);
    rz_config_set_i(core->config, "dbg.swstep", (core->dbg->cur && !core->dbg->cur->canstep));
    rz_io_system(core->io, rz_strf(buf, "pid %d", core->dbg->pid));
}

References rz_debug_plugin_t::canstep, rz_core_t::config, rz_debug_t::cur, rz_core_t::dbg, rz_core_file_t::fd, rz_core_t::file, rz_core_t::io, rz_debug_t::pid, pid, rz_config_set_i(), rz_debug_attach(), rz_debug_reg_profile_sync(), rz_debug_select(), rz_io_fd_get_pid(), rz_io_system(), rz_strf, and rz_debug_t::tid.

Referenced by cmd_debug_pid(), and rz_core_setup_debugger().

rz_core_debug_backtraces()

RZ_API RZ_OWN RzList* rz_core_debug_backtraces

(

RzCore *

core

)

Get backtraces based on dbg.btdepth and dbg.btalgo.

Parameters

core	The RzCore instance

Returns

A list of RzBacktrace

Definition at line 926 of file cdebug.c.

                                                               {
    RzList *list = rz_debug_frames(core->dbg, UT64_MAX);
    if (!list) {
        return NULL;
    }
    RzListIter *iter;
    RzDebugFrame *frame;
    RzList *bts = rz_list_newf((RzListFree)rz_backtrace_free);
    if (!bts) {
        rz_list_free(list);
        return NULL;
    }
    rz_list_foreach (list, iter, frame) {
        RzBacktrace *bt = RZ_NEW0(RzBacktrace);
        if (!bt) {
            rz_list_free(list);
            rz_list_free(bts);
            return NULL;
        }
        rz_list_append(bts, bt);
        get_backtrace_info(core, frame, UT64_MAX, &bt->flagdesc, &bt->flagdesc2, &bt->pcstr, &bt->spstr);
        bt->fcn = rz_analysis_get_fcn_in(core->analysis, frame->addr, 0);
        bt->frame = RZ_NEWCOPY(RzDebugFrame, frame);
        bt->desc = rz_str_newf("%s%s", rz_str_get_null(bt->flagdesc), rz_str_get_null(bt->flagdesc2));
    }
    rz_list_free(list);
    return bts;
}

References rz_debug_frame_t::addr, rz_core_t::analysis, rz_core_t::dbg, rz_backtrace_t::desc, rz_backtrace_t::fcn, rz_backtrace_t::flagdesc, rz_backtrace_t::flagdesc2, rz_backtrace_t::frame, get_backtrace_info(), list(), NULL, rz_backtrace_t::pcstr, rz_analysis_get_fcn_in(), rz_backtrace_free(), rz_debug_frames(), rz_list_append(), rz_list_free(), rz_list_newf(), RZ_NEW0, RZ_NEWCOPY, rz_str_get_null(), rz_str_newf(), rz_backtrace_t::spstr, and UT64_MAX.

Referenced by rz_cmd_debug_display_bt_handler().

rz_core_debug_bp_add_noreturn_func()

RZ_API void rz_core_debug_bp_add_noreturn_func

(

RzCore *

core

)

Put a breakpoint into every no-return function.

Parameters

core	Current RzCore instance

Returns

void

Definition at line 256 of file cdebug.c.

                                                             {
    RzList *symbols = rz_bin_get_symbols(core->bin);
    if (!symbols) {
        RZ_LOG_ERROR("Unable to find symbols in the binary\n");
        return;
    }
    RzBinSymbol *symbol;
    RzListIter *iter;
    RzBreakpointItem *bp;
    int hwbp = rz_config_get_i(core->config, "dbg.hwbp");
    rz_list_foreach (symbols, iter, symbol) {
        if (symbol->type && !strcmp(symbol->type, RZ_BIN_TYPE_FUNC_STR)) {
            if (rz_analysis_noreturn_at(core->analysis, symbol->vaddr)) {
                bp = rz_debug_bp_add(core->dbg, symbol->vaddr, hwbp, false, 0, NULL, 0);
                if (!bp) {
                    RZ_LOG_ERROR("Unable to add a breakpoint into a noreturn function %s at addr 0x%" PFMT64x "\n", symbol->name, symbol->vaddr);
                    return;
                }
                char *name = rz_str_newf("%s.%s", "sym", symbol->name);
                if (!rz_bp_item_set_name(bp, name)) {
                    RZ_LOG_ERROR("Failed to set name for breakpoint at 0x%" PFMT64x "\n", symbol->vaddr);
                }
                free(name);
            }
        }
    }
}

References rz_core_t::analysis, rz_core_t::bin, rz_core_t::config, rz_core_t::dbg, free(), rz_bin_symbol_t::name, NULL, PFMT64x, rz_analysis_noreturn_at(), rz_bin_get_symbols(), RZ_BIN_TYPE_FUNC_STR, rz_bp_item_set_name(), rz_config_get_i(), rz_debug_bp_add(), RZ_LOG_ERROR, rz_str_newf(), symbols(), rz_bin_symbol_t::type, and rz_bin_symbol_t::vaddr.

Referenced by rz_cmd_debug_add_bp_noreturn_func_handler().

rz_core_debug_breakpoint_toggle()

RZ_API void rz_core_debug_breakpoint_toggle	(	RZ_NONNULL RzCore *	core,
		ut64	addr
	)

Toggle breakpoint.

Parameters

core	RzCore instance
addr	Breakpoint addr

Definition at line 235 of file cdebug.c.

                                                                                {
    rz_return_if_fail(core && core->dbg);
    RzBreakpointItem *bpi = rz_bp_get_at(core->dbg->bp, addr);
    if (bpi) {
        rz_bp_del(core->dbg->bp, addr);
    } else {
        int hwbp = (int)rz_config_get_i(core->config, "dbg.hwbp");
        bpi = rz_debug_bp_add(core->dbg, addr, hwbp, false, 0, NULL, 0);
        if (!bpi) {
            eprintf("Cannot set breakpoint at 0x%" PFMT64x "\n", addr);
        }
    }
    rz_bp_enable(core->dbg->bp, addr, true, 0);
}

References addr, eprintf, int, NULL, PFMT64x, rz_bp_del(), rz_bp_enable(), rz_bp_get_at(), rz_config_get_i(), rz_debug_bp_add(), and rz_return_if_fail.

Referenced by __break_points_cb(), __panel_breakpoint(), __set_breakpoints_on_cursor(), graph_breakpoint(), rz_cmd_debug_toggle_bp_handler(), rz_core_visual_cmd(), and visual_breakpoint().

rz_core_debug_continue()

RZ_IPI void rz_core_debug_continue

(

RzCore *

core

)

Definition at line 81 of file cdebug.c.

                                                 {
    if (rz_core_is_debug(core)) {
        rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
        rz_reg_arena_swap(core->dbg->reg, true);
#if __linux__
        core->dbg->continue_all_threads = true;
#endif
        rz_debug_continue(core->dbg);
        rz_core_reg_update_flags(core);
        rz_cons_break_pop();
        rz_core_dbg_follow_seek_register(core);
    } else {
        rz_core_esil_step(core, UT64_MAX, "0", NULL, false);
        rz_core_reg_update_flags(core);
    }
}

References rz_debug_t::continue_all_threads, rz_core_t::dbg, NULL, rz_debug_t::reg, rz_cons_break_pop(), rz_cons_break_push(), rz_core_dbg_follow_seek_register(), rz_core_esil_step(), rz_core_is_debug(), rz_core_reg_update_flags(), rz_core_static_debug_stop(), rz_debug_continue(), rz_reg_arena_swap(), and UT64_MAX.

Referenced by __continue_cb(), __panels_process(), graph_continue(), rz_cmd_debug_continue_execution_handler(), and visual_nkey().

rz_core_debug_continue_until()

RZ_API bool rz_core_debug_continue_until	(	RzCore *	core,
		ut64	addr,
		ut64	to
	)

Definition at line 98 of file cdebug.c.

                                                                           {
    ut64 pc;
    if (!strcmp(core->dbg->btalgo, "trace") && core->dbg->arch && !strcmp(core->dbg->arch, "x86") && core->dbg->bits == 4) {
        unsigned long steps = 0;
        long level = 0;
        const char *pc_name = core->dbg->reg->name[RZ_REG_NAME_PC];
        ut64 prev_pc = UT64_MAX;
        bool prev_call = false;
        bool prev_ret = false;
        const char *sp_name = core->dbg->reg->name[RZ_REG_NAME_SP];
        ut64 old_sp, cur_sp;
        rz_cons_break_push(NULL, NULL);
        rz_list_free(core->dbg->call_frames);
        core->dbg->call_frames = rz_list_new();
        core->dbg->call_frames->free = free;
        rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_GPR, false);
        old_sp = rz_debug_reg_get(core->dbg, sp_name);
        while (true) {
            rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_GPR, false);
            pc = rz_debug_reg_get(core->dbg, pc_name);
            if (prev_call) {
                ut32 ret_addr;
                RzDebugFrame *frame = RZ_NEW0(RzDebugFrame);
                cur_sp = rz_debug_reg_get(core->dbg, sp_name);
                (void)core->dbg->iob.read_at(core->dbg->iob.io, cur_sp, (ut8 *)&ret_addr,
                    sizeof(ret_addr));
                frame->addr = ret_addr;
                frame->size = old_sp - cur_sp;
                frame->sp = cur_sp;
                frame->bp = old_sp;
                rz_list_prepend(core->dbg->call_frames, frame);
                eprintf("%ld Call from 0x%08" PFMT64x " to 0x%08" PFMT64x " ret 0x%08" PFMT32x "\n",
                    level, prev_pc, pc, ret_addr);
                level++;
                old_sp = cur_sp;
                prev_call = false;
            } else if (prev_ret) {
                RzDebugFrame *head = rz_list_get_bottom(core->dbg->call_frames);
                if (head && head->addr != pc) {
                    eprintf("*");
                } else {
                    rz_list_pop_head(core->dbg->call_frames);
                    eprintf("%ld", level);
                    level--;
                }
                eprintf(" Ret from 0x%08" PFMT64x " to 0x%08" PFMT64x "\n",
                    prev_pc, pc);
                prev_ret = false;
            }
            if (steps % 500 == 0 || pc == addr) {
                eprintf("At 0x%08" PFMT64x " after %lu steps\n", pc, steps);
            }
            if (rz_cons_is_breaked() || rz_debug_is_dead(core->dbg) || pc == addr) {
                break;
            }
            if (is_x86_call(core->dbg, pc)) {
                prev_pc = pc;
                prev_call = true;
            } else if (is_x86_ret(core->dbg, pc)) {
                prev_pc = pc;
                prev_ret = true;
            }
            rz_debug_step(core->dbg, 1);
            steps++;
        }
        rz_core_reg_update_flags(core);
        rz_cons_break_pop();
        return true;
    }
    eprintf("Continue until 0x%08" PFMT64x "\n", addr);
    rz_reg_arena_swap(core->dbg->reg, true);
    if (rz_bp_add_sw(core->dbg->bp, addr, 0, RZ_PERM_X)) {
        if (rz_debug_is_dead(core->dbg)) {
            RZ_LOG_ERROR("Cannot continue, run ood?\n");
        } else {
            rz_debug_continue(core->dbg);
            rz_core_reg_update_flags(core);
        }
        rz_bp_del(core->dbg->bp, addr);
    } else {
        RZ_LOG_ERROR("Cannot set breakpoint for continuing until 0x%08" PFMT64x "\n", addr);
        return false;
    }
    return true;
}

References addr, rz_debug_frame_t::addr, rz_debug_t::arch, rz_debug_t::bits, rz_debug_frame_t::bp, rz_debug_t::bp, rz_debug_t::btalgo, rz_debug_t::call_frames, rz_core_t::dbg, eprintf, rz_list_t::free, free(), test-lz4-versions::head, rz_io_bind_t::io, rz_debug_t::iob, is_x86_call(), is_x86_ret(), level, rz_reg_t::name, NULL, pc, PFMT32x, PFMT64x, rz_io_bind_t::read_at, rz_debug_t::reg, rz_bp_add_sw(), rz_bp_del(), rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_core_reg_update_flags(), rz_debug_continue(), rz_debug_is_dead(), rz_debug_reg_get(), rz_debug_reg_sync(), rz_debug_step(), rz_list_free(), rz_list_get_bottom(), rz_list_new(), rz_list_pop_head(), rz_list_prepend(), RZ_LOG_ERROR, RZ_NEW0, RZ_PERM_X, rz_reg_arena_swap(), RZ_REG_NAME_PC, RZ_REG_NAME_SP, RZ_REG_TYPE_GPR, rz_debug_frame_t::size, rz_debug_frame_t::sp, ut64(), and UT64_MAX.

Referenced by cmd_dcu(), rz_core_debug_single_step_in(), rz_core_setup_debugger(), and visual_nkey().

rz_core_debug_map_print()

RZ_API void rz_core_debug_map_print	(	RzCore *	core,
		ut64	addr,
		RzCmdStateOutput *	state
	)

Definition at line 481 of file cdebug.c.

                                                                                      {
    rz_return_if_fail(core);
    int i;
    RzListIter *iter;
    RzDebugMap *map;
    PJ *pj = state->d.pj;
    RzDebug *dbg = core->dbg;
    if (!dbg) {
        return;
    }
    RzOutputMode mode = state->mode;
    rz_cmd_state_output_array_start(state);
    if (mode == RZ_OUTPUT_MODE_RIZIN) {
        rz_cons_print("fss+ " RZ_FLAGS_FS_DEBUG_MAPS "\n");
    }
    for (i = 0; i < 2; i++) { // Iterate over dbg::maps and dbg::maps_user
        RzList *maps = rz_debug_map_list(dbg, (bool)i);
        if (!maps) {
            continue;
        }
        if (mode == RZ_OUTPUT_MODE_RIZIN) { // "dm*"
            apply_maps_as_flags(core, maps, true);
            continue;
        }
        rz_list_foreach (maps, iter, map) {
            switch (mode) {
            case RZ_OUTPUT_MODE_JSON: // "dmj"
                print_debug_map_json(map, pj);
                break;
            case RZ_OUTPUT_MODE_QUIET: // "dmq"
                print_debug_map_line(dbg, map, addr, mode);
                break;
            case RZ_OUTPUT_MODE_LONG: // workaround for '.'
                if (addr >= map->addr && addr < map->addr_end) {
                    print_debug_map_line(dbg, map, addr, mode);
                }
                break;
            default:
                print_debug_map_line(dbg, map, addr, mode);
                break;
            }
        }
    }
    if (mode == RZ_OUTPUT_MODE_RIZIN) {
        rz_cons_print("fss-\n");
    }
    rz_cmd_state_output_array_end(state);
}

References addr, apply_maps_as_flags(), dbg, rz_core_t::dbg, i, map(), maps(), print_debug_map_json(), print_debug_map_line(), rz_cmd_state_output_array_end(), rz_cmd_state_output_array_start(), rz_debug_map_list(), RZ_FLAGS_FS_DEBUG_MAPS, RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_LONG, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_RIZIN, and rz_return_if_fail.

Referenced by rz_cmd_debug_list_maps_handler(), and rz_cmd_debug_map_current_handler().

rz_core_debug_map_update_flags()

RZ_API void rz_core_debug_map_update_flags

(

RzCore *

core

)

Create or update flags for all current debug maps in the "maps" flagspace

Definition at line 462 of file cdebug.c.

                                                         {
    rz_return_if_fail(core);
    rz_flag_unset_all_in_space(core->flags, RZ_FLAGS_FS_DEBUG_MAPS);
    if (rz_debug_is_dead(core->dbg)) {
        return;
    }
    rz_debug_map_sync(core->dbg);
    rz_flag_space_push(core->flags, RZ_FLAGS_FS_DEBUG_MAPS);
    RzList *maps = rz_debug_map_list(core->dbg, false);
    if (maps) {
        apply_maps_as_flags(core, maps, false);
    }
    maps = rz_debug_map_list(core->dbg, true);
    if (maps) {
        apply_maps_as_flags(core, maps, false);
    }
    rz_flag_space_pop(core->flags);
}

References apply_maps_as_flags(), rz_core_t::dbg, rz_core_t::flags, maps(), rz_debug_is_dead(), rz_debug_map_list(), rz_debug_map_sync(), rz_flag_unset_all_in_space(), RZ_FLAGS_FS_DEBUG_MAPS, and rz_return_if_fail.

Referenced by rz_core_file_reopen(), and rz_main_rizin().

rz_core_debug_plugin_print()

RZ_API RzCmdStatus rz_core_debug_plugin_print	(	RzDebug *	dbg,
		RzDebugPlugin *	plugin,
		RzCmdStateOutput *	state,
		int	count,
		char *	spaces
	)

Definition at line 300 of file cdebug.c.

                                                                                                                                     {
    PJ *pj = state->d.pj;
    switch (state->mode) {
    case RZ_OUTPUT_MODE_QUIET: {
        rz_cons_printf("%s\n", plugin->name);
        break;
    }
    case RZ_OUTPUT_MODE_JSON: {
        pj_o(pj);
        pj_ks(pj, "arch", plugin->arch);
        pj_ks(pj, "name", plugin->name);
        pj_ks(pj, "license", plugin->license);
        pj_end(pj);
        break;
    }
    case RZ_OUTPUT_MODE_STANDARD: {
        rz_cons_printf("%d  %s  %s %s%s\n",
            count, (plugin == dbg->cur) ? "dbg" : "---",
            plugin->name, spaces, plugin->license);
        break;
    }
    default: {
        rz_warn_if_reached();
        return RZ_CMD_STATUS_NONEXISTINGCMD;
    }
    }
    return RZ_CMD_STATUS_OK;
}

References rz_debug_plugin_t::arch, count, rz_debug_t::cur, dbg, rz_debug_plugin_t::license, rz_debug_plugin_t::name, pj_end(), pj_ks(), pj_o(), RZ_CMD_STATUS_NONEXISTINGCMD, RZ_CMD_STATUS_OK, rz_cons_printf(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_STANDARD, rz_warn_if_reached, and spaces().

Referenced by rz_core_debug_plugins_print().

rz_core_debug_plugins_print()

RZ_API RzCmdStatus rz_core_debug_plugins_print	(	RzCore *	core,
		RzCmdStateOutput *	state
	)

Definition at line 329 of file cdebug.c.

                                                                                      {
    int count = 0;
    char spaces[16];
    memset(spaces, ' ', 15);
    spaces[15] = 0;
    RzDebug *dbg = core->dbg;
    RzListIter *iter;
    RzDebugPlugin *plugin;
    RzCmdStatus status;
    if (!dbg) {
        return RZ_CMD_STATUS_ERROR;
    }
    rz_cmd_state_output_array_start(state);
    rz_list_foreach (dbg->plugins, iter, plugin) {
        int sp = 8 - strlen(plugin->name);
        spaces[sp] = 0;
        status = rz_core_debug_plugin_print(dbg, plugin, state, count, spaces);
        if (status != RZ_CMD_STATUS_OK) {
            return status;
        }
        spaces[sp] = ' ';
        count++;
    }
    rz_cmd_state_output_array_end(state);
    return RZ_CMD_STATUS_OK;
}

References count, dbg, rz_core_t::dbg, memset(), rz_debug_plugin_t::name, rz_debug_t::plugins, rz_cmd_state_output_array_end(), rz_cmd_state_output_array_start(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_debug_plugin_print(), sp, spaces(), and status.

Referenced by cb_dbgbackend(), rz_cmd_debug_handler_list_handler(), rz_main_rizin(), and rz_plugins_debug_print_handler().

rz_core_debug_print_status()

RZ_IPI void rz_core_debug_print_status

(

RzCore *

core

)

Definition at line 356 of file cdebug.c.

                                                     {
    RzReg *reg = rz_core_reg_default(core);
    RzList *ritems = rz_reg_filter_items_covered(reg->allregs);
    if (ritems) {
        rz_core_reg_print_diff(reg, ritems);
        rz_list_free(ritems);
    }
    ut64 old_address = core->offset;
    rz_core_seek(core, rz_reg_get_value_by_role(reg, RZ_REG_NAME_PC), true);
    rz_core_print_disasm_instructions(core, 0, 1);
    rz_core_seek(core, old_address, true);
    rz_cons_flush();
}

References rz_core_t::offset, reg, rz_cons_flush(), rz_core_print_disasm_instructions(), rz_core_reg_default(), rz_core_reg_print_diff(), rz_core_seek(), rz_list_free(), rz_reg_filter_items_covered(), rz_reg_get_value_by_role(), RZ_REG_NAME_PC, and ut64().

Referenced by rz_core_prompt_loop().

rz_core_debug_process_close()

RZ_API bool rz_core_debug_process_close

(

RzCore *

core

)

Close debug process (Kill debugee and all child processes)

Parameters

core	The RzCore instance

Returns

success

Definition at line 707 of file cdebug.c.

                                                      {
    rz_return_val_if_fail(core && core->dbg, false);
    RzDebug *dbg = core->dbg;
    // Stop trace session
    if (dbg->session) {
        rz_debug_session_free(dbg->session);
        dbg->session = NULL;
    }
#ifndef SIGKILL
#define SIGKILL 9
#endif
    // Kill debugee and all child processes
    if (dbg->cur && dbg->cur->pids && dbg->pid != -1) {
        RzList *list = dbg->cur->pids(dbg, dbg->pid);
        RzListIter *iter;
        RzDebugPid *p;
        if (list) {
            rz_list_foreach (list, iter, p) {
                rz_debug_kill(dbg, p->pid, p->pid, SIGKILL);
                rz_debug_detach(dbg, p->pid);
            }
        } else {
            rz_debug_kill(dbg, dbg->pid, dbg->pid, SIGKILL);
            rz_debug_detach(dbg, dbg->pid);
        }
    }
    // Remove the target's registers from the flag list
    rz_core_debug_clear_register_flags(core);
    // Reopen and rebase the original file
    rz_core_io_file_open(core, core->io->desc->fd);
    return true;
}

References rz_debug_t::cur, dbg, rz_core_t::dbg, rz_io_t::desc, rz_io_desc_t::fd, rz_core_t::io, list(), NULL, p, rz_debug_t::pid, rz_debug_plugin_t::pids, rz_core_debug_clear_register_flags(), rz_core_io_file_open(), rz_debug_detach(), rz_debug_kill(), rz_debug_session_free(), rz_return_val_if_fail, rz_debug_t::session, and SIGKILL.

Referenced by rz_cmd_debug_process_close_handler().

rz_core_debug_single_step_in()

RZ_IPI void rz_core_debug_single_step_in

(

RzCore *

core

)

Definition at line 193 of file cdebug.c.

                                                       {
    if (rz_core_is_debug(core)) {
        if (core->print->cur_enabled) {
            rz_core_debug_continue_until(core, core->offset, core->offset + core->print->cur);
            core->print->cur_enabled = 0;
        } else {
            rz_core_debug_step_one(core, 1);
        }
    } else {
        rz_core_esil_step(core, UT64_MAX, NULL, NULL, false);
        rz_core_reg_update_flags(core);
    }
}

References rz_print_t::cur, rz_print_t::cur_enabled, NULL, rz_core_t::offset, rz_core_t::print, rz_core_debug_continue_until(), rz_core_debug_step_one(), rz_core_esil_step(), rz_core_is_debug(), rz_core_reg_update_flags(), and UT64_MAX.

Referenced by __panel_single_step_in(), graph_single_step_in(), rz_core_visual_cmd(), and visual_nkey().

rz_core_debug_single_step_over()

RZ_IPI void rz_core_debug_single_step_over

(

RzCore *

core

)

Definition at line 207 of file cdebug.c.

                                                         {
    bool io_cache = rz_config_get_b(core->config, "io.cache");
    rz_config_set_b(core->config, "io.cache", false);
    if (rz_core_is_debug(core)) {
        if (core->print->cur_enabled) {
            rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
            rz_reg_arena_swap(core->dbg->reg, true);
            rz_debug_continue_until_optype(core->dbg, RZ_ANALYSIS_OP_TYPE_RET, 1);
            rz_core_reg_update_flags(core);
            rz_cons_break_pop();
            rz_core_dbg_follow_seek_register(core);
            core->print->cur_enabled = 0;
        } else {
            rz_core_debug_step_over(core, 1);
            rz_core_dbg_follow_seek_register(core);
            rz_core_reg_update_flags(core);
        }
    } else {
        rz_core_analysis_esil_step_over(core);
    }
    rz_config_set_b(core->config, "io.cache", io_cache);
}

References rz_core_t::config, rz_print_t::cur_enabled, rz_core_t::dbg, rz_core_t::print, rz_debug_t::reg, RZ_ANALYSIS_OP_TYPE_RET, rz_config_get_b(), rz_config_set_b(), rz_cons_break_pop(), rz_cons_break_push(), rz_core_analysis_esil_step_over(), rz_core_dbg_follow_seek_register(), rz_core_debug_step_over(), rz_core_is_debug(), rz_core_reg_update_flags(), rz_core_static_debug_stop(), rz_debug_continue_until_optype(), and rz_reg_arena_swap().

Referenced by __panel_single_step_over(), graph_single_step_over(), rz_core_visual_cmd(), and visual_nkey().

rz_core_debug_step_back()

RZ_API bool rz_core_debug_step_back	(	RzCore *	core,
		int	steps
	)

Step back.

Parameters

core	The RzCore instance
steps	Step steps

Returns

success

Definition at line 777 of file cdebug.c.

                                                             {
    if (!rz_core_is_debug(core)) {
        if (!rz_core_esil_step_back(core)) {
            RZ_LOG_ERROR("cannot step back\n");
            return false;
        }
        return true;
    }
    if (!core->dbg->session) {
        RZ_LOG_ERROR("session has not started\n");
        return false;
    }
    if (rz_debug_step_back(core->dbg, steps) < 0) {
        RZ_LOG_ERROR("stepping back failed\n");
        return false;
    }
    rz_core_reg_update_flags(core);
    return true;
}

References rz_core_t::dbg, rz_core_esil_step_back(), rz_core_is_debug(), rz_core_reg_update_flags(), rz_debug_step_back(), RZ_LOG_ERROR, and rz_debug_t::session.

Referenced by rz_cmd_debug_step_back_handler().

rz_core_debug_step_one()

RZ_API bool rz_core_debug_step_one	(	RzCore *	core,
		int	times
	)

Definition at line 56 of file cdebug.c.

                                                            {
    if (rz_core_is_debug(core)) {
        rz_reg_arena_swap(core->dbg->reg, true);
        // sync registers for BSD PT_STEP/PT_CONT
        rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_GPR, false);
        ut64 pc = rz_debug_reg_get(core->dbg, "PC");
        rz_debug_trace_pc(core->dbg, pc);
        if (!rz_debug_step(core->dbg, times)) {
            eprintf("Step failed\n");
            rz_core_reg_update_flags(core);
            core->break_loop = true;
            return false;
        }
        rz_core_reg_update_flags(core);
    } else {
        int i = 0;
        do {
            rz_core_esil_step(core, UT64_MAX, NULL, NULL, false);
            rz_core_reg_update_flags(core);
            i++;
        } while (i < times);
    }
    return true;
}

References rz_core_t::break_loop, rz_core_t::dbg, eprintf, i, NULL, pc, rz_debug_t::reg, rz_core_esil_step(), rz_core_is_debug(), rz_core_reg_update_flags(), rz_debug_reg_get(), rz_debug_reg_sync(), rz_debug_step(), rz_debug_trace_pc(), rz_reg_arena_swap(), RZ_REG_TYPE_GPR, times, ut64(), and UT64_MAX.

Referenced by loadGP(), rz_cmd_debug_step_handler(), and rz_core_debug_single_step_in().

rz_core_debug_step_over()

RZ_API bool rz_core_debug_step_over	(	RzCore *	core,
		int	steps
	)

Step over.

Parameters

core	The RzCore instance
steps	Step steps

Definition at line 802 of file cdebug.c.

                                                             {
    if (rz_config_get_i(core->config, "dbg.skipover")) {
        rz_core_debug_step_skip(core, steps);
        return true;
    }
    if (!rz_core_is_debug(core)) {
        for (int i = 0; i < steps; i++) {
            rz_core_analysis_esil_step_over(core);
        }
        return true;
    }
    bool hwbp = rz_config_get_b(core->config, "dbg.hwbp");
    ut64 addr = rz_debug_reg_get(core->dbg, "PC");
    RzBreakpointItem *bpi = rz_bp_get_at(core->dbg->bp, addr);
    rz_bp_del(core->dbg->bp, addr);
    rz_reg_arena_swap(core->dbg->reg, true);
    rz_debug_step_over(core->dbg, steps);
    if (bpi) {
        (void)rz_debug_bp_add(core->dbg, addr, hwbp, false, 0, NULL, 0);
    }
    rz_core_reg_update_flags(core);
    return true;
}

References addr, rz_debug_t::bp, rz_core_t::config, rz_core_t::dbg, i, NULL, rz_debug_t::reg, rz_bp_del(), rz_bp_get_at(), rz_config_get_b(), rz_config_get_i(), rz_core_analysis_esil_step_over(), rz_core_debug_step_skip(), rz_core_is_debug(), rz_core_reg_update_flags(), rz_debug_bp_add(), rz_debug_reg_get(), rz_debug_step_over(), rz_reg_arena_swap(), and ut64().

Referenced by rz_cmd_debug_step_over_handler(), and rz_core_debug_single_step_over().

rz_core_debug_step_skip()

RZ_API bool rz_core_debug_step_skip	(	RzCore *	core,
		int	times
	)

Skip operations.

Parameters

core	The RzCore instance
times	Skip op times

Definition at line 831 of file cdebug.c.

                                                             {
    bool hwbp = rz_config_get_b(core->config, "dbg.hwbp");
    ut64 addr = rz_debug_reg_get(core->dbg, "PC");
    ut8 buf[64];
    RzAnalysisOp aop;
    RzBreakpointItem *bpi = rz_bp_get_at(core->dbg->bp, addr);
    rz_reg_arena_swap(core->dbg->reg, true);
    for (int i = 0; i < times; i++) {
        rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_GPR, false);
        rz_io_read_at(core->io, addr, buf, sizeof(buf));
        rz_analysis_op(core->analysis, &aop, addr, buf, sizeof(buf), RZ_ANALYSIS_OP_MASK_BASIC);
        addr += aop.size;
    }
    rz_debug_reg_set(core->dbg, "PC", addr);
    rz_reg_setv(core->analysis->reg, "PC", addr);
    rz_core_reg_update_flags(core);
    if (bpi) {
        (void)rz_debug_bp_add(core->dbg, addr, hwbp, false, 0, NULL, 0);
    }
    return true;
}

References addr, rz_core_t::analysis, rz_debug_t::bp, rz_core_t::config, rz_core_t::dbg, i, rz_core_t::io, NULL, rz_analysis_t::reg, rz_debug_t::reg, rz_analysis_op(), RZ_ANALYSIS_OP_MASK_BASIC, rz_bp_get_at(), rz_config_get_b(), rz_core_reg_update_flags(), rz_debug_bp_add(), rz_debug_reg_get(), rz_debug_reg_set(), rz_debug_reg_sync(), rz_io_read_at(), rz_reg_arena_swap(), rz_reg_setv(), RZ_REG_TYPE_GPR, rz_analysis_op_t::size, times, and ut64().

Referenced by rz_cmd_debug_step_skip_handler(), and rz_core_debug_step_over().

rz_core_debug_step_until_frame()

RZ_API bool rz_core_debug_step_until_frame

(

RzCore *

core

)

Step until end of frame.

Parameters

core	The RzCore instance

Returns

success

Definition at line 745 of file cdebug.c.

                                                         {
    rz_return_val_if_fail(core && core->dbg, false);
    int maxLoops = 200000;
    ut64 off, now = rz_debug_reg_get(core->dbg, "SP");
    rz_cons_break_push(NULL, NULL);
    do {
        if (rz_cons_is_breaked()) {
            break;
        }
        if (rz_debug_is_dead(core->dbg)) {
            break;
        }
        // XXX (HACK!)
        rz_debug_step_over(core->dbg, 1);
        off = rz_debug_reg_get(core->dbg, "SP");
        // check breakpoint here
        if (--maxLoops < 0) {
            RZ_LOG_INFO("step loop limit exceeded\n");
            break;
        }
    } while (off <= now);
    rz_core_reg_update_flags(core);
    rz_cons_break_pop();
    return true;
}

References rz_core_t::dbg, NULL, off, rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_core_reg_update_flags(), rz_debug_is_dead(), rz_debug_reg_get(), rz_debug_step_over(), RZ_LOG_INFO, rz_return_val_if_fail, and ut64().

Referenced by rz_cmd_debug_step_frame_handler().

rz_core_debug_sync_bits()

RZ_IPI void rz_core_debug_sync_bits

(

RzCore *

core

)

Definition at line 184 of file cdebug.c.

                                                  {
    if (rz_core_is_debug(core)) {
        ut64 asm_bits = rz_config_get_i(core->config, "asm.bits");
        if (asm_bits != core->dbg->bits * 8) {
            rz_config_set_i(core->config, "asm.bits", core->dbg->bits * 8);
        }
    }
}

References rz_debug_t::bits, rz_core_t::config, rz_core_t::dbg, rz_config_get_i(), rz_config_set_i(), rz_core_is_debug(), and ut64().

Referenced by rz_core_dbg_follow_seek_register(), and rz_core_visual_title().

rz_core_is_debug()

RZ_API bool rz_core_is_debug

(

RzCore *

core

)

Check whether the core is in debug mode (equivalent to cfg.debug)

Definition at line 13 of file cdebug.c.

                                           {
    return core->bin->is_debugger;
}

References rz_core_t::bin, and rz_bin_t::is_debugger.

Referenced by bp_is_mapped(), bp_maps_sync(), rz_core_analysis_address(), rz_core_arg_get(), rz_core_debug_continue(), rz_core_debug_single_step_in(), rz_core_debug_single_step_over(), rz_core_debug_step_back(), rz_core_debug_step_one(), rz_core_debug_step_over(), rz_core_debug_sync_bits(), rz_core_reg_default(), rz_core_reg_getv_by_role_or_name(), rz_core_reg_set_by_role_or_name(), and rz_core_reg_update_flags().

rz_debug_map_list_visual()

RZ_API void rz_debug_map_list_visual	(	RzDebug *	dbg,
		ut64	addr,
		const char *	input,
		int	colors
	)

Definition at line 638 of file cdebug.c.

                                                                                             {
    if (!dbg) {
        return;
    }
    int i;
    for (i = 0; i < 2; i++) { // Iterate over dbg::maps and dbg::maps_user
        RzList *maps = rz_debug_map_list(dbg, (bool)i);
        if (!maps) {
            continue;
        }
        print_debug_maps_ascii_art(dbg, maps, addr, colors);
    }
}

References addr, colors, dbg, i, maps(), print_debug_maps_ascii_art(), and rz_debug_map_list().

Referenced by rz_cmd_debug_list_maps_ascii_handler().

rz_debug_trace_print()

RZ_API void rz_debug_trace_print	(	RzDebug *	dbg,
		RzCmdStateOutput *	state,
		ut64	offset
	)

Print all traces

Parameters

dbg	core->dbg
mode	output mode, default RZ_OUTPUT_MODE_STANDARD
offset	offset of address

Definition at line 658 of file cdebug.c.

                                                                                     {
    rz_return_if_fail(dbg);
    int tag = dbg->trace->tag;
    RzListIter *iter;
    RzDebugTracepoint *trace;
    rz_list_foreach (dbg->trace->traces, iter, trace) {
        if (trace->tag && !(tag & trace->tag)) {
            continue;
        }
        switch (state->mode) {
        case RZ_OUTPUT_MODE_QUIET:
            rz_cons_printf("0x%" PFMT64x "\n", trace->addr);
            break;
        case RZ_OUTPUT_MODE_RIZIN:
            rz_cons_printf("dt+ 0x%" PFMT64x " %d\n", trace->addr, trace->times);
            break;
        case RZ_OUTPUT_MODE_STANDARD:
        default:
            rz_cons_printf("0x%08" PFMT64x " size=%d count=%d times=%d tag=%d\n",
                trace->addr, trace->size, trace->count, trace->times, trace->tag);
            break;
        }
    }
}

References rz_debug_tracepoint_t::addr, rz_debug_tracepoint_t::count, dbg, PFMT64x, rz_cons_printf(), RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_RIZIN, RZ_OUTPUT_MODE_STANDARD, rz_return_if_fail, 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_cmd_debug_traces_handler().

rz_debug_traces_ascii()

RZ_API void rz_debug_traces_ascii	(	RzDebug *	dbg,
		ut64	offset
	)

Print trace info in ASCII Art

Parameters

dbg	core->dbg
offset	offset of address

Definition at line 688 of file cdebug.c.

                                                             {
    rz_return_if_fail(dbg);
    RzList *info_list = rz_debug_traces_info(dbg, offset);
    RzTable *table = rz_table_new();
    table->cons = rz_cons_singleton();
    rz_table_visual_list(table, info_list, offset, 1,
        rz_cons_get_size(NULL), dbg->iob.io->va);
    char *s = rz_table_tostring(table);
    rz_cons_printf("\n%s\n", s);
    free(s);
    rz_table_free(table);
    rz_list_free(info_list);
}

References RzTable::cons, dbg, free(), rz_io_bind_t::io, rz_debug_t::iob, NULL, rz_cons_get_size(), rz_cons_printf(), rz_cons_singleton(), rz_debug_traces_info(), rz_list_free(), rz_return_if_fail, rz_table_free(), rz_table_new(), rz_table_tostring(), rz_table_visual_list(), s, and rz_io_t::va.

Referenced by rz_cmd_debug_traces_ascii_handler().