#include <rz_core.h>
#include <rz_debug.h>
#include <sdb.h>
#include "rz_heap_glibc.h"
#include "../core_private.h"
#include "cmd_regs_meta.inc"

Classes
struct	dot_trace_ght

struct	trace_node

Macros
#define	TN_KEY_LEN 32

#define	TN_KEY_FMT "%" PFMT64u

#define	CMD_CHECK_DEBUG_DEAD(core)

#define	MAX_MAP_SIZE (1024 * 1024 * 512)

#define	P rz_cons_printf

#define	PS(X, Y)

#define	CMD_REGS_PREFIX debug

#define	CMD_REGS_REG_PATH dbg->reg

#define	CMD_REGS_SYNC cmd_regs_sync

Functions
static void	set_profile_string (RzCore core, const char str)

static void	cmd_debug_cont_syscall (RzCore core, const char _str)

static RzGraphNode *	get_graphtrace_node (RzGraph g, Sdb nodes, struct trace_node *tn)

static void	dot_trace_create_node (RTreeNode n, RTreeVisitor vis)

static void	dot_trace_discover_child (RTreeNode n, RTreeVisitor vis)

static void	dot_trace_traverse (RzCore core, RTree t, int fmt)

static int	step_until (RzCore *core, ut64 addr)

static int	step_until_esil (RzCore core, const char esilstr)

static bool	is_repeatable_inst (RzCore *core, ut64 addr)

static bool	step_until_inst (RzCore core, const char instr, bool regex)

RZ_API void	rz_core_dbg_follow_seek_register (RzCore *core)
	Seek to `PC` if needed. More...

static bool	step_until_optype (RzCore core, RzList optypes_list)

static int	step_until_flag (RzCore core, const char flagstr)

static bool	step_line (RzCore *core, int times)

static void	cmd_debug_pid (RzCore core, const char input)

static void	cmd_debug_backtrace (RzCore *core, ut64 len)

static int	dump_maps (RzCore core, int perm, const char filename)

static void	cmd_debug_current_modules (RzCore *core, RzOutputMode mode)

static void	cmd_debug_modules (RzCore core, RzCmdStateOutput state)

static ut64	addroflib (RzCore core, const char libname)

static RzDebugMap *	get_closest_map (RzCore *core, ut64 addr)

static RzOutputMode	rad2mode (int mode)

static bool	get_bin_info (RzCore core, const char file, ut64 baseaddr, PJ pj, int mode, bool symbols_only, RzCoreBinFilter filter)

RZ_IPI RzCmdStatus	rz_cmd_debug_list_maps_handler (RzCore core, int argc, const char argv, RzCmdStateOutput state)

RZ_IPI RzCmdStatus	rz_cmd_debug_allocate_maps_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_modules_handler (RzCore core, int argc, const char argv, RzCmdStateOutput state)

RZ_IPI RzCmdStatus	rz_cmd_debug_current_modules_handler (RzCore core, int argc, const char *argv, RzOutputMode mode)

RZ_IPI RzCmdStatus	rz_cmd_debug_deallocate_map_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_list_maps_ascii_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_map_current_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_dump_maps_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_dump_maps_all_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_dump_maps_writable_handler (RzCore core, int argc, const char *argv)

RZ_IPI int	rz_cmd_debug_dmi (void data, const char input)

RZ_IPI RzCmdStatus	rz_debug_memory_permission_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_dmS_handler (RzCore core, int argc, const char *argv, RzOutputMode m)

RZ_IPI RzCmdStatus	rz_cmd_debug_dml_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_dmL_handler (RzCore core, int argc, const char *argv)

RZ_IPI int	rz_cmd_debug_heap_jemalloc (void data, const char input)

static void	foreach_reg_set_or_clear (RzCore *core, bool set)

RZ_API void	rz_core_debug_set_register_flags (RzCore *core)

RZ_API void	rz_core_debug_clear_register_flags (RzCore *core)

static void	backtrace_vars (RzCore core, RzList frames)

static void	asciiart_backtrace (RzCore core, RzList frames)

RZ_IPI void	rz_core_static_debug_stop (void *u)

RZ_IPI void	rz_core_debug_bp_add (RzCore core, ut64 addr, const char arg_perm, bool hwbp, bool watch)

static RTreeNode *	add_trace_tree_child (HtUP ht, RTree t, RTreeNode *cur, ut64 addr)

static void	trace_traverse_pre (RTreeNode n, RTreeVisitor vis)

static void	trace_traverse (RTree *t)

static void	do_debug_trace_calls (RzCore *core, ut64 from, ut64 to, ut64 final_addr)

static void	debug_trace_calls (RzCore *core, ut64 from, ut64 to, ut64 final_addr)

static void	rz_core_debug_esil (RzCore core, const char input)

static void	rz_core_debug_kill (RzCore core, const char input)

static bool	cmd_dcu (RzCore core, const char input)

RZ_IPI RzCmdStatus	rz_cmd_debug_step_until_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_step_until_instr_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_step_until_instr_regex_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_step_until_optype_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_step_until_esil_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_step_until_flag_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_trace_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_traces_handler (RzCore core, int argc, const char argv, RzCmdStateOutput state)

RZ_IPI RzCmdStatus	rz_cmd_debug_traces_ascii_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_trace_add_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_trace_add_addrs_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_traces_reset_handler (RzCore core, int argc, const char *argv)

RZ_IPI int	rz_cmd_debug_trace_addr (void data, const char input)

RZ_IPI RzCmdStatus	rz_cmd_debug_trace_calls_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_trace_esil_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_trace_esils_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_traces_esil_delete_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_traces_esil_i_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_trace_graph_handler (RzCore core, int argc, const char *argv, RzOutputMode mode)

RZ_IPI RzCmdStatus	rz_cmd_debug_trace_interactive_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_start_trace_session_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_stop_trace_session_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_save_trace_session_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_load_trace_session_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_list_trace_session_mmap_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_trace_tag_handler (RzCore core, int argc, const char *argv)

static char *	get_corefile_name (const char *raw_name, int pid)

static ut8 *	getFileData (RzCore core, const char arg)

static void	consumeBuffer (RzBuffer buf, const char cmd, const char *errmsg)

RZ_IPI int	rz_cmd_debug (void data, const char input)

RZ_IPI RzCmdStatus	rz_cmd_debug_add_bp_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_list_bp_handler (RzCore core, int argc, const char argv, RzCmdStateOutput state)

RZ_IPI RzCmdStatus	rz_cmd_debug_add_hw_bp_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_remove_bp_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_remove_all_bp_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_show_cur_bp_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_command_bp_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_add_cond_bp_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_disable_bp_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_enable_bp_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_toggle_bp_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_add_bp_noreturn_func_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_add_bp_module_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_name_bp_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_show_bp_index_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_list_bp_indexes_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_remove_bp_index_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_set_expr_bp_index_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_run_command_bp_index_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_enable_bp_index_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_disable_bp_index_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_toggle_bp_index_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_enable_bp_trace_index_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_disable_bp_trace_index_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_toggle_bp_trace_index_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_bp_plugin_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_remove_bp_plugin_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_display_bt_handler (RzCore core, int argc, const char argv, RzCmdStateOutput state)

RZ_IPI RzCmdStatus	rz_cmd_debug_display_bt_oneline_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_display_bt_local_vars_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_display_bt_ascii_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_bt_enable_bp_trace_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_bt_disable_bp_trace_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_bt_toggle_bp_trace_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_bp_set_expr_cur_offset_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_add_watchpoint_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_set_cond_bp_win_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_continue_execution_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_continue_back_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_continue_call_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_continue_unknown_call_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_continue_exception_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_continue_fork_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_continue_send_signal_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_continue_mapped_io_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_continue_ret_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_continue_traptrace_handler (RzCore core, int argc, const char *argv)

RZ_IPI int	rz_cmd_debug_continue_syscall (void data, const char input)

RZ_IPI int	rz_cmd_debug_continue_until (void data, const char input)

RZ_IPI RzCmdStatus	rz_cmd_debug_handler_list_handler (RzCore core, int argc, const char argv, RzCmdStateOutput state)

RZ_IPI RzCmdStatus	rz_cmd_debug_handler_set_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_process_profile_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_process_profile_edit_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_process_close_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_step_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_step_back_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_step_frame_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_step_cond_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_step_line_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_step_over_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_step_prog_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_cmd_debug_step_skip_handler (RzCore core, int argc, const char *argv)

static bool	cmd_regs_sync (RzCore *core, RzRegisterType type, bool write)

RZ_API void	rz_core_debug_ri (RzCore *core)

RZ_IPI RzCmdStatus	rz_debug_drx_handler (RzCore core, int argc, const char *argv)

RZ_IPI RzCmdStatus	rz_debug_drx_unset_handler (RzCore core, int argc, const char *argv)

Variables
static const char *	help_msg_d []

static const char *	help_msg_dcs []

static const char *	help_msg_dcu []

static const char *	help_msg_dd []

static const char *	help_msg_de []

static const char *	help_msg_des []

static const char *	help_msg_di []

static const char *	help_msg_dk []

static const char *	help_msg_dko []

static const char *	help_msg_dmi []

static const char *	help_msg_dp []

static const char *	help_msg_dx []

static RzCore *	_core = NULL

Macro Definition Documentation

◆ CMD_CHECK_DEBUG_DEAD

#define CMD_CHECK_DEBUG_DEAD ( core )

Value:

    do { \
        if (rz_debug_is_dead(core->dbg)) { \
            rz_cons_println("Debugging is not enabled. Run ood?"); \
            return RZ_CMD_STATUS_ERROR; \
        } \
    } while (0)

Definition at line 19 of file cmd_debug.c.

◆ CMD_REGS_PREFIX

#define CMD_REGS_PREFIX debug

Definition at line 3605 of file cmd_debug.c.

◆ CMD_REGS_REG_PATH

#define CMD_REGS_REG_PATH dbg->reg

Definition at line 3606 of file cmd_debug.c.

◆ CMD_REGS_SYNC

#define CMD_REGS_SYNC cmd_regs_sync

Definition at line 3610 of file cmd_debug.c.

◆ MAX_MAP_SIZE

#define MAX_MAP_SIZE (1024 * 1024 * 512)

Definition at line 809 of file cmd_debug.c.

◆ P

#define P rz_cons_printf

◆ PS

#define PS	(	X,
		Y
	)

Value:

    { \
        escaped_str = rz_str_escape(Y); \
        rz_cons_printf(X, escaped_str); \
        free(escaped_str); \
    }

◆ TN_KEY_FMT

#define TN_KEY_FMT "%" PFMT64u

Definition at line 8 of file cmd_debug.c.

◆ TN_KEY_LEN

#define TN_KEY_LEN 32

Definition at line 7 of file cmd_debug.c.

Function Documentation

◆ add_trace_tree_child()

static RTreeNode* add_trace_tree_child	(	HtUP *	ht,
		RTree *	t,
		RTreeNode *	cur,
		ut64	addr
	)

static

Definition at line 1607 of file cmd_debug.c.

                                                                                       {
     struct trace_node *t_node = ht_up_find(ht, addr, NULL);
     if (!t_node) {
         t_node = RZ_NEW0(struct trace_node);
         if (t_node) {
             t_node->addr = addr;
             t_node->refs = 1;
             ht_up_insert(ht, addr, t_node);
         }
     } else {
         t_node->refs++;
     }
     return rz_tree_add_node(t, cur, t_node);
 }

References addr, trace_node::addr, NULL, trace_node::refs, RZ_NEW0, and rz_tree_add_node().

Referenced by do_debug_trace_calls().

◆ addroflib()

static ut64 addroflib	(	RzCore *	core,
		const char *	libname
	)

static

Definition at line 923 of file cmd_debug.c.

                                                          {
     RzListIter *iter;
     RzDebugMap *map;
     if (!core || !libname) {
         return UT64_MAX;
     }
     rz_debug_map_sync(core->dbg);
     // RzList *list = rz_debug_native_modules_get (core->dbg);
     RzList *list = rz_debug_modules_list(core->dbg);
     rz_list_foreach (list, iter, map) {
         if (strstr(rz_file_basename(map->name), libname)) {
             return map->addr;
         }
     }
     rz_list_foreach (core->dbg->maps, iter, map) {
         if (strstr(rz_file_basename(map->name), libname)) {
             return map->addr;
         }
     }
     return UT64_MAX;
 }

References rz_core_t::dbg, list(), map(), rz_debug_t::maps, rz_debug_map_sync(), rz_debug_modules_list(), rz_file_basename(), and UT64_MAX.

Referenced by rz_cmd_debug_dmi().

◆ asciiart_backtrace()

static void asciiart_backtrace	(	RzCore *	core,
		RzList *	frames
	)

static

Definition at line 1514 of file cmd_debug.c.

                                                              {
     // TODO: show local variables
     // TODO: show function/flags/symbols related
     // TODO: show contents of stack
     // TODO: honor scr.color
     RzDebugFrame *f;
     RzListIter *iter;
     bool mymap = false;
     // analysis vs debug ?
     const char *sp = rz_reg_get_name(core->analysis->reg, RZ_REG_NAME_SP);
     const char *bp = rz_reg_get_name(core->analysis->reg, RZ_REG_NAME_BP);
     if (!sp) {
         sp = "SP";
     }
     if (!bp) {
         bp = "BP";
     }
     ut64 dsp = rz_reg_getv(core->analysis->reg, sp);
     ut64 dbp = rz_reg_getv(core->analysis->reg, bp);
     RzDebugMap *map = rz_debug_map_get(core->dbg, dsp);
     if (!map) {
         mymap = true;
         map = RZ_NEW0(RzDebugMap);
         map->addr = UT64_MAX;
         map->addr_end = UT64_MAX;
     }
  
     rz_cons_printf("0x%016" PFMT64x "  STACK END  ^^^\n", map->addr);
     rz_cons_printf("0x%016" PFMT64x "  STACK POINTER: %s\n", dsp, sp);
     rz_cons_printf("                    .------------------------.\n");
     int n = 0;
     rz_list_foreach (frames, iter, f) {
         ut64 s = f->sp ? f->sp : dsp;
         ut64 b = f->bp ? f->bp : dbp;
         char *str = rz_str_newf("[frame %d]", n);
         rz_cons_printf("0x%016" PFMT64x "  |%4s    %10s      | ; size %" PFMTDPTR "\n", s, sp, str, (ptrdiff_t)(s - b));
         free(str);
         rz_cons_printf("                    |            ...         |\n");
         rz_cons_printf("0x%016" PFMT64x "  |%4s 0x%016" PFMT64x " | %s\n", b, bp, f->addr, "; return address");
         rz_cons_printf("                    )------------------------(\n");
         // eprintf ("0x%08llx 0x%08llx 0x%08llx\n", f->addr, s, b);
         n++;
     }
     rz_cons_printf("                    |           ...          |\n");
     rz_cons_printf("                    `------------------------'\n");
     rz_cons_printf("0x%016" PFMT64x "  STACK BOTTOM\n", map->addr_end);
     if (mymap) {
         rz_debug_map_free(map);
     }
 }

References rz_core_t::analysis, b, rz_core_t::dbg, f, free(), map(), n, PFMT64x, PFMTDPTR, rz_analysis_t::reg, rz_cons_printf(), rz_debug_map_free(), rz_debug_map_get(), RZ_NEW0, rz_reg_get_name(), rz_reg_getv(), RZ_REG_NAME_BP, RZ_REG_NAME_SP, rz_str_newf(), s, sp, cmd_descs_generate::str, ut64(), and UT64_MAX.

Referenced by rz_cmd_debug_display_bt_ascii_handler().

◆ backtrace_vars()

static void backtrace_vars	(	RzCore *	core,
		RzList *	frames
	)

static

Definition at line 1453 of file cmd_debug.c.

                                                          {
     RzDebugFrame *f;
     RzListIter *iter;
     // analysis vs debug ?
     const char *sp = rz_reg_get_name(core->analysis->reg, RZ_REG_NAME_SP);
     const char *bp = rz_reg_get_name(core->analysis->reg, RZ_REG_NAME_BP);
     if (!sp) {
         sp = "SP";
     }
     if (!bp) {
         bp = "BP";
     }
     RzReg *r = core->analysis->reg;
     ut64 dsp = rz_reg_getv(r, sp);
     ut64 dbp = rz_reg_getv(r, bp);
     int n = 0;
     rz_list_foreach (frames, iter, f) {
         ut64 s = f->sp ? f->sp : dsp;
         ut64 b = f->bp ? f->bp : dbp;
         rz_reg_setv(r, bp, s);
         rz_reg_setv(r, sp, b);
         char flagdesc[1024], flagdesc2[1024];
         RzFlagItem *fi = rz_flag_get_at(core->flags, f->addr, true);
         flagdesc[0] = flagdesc2[0] = 0;
         if (fi) {
             if (fi->offset != f->addr) {
                 int delta = (int)(f->addr - fi->offset);
                 if (delta > 0) {
                     snprintf(flagdesc, sizeof(flagdesc),
                         "%s+%d", fi->name, delta);
                 } else if (delta < 0) {
                     snprintf(flagdesc, sizeof(flagdesc),
                         "%s%d", fi->name, delta);
                 } else {
                     snprintf(flagdesc, sizeof(flagdesc),
                         "%s", fi->name);
                 }
             } else {
                 snprintf(flagdesc, sizeof(flagdesc),
                     "%s", fi->name);
             }
         }
         RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, f->addr, 0);
         // char *str = rz_str_newf ("[frame %d]", n);
         rz_cons_printf("%d  0x%08" PFMT64x " sp: 0x%08" PFMT64x " %-5d"
                    "[%s]  %s %s\n",
             n, f->addr, f->sp, (int)f->size,
             fcn ? fcn->name : "??", flagdesc, flagdesc2);
         rz_cons_push();
         char *res = rz_core_analysis_all_vars_display(core, fcn, true);
         rz_cons_pop();
         rz_cons_printf("%s", res);
         free(res);
         n++;
     }
     rz_reg_setv(r, bp, dbp);
     rz_reg_setv(r, sp, dsp);
 }

References rz_core_t::analysis, b, delta, f, rz_core_t::flags, free(), int, n, rz_analysis_function_t::name, rz_flag_item_t::name, rz_flag_item_t::offset, PFMT64x, r, rz_analysis_t::reg, rz_analysis_get_fcn_in(), rz_cons_pop(), rz_cons_printf(), rz_cons_push(), rz_core_analysis_all_vars_display(), rz_flag_get_at(), rz_reg_get_name(), rz_reg_getv(), RZ_REG_NAME_BP, RZ_REG_NAME_SP, rz_reg_setv(), s, snprintf, sp, and ut64().

Referenced by rz_cmd_debug_display_bt_local_vars_handler().

◆ cmd_dcu()

static bool cmd_dcu	(	RzCore *	core,
		const char *	input
	)

static

Definition at line 1947 of file cmd_debug.c.

                                                      {
     const char *ptr = NULL;
     ut64 from, to, pc;
     bool dcu_range = false;
     bool invalid = (!input[0] || !input[1] || !input[2]);
     if (invalid || (input[2] != ' ' && input[2] != '.')) {
         rz_core_cmd_help(core, help_msg_dcu);
         return false;
     }
     to = UT64_MAX;
     if (input[2] == '.') {
         ptr = strchr(input + 3, ' ');
         if (ptr) { // TODO: put '\0' in *ptr to avoid
             from = rz_num_tail(core->num, core->offset, input + 2);
             if (ptr[1] == '.') {
                 to = rz_num_tail(core->num, core->offset, ptr + 2);
             } else {
                 to = rz_num_math(core->num, ptr + 1);
             }
             dcu_range = true;
         } else {
             from = rz_num_tail(core->num, core->offset, input + 2);
         }
     } else {
         ptr = strchr(input + 3, ' ');
         if (ptr) { // TODO: put '\0' in *ptr to avoid
             from = rz_num_math(core->num, input + 3);
             if (ptr[1] == '.') {
                 to = rz_num_tail(core->num, core->offset, ptr + 2);
             } else {
                 to = rz_num_math(core->num, ptr + 1);
             }
             dcu_range = true;
         } else {
             from = rz_num_math(core->num, input + 3);
         }
     }
     if (core->num->nc.errors && rz_cons_is_interactive()) {
         eprintf("Cannot continue until unknown address '%s'\n", core->num->nc.calc_buf);
         return false;
     }
     if (to == UT64_MAX) {
         to = from;
     }
     if (dcu_range) {
         rz_cons_break_push(NULL, NULL);
         do {
             if (rz_cons_is_breaked()) {
                 break;
             }
             rz_debug_step(core->dbg, 1);
             rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_GPR, false);
             pc = rz_debug_reg_get(core->dbg, "PC");
             eprintf("Continue 0x%08" PFMT64x " > 0x%08" PFMT64x " < 0x%08" PFMT64x "\n",
                 from, pc, to);
         } while (pc < from || pc > to);
         rz_cons_break_pop();
     } else {
         return rz_core_debug_continue_until(core, from, to);
     }
     return true;
 }

References rz_num_calc_t::calc_buf, rz_core_t::dbg, eprintf, rz_num_calc_t::errors, from, help_msg_dcu, input(), rz_num_t::nc, NULL, rz_core_t::num, rz_core_t::offset, pc, PFMT64x, rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_cons_is_interactive(), rz_core_cmd_help(), rz_core_debug_continue_until(), rz_debug_reg_get(), rz_debug_reg_sync(), rz_debug_step(), rz_num_math(), rz_num_tail(), RZ_REG_TYPE_GPR, to, ut64(), and UT64_MAX.

Referenced by rz_cmd_debug_continue_until().

◆ cmd_debug_backtrace()

static void cmd_debug_backtrace	(	RzCore *	core,
		ut64	len
	)

static

Definition at line 774 of file cmd_debug.c.

                                                         {
     RzAnalysisOp analop;
     ut64 addr;
     if (!len) {
         rz_bp_traptrace_list(core->dbg->bp);
     } else {
         ut64 oaddr = 0LL;
         eprintf("Trap tracing 0x%08" PFMT64x "-0x%08" PFMT64x "\n",
             core->offset, core->offset + len);
         rz_reg_arena_swap(core->dbg->reg, true);
         rz_bp_traptrace_reset(core->dbg->bp, true);
         rz_bp_traptrace_add(core->dbg->bp, core->offset, core->offset + len);
         rz_bp_traptrace_enable(core->dbg->bp, true);
         do {
             ut8 buf[32];
             rz_debug_continue(core->dbg);
             addr = rz_debug_reg_get(core->dbg, "PC");
             if (!addr) {
                 eprintf("pc=0\n");
                 break;
             }
             if (addr == oaddr) {
                 eprintf("pc=opc\n");
                 break;
             }
             oaddr = addr;
             /* XXX Bottleneck..we need to reuse the bytes read by traptrace */
             // XXX Do asm.arch should define the max size of opcode?
             rz_io_read_at(core->io, addr, buf, 32); // XXX longer opcodes?
             rz_analysis_op(core->analysis, &analop, addr, buf, sizeof(buf), RZ_ANALYSIS_OP_MASK_BASIC);
         } while (rz_bp_traptrace_at(core->dbg->bp, addr, analop.size));
         rz_bp_traptrace_enable(core->dbg->bp, false);
     }
 }

References addr, analop(), rz_core_t::analysis, rz_debug_t::bp, rz_core_t::dbg, eprintf, rz_core_t::io, len, rz_core_t::offset, PFMT64x, rz_debug_t::reg, rz_analysis_op(), RZ_ANALYSIS_OP_MASK_BASIC, rz_bp_traptrace_add(), rz_bp_traptrace_at(), rz_bp_traptrace_enable(), rz_bp_traptrace_list(), rz_bp_traptrace_reset(), rz_debug_continue(), rz_debug_reg_get(), rz_io_read_at(), rz_reg_arena_swap(), and ut64().

Referenced by rz_cmd_debug_continue_traptrace_handler().

◆ cmd_debug_cont_syscall()

static void cmd_debug_cont_syscall	(	RzCore *	core,
		const char *	_str
	)

static

Definition at line 204 of file cmd_debug.c.

                                                                    {
     // TODO : handle more than one stopping syscall
     int i, *syscalls = NULL;
     int count = 0;
     if (_str && *_str) {
         char *str = strdup(_str);
         count = rz_str_word_set0(str);
         syscalls = calloc(sizeof(int), count);
         for (i = 0; i < count; i++) {
             const char *sysnumstr = rz_str_word_get0(str, i);
             int sig = (int)rz_num_math(core->num, sysnumstr);
             if (sig == -1) { // trace ALL syscalls
                 syscalls[i] = -1;
             } else if (sig == 0) {
                 sig = rz_syscall_get_num(core->analysis->syscall, sysnumstr);
                 if (sig == -1) {
                     eprintf("Unknown syscall number\n");
                     free(str);
                     free(syscalls);
                     return;
                 }
                 syscalls[i] = sig;
             }
         }
         eprintf("Running child until syscalls:");
         for (i = 0; i < count; i++) {
             eprintf("%d ", syscalls[i]);
         }
         eprintf("\n");
         free(str);
     } else {
         eprintf("Running child until next syscall\n");
     }
     rz_reg_arena_swap(core->dbg->reg, true);
     rz_debug_continue_syscalls(core->dbg, syscalls, count);
     free(syscalls);
 }

References rz_core_t::analysis, calloc(), count, rz_core_t::dbg, eprintf, free(), i, int, NULL, rz_core_t::num, rz_debug_t::reg, rz_debug_continue_syscalls(), rz_num_math(), rz_reg_arena_swap(), rz_str_word_get0(), rz_str_word_set0(), rz_syscall_get_num(), cmd_descs_generate::str, strdup(), and rz_analysis_t::syscall.

Referenced by rz_cmd_debug_continue_fork_handler(), and rz_cmd_debug_continue_syscall().

◆ cmd_debug_current_modules()

static void cmd_debug_current_modules	(	RzCore *	core,
		RzOutputMode	mode
	)

static

Definition at line 861 of file cmd_debug.c.

                                                                        { // "dmm"
     ut64 addr = core->offset;
     RzDebugMap *map;
     RzList *list;
     RzListIter *iter;
     list = rz_debug_modules_list(core->dbg);
     rz_list_foreach (list, iter, map) {
         if (!(addr >= map->addr && addr < map->addr_end)) {
             continue;
         }
         if (mode == RZ_OUTPUT_MODE_STANDARD) {
             rz_cons_printf("0x%08" PFMT64x " 0x%08" PFMT64x "  %s\n", map->addr, map->addr_end, map->file);
         } else if (mode == RZ_OUTPUT_MODE_RIZIN) {
             /* Escape backslashes (e.g. for Windows). */
             char *escaped_path = rz_str_escape(map->file);
             char *filtered_name = strdup(map->name);
             rz_name_filter(filtered_name, 0, true);
             rz_cons_printf("f mod.%s @ 0x%08" PFMT64x "\n",
                 filtered_name, map->addr);
             rz_cons_printf("oba 0x%08" PFMT64x " %s\n", map->addr, escaped_path);
             free(escaped_path);
             free(filtered_name);
         }
     }
     rz_list_free(list);
 }

References addr, rz_core_t::dbg, free(), list(), map(), rz_core_t::offset, PFMT64x, rz_cons_printf(), rz_debug_modules_list(), rz_list_free(), rz_name_filter(), RZ_OUTPUT_MODE_RIZIN, RZ_OUTPUT_MODE_STANDARD, rz_str_escape(), strdup(), and ut64().

Referenced by rz_cmd_debug_current_modules_handler().

◆ cmd_debug_modules()

static void cmd_debug_modules	(	RzCore *	core,
		RzCmdStateOutput *	state
	)

static

Definition at line 888 of file cmd_debug.c.

                                                                      { // "dmm"
     RzDebugMap *map;
     RzList *list;
     RzListIter *iter;
     PJ *pj = state->d.pj;
     RzOutputMode mode = state->mode;
     rz_cmd_state_output_array_start(state);
     list = rz_debug_modules_list(core->dbg);
     rz_list_foreach (list, iter, map) {
         if (mode == RZ_OUTPUT_MODE_STANDARD) {
             rz_cons_printf("0x%08" PFMT64x " 0x%08" PFMT64x "  %s\n", map->addr, map->addr_end, map->file);
         } else if (mode == RZ_OUTPUT_MODE_JSON) {
             /* Escape backslashes (e.g. for Windows). */
             pj_o(pj);
             pj_kn(pj, "addr", map->addr);
             pj_kn(pj, "addr_end", map->addr_end);
             pj_ks(pj, "file", map->file);
             pj_ks(pj, "name", map->name);
             pj_end(pj);
         } else if (mode == RZ_OUTPUT_MODE_RIZIN) {
             /* Escape backslashes (e.g. for Windows). */
             char *escaped_path = rz_str_escape(map->file);
             char *filtered_name = strdup(map->name);
             rz_name_filter(filtered_name, 0, true);
             rz_cons_printf("f mod.%s @ 0x%08" PFMT64x "\n",
                 filtered_name, map->addr);
             rz_cons_printf("oba 0x%08" PFMT64x " %s\n", map->addr, escaped_path);
             free(escaped_path);
             free(filtered_name);
         }
     }
     rz_cmd_state_output_array_end(state);
     rz_list_free(list);
 }

References rz_core_t::dbg, free(), list(), map(), PFMT64x, pj_end(), pj_kn(), pj_ks(), pj_o(), rz_cmd_state_output_array_end(), rz_cmd_state_output_array_start(), rz_cons_printf(), rz_debug_modules_list(), rz_list_free(), rz_name_filter(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_RIZIN, RZ_OUTPUT_MODE_STANDARD, rz_str_escape(), and strdup().

Referenced by rz_cmd_debug_dmi(), and rz_cmd_debug_modules_handler().

◆ cmd_debug_pid()

static void cmd_debug_pid	(	RzCore *	core,
		const char *	input
	)

static

Definition at line 640 of file cmd_debug.c.

                                                            {
     int pid, sig;
     const char *ptr;
     switch (input[1]) {
     case '\0': // "dp"
         eprintf("Selected: %d %d\n", core->dbg->pid, core->dbg->tid);
         rz_debug_pid_list(core->dbg, core->dbg->pid, 0);
         break;
     case '-': // "dp-"
         if (input[2] == ' ') {
             rz_debug_detach(core->dbg, rz_num_math(core->num, input + 2));
         } else {
             rz_debug_detach(core->dbg, core->dbg->pid);
         }
         break;
     case 'c': // "dpc"
         if (core->dbg->forked_pid != -1) {
             if (input[2] == '*') {
                 eprintf("dp %d\n", core->dbg->forked_pid);
             } else {
                 rz_debug_select(core->dbg, core->dbg->forked_pid, core->dbg->tid);
                 core->dbg->main_pid = core->dbg->forked_pid;
                 core->dbg->n_threads = 0;
                 core->dbg->forked_pid = -1;
             }
         } else {
             eprintf("No recently forked children\n");
         }
         break;
     case 'k': // "dpk"
         /* stop, print, pass -- just use flags*/
         /* XXX: not for threads? signal is for a whole process!! */
         /* XXX: but we want fine-grained access to process resources */
         pid = atoi(input + 2);
         if (pid > 0) {
             ptr = rz_str_trim_head_ro(input + 2);
             ptr = strchr(ptr, ' ');
             sig = ptr ? atoi(ptr + 1) : 0;
             eprintf("Sending signal '%d' to pid '%d'\n", sig, pid);
             rz_debug_kill(core->dbg, pid, false, sig);
         } else
             eprintf("cmd_debug_pid: Invalid arguments (%s)\n", input);
         break;
     case 'n': // "dpn"
         eprintf("TODO: debug_fork: %d\n", rz_debug_child_fork(core->dbg));
         break;
     case 't': // "dpt"
         switch (input[2]) {
         case '\0': // "dpt"
             rz_debug_thread_list(core->dbg, core->dbg->pid, 0);
             break;
         case 'j': // "dptj"
             if (input[3] != ' ') { // "dptj"
                 rz_debug_thread_list(core->dbg, core->dbg->pid, 'j');
             } else { // "dptj "
                 rz_debug_thread_list(core->dbg, atoi(input + 3), 'j');
             }
             break;
         case ' ': // "dpt "
             rz_debug_thread_list(core->dbg, atoi(input + 2), 0);
             break;
         case '=': // "dpt="
             rz_debug_select(core->dbg, core->dbg->pid,
                 (int)rz_num_math(core->num, input + 3));
             break;
         case 'n': // "dptn"
             eprintf("TODO: debug_clone: %d\n", rz_debug_child_clone(core->dbg));
             break;
         case '?': // "dpt?"
         default:
             rz_core_cmd_help(core, help_msg_dp);
             break;
         }
         break;
     case 'a': // "dpa"
         if (input[2]) {
             int pid = rz_num_math(core->num, input + 2);
             rz_core_debug_attach(core, pid);
         } else {
             rz_core_debug_attach(core, 0);
         }
         break;
     case 'f': // "dpf"
         if (core->file && core->io) {
             rz_debug_select(core->dbg, rz_io_fd_get_pid(core->io, core->file->fd),
                 rz_io_fd_get_tid(core->io, core->file->fd));
         }
         break;
     case '=': // "dp="
         rz_debug_select(core->dbg,
             (int)rz_num_math(core->num, input + 2), core->dbg->tid);
         core->dbg->main_pid = rz_num_math(core->num, input + 2);
         break;
     case 'l': // "dpl"
         switch (input[2]) {
         case '\0': // "dpl"
             rz_debug_pid_list(core->dbg, 0, 0);
             break;
         case 'j': // "dplj"
             rz_debug_pid_list(core->dbg, 0, 'j');
             break;
         }
         break;
     case 'j': // "dpj"
         switch (input[2]) {
         case '\0': // "dpj"
             rz_debug_pid_list(core->dbg, core->dbg->pid, 'j');
             break;
         case ' ': // "dpj "
             rz_debug_pid_list(core->dbg,
                 (int)RZ_MAX(0, (int)rz_num_math(core->num, input + 2)), 'j');
             break;
         }
         break;
     case 'e': // "dpe"
     {
         int pid = (input[2] == ' ') ? atoi(input + 2) : core->dbg->pid;
         char *exe = rz_sys_pid_to_path(pid);
         if (exe) {
             rz_cons_println(exe);
             free(exe);
         }
     } break;
     case ' ': // "dp "
         rz_debug_pid_list(core->dbg,
             (int)RZ_MAX(0, (int)rz_num_math(core->num, input + 2)), 0);
         break;
     case '?': // "dp?"
     default:
         rz_core_cmd_help(core, help_msg_dp);
         break;
     }
 }

References rz_core_t::dbg, eprintf, rz_core_file_t::fd, rz_core_t::file, rz_debug_t::forked_pid, free(), help_msg_dp, input(), rz_core_t::io, rz_debug_t::main_pid, rz_debug_t::n_threads, rz_core_t::num, rz_debug_t::pid, pid, rz_cons_println(), rz_core_cmd_help(), rz_core_debug_attach(), rz_debug_child_clone(), rz_debug_child_fork(), rz_debug_detach(), rz_debug_kill(), rz_debug_pid_list(), rz_debug_select(), rz_debug_thread_list(), rz_io_fd_get_pid(), rz_io_fd_get_tid(), RZ_MAX, rz_num_math(), rz_str_trim_head_ro(), rz_sys_pid_to_path(), and rz_debug_t::tid.

Referenced by rz_cmd_debug().

◆ cmd_regs_sync()

static bool cmd_regs_sync	(	RzCore *	core,
		RzRegisterType	type,
		bool	write
	)

static

Definition at line 3607 of file cmd_debug.c.

                                                                          {
     return rz_debug_reg_sync(core->dbg, type, write);
 }

References rz_core_t::dbg, rz_debug_reg_sync(), type, and write.

Referenced by rz_core_debug_ri().

◆ consumeBuffer()

static void consumeBuffer	(	RzBuffer *	buf,
		const char *	cmd,
		const char *	errmsg
	)

static

Definition at line 2267 of file cmd_debug.c.

                                                                               {
     if (!buf) {
         if (errmsg) {
             rz_cons_printf("%s\n", errmsg);
         }
         return;
     }
     if (cmd) {
         rz_cons_printf("%s", cmd);
     }
     int i;
     rz_buf_seek(buf, 0, RZ_BUF_SET);
     for (i = 0; i < rz_buf_size(buf); i++) {
         ut8 tmp;
         if (!rz_buf_read8(buf, &tmp)) {
             return;
         }
         rz_cons_printf("%02x", tmp);
     }
     rz_cons_printf("\n");
 }

References cmd, i, rz_buf_read8(), rz_buf_seek(), RZ_BUF_SET, rz_buf_size(), rz_cons_printf(), and autogen_x86imm::tmp.

Referenced by rz_cmd_debug().

◆ debug_trace_calls()

static void debug_trace_calls	(	RzCore *	core,
		ut64	from,
		ut64	to,
		ut64	final_addr
	)

static

Definition at line 1753 of file cmd_debug.c.

                                                                                  {
     RzBreakpointItem *bp_final = NULL;
     int t = core->dbg->trace->enabled;
  
     if (rz_debug_is_dead(core->dbg)) {
         eprintf("No process to debug.");
         return;
     }
     core->dbg->trace->enabled = 0;
     rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
     rz_reg_arena_swap(core->dbg->reg, true);
     if (final_addr != UT64_MAX) {
         bool hwbp = rz_config_get_b(core->config, "dbg.hwbp");
         bp_final = rz_debug_bp_add(core->dbg, final_addr, hwbp, false, 0, NULL, 0);
         if (!bp_final) {
             eprintf("Cannot set breakpoint at final address (%" PFMT64x ")\n", final_addr);
         }
     }
     do_debug_trace_calls(core, from, to, final_addr);
     if (bp_final) {
         rz_bp_del(core->dbg->bp, final_addr);
     }
     _core = core;
     trace_traverse(core->dbg->tree);
     core->dbg->trace->enabled = t;
     rz_cons_break_pop();
 }

References _core, rz_debug_t::bp, rz_core_t::config, rz_core_t::dbg, do_debug_trace_calls(), rz_debug_trace_t::enabled, eprintf, from, NULL, PFMT64x, rz_debug_t::reg, rz_bp_del(), rz_config_get_b(), rz_cons_break_pop(), rz_cons_break_push(), rz_core_static_debug_stop(), rz_debug_bp_add(), rz_debug_is_dead(), rz_reg_arena_swap(), to, rz_debug_t::trace, trace_traverse(), rz_debug_t::tree, and UT64_MAX.

Referenced by rz_cmd_debug_trace_calls_handler().

◆ do_debug_trace_calls()

static void do_debug_trace_calls	(	RzCore *	core,
		ut64	from,
		ut64	to,
		ut64	final_addr
	)

static

Definition at line 1652 of file cmd_debug.c.

                                                                                     {
     bool trace_libs = rz_config_get_i(core->config, "dbg.trace.libs");
     bool shallow_trace = rz_config_get_i(core->config, "dbg.trace.inrange");
     HtUP *tracenodes = core->dbg->tracenodes;
     RTree *tr = core->dbg->tree;
     RzDebug *dbg = core->dbg;
     ut64 debug_to = UT64_MAX;
     RTreeNode *cur;
     ut64 addr = 0;
     int n = 0;
  
     if (!trace_libs) {
 #if NOOP
         RzList *bounds = rz_core_get_boundaries_prot(core, -1, "dbg.program", "search");
         rz_list_free(bounds);
 #endif
     }
  
     /* set root if not already present */
     rz_tree_add_node(tr, NULL, NULL);
     cur = tr->root;
  
     while (true) {
         ut8 buf[32];
         RzAnalysisOp aop;
         int addr_in_range;
  
         if (rz_cons_is_breaked()) {
             break;
         }
         if (rz_debug_is_dead(dbg)) {
             break;
         }
         if (debug_to != UT64_MAX && !rz_debug_continue_until(dbg, debug_to)) {
             break;
         }
         if (!rz_debug_step(dbg, 1)) {
             break;
         }
         debug_to = UT64_MAX;
         if (!rz_debug_reg_sync(dbg, RZ_REG_TYPE_GPR, false)) {
             break;
         }
         addr = rz_debug_reg_get(dbg, "PC");
         if (addr == final_addr) {
             // we finished the tracing so break the loop
             break;
         }
         addr_in_range = addr >= from && addr < to;
  
         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);
         eprintf("%d %" PFMT64x "\r", n++, addr);
         switch (aop.type) {
         case RZ_ANALYSIS_OP_TYPE_UCALL:
         case RZ_ANALYSIS_OP_TYPE_ICALL:
         case RZ_ANALYSIS_OP_TYPE_RCALL:
         case RZ_ANALYSIS_OP_TYPE_IRCALL: {
             ut64 called_addr;
             int called_in_range;
             // store regs
             // step into
             // get pc
             rz_debug_step(dbg, 1);
             rz_debug_reg_sync(dbg, RZ_REG_TYPE_GPR, false);
             called_addr = rz_debug_reg_get(dbg, "PC");
             called_in_range = called_addr >= from && called_addr < to;
             if (!called_in_range && addr_in_range && !shallow_trace) {
                 debug_to = addr + aop.size;
             }
             if (addr_in_range || shallow_trace) {
                 cur = add_trace_tree_child(tracenodes, tr, cur, addr);
                 if (debug_to != UT64_MAX) {
                     cur = cur->parent;
                 }
             }
             // TODO: push pc+aop.length into the call path stack
             break;
         }
         case RZ_ANALYSIS_OP_TYPE_CALL: {
             int called_in_range = aop.jump >= from && aop.jump < to;
             if (!called_in_range && addr_in_range && !shallow_trace) {
                 debug_to = aop.addr + aop.size;
             }
             if (addr_in_range || shallow_trace) {
                 cur = add_trace_tree_child(tracenodes, tr, cur, addr);
                 if (debug_to != UT64_MAX) {
                     cur = cur->parent;
                 }
             }
             break;
         }
         case RZ_ANALYSIS_OP_TYPE_RET:
             if (cur != tr->root) {
                 cur = cur->parent;
             }
             break;
         }
     }
 }

References add_trace_tree_child(), addr, rz_analysis_op_t::addr, rz_core_t::analysis, rz_core_t::config, dbg, rz_core_t::dbg, eprintf, from, rz_core_t::io, rz_analysis_op_t::jump, n, NULL, rz_tree_node_t::parent, PFMT64x, rz_analysis_op(), RZ_ANALYSIS_OP_MASK_BASIC, RZ_ANALYSIS_OP_TYPE_CALL, RZ_ANALYSIS_OP_TYPE_ICALL, RZ_ANALYSIS_OP_TYPE_IRCALL, RZ_ANALYSIS_OP_TYPE_RCALL, RZ_ANALYSIS_OP_TYPE_RET, RZ_ANALYSIS_OP_TYPE_UCALL, rz_config_get_i(), rz_cons_is_breaked(), rz_core_get_boundaries_prot(), rz_debug_continue_until(), rz_debug_is_dead(), rz_debug_reg_get(), rz_debug_reg_sync(), rz_debug_step(), rz_io_read_at(), rz_list_free(), RZ_REG_TYPE_GPR, rz_tree_add_node(), rz_analysis_op_t::size, to, tr, rz_debug_t::tracenodes, rz_debug_t::tree, rz_analysis_op_t::type, ut64(), and UT64_MAX.

Referenced by debug_trace_calls().

◆ dot_trace_create_node()

static void dot_trace_create_node	(	RTreeNode *	n,
		RTreeVisitor *	vis
	)

static

Definition at line 255 of file cmd_debug.c.

                                                                    {
     struct dot_trace_ght *data = (struct dot_trace_ght *)vis->data;
     struct trace_node *tn = n->data;
     if (tn)
         get_graphtrace_node(data->graph, data->graphnodes, tn);
 }

References rz_tree_visitor_t::data, get_graphtrace_node(), dot_trace_ght::graph, dot_trace_ght::graphnodes, if(), and n.

Referenced by dot_trace_traverse().

◆ dot_trace_discover_child()

static void dot_trace_discover_child	(	RTreeNode *	n,
		RTreeVisitor *	vis
	)

static

Definition at line 262 of file cmd_debug.c.

                                                                       {
     struct dot_trace_ght *data = (struct dot_trace_ght *)vis->data;
     RzGraph *g = data->graph;
     Sdb *gnodes = data->graphnodes;
     RTreeNode *parent = n->parent;
     struct trace_node *tn = n->data;
     struct trace_node *tn_parent = parent->data;
  
     if (tn && tn_parent) {
         RzGraphNode *gn = get_graphtrace_node(g, gnodes, tn);
         RzGraphNode *gn_parent = get_graphtrace_node(g, gnodes, tn_parent);
  
         if (!rz_graph_adjacent(g, gn_parent, gn))
             rz_graph_add_edge(g, gn_parent, gn);
     }
 }

References rz_tree_visitor_t::data, g, get_graphtrace_node(), dot_trace_ght::graph, dot_trace_ght::graphnodes, if(), n, rz_graph_add_edge(), and rz_graph_adjacent().

Referenced by dot_trace_traverse().

◆ dot_trace_traverse()

static void dot_trace_traverse	(	RzCore *	core,
		RTree *	t,
		int	fmt
	)

static

Definition at line 279 of file cmd_debug.c.

                                                                 {
     const char *gfont = rz_config_get(core->config, "graph.font");
     struct dot_trace_ght aux_data;
     RTreeVisitor vis = { 0 };
     const RzList *nodes;
     RzListIter *iter;
     RzGraphNode *n;
  
     if (fmt == 'i') {
         rz_core_agraph_reset(core);
         rz_core_cmd0(core, ".dtg*");
         rz_core_agraph_print_interactive(core);
         return;
     }
     aux_data.graph = rz_graph_new();
     aux_data.graphnodes = sdb_new0();
  
     /* build a callgraph from the execution trace */
     vis.data = &aux_data;
     vis.pre_visit = (RTreeNodeVisitCb)dot_trace_create_node;
     vis.discover_child = (RTreeNodeVisitCb)dot_trace_discover_child;
     rz_tree_bfs(t, &vis);
  
     /* traverse the callgraph to print the dot file */
     nodes = rz_graph_get_nodes(aux_data.graph);
     if (fmt == 0) {
         rz_cons_printf("digraph code {\n"
                    "graph [bgcolor=white];\n"
                    "    node [color=lightgray, style=filled"
                    " shape=box fontname=\"%s\" fontsize=\"8\"];\n",
             gfont);
     }
     rz_list_foreach (nodes, iter, n) {
         struct trace_node *tn = (struct trace_node *)n->data;
         const RzList *neighbours = rz_graph_get_neighbours(aux_data.graph, n);
         RzListIter *it_n;
         RzGraphNode *w;
  
         if (!fmt && tn) {
             rz_cons_printf("\"0x%08" PFMT64x "\" [URL=\"0x%08" PFMT64x
                        "\" color=\"lightgray\" label=\"0x%08" PFMT64x
                        " (%d)\"]\n",
                 tn->addr, tn->addr, tn->addr, tn->refs);
         }
         rz_list_foreach (neighbours, it_n, w) {
             struct trace_node *tv = (struct trace_node *)w->data;
  
             if (tv && tn) {
                 if (fmt) {
                     rz_cons_printf("agn 0x%08" PFMT64x "\n", tn->addr);
                     rz_cons_printf("agn 0x%08" PFMT64x "\n", tv->addr);
                     rz_cons_printf("age 0x%08" PFMT64x " 0x%08" PFMT64x "\n",
                         tn->addr, tv->addr);
                 } else {
                     rz_cons_printf("\"0x%08" PFMT64x "\" -> \"0x%08" PFMT64x
                                "\" [color=\"red\"];\n",
                         tn->addr, tv->addr);
                 }
             }
         }
     }
     if (!fmt) {
         rz_cons_printf("}\n");
     }
  
     rz_graph_free(aux_data.graph);
     sdb_free(aux_data.graphnodes);
 }

References trace_node::addr, rz_core_t::config, dot_trace_create_node(), dot_trace_discover_child(), dot_trace_ght::graph, dot_trace_ght::graphnodes, if(), n, PFMT64x, trace_node::refs, rz_config_get(), rz_cons_printf(), rz_core_agraph_print_interactive(), rz_core_agraph_reset(), rz_core_cmd0(), rz_graph_free(), rz_graph_get_neighbours(), rz_graph_get_nodes(), rz_graph_new(), rz_tree_bfs(), sdb_free(), sdb_new0(), tv, and w.

Referenced by rz_cmd_debug_trace_graph_handler(), and rz_cmd_debug_trace_interactive_handler().

◆ dump_maps()

static int dump_maps	(	RzCore *	core,
		int	perm,
		const char *	filename
	)

static

XXX: TODO: read by blocks!!1

Definition at line 810 of file cmd_debug.c.

                                                                    {
     RzDebugMap *map;
     RzListIter *iter;
     rz_debug_map_sync(core->dbg); // update process memory maps
     ut64 addr = core->offset;
     int do_dump = false;
     int ret = !rz_list_empty(core->dbg->maps);
     rz_list_foreach (core->dbg->maps, iter, map) {
         do_dump = false;
         if (perm == -1) {
             if (addr >= map->addr && addr < map->addr_end) {
                 do_dump = true;
             }
         } else if (perm == 0) {
             do_dump = true;
         } else if (perm == (map->perm & perm)) {
             do_dump = true;
         }
         if (do_dump) {
             ut8 *buf = malloc(map->size);
             // TODO: use mmap here. we need a portable implementation
             if (!buf) {
                 eprintf("Cannot allocate 0x%08" PFMT64x " bytes\n", map->size);
                 free(buf);
                 continue;
             }
             if (map->size > MAX_MAP_SIZE) {
                 eprintf("Do not dumping 0x%08" PFMT64x " because it's too big\n", map->addr);
                 free(buf);
                 continue;
             }
             rz_io_read_at(core->io, map->addr, buf, map->size);
             char *file = filename
                 ? strdup(filename)
                 : rz_str_newf("0x%08" PFMT64x "-0x%08" PFMT64x "-%s.dmp",
                       map->addr, map->addr_end, rz_str_rwx_i(map->perm));
             if (!rz_file_dump(file, buf, map->size, 0)) {
                 eprintf("Cannot write '%s'\n", file);
                 ret = 0;
             } else {
                 eprintf("Dumped %d byte(s) into %s\n", (int)map->size, file);
             }
             free(file);
             free(buf);
         }
     }
     // eprintf ("No debug region found here\n");
     return ret;
 }

References addr, rz_core_t::dbg, eprintf, free(), rz_core_t::io, malloc(), map(), rz_debug_t::maps, MAX_MAP_SIZE, rz_core_t::offset, PFMT64x, rz_debug_map_sync(), rz_file_dump(), rz_io_read_at(), rz_str_newf(), rz_str_rwx_i(), strdup(), and ut64().

Referenced by rz_cmd_debug_dump_maps_all_handler(), rz_cmd_debug_dump_maps_handler(), and rz_cmd_debug_dump_maps_writable_handler().

◆ foreach_reg_set_or_clear()

static void foreach_reg_set_or_clear	(	RzCore *	core,
		bool	set
	)

static

Definition at line 1428 of file cmd_debug.c.

                                                              {
     RzReg *reg = rz_core_reg_default(core);
     const RzList *regs = rz_reg_get_list(reg, RZ_REG_TYPE_GPR);
     RzListIter *it;
     RzRegItem *reg_item;
     rz_list_foreach (regs, it, reg_item) {
         if (set) {
             const ut64 value = rz_reg_get_value(reg, reg_item);
             rz_flag_set(core->flags, reg_item->name, value, reg_item->size / 8);
         } else {
             rz_flag_unset_name(core->flags, reg_item->name);
         }
     }
 }

References rz_core_t::flags, rz_reg_item_t::name, reg, regs, rz_core_reg_default(), rz_flag_set(), rz_flag_unset_name(), rz_reg_get_list(), rz_reg_get_value(), RZ_REG_TYPE_GPR, rz_reg_item_t::size, ut64(), and value.

Referenced by rz_core_debug_clear_register_flags(), and rz_core_debug_set_register_flags().

◆ get_bin_info()

static bool get_bin_info	(	RzCore *	core,
		const char *	file,
		ut64	baseaddr,
		PJ *	pj,
		int	mode,
		bool	symbols_only,
		RzCoreBinFilter *	filter
	)

static

Definition at line 980 of file cmd_debug.c.

                                                           {
     int fd;
     if ((fd = rz_io_fd_open(core->io, file, RZ_PERM_R, 0)) == -1) {
         return false;
     }
     RzBinOptions opt = { 0 };
     opt.obj_opts.elf_load_sections = true;
     opt.obj_opts.elf_checks_sections = true;
     opt.obj_opts.elf_checks_segments = true;
     opt.fd = fd;
     opt.sz = rz_io_fd_size(core->io, fd);
     opt.obj_opts.baseaddr = baseaddr;
     RzBinFile *obf = rz_bin_cur(core->bin);
     RzBinFile *bf = rz_bin_open_io(core->bin, &opt);
     if (!bf) {
         rz_io_fd_close(core->io, fd);
         return false;
     }
     int action = RZ_CORE_BIN_ACC_ALL & ~RZ_CORE_BIN_ACC_INFO;
     if (symbols_only || filter->name) {
         action = RZ_CORE_BIN_ACC_SYMBOLS;
     } else if (mode == RZ_MODE_SET || mode == RZ_MODE_RIZINCMD) {
         action &= ~RZ_CORE_BIN_ACC_ENTRIES & ~RZ_CORE_BIN_ACC_MAIN & ~RZ_CORE_BIN_ACC_MAPS;
     }
     if (mode == RZ_MODE_SET) {
         rz_core_bin_apply_info(core, core->bin->cur, action);
     } else {
         RzCmdStateOutput state;
         rz_cmd_state_output_init(&state, rad2mode(mode));
         rz_core_bin_print(core, bf, action, filter, &state, NULL);
         rz_cmd_state_output_print(&state);
         rz_cmd_state_output_fini(&state);
     }
     rz_bin_file_delete(core->bin, bf);
     rz_bin_file_set_cur_binfile(core->bin, obf);
     rz_io_fd_close(core->io, fd);
     return true;
 }

References test-lz4-speed::action, baseaddr, rz_core_t::bin, rz_bin_t::cur, fd, rz_core_t::io, NULL, rad2mode(), rz_bin_cur(), rz_bin_file_delete(), rz_bin_file_set_cur_binfile(), rz_bin_open_io(), rz_cmd_state_output_fini(), rz_cmd_state_output_init(), rz_cmd_state_output_print(), rz_core_bin_apply_info(), rz_core_bin_print(), rz_io_fd_close(), rz_io_fd_open(), rz_io_fd_size(), RZ_MODE_RIZINCMD, RZ_MODE_SET, and RZ_PERM_R.

Referenced by rz_cmd_debug_dmi().

◆ get_closest_map()

static RzDebugMap* get_closest_map	(	RzCore *	core,
		ut64	addr
	)

static

Definition at line 945 of file cmd_debug.c.

                                                             {
     RzListIter *iter;
     RzDebugMap *map;
  
     rz_debug_map_sync(core->dbg);
     RzList *list = rz_debug_modules_list(core->dbg);
     rz_list_foreach (list, iter, map) {
         if (addr != UT64_MAX && (addr >= map->addr && addr < map->addr_end)) {
             return map;
         }
     }
     rz_list_foreach (core->dbg->maps, iter, map) {
         if (addr != UT64_MAX && (addr >= map->addr && addr < map->addr_end)) {
             return map;
         }
     }
     return NULL;
 }

References addr, rz_core_t::dbg, list(), map(), rz_debug_t::maps, NULL, rz_debug_map_sync(), rz_debug_modules_list(), and UT64_MAX.

Referenced by rz_cmd_debug_dmi().

◆ get_corefile_name()

static char* get_corefile_name	(	const char *	raw_name,
		int	pid
	)

static

Definition at line 2256 of file cmd_debug.c.

                                                               {
     return (!*raw_name) ? rz_str_newf("core.%u", pid) : rz_str_trim_dup(raw_name);
 }

References pid, rz_str_newf(), and rz_str_trim_dup().

Referenced by rz_cmd_debug().

◆ get_graphtrace_node()

static RzGraphNode* get_graphtrace_node	(	RzGraph *	g,
		Sdb *	nodes,
		struct trace_node *	tn
	)

static

Definition at line 242 of file cmd_debug.c.

                                                                                        {
     RzGraphNode *gn;
     char tn_key[TN_KEY_LEN];
  
     snprintf(tn_key, TN_KEY_LEN, TN_KEY_FMT, tn->addr);
     gn = (RzGraphNode *)(size_t)sdb_num_get(nodes, tn_key, NULL);
     if (!gn) {
         gn = rz_graph_add_node(g, tn);
         sdb_num_set(nodes, tn_key, (ut64)(size_t)gn, 0);
     }
     return gn;
 }

References trace_node::addr, g, NULL, rz_graph_add_node(), sdb_num_get(), sdb_num_set(), snprintf, TN_KEY_FMT, TN_KEY_LEN, and ut64().

Referenced by dot_trace_create_node(), and dot_trace_discover_child().

◆ getFileData()

static ut8* getFileData	(	RzCore *	core,
		const char *	arg
	)

static

Definition at line 2260 of file cmd_debug.c.

                                                        {
     if (*arg == '$') {
         return (ut8 *)rz_cmd_alias_get(core->rcmd, arg, 1);
     }
     return (ut8 *)rz_file_slurp(arg, NULL);
 }

References NULL, rz_core_t::rcmd, rz_cmd_alias_get(), and rz_file_slurp().

Referenced by rz_cmd_debug().

◆ is_repeatable_inst()

static bool is_repeatable_inst	(	RzCore *	core,
		ut64	addr
	)

static

Definition at line 408 of file cmd_debug.c.

                                                         {
     // we have read the bytes already
     RzAnalysisOp *op = rz_core_op_analysis(core, addr, RZ_ANALYSIS_OP_MASK_ALL);
     bool ret = op && ((op->prefix & RZ_ANALYSIS_OP_PREFIX_REP) || (op->prefix & RZ_ANALYSIS_OP_PREFIX_REPNE));
     rz_analysis_op_free(op);
     return ret;
 }

References addr, rz_analysis_op_free(), RZ_ANALYSIS_OP_MASK_ALL, RZ_ANALYSIS_OP_PREFIX_REP, RZ_ANALYSIS_OP_PREFIX_REPNE, and rz_core_op_analysis().

Referenced by step_until_inst().

◆ rad2mode()

static RzOutputMode rad2mode ( int mode )

static

Definition at line 964 of file cmd_debug.c.

                                        {
     switch (mode) {
     case RZ_MODE_PRINT:
     default:
         return RZ_OUTPUT_MODE_STANDARD;
     case RZ_MODE_JSON:
         return RZ_OUTPUT_MODE_JSON;
     case RZ_MODE_SIMPLE:
         return RZ_OUTPUT_MODE_QUIET;
     case RZ_MODE_SIMPLEST:
         return RZ_OUTPUT_MODE_QUIETEST;
     case RZ_MODE_RIZINCMD:
         return RZ_OUTPUT_MODE_RIZIN;
     }
 }

References RZ_MODE_JSON, RZ_MODE_PRINT, RZ_MODE_RIZINCMD, RZ_MODE_SIMPLE, RZ_MODE_SIMPLEST, RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_QUIETEST, RZ_OUTPUT_MODE_RIZIN, and RZ_OUTPUT_MODE_STANDARD.

Referenced by get_bin_info(), and rz_cmd_debug_dmi().

◆ rz_cmd_debug()

RZ_IPI int rz_cmd_debug	(	void *	data,
		const char *	input
	)

Definition at line 2289 of file cmd_debug.c.

                                                        {
     RzCore *core = (RzCore *)data;
     int follow = 0;
  
     if (!strncmp(input, "ate", 3)) {
         char *now = rz_time_date_now_to_string();
         rz_cons_printf("%s\n", now);
         free(now);
         return 0;
     }
  
     switch (input[0]) {
     case 'd': // "ddd"
         switch (input[1]) {
         case '\0': // "ddd"
             rz_debug_desc_list(core->dbg, 0);
             break;
         case '*': // "dtd*"
             rz_debug_desc_list(core->dbg, 1);
             break;
         case 's': // "dtds"
         {
             ut64 off = UT64_MAX;
             int fd = atoi(input + 2);
             char *str = strchr(input + 2, ' ');
             if (str)
                 off = rz_num_math(core->num, str + 1);
             if (off == UT64_MAX || !rz_debug_desc_seek(core->dbg, fd, off)) {
                 RzBuffer *buf = rz_core_syscallf(core, "lseek", "%d, 0x%" PFMT64x ", %d", fd, off, 0);
                 consumeBuffer(buf, "dx ", "Cannot seek");
             }
         } break;
         case 't': { // "ddt" <ttypath>
             RzBuffer *buf = rz_core_syscall(core, "close", 0);
             consumeBuffer(buf, "dx ", "Cannot close");
             break;
         }
         case 'd': // "ddd"
         {
             ut64 newfd = UT64_MAX;
             int fd = atoi(input + 2);
             char *str = strchr(input + 3, ' ');
             if (str)
                 newfd = rz_num_math(core->num, str + 1);
             if (newfd == UT64_MAX || !rz_debug_desc_dup(core->dbg, fd, newfd)) {
                 RzBuffer *buf = rz_core_syscallf(core, "dup2", "%d, %d", fd, (int)newfd);
                 if (buf) {
                     consumeBuffer(buf, "dx ", NULL);
                 } else {
                     eprintf("Cannot dup %d %d\n", fd, (int)newfd);
                 }
             }
         } break;
         case 'r': {
             ut64 off = UT64_MAX;
             ut64 len = UT64_MAX;
             int fd = atoi(input + 2);
             char *str = strchr(input + 2, ' ');
             if (str)
                 off = rz_num_math(core->num, str + 1);
             if (str)
                 str = strchr(str + 1, ' ');
             if (str)
                 len = rz_num_math(core->num, str + 1);
             if (len == UT64_MAX || off == UT64_MAX ||
                 !rz_debug_desc_read(core->dbg, fd, off, len)) {
                 consumeBuffer(rz_core_syscallf(core, "read", "%d, 0x%" PFMT64x ", %d",
                               fd, off, (int)len),
                     "dx ", "Cannot read");
             }
         } break;
         case 'w': {
             ut64 off = UT64_MAX;
             ut64 len = UT64_MAX;
             int fd = atoi(input + 2);
             char *str = strchr(input + 2, ' ');
             if (str)
                 off = rz_num_math(core->num, str + 1);
             if (str)
                 str = strchr(str + 1, ' ');
             if (str)
                 len = rz_num_math(core->num, str + 1);
             if (len == UT64_MAX || off == UT64_MAX ||
                 !rz_debug_desc_write(core->dbg, fd, off, len)) {
                 RzBuffer *buf = rz_core_syscallf(core, "write", "%d, 0x%" PFMT64x ", %d", fd, off, (int)len);
                 consumeBuffer(buf, "dx ", "Cannot write");
             }
             break;
         }
         case '-': // "dd-"
         {
             int fd = atoi(input + 2);
             // rz_core_cmdf (core, "dxs close %d", (int)rz_num_math ( core->num, input + 2));
             RzBuffer *buf = rz_core_syscallf(core, "close", "%d", fd);
             consumeBuffer(buf, "dx ", "Cannot close");
             break;
         }
         case ' ': // "dd"
         {
             // TODO: handle read, readwrite, append
             RzBuffer *buf = rz_core_syscallf(core, "open", "%s, %d, %d", input + 2, 2, 0644);
             consumeBuffer(buf, "dx ", "Cannot open");
             break;
         }
         case '?':
         default:
             rz_core_cmd_help(core, help_msg_dd);
             break;
         }
         break;
     case 'H': // "dH"
         eprintf("TODO: transplant process\n");
         break;
     case 'p': // "dp"
         cmd_debug_pid(core, input);
         break;
     case 'i': // "di"
     {
         RzDebugInfo *rdi = rz_debug_info(core->dbg, input + 2);
         RzDebugReasonType stop = rz_debug_stop_reason(core->dbg);
         char *escaped_str;
         switch (input[1]) {
         case '\0': // "di"
 #define P rz_cons_printf
 #define PS(X, Y) \
     { \
         escaped_str = rz_str_escape(Y); \
         rz_cons_printf(X, escaped_str); \
         free(escaped_str); \
     }
             if (rdi) {
                 const char *s = rz_signal_to_string(core->dbg->reason.signum);
                 P("type=%s\n", rz_debug_reason_to_string(core->dbg->reason.type));
                 P("signal=%s\n", s ? s : "none");
                 P("signum=%d\n", core->dbg->reason.signum);
                 P("sigpid=%d\n", core->dbg->reason.tid);
                 P("addr=0x%" PFMT64x "\n", core->dbg->reason.addr);
                 P("bp_addr=0x%" PFMT64x "\n", core->dbg->reason.bp_addr);
                 P("inbp=%s\n", rz_str_bool(core->dbg->reason.bp_addr));
                 P("baddr=0x%" PFMT64x "\n", rz_debug_get_baddr(core->dbg, NULL));
                 P("pid=%d\n", rdi->pid);
                 P("tid=%d\n", rdi->tid);
                 P("stopaddr=0x%" PFMT64x "\n", core->dbg->stopaddr);
                 if (rdi->uid != -1) {
                     P("uid=%d\n", rdi->uid);
                 }
                 if (rdi->gid != -1) {
                     P("gid=%d\n", rdi->gid);
                 }
                 if (rdi->usr) {
                     P("usr=%s\n", rdi->usr);
                 }
                 if (rdi->exe && *rdi->exe) {
                     P("exe=%s\n", rdi->exe);
                 }
                 if (rdi->cmdline && *rdi->cmdline) {
                     P("cmdline=%s\n", rdi->cmdline);
                 }
                 if (rdi->cwd && *rdi->cwd) {
                     P("cwd=%s\n", rdi->cwd);
                 }
                 if (rdi->kernel_stack && *rdi->kernel_stack) {
                     P("kernel_stack=\n%s\n", rdi->kernel_stack);
                 }
             }
             if (stop != -1) {
                 P("stopreason=%d\n", stop);
             }
             break;
         case 'f': // "dif" "diff"
             if (input[1] == '?') {
                 eprintf("Usage: dif $a $b  # diff two alias files\n");
             } else {
                 char *arg = strchr(input, ' ');
                 if (arg) {
                     arg = strdup(rz_str_trim_head_ro(arg + 1));
                     char *arg2 = strchr(arg, ' ');
                     if (arg2) {
                         *arg2++ = 0;
                         char *a = (char *)getFileData(core, arg);
                         char *b = (char *)getFileData(core, arg2);
                         if (a && b) {
                             RzDiff *dff = rz_diff_lines_new(a, b, NULL);
                             char *uni = rz_diff_unified_text(dff, arg, arg2, false, false);
                             rz_diff_free(dff);
                             rz_cons_printf("%s\n", uni);
                             free(uni);
                         } else {
                             eprintf("Cannot open those alias files\n");
                         }
                         free(a);
                         free(b);
                     }
                     free(arg);
                 } else {
                     eprintf("Usage: dif $a $b  # diff two alias files\n");
                 }
             }
             break;
         case '*': // "di*"
             if (rdi) {
                 rz_cons_printf("f dbg.signal @ %d\n", core->dbg->reason.signum);
                 rz_cons_printf("f dbg.sigpid @ %d\n", core->dbg->reason.tid);
                 rz_cons_printf("f dbg.inbp @ %d\n", core->dbg->reason.bp_addr ? 1 : 0);
                 rz_cons_printf("f dbg.sigaddr @ 0x%" PFMT64x "\n", core->dbg->reason.addr);
                 rz_cons_printf("f dbg.baddr @ 0x%" PFMT64x "\n", rz_debug_get_baddr(core->dbg, NULL));
                 rz_cons_printf("f dbg.pid @ %d\n", rdi->pid);
                 rz_cons_printf("f dbg.tid @ %d\n", rdi->tid);
                 rz_cons_printf("f dbg.uid @ %d\n", rdi->uid);
                 rz_cons_printf("f dbg.gid @ %d\n", rdi->gid);
             }
             break;
         case 'j': // "dij"
             P("{");
             if (rdi) {
                 const char *s = rz_signal_to_string(core->dbg->reason.signum);
                 P("\"type\":\"%s\",", rz_debug_reason_to_string(core->dbg->reason.type));
                 P("\"signal\":\"%s\",", s ? s : "none");
                 P("\"signum\":%d,", core->dbg->reason.signum);
                 P("\"sigpid\":%d,", core->dbg->reason.tid);
                 P("\"addr\":%" PFMT64d ",", core->dbg->reason.addr);
                 P("\"inbp\":%s,", rz_str_bool(core->dbg->reason.bp_addr));
                 P("\"baddr\":%" PFMT64d ",", rz_debug_get_baddr(core->dbg, NULL));
                 P("\"stopaddr\":%" PFMT64d ",", core->dbg->stopaddr);
                 P("\"pid\":%d,", rdi->pid);
                 P("\"tid\":%d,", rdi->tid);
                 P("\"uid\":%d,", rdi->uid);
                 P("\"gid\":%d,", rdi->gid);
                 if (rdi->usr) {
                     PS("\"usr\":\"%s\",", rdi->usr);
                 }
                 if (rdi->exe) {
                     PS("\"exe\":\"%s\",", rdi->exe);
                 }
                 if (rdi->cmdline) {
                     PS("\"cmdline\":\"%s\",", rdi->cmdline);
                 }
                 if (rdi->cwd) {
                     PS("\"cwd\":\"%s\",", rdi->cwd);
                 }
             }
             P("\"stopreason\":%d}\n", stop);
             break;
 #undef P
 #undef PS
         case 'q': {
             const char *r = rz_debug_reason_to_string(core->dbg->reason.type);
             if (!r) {
                 r = "none";
             }
             rz_cons_printf("%s at 0x%08" PFMT64x "\n", r, core->dbg->stopaddr);
         } break;
         case '?': // "di?"
         default:
             rz_core_cmd_help(core, help_msg_di);
             break;
         }
         rz_debug_info_free(rdi);
     } break;
     case 'e': // "de"
         rz_core_debug_esil(core, input + 1);
         break;
     case 'g': // "dg"
         if (core->dbg->cur && core->dbg->cur->gcore) {
             if (core->dbg->pid == -1) {
                 eprintf("Not debugging, can't write core.\n");
                 break;
             }
             char *corefile = get_corefile_name(input + 1, core->dbg->pid);
             eprintf("Writing to file '%s'\n", corefile);
             rz_file_rm(corefile);
             RzBuffer *dst = rz_buf_new_file(corefile, O_RDWR | O_CREAT, 0644);
             if (dst) {
                 if (!core->dbg->cur->gcore(core->dbg, corefile, dst)) {
                     eprintf("dg: coredump failed\n");
                 }
                 rz_buf_free(dst);
             } else {
                 perror("rz_buf_new_file");
             }
             free(corefile);
         }
         break;
     case 'k': // "dk"
         rz_core_debug_kill(core, input + 1);
         break;
 #if __WINDOWS__
     case 'W': // "dW"
         if (input[1] == 'i') {
             rz_w32_identify_window();
         } else {
             rz_w32_print_windows(core->dbg);
         }
         break;
 #endif
     case 'w': // "dw"
         rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
         for (; !rz_cons_is_breaked();) {
             int pid = atoi(input + 1);
             // int opid = core->dbg->pid = pid;
             int res = rz_debug_kill(core->dbg, pid, 0, 0);
             if (!res) {
                 break;
             }
             rz_sys_usleep(200);
         }
         rz_cons_break_pop();
         break;
     case 'x': // "dx"
         switch (input[1]) {
         case ' ': { // "dx "
             ut8 bytes[4096];
             if (strlen(input + 2) < 4096) {
                 int bytes_len = rz_hex_str2bin(input + 2, bytes);
                 if (bytes_len > 0)
                     rz_debug_execute(core->dbg,
                         bytes, bytes_len, 0);
                 else
                     eprintf("Invalid hexpairs\n");
             } else
                 eprintf("Injection opcodes so long\n");
             break;
         }
         case 'a': { // "dxa"
             RzAsmCode *acode;
             rz_asm_set_pc(core->rasm, core->offset);
             acode = rz_asm_massemble(core->rasm, input + 2);
             if (acode) {
                 rz_reg_arena_push(core->dbg->reg);
                 rz_debug_execute(core->dbg, acode->bytes, acode->len, 0);
                 rz_reg_arena_pop(core->dbg->reg);
             }
             rz_asm_code_free(acode);
             break;
         }
         case 'e': { // "dxe"
             RzEgg *egg = core->egg;
             RzBuffer *b;
             const char *asm_arch = rz_config_get(core->config, "asm.arch");
             int asm_bits = rz_config_get_i(core->config, "asm.bits");
             const char *asm_os = rz_config_get(core->config, "asm.os");
             rz_egg_setup(egg, asm_arch, asm_bits, 0, asm_os);
             rz_egg_reset(egg);
             rz_egg_load(egg, input + 1, 0);
             rz_egg_compile(egg);
             b = rz_egg_get_bin(egg);
             rz_asm_set_pc(core->rasm, core->offset);
             rz_reg_arena_push(core->dbg->reg);
             ut64 tmpsz;
             const ut8 *tmp = rz_buf_data(b, &tmpsz);
             rz_debug_execute(core->dbg, tmp, tmpsz, 0);
             rz_reg_arena_pop(core->dbg->reg);
             break;
         }
         case 'r': // "dxr"
             rz_reg_arena_push(core->dbg->reg);
             if (input[2] == ' ') {
                 ut8 bytes[4096];
                 if (strlen(input + 2) < 4096) {
                     int bytes_len = rz_hex_str2bin(input + 2,
                         bytes);
                     if (bytes_len > 0) {
                         rz_debug_execute(core->dbg,
                             bytes, bytes_len,
                             0);
                     } else {
                         eprintf("Invalid hexpairs\n");
                     }
                 } else
                     eprintf("Injection opcodes so long\n");
             }
             rz_reg_arena_pop(core->dbg->reg);
             break;
         case 's': // "dxs"
             if (input[2]) {
                 char *str;
                 str = rz_core_cmd_str(core, sdb_fmt("gs %s", input + 2));
                 rz_core_cmdf(core, "dx %s", str); //`gs %s`", input + 2);
                 free(str);
             } else {
                 eprintf("Missing parameter used in gs by dxs\n");
             }
             break;
         case '?': // "dx?"
         default:
             rz_core_cmd_help(core, help_msg_dx);
             break;
         }
         break;
     case '?': // "d?"
     default:
         rz_core_cmd_help(core, help_msg_d);
         break;
     }
     if (follow > 0) {
         rz_core_dbg_follow_seek_register(core);
     }
     return 0;
 }

References a, rz_debug_reason_t::addr, b, rz_debug_reason_t::bp_addr, bytes, rz_asm_code_t::bytes, cmd_debug_pid(), rz_core_t::config, consumeBuffer(), rz_debug_t::cur, rz_core_t::dbg, dst, rz_core_t::egg, eprintf, fd, free(), rz_debug_plugin_t::gcore, get_corefile_name(), getFileData(), help_msg_d, help_msg_dd, help_msg_di, help_msg_dx, input(), len, rz_asm_code_t::len, NULL, rz_core_t::num, O_CREAT, O_RDWR, off, rz_core_t::offset, P, PFMT64d, PFMT64x, rz_debug_t::pid, pid, PS, r, rz_core_t::rasm, rdi, rz_debug_t::reason, rz_debug_t::reg, rz_asm_code_free(), rz_asm_massemble(), rz_asm_set_pc(), rz_buf_data(), rz_buf_free(), rz_buf_new_file(), rz_config_get(), rz_config_get_i(), rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_cons_printf(), rz_core_cmd_help(), rz_core_cmd_str(), rz_core_cmdf(), rz_core_dbg_follow_seek_register(), rz_core_debug_esil(), rz_core_debug_kill(), rz_core_static_debug_stop(), rz_core_syscall(), rz_core_syscallf(), rz_debug_desc_dup(), rz_debug_desc_list(), rz_debug_desc_read(), rz_debug_desc_seek(), rz_debug_desc_write(), rz_debug_execute(), rz_debug_get_baddr(), rz_debug_info(), rz_debug_info_free(), rz_debug_kill(), rz_debug_reason_to_string(), rz_debug_stop_reason(), rz_diff_free(), rz_diff_lines_new(), rz_diff_unified_text(), rz_egg_compile(), rz_egg_get_bin(), rz_egg_load(), rz_egg_reset(), rz_egg_setup(), rz_file_rm(), rz_hex_str2bin(), rz_num_math(), rz_reg_arena_pop(), rz_reg_arena_push(), rz_signal_to_string(), rz_str_bool(), rz_str_trim_head_ro(), rz_sys_usleep(), rz_time_date_now_to_string(), rz_w32_identify_window(), rz_w32_print_windows(), s, sdb_fmt(), rz_debug_reason_t::signum, rz_debug_t::stopaddr, cmd_descs_generate::str, strdup(), rz_debug_reason_t::tid, autogen_x86imm::tmp, rz_debug_reason_t::type, ut64(), and UT64_MAX.

Referenced by rz_core_cmd_init(), and rzshell_cmddescs_init().

◆ rz_cmd_debug_add_bp_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_add_bp_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2690 of file cmd_debug.c.

                                                                                           {
     bool hwbp = rz_config_get_b(core->config, "dbg.hwbp");
     rz_core_debug_bp_add(core, core->offset, NULL, hwbp, false);
     return RZ_CMD_STATUS_OK;
 }

References rz_core_t::config, NULL, rz_core_t::offset, RZ_CMD_STATUS_OK, rz_config_get_b(), and rz_core_debug_bp_add().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_add_bp_module_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_add_bp_module_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2854 of file cmd_debug.c.

                                                                                                  {
     bool hwbp = rz_config_get_b(core->config, "dbg.hwbp");
     ut64 delta = rz_num_math(core->num, argv[2]);
     RzBreakpointItem *bp = rz_debug_bp_add(core->dbg, 0, hwbp, false, 0, argv[1], delta);
     if (!bp) {
         RZ_LOG_ERROR("Cannot set breakpoint.\n");
     }
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_core_t::config, rz_core_t::dbg, delta, rz_core_t::num, RZ_CMD_STATUS_OK, rz_config_get_b(), rz_debug_bp_add(), RZ_LOG_ERROR, rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_add_bp_noreturn_func_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_add_bp_noreturn_func_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2848 of file cmd_debug.c.

                                                                                                         {
     rz_core_debug_bp_add_noreturn_func(core);
     return RZ_CMD_STATUS_OK;
 }

References RZ_CMD_STATUS_OK, and rz_core_debug_bp_add_noreturn_func().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_add_cond_bp_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_add_cond_bp_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2812 of file cmd_debug.c.

                                                                                                {
     RzBreakpointItem *bp = rz_bp_get_at(core->dbg->bp, core->offset);
     if (!bp) {
         RZ_LOG_ERROR("No breakpoint defined at 0x%08" PFMT64x "\n", core->offset);
         return RZ_CMD_STATUS_ERROR;
     }
     if (!rz_bp_item_set_cond(bp, argv[1])) {
         RZ_LOG_ERROR("Failed to set condition for breakpoint at 0x%08" PFMT64x "\n", core->offset);
         return RZ_CMD_STATUS_ERROR;
     }
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_debug_t::bp, rz_core_t::dbg, rz_core_t::offset, PFMT64x, rz_bp_get_at(), rz_bp_item_set_cond(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_add_hw_bp_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_add_hw_bp_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2764 of file cmd_debug.c.

                                                                                              {
     rz_core_debug_bp_add(core, core->offset, NULL, true, false);
     return RZ_CMD_STATUS_OK;
 }

References NULL, rz_core_t::offset, RZ_CMD_STATUS_OK, and rz_core_debug_bp_add().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_add_watchpoint_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_add_watchpoint_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3208 of file cmd_debug.c.

                                                                                                   {
     bool hwbp = rz_config_get_b(core->config, "dbg.hwbp");
     rz_core_debug_bp_add(core, core->offset, argv[1], hwbp, true);
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_core_t::config, rz_core_t::offset, RZ_CMD_STATUS_OK, rz_config_get_b(), and rz_core_debug_bp_add().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_allocate_maps_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_allocate_maps_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1029 of file cmd_debug.c.

                                                                                                  {
     CMD_CHECK_DEBUG_DEAD(core);
     ut64 addr = core->offset;
     int size = (int)rz_num_math(core->num, argv[1]);
     rz_debug_map_alloc(core->dbg, addr, size, false);
     return RZ_CMD_STATUS_OK;
 }

References addr, argv, CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, int, rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_OK, rz_debug_map_alloc(), rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_bp_plugin_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_bp_plugin_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3014 of file cmd_debug.c.

                                                                                              {
     if (argc == 1) {
         rz_bp_plugin_list(core->dbg->bp);
     } else if (argc == 2) {
         if (!rz_bp_use(core->dbg->bp, argv[1])) {
             RZ_LOG_ERROR("Failed to set breakpoint plugin handler to %s\n", argv[1]);
             return RZ_CMD_STATUS_ERROR;
         }
     }
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_debug_t::bp, rz_core_t::dbg, rz_bp_plugin_list(), rz_bp_use(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_bp_set_expr_cur_offset_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_bp_set_expr_cur_offset_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3186 of file cmd_debug.c.

                                                                                                           {
     if (argc == 1) {
         RzBreakpointItem *bpi;
         RzListIter *iter;
         rz_list_foreach (core->dbg->bp->bps, iter, bpi) {
             rz_cons_printf("0x%08" PFMT64x " %s\n", bpi->addr, rz_str_get(bpi->expr));
         }
     } else if (argc == 2) {
         RzBreakpointItem *bpi = rz_bp_get_at(core->dbg->bp, core->offset);
         if (!bpi) {
             RZ_LOG_ERROR("No breakpoint found at current offset: 0x%" PFMT64x "\n", core->offset);
             return RZ_CMD_STATUS_ERROR;
         }
         if (!rz_bp_item_set_expr(bpi, argv[1])) {
             RZ_LOG_ERROR("Failed to set expression\n");
             return RZ_CMD_STATUS_ERROR;
         }
     }
     return RZ_CMD_STATUS_OK;
 }

References rz_bp_item_t::addr, argv, rz_debug_t::bp, rz_bp_t::bps, rz_core_t::dbg, rz_bp_item_t::expr, rz_core_t::offset, PFMT64x, rz_bp_get_at(), rz_bp_item_set_expr(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_printf(), RZ_LOG_ERROR, and rz_str_get().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_bt_disable_bp_trace_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_bt_disable_bp_trace_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3167 of file cmd_debug.c.

                                                                                                        {
     if (!rz_bp_set_trace(core->dbg->bp, core->offset, false)) {
         RZ_LOG_ERROR("Failed to enable trace for breakpoint at 0x%" PFMT64x "\n", core->offset);
     }
     return RZ_CMD_STATUS_OK;
 }

References rz_debug_t::bp, rz_core_t::dbg, rz_core_t::offset, PFMT64x, rz_bp_set_trace(), RZ_CMD_STATUS_OK, and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_bt_enable_bp_trace_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_bt_enable_bp_trace_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3159 of file cmd_debug.c.

                                                                                                       {
     if (!rz_bp_set_trace(core->dbg->bp, core->offset, true)) {
         RZ_LOG_ERROR("Failed to enable trace for breakpoint at 0x%" PFMT64x "\n", core->offset);
     }
     return RZ_CMD_STATUS_OK;
 }

References rz_debug_t::bp, rz_core_t::dbg, rz_core_t::offset, PFMT64x, rz_bp_set_trace(), RZ_CMD_STATUS_OK, and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_bt_toggle_bp_trace_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_bt_toggle_bp_trace_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3175 of file cmd_debug.c.

                                                                                                       {
     RzBreakpointItem *bpi = rz_bp_get_in(core->dbg->bp, core->offset, 0);
     if (!bpi) {
         RZ_LOG_ERROR("No breakpoint found at 0x%" PFMT64x "\n", core->offset);
     } else {
         bpi->trace = !bpi->trace;
     }
     return RZ_CMD_STATUS_OK;
 }

References rz_debug_t::bp, rz_core_t::dbg, rz_core_t::offset, PFMT64x, rz_bp_get_in(), RZ_CMD_STATUS_OK, RZ_LOG_ERROR, and rz_bp_item_t::trace.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_command_bp_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_command_bp_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2798 of file cmd_debug.c.

                                                                                               {
     RzBreakpointItem *bp = rz_bp_get_at(core->dbg->bp, core->offset);
     if (!bp) {
         RZ_LOG_ERROR("No breakpoint defined at 0x%08" PFMT64x "\n", core->offset);
         return RZ_CMD_STATUS_ERROR;
     }
     if (!rz_bp_item_set_data(bp, argv[1])) {
         RZ_LOG_ERROR("Failed to set data for breakpoint at 0x%08" PFMT64x "\n", core->offset);
         return RZ_CMD_STATUS_ERROR;
     }
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_debug_t::bp, rz_core_t::dbg, rz_core_t::offset, PFMT64x, rz_bp_get_at(), rz_bp_item_set_data(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_continue_back_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_continue_back_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3257 of file cmd_debug.c.

                                                                                                  {
     CMD_CHECK_DEBUG_DEAD(core);
     rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
  
     if (!rz_debug_continue_back(core->dbg)) {
         eprintf("cannot continue back\n");
         return RZ_CMD_STATUS_ERROR;
     }
  
     rz_cons_break_pop();
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, eprintf, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_core_dbg_follow_seek_register(), rz_core_static_debug_stop(), and rz_debug_continue_back().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_continue_call_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_continue_call_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3272 of file cmd_debug.c.

                                                                                                  {
     CMD_CHECK_DEBUG_DEAD(core);
     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_CALL, 0);
  
     rz_cons_break_pop();
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, rz_debug_t::reg, RZ_ANALYSIS_OP_TYPE_CALL, RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_core_dbg_follow_seek_register(), rz_core_static_debug_stop(), rz_debug_continue_until_optype(), and rz_reg_arena_swap().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_continue_exception_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_continue_exception_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3297 of file cmd_debug.c.

                                                                                                       {
     CMD_CHECK_DEBUG_DEAD(core);
     rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
     rz_reg_arena_swap(core->dbg->reg, true);
     rz_debug_continue_pass_exception(core->dbg);
     rz_cons_break_pop();
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, rz_debug_t::reg, RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_core_dbg_follow_seek_register(), rz_core_static_debug_stop(), rz_debug_continue_pass_exception(), and rz_reg_arena_swap().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_continue_execution_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_continue_execution_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3236 of file cmd_debug.c.

                                                                                                       {
     CMD_CHECK_DEBUG_DEAD(core);
     rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
  
     if (argc == 2) {
         int old_pid = core->dbg->pid;
         // using rz_num instead of atoi
         int pid = rz_num_math(core->num, argv[1]);
         rz_debug_select(core->dbg, pid, core->dbg->tid);
         rz_core_debug_continue(core);
         rz_debug_select(core->dbg, old_pid, core->dbg->tid);
     } else {
         rz_core_debug_continue(core);
     }
  
     rz_cons_break_pop();
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References argv, CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, rz_core_t::num, rz_debug_t::pid, pid, RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_core_dbg_follow_seek_register(), rz_core_debug_continue(), rz_core_static_debug_stop(), rz_debug_select(), rz_num_math(), and rz_debug_t::tid.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_continue_fork_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_continue_fork_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3308 of file cmd_debug.c.

                                                                                                  {
     CMD_CHECK_DEBUG_DEAD(core);
     rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
  
     eprintf("[+] Running 'dcs vfork fork clone' behind the scenes...\n");
     // we should stop in fork, vfork, and clone syscalls
     cmd_debug_cont_syscall(core, "vfork fork clone");
  
     rz_cons_break_pop();
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References CMD_CHECK_DEBUG_DEAD, cmd_debug_cont_syscall(), rz_core_t::dbg, eprintf, RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_core_dbg_follow_seek_register(), and rz_core_static_debug_stop().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_continue_mapped_io_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_continue_mapped_io_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3347 of file cmd_debug.c.

                                                                                                       {
     CMD_CHECK_DEBUG_DEAD(core);
     rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
     RzIOMap *s;
     ut64 pc;
     int n = 0;
     bool t = core->dbg->trace->enabled;
     core->dbg->trace->enabled = false;
     rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
     do {
         rz_debug_step(core->dbg, 1);
         rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_GPR, false);
         pc = rz_debug_reg_get(core->dbg, "PC");
         eprintf(" %d %" PFMT64x "\r", n++, pc);
         s = rz_io_map_get(core->io, pc);
         if (rz_cons_is_breaked()) {
             break;
         }
     } while (!s);
     eprintf("\n");
     core->dbg->trace->enabled = t;
     rz_cons_break_pop();
     return RZ_CMD_STATUS_OK;
 }

References CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, rz_debug_trace_t::enabled, eprintf, rz_core_t::io, n, pc, PFMT64x, RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_core_static_debug_stop(), rz_debug_reg_get(), rz_debug_reg_sync(), rz_debug_step(), rz_io_map_get(), RZ_REG_TYPE_GPR, s, rz_debug_t::trace, and ut64().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_continue_ret_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_continue_ret_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3373 of file cmd_debug.c.

                                                                                                 {
     CMD_CHECK_DEBUG_DEAD(core);
     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_cons_break_pop();
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, rz_debug_t::reg, RZ_ANALYSIS_OP_TYPE_RET, RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_core_dbg_follow_seek_register(), rz_core_static_debug_stop(), rz_debug_continue_until_optype(), and rz_reg_arena_swap().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_continue_send_signal_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_continue_send_signal_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3322 of file cmd_debug.c.

                                                                                                         {
     CMD_CHECK_DEBUG_DEAD(core);
     rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
  
     rz_reg_arena_swap(core->dbg->reg, true);
     int signum = rz_num_math(core->num, argv[1]);
  
     if (argc == 3) {
         int old_pid = core->dbg->pid;
         int old_tid = core->dbg->tid;
         int pid = rz_num_math(core->num, argv[2]);
         int tid = pid; // XXX
         rz_debug_select(core->dbg, pid, tid);
         rz_debug_continue_kill(core->dbg, signum);
         rz_debug_select(core->dbg, old_pid, old_tid);
     } else {
         rz_debug_continue_kill(core->dbg, signum);
     }
  
     rz_cons_break_pop();
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References argv, CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, rz_core_t::num, rz_debug_t::pid, pid, rz_debug_t::reg, RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_core_dbg_follow_seek_register(), rz_core_static_debug_stop(), rz_debug_continue_kill(), rz_debug_select(), rz_num_math(), rz_reg_arena_swap(), signum, and rz_debug_t::tid.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_continue_syscall()

RZ_IPI int rz_cmd_debug_continue_syscall	(	void *	data,
		const char *	input
	)

Definition at line 3400 of file cmd_debug.c.

                                                                         {
     RzCore *core = (RzCore *)data;
     CMD_CHECK_DEBUG_DEAD(core);
     rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
     switch (input[0]) {
     case '*':
         cmd_debug_cont_syscall(core, "-1");
         break;
     case ' ':
         cmd_debug_cont_syscall(core, input + 2);
         break;
     case '\0':
         cmd_debug_cont_syscall(core, NULL);
         break;
     default:
     case '?':
         rz_core_cmd_help(core, help_msg_dcs);
         break;
     }
     rz_cons_break_pop();
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References CMD_CHECK_DEBUG_DEAD, cmd_debug_cont_syscall(), rz_core_t::dbg, help_msg_dcs, input(), NULL, RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_core_cmd_help(), rz_core_dbg_follow_seek_register(), and rz_core_static_debug_stop().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_continue_traptrace_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_continue_traptrace_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3386 of file cmd_debug.c.

                                                                                                       {
     CMD_CHECK_DEBUG_DEAD(core);
     rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
     if (argc == 1) {
         cmd_debug_backtrace(core, 0);
     } else {
         cmd_debug_backtrace(core, rz_num_math(core->num, argv[1]));
     }
     rz_cons_break_pop();
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References argv, CMD_CHECK_DEBUG_DEAD, cmd_debug_backtrace(), rz_core_t::dbg, rz_core_t::num, RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_core_dbg_follow_seek_register(), rz_core_static_debug_stop(), and rz_num_math().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_continue_unknown_call_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_continue_unknown_call_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3285 of file cmd_debug.c.

                                                                                                          {
     CMD_CHECK_DEBUG_DEAD(core);
     rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
  
     rz_debug_continue_until_optype(core->dbg, RZ_ANALYSIS_OP_TYPE_UCALL, 0);
  
     rz_cons_break_pop();
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, RZ_ANALYSIS_OP_TYPE_UCALL, RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_core_dbg_follow_seek_register(), rz_core_static_debug_stop(), and rz_debug_continue_until_optype().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_continue_until()

RZ_IPI int rz_cmd_debug_continue_until	(	void *	data,
		const char *	input
	)

Definition at line 3425 of file cmd_debug.c.

                                                                       {
     RzCore *core = (RzCore *)data;
     CMD_CHECK_DEBUG_DEAD(core);
     rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
     if (input[0] == '?') {
         rz_core_cmd_help(core, help_msg_dcu);
     } else if (input[0] == '.' || input[0] == '\0') {
         cmd_dcu(core, "cu $$");
     } else {
         char *tmpinp = rz_str_newf("cu %s", input + 1);
         cmd_dcu(core, tmpinp);
         free(tmpinp);
     }
     rz_cons_break_pop();
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References CMD_CHECK_DEBUG_DEAD, cmd_dcu(), rz_core_t::dbg, free(), help_msg_dcu, input(), RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_core_cmd_help(), rz_core_dbg_follow_seek_register(), rz_core_static_debug_stop(), and rz_str_newf().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_current_modules_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_current_modules_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzOutputMode	mode
	)

Definition at line 1045 of file cmd_debug.c.

                                                                                                                       {
     CMD_CHECK_DEBUG_DEAD(core);
     cmd_debug_current_modules(core, mode);
     return RZ_CMD_STATUS_OK;
 }

References CMD_CHECK_DEBUG_DEAD, cmd_debug_current_modules(), and RZ_CMD_STATUS_OK.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_deallocate_map_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_deallocate_map_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1052 of file cmd_debug.c.

                                                                                                   {
     CMD_CHECK_DEBUG_DEAD(core);
     RzListIter *iter;
     RzDebugMap *map;
     ut64 addr = core->offset;
     rz_list_foreach (core->dbg->maps, iter, map) {
         if (addr >= map->addr && addr < map->addr_end) {
             rz_debug_map_dealloc(core->dbg, map);
             rz_debug_map_sync(core->dbg);
             return RZ_CMD_STATUS_OK;
         }
     }
     eprintf("The address doesn't match with any map.\n");
     return RZ_CMD_STATUS_ERROR;
 }

References addr, CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, eprintf, map(), rz_debug_t::maps, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_debug_map_dealloc(), rz_debug_map_sync(), and ut64().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_disable_bp_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_disable_bp_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2826 of file cmd_debug.c.

                                                                                               {
     if (!rz_bp_enable(core->dbg->bp, core->offset, false, 1)) {
         RZ_LOG_ERROR("Failed to disable breakpoint at 0x%" PFMT64x "\n", core->offset);
     }
     return RZ_CMD_STATUS_OK;
 }

References rz_debug_t::bp, rz_core_t::dbg, rz_core_t::offset, PFMT64x, rz_bp_enable(), RZ_CMD_STATUS_OK, and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_disable_bp_index_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_disable_bp_index_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2949 of file cmd_debug.c.

                                                                                                     {
     RzBreakpointItem *bpi;
     int index = rz_num_math(core->num, argv[1]);
     bpi = rz_bp_get_index(core->dbg->bp, index);
     if (!bpi) {
         RZ_LOG_ERROR("Unable to find breakpoint with index %d\n", index);
         return RZ_CMD_STATUS_ERROR;
     }
     bpi->enabled = false;
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_debug_t::bp, rz_core_t::dbg, rz_bp_item_t::enabled, rz_core_t::num, rz_bp_get_index(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_disable_bp_trace_index_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_disable_bp_trace_index_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2988 of file cmd_debug.c.

                                                                                                           {
     RzBreakpointItem *bpi;
     int index = rz_num_math(core->num, argv[1]);
     bpi = rz_bp_get_index(core->dbg->bp, index);
     if (!bpi) {
         RZ_LOG_ERROR("Unable to find breakpoint with index %d\n", index);
         return RZ_CMD_STATUS_ERROR;
     }
     bpi->trace = false;
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_debug_t::bp, rz_core_t::dbg, rz_core_t::num, rz_bp_get_index(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, RZ_LOG_ERROR, rz_num_math(), and rz_bp_item_t::trace.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_display_bt_ascii_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_display_bt_ascii_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3147 of file cmd_debug.c.

                                                                                                     {
     RzList *list = rz_debug_frames(core->dbg, UT64_MAX);
     if (!list) {
         RZ_LOG_ERROR("Unable to find debug backtrace frames\n");
         return RZ_CMD_STATUS_ERROR;
     }
     asciiart_backtrace(core, list);
     rz_list_free(list);
     return RZ_CMD_STATUS_OK;
 }

References asciiart_backtrace(), rz_core_t::dbg, list(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_debug_frames(), rz_list_free(), RZ_LOG_ERROR, and UT64_MAX.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_display_bt_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_display_bt_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 3037 of file cmd_debug.c.

                                                                                                                        {
     RzList *list = rz_core_debug_backtraces(core);
     if (!list) {
         RZ_LOG_ERROR("Unable to find debug backtrace frames\n");
         return RZ_CMD_STATUS_ERROR;
     }
     RzOutputMode mode = state->mode;
     if (mode == RZ_OUTPUT_MODE_RIZIN) {
         rz_list_reverse(list);
         rz_cons_printf("f-bt.*\n");
     }
  
     int i = 0;
     RzListIter *iter;
     RzBacktrace *bt;
     PJ *pj = state->d.pj;
     rz_cmd_state_output_array_start(state);
     rz_list_foreach (list, iter, bt) {
         switch (mode) {
         case RZ_OUTPUT_MODE_STANDARD: {
             rz_cons_printf("%d  %s sp: %s  %-5d"
                        "[%s]  %s %s\n",
                 i++, bt->pcstr, bt->spstr, bt->frame->size, bt->fcn ? bt->fcn->name : "??", rz_str_get(bt->flagdesc), rz_str_get(bt->flagdesc2));
             break;
         }
         case RZ_OUTPUT_MODE_RIZIN: {
             rz_cons_printf("f bt.frame%d @ 0x%08" PFMT64x "\n", i, bt->frame->addr);
             rz_cons_printf("f bt.frame%d.stack %d @ 0x%08" PFMT64x "\n", i, bt->frame->size, bt->frame->sp);
             i++;
             break;
         }
         case RZ_OUTPUT_MODE_JSON: {
             pj_o(pj);
             pj_ki(pj, "idx", i);
             pj_kn(pj, "pc", bt->frame->addr);
             pj_kn(pj, "sp", bt->frame->sp);
             pj_ki(pj, "frame_size", bt->frame->size);
             pj_ks(pj, "fname", bt->fcn ? bt->fcn->name : "");
             pj_ks(pj, "desc", bt->desc);
             pj_end(pj);
             i++;
             break;
         }
         case RZ_OUTPUT_MODE_QUIET: {
             rz_cons_printf("%s\n", bt->pcstr);
             break;
         }
         default:
             rz_warn_if_reached();
             break;
         }
     }
     rz_cmd_state_output_array_end(state);
     rz_list_free(list);
     return RZ_CMD_STATUS_OK;
 }

References rz_debug_frame_t::addr, rz_backtrace_t::desc, rz_backtrace_t::fcn, rz_backtrace_t::flagdesc, rz_backtrace_t::flagdesc2, rz_backtrace_t::frame, i, list(), rz_analysis_function_t::name, rz_backtrace_t::pcstr, PFMT64x, pj_end(), pj_ki(), pj_kn(), pj_ks(), pj_o(), rz_cmd_state_output_array_end(), rz_cmd_state_output_array_start(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_core_debug_backtraces(), rz_list_free(), rz_list_reverse(), RZ_LOG_ERROR, RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_RIZIN, RZ_OUTPUT_MODE_STANDARD, rz_str_get(), rz_warn_if_reached, rz_debug_frame_t::size, rz_debug_frame_t::sp, and rz_backtrace_t::spstr.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_display_bt_local_vars_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_display_bt_local_vars_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3135 of file cmd_debug.c.

                                                                                                          {
     RzList *list = rz_debug_frames(core->dbg, UT64_MAX);
     if (!list) {
         RZ_LOG_ERROR("Unable to find debug backtrace frames\n");
         return RZ_CMD_STATUS_ERROR;
     }
     backtrace_vars(core, list);
     rz_list_free(list);
     return RZ_CMD_STATUS_OK;
 }

References backtrace_vars(), rz_core_t::dbg, list(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_debug_frames(), rz_list_free(), RZ_LOG_ERROR, and UT64_MAX.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_display_bt_oneline_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_display_bt_oneline_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3095 of file cmd_debug.c.

                                                                                                       {
     int mode = 0;
     if (argc > 1) {
         if (!strcmp(argv[1], "b")) {
             mode = 1;
         } else if (!strcmp(argv[1], "s")) {
             mode = 2;
         }
     }
     RzList *list = rz_debug_frames(core->dbg, UT64_MAX);
     if (!list) {
         RZ_LOG_ERROR("Unable to find debug backtrace frames\n");
         return RZ_CMD_STATUS_ERROR;
     }
     int i = 0;
     RzListIter *iter;
     RzDebugFrame *frame;
     rz_list_reverse(list);
     rz_list_foreach (list, iter, frame) {
         if (i != 0) {
             rz_cons_printf(" ");
         }
         switch (mode) {
         case 0:
             rz_cons_printf("0x08%" PFMT64x, frame->addr);
             break;
         case 1:
             rz_cons_printf("0x08%" PFMT64x, frame->bp);
             break;
         case 2:
             rz_cons_printf("0x08%" PFMT64x, frame->sp);
             break;
         }
     }
     rz_cons_newline();
     rz_list_free(list);
     return RZ_CMD_STATUS_OK;
 }

References rz_debug_frame_t::addr, argv, rz_debug_frame_t::bp, rz_core_t::dbg, i, list(), PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_newline(), rz_cons_printf(), rz_debug_frames(), rz_list_free(), rz_list_reverse(), RZ_LOG_ERROR, rz_debug_frame_t::sp, and UT64_MAX.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_dmi()

RZ_IPI int rz_cmd_debug_dmi	(	void *	data,
		const char *	input
	)

Definition at line 1117 of file cmd_debug.c.

                                                            {
     RzCore *core = (RzCore *)data;
     CMD_CHECK_DEBUG_DEAD(core);
     RzListIter *iter;
     RzDebugMap *map;
     ut64 addr = core->offset;
     switch (input[0]) {
     case '\0': // "dmi" alias of "dmm"
     {
         RzCmdStateOutput state = { 0 };
         rz_cmd_state_output_init(&state, RZ_OUTPUT_MODE_STANDARD);
         cmd_debug_modules(core, &state);
         rz_cmd_state_output_print(&state);
         rz_cmd_state_output_fini(&state);
         rz_cons_flush();
         break;
     }
     case ' ': // "dmi "
     case '*': // "dmi*"
     case 'v': // "dmiv"
     case 'j': // "dmij"
     case 'q': // "dmiq"
     case 'a': // "dmia"
     {
         const char *libname = NULL, *symname = NULL, *a0;
         int mode;
         ut64 baddr = 0LL;
         char *ptr;
         int i = 1;
         bool symbols_only = true;
         if (input[0] == 'a') {
             symbols_only = false;
             input++;
         }
         PJ *pj = NULL;
         switch (input[0]) {
         case 's':
             mode = RZ_MODE_SET;
             break;
         case '*':
             mode = RZ_MODE_RIZINCMD;
             break;
         case 'j':
             mode = RZ_MODE_JSON;
             pj = pj_new();
             if (!pj) {
                 return false;
             }
             break;
         case 'q':
             mode = input[1] == 'q' ? input++, RZ_MODE_SIMPLEST : RZ_MODE_SIMPLE;
             break;
         default:
             mode = RZ_MODE_PRINT;
             break;
         }
         ptr = strdup(input[0] ? rz_str_trim_head_ro(input + 1) : "");
         if (!ptr || !*ptr) {
             rz_core_cmd(core, "dmm", 0);
             free(ptr);
             pj_free(pj);
             break;
         }
         if (symbols_only) {
             i = rz_str_word_set0(ptr);
         }
         switch (i) {
         case 2:
             symname = rz_str_word_get0(ptr, 1);
             // fall through
         case 1:
             a0 = rz_str_word_get0(ptr, 0);
             addr = rz_num_get(core->num, a0);
             if (!addr || addr == UT64_MAX) {
                 libname = rz_str_word_get0(ptr, 0);
             }
             break;
         }
         if (libname && !addr) {
             addr = addroflib(core, rz_file_basename(libname));
             if (addr == UT64_MAX) {
                 eprintf("Unknown library, or not found in dm\n");
             }
         }
         map = get_closest_map(core, addr);
         if (map) {
             RzCoreBinFilter filter;
             filter.offset = UT64_MAX;
             filter.name = (char *)symname;
             baddr = map->addr;
  
             if (libname) {
                 const char *file = map->file ? map->file : map->name;
                 char *newfile = NULL;
                 if (!rz_file_exists(file)) {
                     newfile = rz_file_temp("memlib");
                     if (newfile) {
                         file = newfile;
                         rz_core_dump(core, file, baddr, map->size, false);
                     }
                 }
                 get_bin_info(core, file, baddr, pj, mode, symbols_only, &filter);
                 if (newfile) {
                     if (!rz_file_rm(newfile)) {
                         eprintf("Error when removing %s\n", newfile);
                     }
                     free(newfile);
                 }
             } else {
                 RzBinFile *bf = rz_bin_cur(core->bin);
                 if (bf) {
                     rz_bin_set_baddr(core->bin, map->addr);
                     RzCmdStateOutput state;
                     rz_cmd_state_output_init(&state, rad2mode(mode));
                     rz_core_bin_print(core, bf, RZ_CORE_BIN_ACC_SYMBOLS, &filter, &state, NULL);
                     rz_cmd_state_output_print(&state);
                     rz_cmd_state_output_fini(&state);
                     rz_bin_set_baddr(core->bin, baddr);
                 }
             }
         }
         if (mode == RZ_MODE_JSON) {
             rz_cons_println(pj_string(pj));
             pj_free(pj);
         }
         free(ptr);
     } break;
     case '.': // "dmi."
     {
         map = get_closest_map(core, addr);
         if (map) {
             ut64 closest_addr = UT64_MAX;
             RzList *symbols = rz_bin_get_symbols(core->bin);
             RzBinSymbol *symbol, *closest_symbol = NULL;
  
             rz_list_foreach (symbols, iter, symbol) {
                 if (symbol->vaddr > addr) {
                     if (symbol->vaddr - addr < closest_addr) {
                         closest_addr = symbol->vaddr - addr;
                         closest_symbol = symbol;
                     }
                 } else {
                     if (addr - symbol->vaddr < closest_addr) {
                         closest_addr = addr - symbol->vaddr;
                         closest_symbol = symbol;
                     }
                 }
             }
             RzBinFile *bf = rz_bin_cur(core->bin);
             if (closest_symbol && bf) {
                 RzCoreBinFilter filter;
                 filter.offset = UT64_MAX;
                 filter.name = (char *)closest_symbol->name;
  
                 rz_bin_set_baddr(core->bin, map->addr);
                 RzCmdStateOutput state;
                 rz_cmd_state_output_init(&state, RZ_OUTPUT_MODE_STANDARD);
                 rz_core_bin_print(core, bf, RZ_CORE_BIN_ACC_SYMBOLS, &filter, &state, NULL);
                 rz_cmd_state_output_print(&state);
                 rz_cmd_state_output_fini(&state);
             }
         }
     } break;
     default:
         rz_core_cmd_help(core, help_msg_dmi);
         break;
     }
     return RZ_CMD_STATUS_OK;
 }

References a0, addr, addroflib(), baddr(), rz_core_t::bin, CMD_CHECK_DEBUG_DEAD, cmd_debug_modules(), eprintf, filter(), free(), get_bin_info(), get_closest_map(), help_msg_dmi, i, input(), map(), rz_bin_symbol_t::name, NULL, rz_core_t::num, rz_core_t::offset, pj_free(), pj_new(), pj_string(), rad2mode(), rz_bin_cur(), rz_bin_get_symbols(), rz_bin_set_baddr(), rz_cmd_state_output_fini(), rz_cmd_state_output_init(), rz_cmd_state_output_print(), RZ_CMD_STATUS_OK, rz_cons_flush(), rz_cons_println(), rz_core_bin_print(), rz_core_cmd(), rz_core_cmd_help(), rz_core_dump(), rz_file_basename(), rz_file_exists(), rz_file_rm(), rz_file_temp(), RZ_MODE_JSON, RZ_MODE_PRINT, RZ_MODE_RIZINCMD, RZ_MODE_SET, RZ_MODE_SIMPLE, RZ_MODE_SIMPLEST, rz_num_get(), RZ_OUTPUT_MODE_STANDARD, rz_str_trim_head_ro(), rz_str_word_get0(), rz_str_word_set0(), strdup(), symbols(), ut64(), UT64_MAX, and rz_bin_symbol_t::vaddr.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_dml_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_dml_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1374 of file cmd_debug.c.

                                                                                        {
     CMD_CHECK_DEBUG_DEAD(core);
     RzListIter *iter;
     RzDebugMap *map;
     ut64 addr = core->offset;
     rz_debug_map_sync(core->dbg); // update process memory maps
     rz_list_foreach (core->dbg->maps, iter, map) {
         if (addr >= map->addr && addr < map->addr_end) {
             size_t sz;
             char *buf = rz_file_slurp(argv[1], &sz);
             // TODO: use mmap here. we need a portable implementation
             if (!buf) {
                 eprintf("Cannot allocate 0x%08" PFMT64x " byte(s)\n", map->size);
                 return RZ_CMD_STATUS_ERROR;
             }
             rz_io_write_at(core->io, map->addr, (const ut8 *)buf, sz);
             if (sz != map->size)
                 eprintf("File size differs from region size (%" PFMT64u " vs %" PFMT64d ")\n",
                     (ut64)sz, map->size);
             eprintf("Loaded %" PFMT64u " byte(s) into the map region at 0x%08" PFMT64x "\n",
                 (ut64)sz, map->addr);
             free(buf);
             return RZ_CMD_STATUS_OK;
         }
     }
     eprintf("No debug region found here\n");
     return RZ_CMD_STATUS_ERROR;
 }

References addr, argv, CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, eprintf, free(), rz_core_t::io, map(), rz_debug_t::maps, rz_core_t::offset, PFMT64d, PFMT64u, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_debug_map_sync(), rz_file_slurp(), rz_io_write_at(), and ut64().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_dmL_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_dmL_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1404 of file cmd_debug.c.

                                                                                        {
     CMD_CHECK_DEBUG_DEAD(core);
     int size;
     ut64 addr;
     addr = core->offset;
     size = (int)rz_num_math(core->num, argv[1]);
     rz_debug_map_alloc(core->dbg, addr, size, true);
     return RZ_CMD_STATUS_OK;
 }

References addr, argv, CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, int, rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_OK, rz_debug_map_alloc(), rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_dmS_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_dmS_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzOutputMode	m
	)

Definition at line 1318 of file cmd_debug.c.

                                                                                                        {
     CMD_CHECK_DEBUG_DEAD(core);
     RzListIter *iter;
     RzDebugMap *map;
     ut64 addr;
     const char *libname = NULL, *sectname = NULL, *mode = "";
     ut64 baddr = 0LL;
     if (m == RZ_OUTPUT_MODE_RIZIN) {
         mode = "-r ";
     }
     addr = UT64_MAX;
     if (argc == 3) {
         sectname = argv[2];
     }
     if (argc >= 2) {
         if (IS_DIGIT(*argv[1])) {
             const char *a0 = argv[1];
             addr = rz_num_math(core->num, a0);
         } else {
             addr = UT64_MAX;
         }
         if (!addr || addr == UT64_MAX) {
             libname = argv[1];
         }
     }
     rz_debug_map_sync(core->dbg); // update process memory maps
     RzList *list = rz_debug_modules_list(core->dbg);
     rz_list_foreach (list, iter, map) {
         if ((!libname ||
                 (addr != UT64_MAX && (addr >= map->addr && addr < map->addr_end)) ||
                 (libname != NULL && (strstr(map->name, libname))))) {
             baddr = map->addr;
             char *res;
             const char *file = map->file ? map->file : map->name;
             char *name = rz_str_escape((char *)rz_file_basename(file));
             char *filesc = rz_str_escape(file);
             /* TODO: do not spawn. use RzBin API */
             if (sectname) {
                 char *sect = rz_str_escape(sectname);
                 res = rz_sys_cmd_strf("env RZ_BIN_PREFIX=\"%s\" rz-bin %s-B 0x%08" PFMT64x " -S \"%s\" | grep \"%s\"", name, mode, baddr, filesc, sect);
                 free(sect);
             } else {
                 res = rz_sys_cmd_strf("env RZ_BIN_PREFIX=\"%s\" rz-bin %s-B 0x%08" PFMT64x " -S \"%s\"", name, mode, baddr, filesc);
             }
             free(filesc);
             rz_cons_println(res);
             free(name);
             free(res);
             if (libname || addr != UT64_MAX) { // only single match requested
                 break;
             }
         }
     }
     return RZ_CMD_STATUS_OK;
 }

References a0, addr, argv, baddr(), CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, free(), IS_DIGIT, list(), regress::m, map(), NULL, rz_core_t::num, PFMT64x, RZ_CMD_STATUS_OK, rz_cons_println(), rz_debug_map_sync(), rz_debug_modules_list(), rz_file_basename(), rz_num_math(), RZ_OUTPUT_MODE_RIZIN, rz_str_escape(), rz_sys_cmd_strf(), ut64(), and UT64_MAX.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_dump_maps_all_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_dump_maps_all_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1103 of file cmd_debug.c.

                                                                                                  {
     CMD_CHECK_DEBUG_DEAD(core);
     dump_maps(core, 0, NULL);
     return RZ_CMD_STATUS_OK;
 }

References CMD_CHECK_DEBUG_DEAD, dump_maps(), NULL, and RZ_CMD_STATUS_OK.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_dump_maps_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_dump_maps_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1092 of file cmd_debug.c.

                                                                                              {
     CMD_CHECK_DEBUG_DEAD(core);
     if (argc == 2) {
         dump_maps(core, -1, argv[1]);
     } else if (argc == 1) {
         dump_maps(core, -1, NULL);
     }
     return RZ_CMD_STATUS_OK;
 }

References argv, CMD_CHECK_DEBUG_DEAD, dump_maps(), NULL, and RZ_CMD_STATUS_OK.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_dump_maps_writable_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_dump_maps_writable_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1110 of file cmd_debug.c.

                                                                                                       {
     CMD_CHECK_DEBUG_DEAD(core);
     dump_maps(core, RZ_PERM_RW, NULL);
     return RZ_CMD_STATUS_OK;
 }

References CMD_CHECK_DEBUG_DEAD, dump_maps(), NULL, RZ_CMD_STATUS_OK, and RZ_PERM_RW.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_enable_bp_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_enable_bp_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2834 of file cmd_debug.c.

                                                                                              {
     if (!rz_bp_enable(core->dbg->bp, core->offset, true, 1)) { // correct value of count?
         RZ_LOG_ERROR("Failed to enable breakpoint at 0x%" PFMT64x "\n", core->offset);
     }
     return RZ_CMD_STATUS_OK;
 }

References rz_debug_t::bp, rz_core_t::dbg, rz_core_t::offset, PFMT64x, rz_bp_enable(), RZ_CMD_STATUS_OK, and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_enable_bp_index_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_enable_bp_index_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2936 of file cmd_debug.c.

                                                                                                    {
     RzBreakpointItem *bpi;
     int index = rz_num_math(core->num, argv[1]);
     bpi = rz_bp_get_index(core->dbg->bp, index);
     if (!bpi) {
         RZ_LOG_ERROR("Unable to find breakpoint with index %d\n", index);
         return RZ_CMD_STATUS_ERROR;
     }
     bpi->enabled = true;
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_debug_t::bp, rz_core_t::dbg, rz_bp_item_t::enabled, rz_core_t::num, rz_bp_get_index(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_enable_bp_trace_index_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_enable_bp_trace_index_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2975 of file cmd_debug.c.

                                                                                                          {
     RzBreakpointItem *bpi;
     int index = rz_num_math(core->num, argv[1]);
     bpi = rz_bp_get_index(core->dbg->bp, index);
     if (!bpi) {
         RZ_LOG_ERROR("Unable to find breakpoint with index %d\n", index);
         return RZ_CMD_STATUS_ERROR;
     }
     bpi->trace = true;
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_debug_t::bp, rz_core_t::dbg, rz_core_t::num, rz_bp_get_index(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, RZ_LOG_ERROR, rz_num_math(), and rz_bp_item_t::trace.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_handler_list_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_handler_list_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 3443 of file cmd_debug.c.

                                                                                                                          {
     return rz_core_debug_plugins_print(core, state);
 }

References rz_core_debug_plugins_print().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_handler_set_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_handler_set_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3447 of file cmd_debug.c.

                                                                                                {
     return bool2status(rz_config_set(core->config, "dbg.backend", argv[1]));
 }

References argv, bool2status(), rz_core_t::config, and rz_config_set().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_heap_jemalloc()

RZ_IPI int rz_cmd_debug_heap_jemalloc	(	void *	data,
		const char *	input
	)

Definition at line 1415 of file cmd_debug.c.

                                                                      {
     RzCore *core = (RzCore *)data;
     CMD_CHECK_DEBUG_DEAD(core);
 #if HAVE_JEMALLOC
     if (core->rasm->bits == 64) {
         return cmd_dbg_map_jemalloc_64(core, input);
     } else {
         return cmd_dbg_map_jemalloc_32(core, input);
     }
 #endif
     return RZ_CMD_STATUS_ERROR;
 }

References rz_asm_t::bits, CMD_CHECK_DEBUG_DEAD, input(), rz_core_t::rasm, and RZ_CMD_STATUS_ERROR.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_list_bp_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_list_bp_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 2697 of file cmd_debug.c.

                                                                                                                     {
     rz_return_val_if_fail(state && core->dbg && core->dbg->bp, RZ_CMD_STATUS_ERROR);
     RzBreakpointItem *b;
     RzListIter *iter;
     PJ *pj = state->d.pj;
     RzTable *t = state->d.t;
     rz_cmd_state_output_array_start(state);
     rz_cmd_state_output_set_columnsf(state, "XXdsssssssss", "start", "end", "size",
         "perm", "hwsw", "type", "state", "valid", "cmd", "cond", "name", "module");
  
     rz_list_foreach (core->dbg->bp->bps, iter, b) {
         switch (state->mode) {
         case RZ_OUTPUT_MODE_STANDARD:
             rz_cons_printf("0x%08" PFMT64x " - 0x%08" PFMT64x
                        " %d %s %s %s %s %s cmd=\"%s\" cond=\"%s\" "
                        "name=\"%s\" module=\"%s\"\n",
                 b->addr, b->addr + b->size, b->size,
                 rz_str_rwx_i(b->perm),
                 b->hw ? "hw" : "sw",
                 b->trace ? "trace" : "break",
                 b->enabled ? "enabled" : "disabled",
                 rz_bp_is_valid(core->dbg->bp, b) ? "valid" : "invalid",
                 rz_str_get(b->data),
                 rz_str_get(b->cond),
                 rz_str_get(b->name),
                 rz_str_get(b->module_name));
             break;
         case RZ_OUTPUT_MODE_TABLE:
             rz_table_add_rowf(t, "XXdsssssssss", b->addr, b->addr + b->size, b->size,
                 rz_str_rwx_i(b->perm), b->hw ? "hw" : "sw", b->trace ? "trace" : "break",
                 b->enabled ? "enabled" : "disabled", rz_bp_is_valid(core->dbg->bp, b) ? "valid" : "invalid",
                 rz_str_get(b->data), rz_str_get(b->cond), rz_str_get(b->name), rz_str_get(b->module_name));
             break;
         case RZ_OUTPUT_MODE_RIZIN:
             if (b->module_name) {
                 rz_cons_printf("dbm %s %" PFMT64d "\n", b->module_name, b->module_delta);
             } else {
                 rz_cons_printf("db @ 0x%08" PFMT64x "\n", b->addr);
             }
             break;
         case RZ_OUTPUT_MODE_JSON:
             pj_o(pj);
             pj_kN(pj, "addr", b->addr);
             pj_ki(pj, "size", b->size);
             pj_ks(pj, "perm", rz_str_rwx_i(b->perm));
             pj_kb(pj, "hw", b->hw);
             pj_kb(pj, "trace", b->trace);
             pj_kb(pj, "enabled", b->enabled);
             pj_kb(pj, "valid", rz_bp_is_valid(core->dbg->bp, b));
             pj_ks(pj, "data", rz_str_get(b->data));
             pj_ks(pj, "cond", rz_str_get(b->cond));
             pj_end(pj);
             break;
         case RZ_OUTPUT_MODE_QUIET:
             rz_cons_printf("0x%08" PFMT64x "\n", b->addr);
             break;
         default:
             rz_warn_if_reached();
             break;
         }
     }
     rz_cmd_state_output_array_end(state);
  
     return RZ_CMD_STATUS_OK;
 }

References b, rz_debug_t::bp, rz_bp_t::bps, rz_core_t::dbg, PFMT64d, PFMT64x, pj_end(), pj_kb(), pj_ki(), pj_kN(), pj_ks(), pj_o(), rz_bp_is_valid(), rz_cmd_state_output_array_end(), rz_cmd_state_output_array_start(), rz_cmd_state_output_set_columnsf(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_printf(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_RIZIN, RZ_OUTPUT_MODE_STANDARD, RZ_OUTPUT_MODE_TABLE, rz_return_val_if_fail, rz_str_get(), rz_str_rwx_i(), rz_table_add_rowf(), and rz_warn_if_reached.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_list_bp_indexes_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_list_bp_indexes_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2892 of file cmd_debug.c.

                                                                                                    {
     RzBreakpointItem *bpi;
     RzListIter *iter;
     unsigned int index = 0;
     rz_list_foreach (core->dbg->bp->bps, iter, bpi) {
         if (!bpi) {
             RZ_LOG_ERROR("Unable to find breakpoint at index %d\n", index);
         } else {
             rz_cons_printf("%d 0x%08" PFMT64x " E:%d T:%d\n", index, bpi->addr, bpi->enabled, bpi->trace);
         }
         index++;
     }
     return RZ_CMD_STATUS_OK;
 }

References rz_bp_item_t::addr, rz_debug_t::bp, rz_bp_t::bps, rz_core_t::dbg, rz_bp_item_t::enabled, PFMT64x, RZ_CMD_STATUS_OK, rz_cons_printf(), RZ_LOG_ERROR, and rz_bp_item_t::trace.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_list_maps_ascii_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_list_maps_ascii_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1069 of file cmd_debug.c.

                                                                                                    {
     CMD_CHECK_DEBUG_DEAD(core);
     rz_debug_map_sync(core->dbg);
     rz_debug_map_list_visual(core->dbg, core->offset, argv[0] + 2,
         rz_config_get_i(core->config, "scr.color"));
     return RZ_CMD_STATUS_OK;
 }

References argv, CMD_CHECK_DEBUG_DEAD, rz_core_t::config, rz_core_t::dbg, rz_core_t::offset, RZ_CMD_STATUS_OK, rz_config_get_i(), rz_debug_map_list_visual(), and rz_debug_map_sync().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_list_maps_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_list_maps_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 1021 of file cmd_debug.c.

                                                                                                                       {
     CMD_CHECK_DEBUG_DEAD(core);
     rz_debug_map_sync(core->dbg); // update process memory maps
     rz_core_debug_map_print(core, core->offset, state);
     return RZ_CMD_STATUS_OK;
 }

References CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, rz_core_t::offset, RZ_CMD_STATUS_OK, rz_core_debug_map_print(), and rz_debug_map_sync().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_list_trace_session_mmap_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_list_trace_session_mmap_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2242 of file cmd_debug.c.

                                                                                                            {
     if (core->dbg->session) {
         rz_debug_session_list_memory(core->dbg);
     }
     return RZ_CMD_STATUS_OK;
 }

References rz_core_t::dbg, RZ_CMD_STATUS_OK, rz_debug_session_list_memory(), and rz_debug_t::session.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_load_trace_session_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_load_trace_session_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2231 of file cmd_debug.c.

                                                                                                       {
     if (core->dbg->session) {
         rz_debug_session_free(core->dbg->session);
         core->dbg->session = NULL;
     }
     core->dbg->session = rz_debug_session_new();
     rz_debug_session_load(core->dbg, argv[1]);
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_core_t::dbg, NULL, RZ_CMD_STATUS_OK, rz_debug_session_free(), rz_debug_session_load(), rz_debug_session_new(), and rz_debug_t::session.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_map_current_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_map_current_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1078 of file cmd_debug.c.

                                                                                                {
     CMD_CHECK_DEBUG_DEAD(core);
     ut64 addr = core->offset;
     // RZ_OUTPUT_MODE_LONG is workaround for '.'
     RzCmdStateOutput state = { 0 };
     rz_cmd_state_output_init(&state, RZ_OUTPUT_MODE_LONG);
     rz_core_debug_map_print(core, addr, &state);
     rz_cmd_state_output_print(&state);
     rz_cmd_state_output_fini(&state);
     rz_cons_flush();
     return RZ_CMD_STATUS_OK;
 }

References addr, CMD_CHECK_DEBUG_DEAD, rz_core_t::offset, rz_cmd_state_output_fini(), rz_cmd_state_output_init(), rz_cmd_state_output_print(), RZ_CMD_STATUS_OK, rz_cons_flush(), rz_core_debug_map_print(), RZ_OUTPUT_MODE_LONG, and ut64().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_modules_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_modules_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 1038 of file cmd_debug.c.

                                                                                                                     {
     CMD_CHECK_DEBUG_DEAD(core);
     cmd_debug_modules(core, state);
     return RZ_CMD_STATUS_OK;
 }

References CMD_CHECK_DEBUG_DEAD, cmd_debug_modules(), and RZ_CMD_STATUS_OK.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_name_bp_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_name_bp_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2865 of file cmd_debug.c.

                                                                                            {
     RzBreakpointItem *bp = rz_bp_get_at(core->dbg->bp, core->offset);
     if (!bp) {
         RZ_LOG_ERROR("No breakpoint found at 0x%08" PFMT64x "\n", core->offset);
         return RZ_CMD_STATUS_ERROR;
     } else if (argc == 1) {
         if (bp->name) {
             rz_cons_println(bp->name);
         }
     } else if (argc == 2) {
         rz_bp_item_set_name(bp, argv[1]);
     }
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_debug_t::bp, rz_core_t::dbg, rz_bp_item_t::name, rz_core_t::offset, PFMT64x, rz_bp_get_at(), rz_bp_item_set_name(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_println(), and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_process_close_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_process_close_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3497 of file cmd_debug.c.

                                                                                                  {
     CMD_CHECK_DEBUG_DEAD(core);
     return bool2status(rz_core_debug_process_close(core));
 }

References bool2status(), CMD_CHECK_DEBUG_DEAD, and rz_core_debug_process_close().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_process_profile_edit_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_process_profile_edit_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3485 of file cmd_debug.c.

                                                                                                         {
     char *out = rz_core_editor(core, NULL, core->io->envprofile);
     if (!out) {
         return RZ_CMD_STATUS_ERROR;
     }
     free(core->io->envprofile);
     core->io->envprofile = out;
     rz_cons_printf("%s\n", core->io->envprofile);
     return RZ_CMD_STATUS_OK;
 }

References rz_io_t::envprofile, free(), rz_core_t::io, NULL, out, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_printf(), and rz_core_editor().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_process_profile_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_process_profile_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3452 of file cmd_debug.c.

                                                                                                    {
     RzList *list = rz_list_new();
     int i;
     for (i = 1; i < argc; i++) {
         RzList *l = rz_str_split_duplist_n(argv[i], "=", 1, false);
         if (!l) {
             rz_list_free(list);
             return RZ_CMD_STATUS_ERROR;
         }
         size_t llen = rz_list_length(l);
         if (llen < 2) {
             rz_list_free(list);
             rz_list_free(l);
             return RZ_CMD_STATUS_ERROR;
         }
         char *key = rz_list_get_n(l, 0);
         char *val = rz_list_get_n(l, 1);
         if (RZ_STR_ISEMPTY(key) || RZ_STR_ISEMPTY(val)) {
             RZ_LOG_ERROR("Make sure to use the format <key>=<value> without spaces.\n");
             rz_list_free(l);
             continue;
         }
         rz_list_append(list, (void *)argv[i]);
         rz_list_free(l);
     }
     char *str = rz_list_to_str(list, '\n');
     set_profile_string(core, str);
     free(str);
     rz_list_free(list);
     return RZ_CMD_STATUS_OK;
 }

References argv, free(), i, key, list(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_list_append(), rz_list_free(), rz_list_get_n(), rz_list_length(), rz_list_new(), rz_list_to_str(), RZ_LOG_ERROR, RZ_STR_ISEMPTY, rz_str_split_duplist_n(), set_profile_string(), cmd_descs_generate::str, and val.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_remove_all_bp_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_remove_all_bp_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2778 of file cmd_debug.c.

                                                                                                  {
     if (!rz_bp_del_all(core->dbg->bp)) {
         RZ_LOG_ERROR("Failed to delete all breakpoints\n");
         return RZ_CMD_STATUS_ERROR;
     }
     return RZ_CMD_STATUS_OK;
 }

References rz_debug_t::bp, rz_core_t::dbg, rz_bp_del_all(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_remove_bp_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_remove_bp_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2770 of file cmd_debug.c.

                                                                                              {
     if (!rz_bp_del(core->dbg->bp, core->offset)) {
         RZ_LOG_ERROR("Failed to delete breakpoint at 0x%" PFMT64x "\n", core->offset);
     }
     return RZ_CMD_STATUS_OK;
 }

References rz_debug_t::bp, rz_core_t::dbg, rz_core_t::offset, PFMT64x, rz_bp_del(), RZ_CMD_STATUS_OK, and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_remove_bp_index_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_remove_bp_index_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2908 of file cmd_debug.c.

                                                                                                    {
     ut64 addr;
     for (int i = 1; i < argc; i++) {
         addr = rz_num_math(core->num, argv[i]);
         if (!rz_bp_del_index(core->dbg->bp, addr)) {
             RZ_LOG_ERROR("No breakpoint found at %" PFMT64x "\n", addr);
         }
     }
     return RZ_CMD_STATUS_OK;
 }

References addr, argv, rz_debug_t::bp, rz_core_t::dbg, i, rz_core_t::num, PFMT64x, rz_bp_del_index(), RZ_CMD_STATUS_OK, RZ_LOG_ERROR, rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_remove_bp_plugin_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_remove_bp_plugin_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3027 of file cmd_debug.c.

                                                                                                     {
     for (int i = 1; i < argc; i++) {
         if (!rz_bp_plugin_del(core->dbg->bp, argv[i])) {
             RZ_LOG_ERROR("Failed to delete breakpoint plugin handler: %s\n", argv[i]);
         }
     }
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_debug_t::bp, rz_core_t::dbg, i, rz_bp_plugin_del(), RZ_CMD_STATUS_OK, and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_run_command_bp_index_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_run_command_bp_index_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2928 of file cmd_debug.c.

                                                                                                         {
     int index = rz_num_math(core->num, argv[1]);
     RzBreakpointItem *bpi = rz_bp_get_index(core->dbg->bp, index);
     rz_bp_item_set_data(bpi, argv[2]);
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_debug_t::bp, rz_core_t::dbg, rz_core_t::num, rz_bp_get_index(), rz_bp_item_set_data(), RZ_CMD_STATUS_OK, and rz_num_math().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_save_trace_session_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_save_trace_session_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2221 of file cmd_debug.c.

                                                                                                       {
     if (!core->dbg->session) {
         RZ_LOG_ERROR("No session started\n");
         return RZ_CMD_STATUS_ERROR;
     }
     rz_debug_session_save(core->dbg->session, argv[1]);
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_core_t::dbg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_debug_session_save(), RZ_LOG_ERROR, and rz_debug_t::session.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_set_cond_bp_win_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_set_cond_bp_win_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3215 of file cmd_debug.c.

                                                                                                    {
 #if __WINDOWS__
     bool res;
     if (argc > 2) {
         res = rz_w32_add_winmsg_breakpoint(core->dbg, argv[1], argv[2]);
     } else {
         res = rz_w32_add_winmsg_breakpoint(core->dbg, argv[1], NULL);
     }
     if (res) {
         rz_cons_print("Breakpoint set.\n");
     } else {
         rz_cons_print("Breakpoint not set.\n");
     }
 #else
     RZ_LOG_ERROR("This command is only meant for Windows systems and cannot be used by your system\n");
 #endif
  
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_core_t::dbg, NULL, RZ_CMD_STATUS_OK, RZ_LOG_ERROR, and rz_w32_add_winmsg_breakpoint().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_set_expr_bp_index_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_set_expr_bp_index_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2920 of file cmd_debug.c.

                                                                                                      {
     int index = rz_num_math(core->num, argv[1]);
     RzBreakpointItem *bpi = rz_bp_get_index(core->dbg->bp, index);
     rz_bp_item_set_expr(bpi, argv[2]);
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_debug_t::bp, rz_core_t::dbg, rz_core_t::num, rz_bp_get_index(), rz_bp_item_set_expr(), RZ_CMD_STATUS_OK, and rz_num_math().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_show_bp_index_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_show_bp_index_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2881 of file cmd_debug.c.

                                                                                                  {
     const int index = rz_bp_get_index_at(core->dbg->bp, core->offset);
     if (index == -1) {
         RZ_LOG_ERROR("No breakpoint found at %" PFMT64x "\n", core->offset);
     } else {
         rz_cons_printf("%d\n", index);
     }
     return RZ_CMD_STATUS_OK;
 }

References rz_debug_t::bp, rz_core_t::dbg, rz_core_t::offset, PFMT64x, rz_bp_get_index_at(), RZ_CMD_STATUS_OK, rz_cons_printf(), and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_show_cur_bp_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_show_cur_bp_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2787 of file cmd_debug.c.

                                                                                                {
     RzBreakpointItem *cur = rz_bp_get_at(core->dbg->bp, core->offset);
     if (!cur) {
         rz_cons_printf("No breakpoint found at current offset (0x%" PFMT64x ")\n", core->offset);
         return RZ_CMD_STATUS_ERROR;
     }
     rz_cons_printf("breakpoint %s %s %s\n", rz_str_rwx_i(cur->perm), cur->enabled ? "enabled" : "disabled", cur->name ? cur->name : "");
     return RZ_CMD_STATUS_OK;
 }

References rz_debug_t::bp, rz_core_t::dbg, rz_bp_item_t::enabled, rz_bp_item_t::name, rz_core_t::offset, rz_bp_item_t::perm, PFMT64x, rz_bp_get_at(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_printf(), and rz_str_rwx_i().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_start_trace_session_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_start_trace_session_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2195 of file cmd_debug.c.

                                                                                                        {
     if (rz_debug_is_dead(core->dbg)) {
         RZ_LOG_ERROR("Cannot start session outside of debug mode, run ood?\n");
         return RZ_CMD_STATUS_ERROR;
     }
     if (core->dbg->session) {
         RZ_LOG_ERROR("Session already started\n");
         return RZ_CMD_STATUS_ERROR;
     }
     core->dbg->session = rz_debug_session_new();
     rz_debug_add_checkpoint(core->dbg);
     return RZ_CMD_STATUS_OK;
 }

References rz_core_t::dbg, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_debug_add_checkpoint(), rz_debug_is_dead(), rz_debug_session_new(), RZ_LOG_ERROR, and rz_debug_t::session.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_step_back_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_step_back_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3511 of file cmd_debug.c.

                                                                                              {
     CMD_CHECK_DEBUG_DEAD(core);
     const int times = (int)rz_num_math(core->num, argv[1]);
     bool ret = rz_core_debug_step_back(core, times);
     rz_core_dbg_follow_seek_register(core);
     return bool2status(ret);
 }

References argv, bool2status(), CMD_CHECK_DEBUG_DEAD, int, rz_core_t::num, rz_core_dbg_follow_seek_register(), rz_core_debug_step_back(), rz_num_math(), and times.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_step_cond_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_step_cond_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3528 of file cmd_debug.c.

                                                                                              {
     CMD_CHECK_DEBUG_DEAD(core);
     int n = 0;
     rz_cons_break_push(rz_core_static_debug_stop, core->dbg);
     do {
         if (rz_cons_is_breaked()) {
             break;
         }
         rz_debug_step(core->dbg, 1);
         if (rz_debug_is_dead(core->dbg)) {
             core->break_loop = true;
             break;
         }
         rz_core_reg_update_flags(core);
         n++;
     } while (!rz_num_conditional(core->num, argv[1]));
     rz_cons_break_pop();
     RZ_LOG_INFO("stopped after %d instructions\n", n);
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_core_t::break_loop, CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, n, rz_core_t::num, RZ_CMD_STATUS_OK, rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_core_dbg_follow_seek_register(), rz_core_reg_update_flags(), rz_core_static_debug_stop(), rz_debug_is_dead(), rz_debug_step(), RZ_LOG_INFO, and rz_num_conditional().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_step_frame_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_step_frame_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3520 of file cmd_debug.c.

                                                                                               {
     CMD_CHECK_DEBUG_DEAD(core);
     bool ret = rz_core_debug_step_until_frame(core);
     rz_core_dbg_follow_seek_register(core);
     return bool2status(ret);
 }

References bool2status(), CMD_CHECK_DEBUG_DEAD, rz_core_dbg_follow_seek_register(), and rz_core_debug_step_until_frame().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_step_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_step_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3503 of file cmd_debug.c.

                                                                                         {
     const int times = (int)rz_num_math(core->num, argv[1]);
     bool ret = rz_core_debug_step_one(core, times);
     rz_core_dbg_follow_seek_register(core);
     return bool2status(ret);
 }

References argv, bool2status(), int, rz_core_t::num, rz_core_dbg_follow_seek_register(), rz_core_debug_step_one(), rz_num_math(), and times.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_step_line_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_step_line_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3551 of file cmd_debug.c.

                                                                                              {
     CMD_CHECK_DEBUG_DEAD(core);
     const int times = (int)rz_num_math(core->num, argv[1]);
     rz_reg_arena_swap(core->dbg->reg, true);
     bool ret = step_line(core, times);
     rz_core_dbg_follow_seek_register(core);
     return bool2status(ret);
 }

References argv, bool2status(), CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, int, rz_core_t::num, rz_debug_t::reg, rz_core_dbg_follow_seek_register(), rz_num_math(), rz_reg_arena_swap(), step_line(), and times.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_step_over_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_step_over_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3561 of file cmd_debug.c.

                                                                                              {
     CMD_CHECK_DEBUG_DEAD(core);
     const int times = (int)rz_num_math(core->num, argv[1]);
     bool ret = rz_core_debug_step_over(core, times);
     rz_core_dbg_follow_seek_register(core);
     return bool2status(ret);
 }

References argv, bool2status(), CMD_CHECK_DEBUG_DEAD, int, rz_core_t::num, rz_core_dbg_follow_seek_register(), rz_core_debug_step_over(), rz_num_math(), and times.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_step_prog_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_step_prog_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3570 of file cmd_debug.c.

                                                                                              {
     CMD_CHECK_DEBUG_DEAD(core);
     const int times = (int)rz_num_math(core->num, argv[1]);
     rz_reg_arena_swap(core->dbg->reg, true);
     ut8 buf[64];
     for (int i = 0; i < times; i++) {
         rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_GPR, false);
         ut64 addr = rz_debug_reg_get(core->dbg, "PC");
         rz_io_read_at(core->io, addr, buf, sizeof(buf));
         RzAnalysisOp aop;
         rz_analysis_op(core->analysis, &aop, addr, buf, sizeof(buf), RZ_ANALYSIS_OP_MASK_BASIC);
         if (aop.type == RZ_ANALYSIS_OP_TYPE_CALL) {
             RzBinObject *o = rz_bin_cur_object(core->bin);
             RzBinSection *s = rz_bin_get_section_at(o, aop.jump, true);
             if (!s) {
                 rz_debug_step_over(core->dbg, times);
                 continue;
             }
         }
         rz_debug_step(core->dbg, 1);
     }
     rz_core_reg_update_flags(core);
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References addr, rz_core_t::analysis, argv, rz_core_t::bin, CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, i, int, rz_core_t::io, rz_analysis_op_t::jump, rz_core_t::num, rz_debug_t::reg, rz_analysis_op(), RZ_ANALYSIS_OP_MASK_BASIC, RZ_ANALYSIS_OP_TYPE_CALL, rz_bin_cur_object(), rz_bin_get_section_at(), RZ_CMD_STATUS_OK, rz_core_dbg_follow_seek_register(), rz_core_reg_update_flags(), rz_debug_reg_get(), rz_debug_reg_sync(), rz_debug_step(), rz_debug_step_over(), rz_io_read_at(), rz_num_math(), rz_reg_arena_swap(), RZ_REG_TYPE_GPR, s, times, rz_analysis_op_t::type, and ut64().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_step_skip_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_step_skip_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3597 of file cmd_debug.c.

                                                                                              {
     CMD_CHECK_DEBUG_DEAD(core);
     const int times = (int)rz_num_math(core->num, argv[1]);
     bool ret = rz_core_debug_step_skip(core, times);
     rz_core_dbg_follow_seek_register(core);
     return bool2status(ret);
 }

References argv, bool2status(), CMD_CHECK_DEBUG_DEAD, int, rz_core_t::num, rz_core_dbg_follow_seek_register(), rz_core_debug_step_skip(), rz_num_math(), and times.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_step_until_esil_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_step_until_esil_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2046 of file cmd_debug.c.

                                                                                                    {
     step_until_esil(core, argv[1]);
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References argv, RZ_CMD_STATUS_OK, rz_core_dbg_follow_seek_register(), and step_until_esil().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_step_until_flag_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_step_until_flag_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2053 of file cmd_debug.c.

                                                                                                    {
     step_until_flag(core, argv[1]);
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References argv, RZ_CMD_STATUS_OK, rz_core_dbg_follow_seek_register(), and step_until_flag().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_step_until_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_step_until_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2011 of file cmd_debug.c.

                                                                                               {
     rz_reg_arena_swap(core->dbg->reg, true);
     step_until(core, rz_num_math(core->num, argv[1]));
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_core_t::dbg, rz_core_t::num, rz_debug_t::reg, RZ_CMD_STATUS_OK, rz_core_dbg_follow_seek_register(), rz_num_math(), rz_reg_arena_swap(), and step_until().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_step_until_instr_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_step_until_instr_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2019 of file cmd_debug.c.

                                                                                                     {
     if (!step_until_inst(core, argv[1], false)) {
         return RZ_CMD_STATUS_ERROR;
     }
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References argv, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_dbg_follow_seek_register(), and step_until_inst().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_step_until_instr_regex_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_step_until_instr_regex_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2028 of file cmd_debug.c.

                                                                                                           {
     if (!step_until_inst(core, argv[1], true)) {
         return RZ_CMD_STATUS_ERROR;
     }
     rz_core_dbg_follow_seek_register(core);
     return RZ_CMD_STATUS_OK;
 }

References argv, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_dbg_follow_seek_register(), and step_until_inst().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_step_until_optype_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_step_until_optype_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2037 of file cmd_debug.c.

                                                                                                      {
     RzList *optypes_list = rz_list_new_from_array((const void **)argv + 1, argc - 1);
     step_until_optype(core, optypes_list);
     rz_core_dbg_follow_seek_register(core);
     rz_list_free(optypes_list);
     return RZ_CMD_STATUS_OK;
 }

References argv, RZ_CMD_STATUS_OK, rz_core_dbg_follow_seek_register(), rz_list_free(), rz_list_new_from_array(), and step_until_optype().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_stop_trace_session_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_stop_trace_session_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2210 of file cmd_debug.c.

                                                                                                       {
     if (!core->dbg->session) {
         RZ_LOG_ERROR("No session started\n");
         return RZ_CMD_STATUS_ERROR;
     }
     rz_debug_session_free(core->dbg->session);
     core->dbg->session = NULL;
     return RZ_CMD_STATUS_OK;
 }

References rz_core_t::dbg, NULL, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_debug_session_free(), RZ_LOG_ERROR, and rz_debug_t::session.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_toggle_bp_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_toggle_bp_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2842 of file cmd_debug.c.

                                                                                              {
     rz_core_debug_breakpoint_toggle(core, core->offset);
     return RZ_CMD_STATUS_OK;
 }

References rz_core_t::offset, RZ_CMD_STATUS_OK, and rz_core_debug_breakpoint_toggle().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_toggle_bp_index_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_toggle_bp_index_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2962 of file cmd_debug.c.

                                                                                                    {
     RzBreakpointItem *bpi;
     int index = rz_num_math(core->num, argv[1]);
     bpi = rz_bp_get_index(core->dbg->bp, index);
     if (!bpi) {
         RZ_LOG_ERROR("Unable to find breakpoint with index %d\n", index);
         return RZ_CMD_STATUS_ERROR;
     }
     bpi->enabled = !bpi->enabled;
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_debug_t::bp, rz_core_t::dbg, rz_bp_item_t::enabled, rz_core_t::num, rz_bp_get_index(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_toggle_bp_trace_index_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_toggle_bp_trace_index_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3001 of file cmd_debug.c.

                                                                                                          {
     RzBreakpointItem *bpi;
     int index = rz_num_math(core->num, argv[1]);
     bpi = rz_bp_get_index(core->dbg->bp, index);
     if (!bpi) {
         RZ_LOG_ERROR("Unable to find breakpoint with index %d\n", index);
         return RZ_CMD_STATUS_ERROR;
     }
     bpi->trace = !bpi->enabled;
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_debug_t::bp, rz_core_t::dbg, rz_bp_item_t::enabled, rz_core_t::num, rz_bp_get_index(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, RZ_LOG_ERROR, rz_num_math(), and rz_bp_item_t::trace.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_trace_add_addrs_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_trace_add_addrs_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2106 of file cmd_debug.c.

                                                                                                    {
     for (int i = 1; i < argc; ++i) {
         ut64 addr = rz_num_get(NULL, argv[i]);
         RzDebugTracepoint *t = rz_debug_trace_add(core->dbg, addr, 1);
         if (!t) {
             RZ_LOG_ERROR("Cannot add trace at address %" PFMT64x ".\n", addr);
             return RZ_CMD_STATUS_ERROR;
         }
     }
     return RZ_CMD_STATUS_OK;
 }

References addr, argv, rz_core_t::dbg, i, NULL, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_debug_trace_add(), RZ_LOG_ERROR, rz_num_get(), and ut64().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_trace_add_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_trace_add_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2087 of file cmd_debug.c.

                                                                                              {
     int count = argc > 1 ? rz_num_math(core->num, argv[1]) : 1;
     RzAnalysisOp *op = rz_core_op_analysis(core, core->offset, RZ_ANALYSIS_OP_MASK_HINT);
     if (!op) {
         RZ_LOG_ERROR("Cannot analyze opcode at 0x%08" PFMT64x "\n", core->offset);
         return RZ_CMD_STATUS_ERROR;
     }
  
     RzDebugTracepoint *tp = rz_debug_trace_add(core->dbg, core->offset, op->size);
     if (!tp) {
         rz_analysis_op_free(op);
         return RZ_CMD_STATUS_ERROR;
     }
     tp->count = count;
     rz_analysis_op_free(op);
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_debug_tracepoint_t::count, count, rz_core_t::dbg, rz_core_t::num, rz_core_t::offset, PFMT64x, rz_analysis_op_free(), RZ_ANALYSIS_OP_MASK_HINT, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_op_analysis(), rz_debug_trace_add(), RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_trace_addr()

RZ_IPI int rz_cmd_debug_trace_addr	(	void *	data,
		const char *	input
	)

Definition at line 2128 of file cmd_debug.c.

                                                                   {
     RzCore *core = (RzCore *)data;
     rz_debug_trace_at(core->dbg, input);
     return 0;
 }

References rz_core_t::dbg, input(), and rz_debug_trace_at().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_trace_calls_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_trace_calls_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2135 of file cmd_debug.c.

                                                                                                {
     ut64 from = argc > 1 ? rz_num_math(core->num, argv[1]) : 0;
     ut64 to = argc > 2 ? rz_num_math(core->num, argv[2]) : UT64_MAX;
     ut64 addr = argc > 3 ? rz_num_math(core->num, argv[3]) : UT64_MAX;
  
     debug_trace_calls(core, from, to, addr);
     return RZ_CMD_STATUS_OK;
 }

References addr, argv, debug_trace_calls(), from, rz_core_t::num, RZ_CMD_STATUS_OK, rz_num_math(), to, ut64(), and UT64_MAX.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_trace_esil_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_trace_esil_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2145 of file cmd_debug.c.

                                                                                               {
     rz_core_analysis_esil_init(core);
     int idx = rz_num_math(core->num, argv[1]);
     rz_analysis_esil_trace_show(core->analysis->esil, idx);
     return RZ_CMD_STATUS_OK;
 }

References rz_core_t::analysis, argv, rz_analysis_t::esil, setup::idx, rz_core_t::num, rz_analysis_esil_trace_show(), RZ_CMD_STATUS_OK, rz_core_analysis_esil_init(), and rz_num_math().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_trace_esils_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_trace_esils_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2153 of file cmd_debug.c.

                                                                                                {
     rz_core_analysis_esil_init(core);
     rz_analysis_esil_trace_list(core->analysis->esil);
     return RZ_CMD_STATUS_OK;
 }

References rz_core_t::analysis, rz_analysis_t::esil, rz_analysis_esil_trace_list(), RZ_CMD_STATUS_OK, and rz_core_analysis_esil_init().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_trace_graph_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_trace_graph_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzOutputMode	mode
	)

Definition at line 2183 of file cmd_debug.c.

                                                                                                                   {
     dot_trace_traverse(core, core->dbg->tree, rz_output_mode_to_char(mode));
     return RZ_CMD_STATUS_OK;
 }

References rz_core_t::dbg, dot_trace_traverse(), RZ_CMD_STATUS_OK, rz_output_mode_to_char(), and rz_debug_t::tree.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_trace_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_trace_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2060 of file cmd_debug.c.

                                                                                          {
     RzDebugTracepoint *t = rz_debug_trace_get(core->dbg, core->offset);
     if (!t) {
         RZ_LOG_ERROR("Cannot find any debug trace at address %" PFMT64x ".\n", core->offset);
         return RZ_CMD_STATUS_ERROR;
     }
  
     rz_cons_printf("offset = 0x%" PFMT64x "\n", t->addr);
     rz_cons_printf("opsize = %d\n", t->size);
     rz_cons_printf("times = %d\n", t->times);
     rz_cons_printf("count = %d\n", t->count);
     return RZ_CMD_STATUS_OK;
 }

References rz_debug_tracepoint_t::addr, rz_debug_tracepoint_t::count, rz_core_t::dbg, rz_core_t::offset, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_debug_trace_get(), RZ_LOG_ERROR, rz_debug_tracepoint_t::size, and rz_debug_tracepoint_t::times.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_trace_interactive_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_trace_interactive_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2189 of file cmd_debug.c.

                                                                                                      {
     dot_trace_traverse(core, core->dbg->tree, 'i');
     return RZ_CMD_STATUS_OK;
 }

References rz_core_t::dbg, dot_trace_traverse(), RZ_CMD_STATUS_OK, and rz_debug_t::tree.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_trace_tag_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_trace_tag_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2250 of file cmd_debug.c.

                                                                                              {
     int tag = rz_num_math(core->num, argv[1]);
     rz_debug_trace_tag(core->dbg, tag);
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_core_t::dbg, rz_core_t::num, RZ_CMD_STATUS_OK, rz_debug_trace_tag(), rz_num_math(), and test-lz4-versions::tag.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_traces_ascii_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_traces_ascii_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2081 of file cmd_debug.c.

                                                                                                 {
     rz_debug_traces_ascii(core->dbg, core->offset);
     return RZ_CMD_STATUS_OK;
 }

References rz_core_t::dbg, rz_core_t::offset, RZ_CMD_STATUS_OK, and rz_debug_traces_ascii().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_traces_esil_delete_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_traces_esil_delete_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2160 of file cmd_debug.c.

                                                                                                       {
     rz_core_analysis_esil_init(core);
     if (core->analysis->esil) {
         rz_pvector_free(core->analysis->esil->trace->instructions);
         core->analysis->esil->trace->instructions = rz_pvector_new((RzPVectorFree)rz_analysis_il_trace_instruction_free);
     }
     return RZ_CMD_STATUS_OK;
 }

References rz_core_t::analysis, rz_analysis_t::esil, rz_analysis_esil_trace_t::instructions, rz_analysis_il_trace_instruction_free(), RZ_CMD_STATUS_OK, rz_core_analysis_esil_init(), rz_pvector_free(), rz_pvector_new(), and rz_analysis_esil_t::trace.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_traces_esil_i_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_traces_esil_i_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2170 of file cmd_debug.c.

                                                                                                  {
     rz_core_analysis_esil_init(core);
     RzAnalysisOp *op = rz_core_analysis_op(core, core->offset, RZ_ANALYSIS_OP_MASK_ESIL);
     if (!op) {
         RZ_LOG_ERROR("Cannot analyze opcode at 0x%08" PFMT64x "\n", core->offset);
         return RZ_CMD_STATUS_ERROR;
     }
     rz_analysis_esil_trace_op(core->analysis->esil, op);
     rz_analysis_op_free(op);
     return RZ_CMD_STATUS_OK;
 }

References rz_core_t::analysis, rz_analysis_t::esil, rz_core_t::offset, PFMT64x, rz_analysis_esil_trace_op(), rz_analysis_op_free(), RZ_ANALYSIS_OP_MASK_ESIL, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_analysis_esil_init(), rz_core_analysis_op(), and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_traces_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_traces_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 2075 of file cmd_debug.c.

                                                                                                                    {
     rz_debug_trace_print(core->dbg, state, core->offset);
     return RZ_CMD_STATUS_OK;
 }

References rz_core_t::dbg, rz_core_t::offset, RZ_CMD_STATUS_OK, and rz_debug_trace_print().

Referenced by rzshell_cmddescs_init().

◆ rz_cmd_debug_traces_reset_handler()

RZ_IPI RzCmdStatus rz_cmd_debug_traces_reset_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 2119 of file cmd_debug.c.

                                                                                                 {
     rz_tree_reset(core->dbg->tree);
     rz_debug_trace_free(core->dbg->trace);
     rz_debug_tracenodes_reset(core->dbg);
     core->dbg->trace = rz_debug_trace_new();
     return RZ_CMD_STATUS_OK;
 }

References rz_core_t::dbg, RZ_CMD_STATUS_OK, rz_debug_trace_free(), rz_debug_trace_new(), rz_debug_tracenodes_reset(), rz_tree_reset(), rz_debug_t::trace, and rz_debug_t::tree.

Referenced by rzshell_cmddescs_init().

◆ rz_core_dbg_follow_seek_register()

RZ_API void rz_core_dbg_follow_seek_register ( RzCore * core )

Seek to PC if needed.

Parameters

core	The RzCore instance

Definition at line 474 of file cmd_debug.c.

                                                            {
     ut64 follow = rz_config_get_i(core->config, "dbg.follow");
     if (follow <= 0) {
         return;
     }
     ut64 pc = rz_debug_reg_get(core->dbg, "PC");
     if ((pc < core->offset) || (pc > (core->offset + follow))) {
         rz_core_seek_to_register(core, "PC", false);
     }
     rz_core_debug_sync_bits(core);
 }

References rz_core_t::config, rz_core_t::dbg, rz_core_t::offset, pc, rz_config_get_i(), rz_core_debug_sync_bits(), rz_core_seek_to_register(), rz_debug_reg_get(), and ut64().

◆ rz_core_debug_bp_add()

RZ_IPI void rz_core_debug_bp_add	(	RzCore *	core,
		ut64	addr,
		const char *	arg_perm,
		bool	hwbp,
		bool	watch
	)

Definition at line 1574 of file cmd_debug.c.

                                                                                                        {
     RzBreakpointItem *bpi;
     int rw = 0;
  
     if (watch) {
         rw = rz_str_rwx(arg_perm);
         rw &= RZ_PERM_RWX; // filter out the rwx bits only
         if (rw == 0) {
             RZ_LOG_WARN("Invalid permissions provided for setting watchpoint. Defaulting to \"rw\".\n");
             rw = RZ_PERM_RW;
         }
     }
     bpi = rz_debug_bp_add(core->dbg, addr, hwbp, watch, rw, NULL, 0);
     if (!bpi) {
         RZ_LOG_ERROR("Cannot set breakpoint at 0x%" PFMT64x "\n", addr);
         return;
     }
     RzFlagItem *f = rz_core_flag_get_by_spaces(core->flags, addr);
     if (f) {
         if (addr > f->offset) {
             char *name = rz_str_newf("%s+0x%" PFMT64x, f->name, addr - f->offset);
             rz_bp_item_set_name(bpi, name);
             free(name);
         } else {
             bpi->name = strdup(f->name);
         }
     } else {
         char *name = rz_str_newf("0x%08" PFMT64x, addr);
         rz_bp_item_set_name(bpi, name);
         free(name);
     }
 }

References addr, rz_core_t::dbg, f, rz_core_t::flags, free(), rz_bp_item_t::name, NULL, PFMT64x, rz_bp_item_set_name(), rz_core_flag_get_by_spaces(), rz_debug_bp_add(), RZ_LOG_ERROR, RZ_LOG_WARN, RZ_PERM_RW, RZ_PERM_RWX, rz_str_newf(), rz_str_rwx(), and strdup().

Referenced by __watch_points_cb(), rz_cmd_debug_add_bp_handler(), rz_cmd_debug_add_hw_bp_handler(), and rz_cmd_debug_add_watchpoint_handler().

◆ rz_core_debug_clear_register_flags()

RZ_API void rz_core_debug_clear_register_flags ( RzCore * core )

Definition at line 1449 of file cmd_debug.c.

                                                              {
     foreach_reg_set_or_clear(core, false);
 }

References foreach_reg_set_or_clear().

Referenced by rz_core_analysis_types_propagation(), and rz_core_debug_process_close().

◆ rz_core_debug_esil()

static void rz_core_debug_esil	(	RzCore *	core,
		const char *	input
	)

static

Definition at line 1781 of file cmd_debug.c.

                                                                 {
     switch (input[0]) {
     case '\0': // "de"
         // list
         rz_debug_esil_watch_list(core->dbg);
         break;
     case ' ': // "de "
     {
         char *line = strdup(input + 1);
         char *p, *q;
         int done = 0;
         int perm = 0, dev = 0;
         p = strchr(line, ' ');
         if (p) {
             *p++ = 0;
             if (strchr(line, 'r'))
                 perm |= RZ_PERM_R;
             if (strchr(line, 'w'))
                 perm |= RZ_PERM_W;
             if (strchr(line, 'x'))
                 perm |= RZ_PERM_X;
             q = strchr(p, ' ');
             if (q) {
                 *q++ = 0;
                 dev = p[0];
                 if (q) {
                     rz_debug_esil_watch(core->dbg, perm, dev, q);
                     done = 1;
                 }
             }
         }
         if (!done) {
             const char *help_de_msg[] = {
                 "Usage:", "de", " [perm] [reg|mem] [expr]",
                 NULL
             };
             rz_core_cmd_help(core, help_de_msg);
         }
         free(line);
     } break;
     case '-': // "de-"
         rz_debug_esil_watch_reset(core->dbg);
         break;
     case 'c': // "dec"
         if (rz_debug_esil_watch_empty(core->dbg)) {
             eprintf("Error: no esil watchpoints defined\n");
         } else {
             rz_core_analysis_esil_reinit(core);
             rz_debug_esil_prestep(core->dbg, rz_config_get_i(core->config, "esil.prestep"));
             rz_debug_esil_continue(core->dbg);
         }
         break;
     case 's': // "des"
         if (input[1] == 'u' && input[2] == ' ') { // "desu"
             ut64 addr, naddr, fin = rz_num_math(core->num, input + 2);
             rz_core_analysis_esil_reinit(core);
             addr = rz_debug_reg_get(core->dbg, "PC");
             while (addr != fin) {
                 rz_debug_esil_prestep(core->dbg, rz_config_get_i(core->config, "esil.prestep"));
                 rz_debug_esil_step(core->dbg, 1);
                 naddr = rz_debug_reg_get(core->dbg, "PC");
                 if (naddr == addr) {
                     eprintf("Detected loophole\n");
                     break;
                 }
                 addr = naddr;
             }
         } else if (input[1] == '?' || !input[1]) {
             rz_core_cmd_help(core, help_msg_des);
         } else {
             rz_core_analysis_esil_reinit(core);
             rz_debug_esil_prestep(core->dbg, rz_config_get_i(core->config, "esil.prestep"));
             // continue
             rz_debug_esil_step(core->dbg, rz_num_math(core->num, input + 1));
         }
         break;
     case '?': // "de?"
     default: {
         rz_core_cmd_help(core, help_msg_de);
         // TODO #7967 help refactor: move to detail
         rz_cons_printf("Examples:\n"
                    " de r r rip       # stop when reads rip\n"
                    " de rw m ADDR     # stop when read or write in ADDR\n"
                    " de w r rdx       # stop when rdx register is modified\n"
                    " de x m FROM..TO  # stop when rip in range\n");
     } break;
     }
 }

References addr, rz_core_t::config, rz_core_t::dbg, dev, done, eprintf, free(), help_msg_de, help_msg_des, input(), setup::line, NULL, rz_core_t::num, p, rz_config_get_i(), rz_cons_printf(), rz_core_analysis_esil_reinit(), rz_core_cmd_help(), rz_debug_esil_continue(), rz_debug_esil_prestep(), rz_debug_esil_step(), rz_debug_esil_watch(), rz_debug_esil_watch_empty(), rz_debug_esil_watch_list(), rz_debug_esil_watch_reset(), rz_debug_reg_get(), rz_num_math(), RZ_PERM_R, RZ_PERM_W, RZ_PERM_X, strdup(), and ut64().

Referenced by rz_cmd_debug().

◆ rz_core_debug_kill()

static void rz_core_debug_kill	(	RzCore *	core,
		const char *	input
	)

static

Definition at line 1870 of file cmd_debug.c.

                                                                 {
     if (!input || *input == '?') {
         if (input && input[1]) {
             const char *signame, *arg = input + 1;
             int signum = atoi(arg);
             if (signum > 0) {
                 signame = rz_signal_to_string(signum);
                 if (signame)
                     rz_cons_println(signame);
             } else {
                 signum = rz_signal_from_string(arg);
                 if (signum > 0) {
                     rz_cons_printf("%d\n", signum);
                 }
             }
         } else {
             rz_core_cmd_help(core, help_msg_dk);
         }
     } else if (*input == 'o') {
         switch (input[1]) {
         case 0: // "dko" - list signal skip/conts
             rz_debug_signal_list(core->dbg, RZ_OUTPUT_MODE_STANDARD);
             break;
         case ' ': // dko SIGNAL
             if (input[2]) {
                 char *p, *name = strdup(input + 2);
                 int signum = atoi(name);
                 p = strchr(name, ' ');
                 if (p)
                     *p++ = 0; /* got SIGNAL and an action */
                 // Actions:
                 //  - pass
                 //  - trace
                 //  - stop
                 if (signum < 1)
                     signum = rz_signal_from_string(name);
                 if (signum > 0) {
                     if (!p || !p[0]) { // stop (the usual)
                         rz_debug_signal_setup(core->dbg, signum, 0);
                     } else if (*p == 's') { // skip
                         rz_debug_signal_setup(core->dbg, signum, RZ_DBG_SIGNAL_SKIP);
                     } else if (*p == 'c') { // cont
                         rz_debug_signal_setup(core->dbg, signum, RZ_DBG_SIGNAL_CONT);
                     } else {
                         eprintf("Invalid option: %s\n", p);
                     }
                 } else {
                     eprintf("Invalid signal: %s\n", input + 2);
                 }
                 free(name);
                 break;
             }
             /* fall through */
         case '?':
         default: {
             rz_core_cmd_help(core, help_msg_dko);
             // TODO #7967 help refactor: move to detail
             rz_cons_println("NOTE: [signal] can be a number or a string that resolves with dk?\n"
                     "  skip means do not enter into the signal handler\n"
                     "  continue means enter into the signal handler");
         }
         }
     } else if (*input == 'j') {
         rz_debug_signal_list(core->dbg, RZ_OUTPUT_MODE_JSON);
     } else if (!*input) {
         rz_debug_signal_list(core->dbg, RZ_OUTPUT_MODE_STANDARD);
     } else {
         int sig = atoi(input);
         char *p = strchr(input, '=');
         if (p) {
             rz_debug_kill_setup(core->dbg, sig, rz_num_math(core->num, p + 1));
         } else {
             rz_debug_kill(core->dbg, core->dbg->pid, core->dbg->tid, sig);
         }
     }
 }

References rz_core_t::dbg, eprintf, free(), help_msg_dk, help_msg_dko, input(), rz_core_t::num, p, rz_debug_t::pid, rz_cons_printf(), rz_cons_println(), rz_core_cmd_help(), RZ_DBG_SIGNAL_CONT, RZ_DBG_SIGNAL_SKIP, rz_debug_kill(), rz_debug_kill_setup(), rz_debug_signal_list(), rz_debug_signal_setup(), rz_num_math(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_STANDARD, rz_signal_from_string(), rz_signal_to_string(), signum, strdup(), and rz_debug_t::tid.

Referenced by rz_cmd_debug().

◆ rz_core_debug_ri()

RZ_API void rz_core_debug_ri ( RzCore * core )

Definition at line 3616 of file cmd_debug.c.

                                            {
     const RzList *list = rz_reg_get_list(core->dbg->reg, RZ_REG_TYPE_GPR);
     rz_regs_show_valgroup(core, core->dbg->reg, cmd_regs_sync, list);
 }

References cmd_regs_sync(), rz_core_t::dbg, list(), rz_debug_t::reg, rz_reg_get_list(), RZ_REG_TYPE_GPR, and rz_regs_show_valgroup().

Referenced by rz_core_visual_debugtraces().

◆ rz_core_debug_set_register_flags()

RZ_API void rz_core_debug_set_register_flags ( RzCore * core )

Definition at line 1443 of file cmd_debug.c.

                                                            {
     rz_flag_space_push(core->flags, RZ_FLAGS_FS_REGISTERS);
     foreach_reg_set_or_clear(core, true);
     rz_flag_space_pop(core->flags);
 }

References rz_core_t::flags, foreach_reg_set_or_clear(), and RZ_FLAGS_FS_REGISTERS.

◆ rz_core_static_debug_stop()

RZ_IPI void rz_core_static_debug_stop ( void * u )

Definition at line 1565 of file cmd_debug.c.

                                                {
     RzDebug *dbg = (RzDebug *)u;
     rz_debug_stop(dbg);
 }

References dbg, and rz_debug_stop().

◆ rz_debug_drx_handler()

RZ_IPI RzCmdStatus rz_debug_drx_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3621 of file cmd_debug.c.

                                                                                    {
     if (argc <= 1) {
         rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_DRX, false);
         rz_debug_drx_list(core->dbg);
         return RZ_CMD_STATUS_OK;
     }
     if (argc != 5) {
         return RZ_CMD_STATUS_WRONG_ARGS;
     }
     int n = (int)rz_num_math(core->num, argv[1]);
     ut64 off = rz_num_math(core->num, argv[2]);
     int len = (int)rz_num_math(core->num, argv[3]);
     int perm = rz_str_rwx(argv[4]);
     if (len == -1) {
         rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_DRX, false);
         rz_debug_drx_set(core->dbg, n, 0, 0, 0, 0);
         rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_DRX, true);
     } else {
         rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_DRX, false);
         rz_debug_drx_set(core->dbg, n, off, len, perm, 0);
         rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_DRX, true);
     }
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_core_t::dbg, int, len, n, rz_core_t::num, off, RZ_CMD_STATUS_OK, RZ_CMD_STATUS_WRONG_ARGS, rz_debug_drx_list(), rz_debug_drx_set(), rz_debug_reg_sync(), rz_num_math(), RZ_REG_TYPE_DRX, rz_str_rwx(), and ut64().

Referenced by rzshell_cmddescs_init().

◆ rz_debug_drx_unset_handler()

RZ_IPI RzCmdStatus rz_debug_drx_unset_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 3646 of file cmd_debug.c.

                                                                                          {
     rz_return_val_if_fail(argc > 1, RZ_CMD_STATUS_WRONG_ARGS);
     rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_DRX, false);
     rz_debug_drx_unset(core->dbg, atoi(argv[1] + 2));
     rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_DRX, true);
     return RZ_CMD_STATUS_OK;
 }

References argv, rz_core_t::dbg, RZ_CMD_STATUS_OK, RZ_CMD_STATUS_WRONG_ARGS, rz_debug_drx_unset(), rz_debug_reg_sync(), RZ_REG_TYPE_DRX, and rz_return_val_if_fail.

Referenced by rzshell_cmddescs_init().

◆ rz_debug_memory_permission_handler()

RZ_IPI RzCmdStatus rz_debug_memory_permission_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1288 of file cmd_debug.c.

                                                                                                  {
     CMD_CHECK_DEBUG_DEAD(core);
     RzListIter *iter;
     RzDebugMap *map;
     ut64 addr = 0, size = 0;
     int perms;
     if (argc == 3) { // dmp <size> <perms> @ <addr>
         addr = core->offset;
         size = rz_num_math(core->num, argv[1]);
         perms = rz_str_rwx(argv[2]);
         rz_debug_map_protect(core->dbg, addr, (int)size, perms);
     } else if (argc == 2) { // dmp <perms>
         addr = UT64_MAX;
         rz_list_foreach (core->dbg->maps, iter, map) {
             if (core->offset >= map->addr && core->offset < map->addr_end) {
                 addr = map->addr;
                 size = map->size;
                 break;
             }
         }
         perms = rz_str_rwx(argv[1]);
         if (addr != UT64_MAX && perms >= 0) {
             rz_debug_map_protect(core->dbg, addr, (int)size, perms);
         } else {
             return RZ_CMD_STATUS_ERROR;
         }
     }
     return RZ_CMD_STATUS_OK;
 }

References addr, argv, CMD_CHECK_DEBUG_DEAD, rz_core_t::dbg, map(), rz_debug_t::maps, rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_debug_map_protect(), rz_num_math(), rz_str_rwx(), ut64(), and UT64_MAX.

Referenced by rzshell_cmddescs_init().

◆ set_profile_string()

static void set_profile_string	(	RzCore *	core,
		const char *	str
	)

static

Definition at line 192 of file cmd_debug.c.

                                                               {
     char *file = strdup(rz_config_get(core->config, "dbg.profile"));
     if (RZ_STR_ISEMPTY(file)) {
         free(file);
         file = rz_file_temp("rz-run");
         rz_config_set(core->config, "dbg.profile", file);
     }
     rz_file_dump(file, (const ut8 *)str, (int)strlen(str), 0);
     rz_file_dump(file, (const ut8 *)"\n", 1, 1);
     free(file);
 }

References rz_core_t::config, free(), rz_config_get(), rz_config_set(), rz_file_dump(), rz_file_temp(), RZ_STR_ISEMPTY, cmd_descs_generate::str, and strdup().

Referenced by rz_cmd_debug_process_profile_handler().

◆ step_line()

static bool step_line	(	RzCore *	core,
		int	times
	)

static

Definition at line 598 of file cmd_debug.c.

                                                {
     char file[512], file2[512];
     int find_meta, line = -1, line2 = -1;
     char *tmp_ptr = NULL;
     ut64 off = rz_debug_reg_get(core->dbg, "PC");
     if (off == 0LL) {
         RZ_LOG_ERROR("cannot 'drn PC'\n");
         return false;
     }
     file[0] = 0;
     file2[0] = 0;
     if (rz_bin_addr2line(core->bin, off, file, sizeof(file), &line)) {
         char *ptr = rz_file_slurp_line(file, line, 0);
         RZ_LOG_INFO("--> 0x%08" PFMT64x " %s : %d\n", off, file, line);
         RZ_LOG_INFO("--> %s\n", ptr);
         find_meta = false;
         free(ptr);
     } else {
         RZ_LOG_INFO("--> Stepping until dwarf line\n");
         find_meta = true;
     }
     do {
         rz_debug_step(core->dbg, 1);
         off = rz_debug_reg_get(core->dbg, "PC");
         if (!rz_bin_addr2line(core->bin, off, file2, sizeof(file2), &line2)) {
             if (find_meta) {
                 continue;
             }
             rz_core_reg_update_flags(core);
             RZ_LOG_ERROR("cannot retrieve dwarf info at 0x%08" PFMT64x "\n", off);
             return false;
         }
     } while (!strcmp(file, file2) && line == line2);
  
     RZ_LOG_INFO("--> 0x%08" PFMT64x " %s : %d\n", off, file2, line2);
     tmp_ptr = rz_file_slurp_line(file2, line2, 0);
     RZ_LOG_INFO("--> %s\n", tmp_ptr);
     free(tmp_ptr);
     rz_core_reg_update_flags(core);
     return true;
 }

References rz_core_t::bin, rz_core_t::dbg, free(), setup::line, NULL, off, PFMT64x, rz_bin_addr2line(), rz_core_reg_update_flags(), rz_debug_reg_get(), rz_debug_step(), rz_file_slurp_line(), RZ_LOG_ERROR, RZ_LOG_INFO, and ut64().

Referenced by rz_cmd_debug_step_line_handler().

◆ step_until()

static int step_until	(	RzCore *	core,
		ut64	addr
	)

static

Definition at line 352 of file cmd_debug.c.

                                                {
     ut64 off = rz_debug_reg_get(core->dbg, "PC");
     if (!off) {
         eprintf("Cannot 'drn PC'\n");
         return false;
     }
     if (!addr) {
         eprintf("Cannot continue until address 0\n");
         return false;
     }
     rz_cons_break_push(NULL, NULL);
     do {
         if (rz_cons_is_breaked()) {
             core->break_loop = true;
             break;
         }
         if (rz_debug_is_dead(core->dbg)) {
             core->break_loop = true;
             break;
         }
         rz_debug_step(core->dbg, 1);
         off = rz_debug_reg_get(core->dbg, "PC");
         // check breakpoint here
     } while (off != addr);
     rz_core_reg_update_flags(core);
     rz_cons_break_pop();
     return true;
 }

References addr, rz_core_t::break_loop, rz_core_t::dbg, eprintf, 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(), and ut64().

Referenced by rz_cmd_debug_step_until_handler().

◆ step_until_esil()

static int step_until_esil	(	RzCore *	core,
		const char *	esilstr
	)

static

Definition at line 381 of file cmd_debug.c.

                                                               {
     if (!core || !esilstr || !core->dbg || !core->dbg->analysis || !core->dbg->analysis->esil) {
         eprintf("Not initialized %p. Run 'aei' first.\n", core->analysis->esil);
         return false;
     }
     rz_cons_break_push(NULL, NULL);
     for (;;) {
         if (rz_cons_is_breaked()) {
             core->break_loop = true;
             break;
         }
         if (rz_debug_is_dead(core->dbg)) {
             core->break_loop = true;
             break;
         }
         rz_debug_step(core->dbg, 1);
         rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_ANY, false);
         if (rz_analysis_esil_condition(core->analysis->esil, esilstr)) {
             eprintf("ESIL BREAK!\n");
             break;
         }
     }
     rz_core_reg_update_flags(core);
     rz_cons_break_pop();
     return true;
 }

References rz_core_t::analysis, rz_debug_t::analysis, rz_core_t::break_loop, rz_core_t::dbg, eprintf, rz_analysis_t::esil, NULL, rz_analysis_esil_condition(), rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_core_reg_update_flags(), rz_debug_is_dead(), rz_debug_reg_sync(), rz_debug_step(), and RZ_REG_TYPE_ANY.

Referenced by rz_cmd_debug_step_until_esil_handler().

◆ step_until_flag()

static int step_until_flag	(	RzCore *	core,
		const char *	flagstr
	)

static

Definition at line 562 of file cmd_debug.c.

                                                               {
     const RzList *list;
     RzListIter *iter;
     RzFlagItem *flag;
     ut64 pc;
  
     if (!core || !flagstr || !core->dbg) {
         RZ_LOG_ERROR("wrong state\n");
         return false;
     }
     rz_cons_break_push(NULL, NULL);
     for (;;) {
         if (rz_cons_is_breaked()) {
             break;
         }
         if (rz_debug_is_dead(core->dbg)) {
             break;
         }
         rz_debug_step(core->dbg, 1);
         rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_ANY, false);
         pc = rz_debug_reg_get(core->dbg, "PC");
         list = rz_flag_get_list(core->flags, pc);
         rz_list_foreach (list, iter, flag) {
             if (flag->realname && strstr(flag->realname, flagstr)) {
                 rz_cons_printf("[ 0x%08" PFMT64x " ] %s\n",
                     flag->offset, flag->realname);
                 goto beach;
             }
         }
     }
 beach:
     rz_core_reg_update_flags(core);
     rz_cons_break_pop();
     return true;
 }

References rz_core_t::dbg, rz_core_t::flags, list(), NULL, rz_flag_item_t::offset, pc, PFMT64x, rz_flag_item_t::realname, rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_cons_printf(), rz_core_reg_update_flags(), rz_debug_is_dead(), rz_debug_reg_get(), rz_debug_reg_sync(), rz_debug_step(), rz_flag_get_list(), RZ_LOG_ERROR, RZ_REG_TYPE_ANY, and ut64().

Referenced by rz_cmd_debug_step_until_flag_handler().

◆ step_until_inst()

static bool step_until_inst	(	RzCore *	core,
		const char *	instr,
		bool	regex
	)

static

Definition at line 416 of file cmd_debug.c.

                                                                          {
     rz_return_val_if_fail(core, false);
     instr = rz_str_trim_head_ro(instr);
     if (!instr || !core->dbg) {
         RZ_LOG_ERROR("wrong debugger state\n");
         return false;
     }
     RzAsmOp asmop;
     ut8 buf[32];
     ut64 pc;
     int ret;
     bool is_x86 = rz_str_startswith(rz_config_get(core->config, "asm.arch"), "x86");
     rz_cons_break_push(NULL, NULL);
     for (;;) {
         if (rz_cons_is_breaked()) {
             break;
         }
         if (rz_debug_is_dead(core->dbg)) {
             break;
         }
         pc = rz_debug_reg_get(core->dbg, "PC");
         if (is_x86 && is_repeatable_inst(core, pc)) {
             rz_debug_step_over(core->dbg, 1);
         } else {
             rz_debug_step(core->dbg, 1);
         }
         pc = rz_debug_reg_get(core->dbg, "PC");
         rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_ANY, false);
         /* TODO: disassemble instruction and strstr */
         rz_asm_set_pc(core->rasm, pc);
         // TODO: speedup if instructions are in the same block as the previous
         rz_io_read_at(core->io, pc, buf, sizeof(buf));
         ret = rz_asm_disassemble(core->rasm, &asmop, buf, sizeof(buf));
         eprintf("0x%08" PFMT64x " %d %s\n", pc, ret, rz_asm_op_get_asm(&asmop)); // asmop.buf_asm);
         if (ret > 0) {
             const char *buf_asm = rz_asm_op_get_asm(&asmop);
             if (regex) {
                 if (rz_regex_match(instr, "e", buf_asm)) {
                     eprintf("Stop.\n");
                     break;
                 }
             } else {
                 if (strstr(buf_asm, instr)) {
                     eprintf("Stop.\n");
                     break;
                 }
             }
         }
     }
     rz_core_reg_update_flags(core);
     rz_cons_break_pop();
     return true;
 }

References rz_core_t::config, rz_core_t::dbg, eprintf, rz_core_t::io, is_repeatable_inst(), NULL, pc, PFMT64x, rz_core_t::rasm, rz_asm_disassemble(), rz_asm_op_get_asm(), rz_asm_set_pc(), rz_config_get(), 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_reg_sync(), rz_debug_step(), rz_debug_step_over(), rz_io_read_at(), RZ_LOG_ERROR, RZ_REG_TYPE_ANY, rz_regex_match(), rz_return_val_if_fail, rz_str_startswith(), rz_str_trim_head_ro(), and ut64().

Referenced by rz_cmd_debug_step_until_instr_handler(), and rz_cmd_debug_step_until_instr_regex_handler().

◆ step_until_optype()

static bool step_until_optype	(	RzCore *	core,
		RzList *	optypes_list
	)

static

Definition at line 486 of file cmd_debug.c.

                                                                   {
     RzAnalysisOp op;
     ut8 buf[32];
     ut64 pc;
     int res = true;
  
     RzListIter *iter;
     char *optype;
  
     if (!core || !core->dbg) {
         RZ_LOG_ERROR("wrong state\n");
         res = false;
         goto end;
     }
     if (!optypes_list) {
         RZ_LOG_ERROR("missing optypes. Usage example: 'dsuo ucall ujmp'\n");
         res = false;
         goto end;
     }
  
     bool debugMode = rz_config_get_b(core->config, "cfg.debug");
  
     rz_cons_break_push(NULL, NULL);
     for (;;) {
         if (rz_cons_is_breaked()) {
             core->break_loop = true;
             break;
         }
         if (debugMode) {
             if (rz_debug_is_dead(core->dbg)) {
                 core->break_loop = true;
                 break;
             }
             rz_debug_step(core->dbg, 1);
             pc = rz_debug_reg_get(core->dbg, core->dbg->reg->name[RZ_REG_NAME_PC]);
             // 'Copy' from rz_debug_step_soft
             if (!core->dbg->iob.read_at) {
                 RZ_LOG_ERROR("ERROR\n");
                 res = false;
                 goto cleanup_after_push;
             }
             if (!core->dbg->iob.read_at(core->dbg->iob.io, pc, buf, sizeof(buf))) {
                 RZ_LOG_ERROR("ERROR\n");
                 res = false;
                 goto cleanup_after_push;
             }
         } else {
             rz_core_esil_step(core, UT64_MAX, NULL, NULL, false);
             pc = rz_reg_getv(core->analysis->reg, "PC");
         }
         rz_io_read_at(core->io, pc, buf, sizeof(buf));
  
         if (rz_analysis_op(core->dbg->analysis, &op, pc, buf, sizeof(buf), RZ_ANALYSIS_OP_MASK_BASIC) < 1) {
             RZ_LOG_ERROR("rz_analysis_op failed\n");
             res = false;
             goto cleanup_after_push;
         }
  
         // This is slow because we do lots of strcmp's.
         // To improve this, the function rz_analysis_optype_string_to_int should be implemented
         // I also don't check if the opcode type exists.
         const char *optype_str = rz_analysis_optype_to_string(op.type);
         rz_list_foreach (optypes_list, iter, optype) {
             if (!strcmp(optype_str, optype)) {
                 goto cleanup_after_push;
             }
         }
     }
  
 cleanup_after_push:
     rz_core_reg_update_flags(core);
     rz_cons_break_pop();
 end:
     return res;
 }

References rz_core_t::analysis, rz_debug_t::analysis, rz_core_t::break_loop, rz_core_t::config, rz_core_t::dbg, test_evm::end, rz_core_t::io, rz_io_bind_t::io, rz_debug_t::iob, rz_reg_t::name, NULL, op, optype, pc, rz_io_bind_t::read_at, rz_analysis_t::reg, rz_debug_t::reg, rz_analysis_op(), RZ_ANALYSIS_OP_MASK_BASIC, rz_analysis_optype_to_string(), rz_config_get_b(), rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_core_esil_step(), rz_core_reg_update_flags(), rz_debug_is_dead(), rz_debug_reg_get(), rz_debug_step(), rz_io_read_at(), RZ_LOG_ERROR, rz_reg_getv(), RZ_REG_NAME_PC, ut64(), and UT64_MAX.

Referenced by rz_cmd_debug_step_until_optype_handler(), and rz_il_step_until_opt_handler().

◆ trace_traverse()

static void trace_traverse ( RTree * t )

static

Definition at line 1642 of file cmd_debug.c.

                                      {
     RTreeVisitor vis = { 0 };
  
     /* clear the line on stderr, because somebody has written there */
     fprintf(stderr, "\x1b[2K\r");
     fflush(stderr);
     vis.pre_visit = (RTreeNodeVisitCb)trace_traverse_pre;
     rz_tree_dfs(t, &vis);
 }

References rz_tree_visitor_t::pre_visit, rz_tree_dfs(), and trace_traverse_pre().

Referenced by debug_trace_calls().

◆ trace_traverse_pre()

static void trace_traverse_pre	(	RTreeNode *	n,
		RTreeVisitor *	vis
	)

static

Definition at line 1624 of file cmd_debug.c.

                                                                 {
     const char *name = "";
     struct trace_node *tn = n->data;
     unsigned int i;
     if (!tn)
         return;
     for (i = 0; i < n->depth - 1; i++) {
         rz_cons_printf("  ");
     }
     if (_core) {
         RzFlagItem *f = rz_flag_get_at(_core->flags, tn->addr, true);
         if (f) {
             name = f->name;
         }
     }
     rz_cons_printf(" 0x%08" PFMT64x " refs %d %s\n", tn->addr, tn->refs, name);
 }

References _core, trace_node::addr, f, rz_core_t::flags, i, n, PFMT64x, trace_node::refs, rz_cons_printf(), and rz_flag_get_at().

Referenced by trace_traverse().

Variable Documentation

◆ _core

RzCore* _core = NULL

static

Definition at line 1622 of file cmd_debug.c.

Referenced by __disasm(), __init_menu_color_settings_layout(), __init_menu_disasm_asm_settings_layout(), __init_menu_disasm_settings_layout(), __init_menu_saved_layout(), __init_menu_screen_settings_layout(), cb_diff_sort(), debug_trace_calls(), rz_analysis_reflines_str(), and trace_traverse_pre().

◆ help_msg_d

const char* help_msg_d[]

static

Initial value:

= {
    "Usage:", "d", " # Debug commands",
    "db", "[?]", "Breakpoints commands",
    "dbt", "[?]", "Display backtrace based on dbg.btdepth and dbg.btalgo",
    "dc", "[?]", "Continue execution",
    "dd", "[?]", "File descriptors (!fd in r1)",
    "de", "[-sc] [perm] [rm] [e]", "Debug with ESIL (see de?)",
    "dg", " <file>", "Generate a core-file (WIP)",
    "dH", " [handler]", "Transplant process to a new handler",
    "di", "[?]", "Show debugger backend information (See dh)",
    "dk", "[?]", "List, send, get, set, signal handlers of child",
    "dL", "[?]", "List or set debugger handler",
    "dm", "[?]", "Show memory maps",
    "do", "[?]", "Open process (reload, alias for 'oo')",
    "doc", "", "Close debug session",
    "dp", "[?]", "List, attach to process or thread id",
    "dr", "[?]", "Cpu registers",
    "ds", "[?]", "Step, over, source line",
    "dt", "[?]", "Display instruction traces",
    "dw", " <pid>", "Block prompt until pid dies",
 
 
 
 
    "dx", "[?]", "Inject and run code on target process (See gs)",
    NULL
}

Definition at line 27 of file cmd_debug.c.

Referenced by rz_cmd_debug().

◆ help_msg_dcs

const char* help_msg_dcs[]

static

Initial value:

= {
    "Usage:", "dcs", " Continue until syscall",
    "dcs", "", "Continue until next syscall",
    "dcs [str]", "", "Continue until next call to the 'str' syscall",
    "dcs", "*", "Trace all syscalls, a la strace",
    NULL
}

Definition at line 55 of file cmd_debug.c.

Referenced by rz_cmd_debug_continue_syscall().

◆ help_msg_dcu

const char* help_msg_dcu[]

static

Initial value:

= {
    "Usage:", "dcu", " Continue until address",
    "dcu.", "", "Alias for dcu $$ (continue until current address",
    "dcu", " address", "Continue until address",
    "dcu", " [..tail]", "Continue until the range",
    "dcu", " [from] [to]", "Continue until the range",
    NULL
}

Definition at line 63 of file cmd_debug.c.

Referenced by cmd_dcu(), and rz_cmd_debug_continue_until().

◆ help_msg_dd

const char* help_msg_dd[]

static

Initial value:

= {
    "Usage: dd", "", "Descriptors commands",
    "dd", "", "List file descriptors",
    "dd", " <file>", "Open and map that file into the UI",
    "dd-", "<fd>", "Close stdout fd",
    "dd*", "", "List file descriptors (in rizin commands)",
    "dds", " <fd> <off>", "Seek given fd)",
    "ddd", " <fd1> <fd2>", "Dup2 from fd1 to fd2",
    "ddr", " <fd> <size>", "Read N bytes from fd",
    "ddw", " <fd> <hexpairs>", "Write N bytes to fd",
    NULL
}

Definition at line 72 of file cmd_debug.c.

Referenced by rz_cmd_debug().

◆ help_msg_de

const char* help_msg_de[]

static

Initial value:

= {
    "Usage:", "de", "[-sc] [perm] [rm] [expr]",
    "de", "", "List esil watchpoints",
    "de-*", "", "Delete all esil watchpoints",
    "de", " [perm] [rm] [addr|reg|from..to]", "Stop on condition",
    "dec", "", "Continue execution until matching expression",
    "des", "[?] [N]", "Step-in N instructions with esildebug",
    "desu", " [addr]", "Esildebug until specific address",
    NULL
}

Definition at line 85 of file cmd_debug.c.

Referenced by rz_core_debug_esil().

◆ help_msg_des

const char* help_msg_des[]

static

Initial value:

= {
    "Usage:", "des", "[u] [arg]",
    "des", " [N]", "step-in N instructions with esildebug",
    "desu", " [addr]", "esildebug until specific address",
    NULL
}

Definition at line 96 of file cmd_debug.c.

Referenced by rz_core_debug_esil().

◆ help_msg_di

const char* help_msg_di[]

static

Initial value:

= {
    "Usage: di", "", "Debugger target information",
    "di", "", "Show debugger target information",
    "di*", "", "Same as above, but in rizin commands",
    "diq", "", "Same as above, but in one line",
    "dij", "", "Same as above, but in JSON format",
    "dif", " [$a] [$b]", "Compare two files (or $alias files)",
    NULL
}

Definition at line 103 of file cmd_debug.c.

Referenced by rz_cmd_debug().

◆ help_msg_dk

const char* help_msg_dk[]

static

Initial value:

= {
    "Usage: dk", "", "Signal commands",
    "dk", "", "List all signal handlers of child process",
    "dk", " <signal>", "Send KILL signal to child",
    "dk", " <signal>=1", "Set signal handler for <signal> in child",
    "dk?", "<signal>", "Name/signum resolver",
    "dko", "[?] <signal>", "Reset skip or cont options for given signal",
    "dko", " <signal> [|skip|cont]", "On signal SKIP handler or CONT into",
    "dkj", "", "List all signal handlers in JSON",
    NULL
}

Definition at line 113 of file cmd_debug.c.

Referenced by rz_core_debug_kill().

◆ help_msg_dko

const char* help_msg_dko[]

static

Initial value:

= {
    "Usage:", "dko", " # Signal handling commands",
    "dko", "", "List existing signal handling",
    "dko", " [signal]", "Clear handling for a signal",
    "dko", " [signal] [skip|cont]", "Set handling for a signal",
    NULL
}

Definition at line 125 of file cmd_debug.c.

Referenced by rz_core_debug_kill().

◆ help_msg_dmi

const char* help_msg_dmi[]

static

Initial value:

= {
    "Usage: dmi", "", " # List/Load Symbols",
    "dmi", "[j|q|*] [libname] [symname]", "List symbols of target lib",
    "dmia", "[j|q|*] [libname]", "List all info of target lib",
    "dmi*", "", "List symbols of target lib in rizin commands",
    "dmi.", "", "List closest symbol to the current address",
    "dmiv", "", "Show address of given symbol for given lib",
    NULL
}

Definition at line 133 of file cmd_debug.c.

Referenced by rz_cmd_debug_dmi().

◆ help_msg_dp

const char* help_msg_dp[]

static

Initial value:

= {
    "Usage:", "dp", " # Process commands",
    "dp", "", "List current pid and children",
    "dp", " <pid>", "List children of pid",
    "dpj", " <pid>", "List children of pid in JSON format",
    "dpl", "", "List all attachable pids",
    "dplj", "", "List all attachable pids in JSON format",
    "dp-", " <pid>", "Detach select pid",
    "dp=", "<pid>", "Select pid",
    "dpa", " <pid>", "Attach and select pid",
    "dpc", "", "Select forked pid (see dbg.forks)",
    "dpc*", "", "Display forked pid (see dbg.forks)",
    "dpe", "", "Show path to executable",
    "dpf", "", "Attach to pid like file fd // HACK",
    "dpk", " <pid> [<signal>]", "Send signal to process (default 0)",
    "dpn", "", "Create new process (fork)",
    "dptn", "", "Create new thread (clone)",
    "dpt", "", "List threads of current pid",
    "dptj", "", "List threads of current pid in JSON format",
    "dpt", " <pid>", "List threads of process",
    "dptj", " <pid>", "List threads of process in JSON format",
    "dpt=", "<thread>", "Attach to thread",
    NULL
}

Definition at line 143 of file cmd_debug.c.

Referenced by cmd_debug_pid().

◆ help_msg_dx

const char* help_msg_dx[]

static

Initial value:

= {
    "Usage: dx", "", " # Code injection commands",
    "dx", " <opcode>...", "Inject opcodes",
    "dxa", " nop", "Assemble code and inject",
    "dxe", " egg-expr", "Compile egg expression and inject it",
    "dxr", " <opcode>...", "Inject opcodes and restore state",
    "dxs", " write 1, 0x8048, 12", "Syscall injection (see gs)",
    "\nExamples:", "", "",
    "dx", " 9090", "Inject two x86 nop",
    "\"dxa mov eax,6;mov ebx,0;int 0x80\"", "", "Inject and restore state",
    NULL
}

Definition at line 168 of file cmd_debug.c.

Referenced by rz_cmd_debug().

Classes

Macros

Functions

Variables

Macro Definition Documentation

◆ CMD_CHECK_DEBUG_DEAD

◆ CMD_REGS_PREFIX

◆ CMD_REGS_REG_PATH

◆ CMD_REGS_SYNC

◆ MAX_MAP_SIZE

◆ P

◆ PS

◆ TN_KEY_FMT

◆ TN_KEY_LEN

Function Documentation

◆ add_trace_tree_child()

◆ addroflib()

◆ asciiart_backtrace()

◆ backtrace_vars()

◆ cmd_dcu()

◆ cmd_debug_backtrace()

◆ cmd_debug_cont_syscall()

◆ cmd_debug_current_modules()

◆ cmd_debug_modules()

◆ cmd_debug_pid()

◆ cmd_regs_sync()

◆ consumeBuffer()

◆ debug_trace_calls()

◆ do_debug_trace_calls()

◆ dot_trace_create_node()

◆ dot_trace_discover_child()

◆ dot_trace_traverse()

◆ dump_maps()

◆ foreach_reg_set_or_clear()

◆ get_bin_info()

◆ get_closest_map()

◆ get_corefile_name()

◆ get_graphtrace_node()

◆ getFileData()

◆ is_repeatable_inst()

◆ rad2mode()

◆ rz_cmd_debug()

◆ rz_cmd_debug_add_bp_handler()

◆ rz_cmd_debug_add_bp_module_handler()

◆ rz_cmd_debug_add_bp_noreturn_func_handler()

◆ rz_cmd_debug_add_cond_bp_handler()

◆ rz_cmd_debug_add_hw_bp_handler()

◆ rz_cmd_debug_add_watchpoint_handler()

◆ rz_cmd_debug_allocate_maps_handler()

◆ rz_cmd_debug_bp_plugin_handler()

◆ rz_cmd_debug_bp_set_expr_cur_offset_handler()

◆ rz_cmd_debug_bt_disable_bp_trace_handler()

◆ rz_cmd_debug_bt_enable_bp_trace_handler()

◆ rz_cmd_debug_bt_toggle_bp_trace_handler()

◆ rz_cmd_debug_command_bp_handler()

◆ rz_cmd_debug_continue_back_handler()

◆ rz_cmd_debug_continue_call_handler()

◆ rz_cmd_debug_continue_exception_handler()

◆ rz_cmd_debug_continue_execution_handler()

◆ rz_cmd_debug_continue_fork_handler()

◆ rz_cmd_debug_continue_mapped_io_handler()

◆ rz_cmd_debug_continue_ret_handler()

◆ rz_cmd_debug_continue_send_signal_handler()

◆ rz_cmd_debug_continue_syscall()

◆ rz_cmd_debug_continue_traptrace_handler()

◆ rz_cmd_debug_continue_unknown_call_handler()

◆ rz_cmd_debug_continue_until()

◆ rz_cmd_debug_current_modules_handler()

◆ rz_cmd_debug_deallocate_map_handler()

◆ rz_cmd_debug_disable_bp_handler()

◆ rz_cmd_debug_disable_bp_index_handler()

◆ rz_cmd_debug_disable_bp_trace_index_handler()

◆ rz_cmd_debug_display_bt_ascii_handler()

◆ rz_cmd_debug_display_bt_handler()

◆ rz_cmd_debug_display_bt_local_vars_handler()

◆ rz_cmd_debug_display_bt_oneline_handler()

◆ rz_cmd_debug_dmi()

◆ rz_cmd_debug_dml_handler()

◆ rz_cmd_debug_dmL_handler()

◆ rz_cmd_debug_dmS_handler()