portugalfuturista/rizin
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Refactor to use API in visual mode

Browse source
This commit is contained in:
Anton Kochkov 2021-02-07 00:33:10 +08:00 committed by Anton Kochkov
parent 96ea7e5126
commit 3e64a2e16a
8 changed files with 264 additions and 226 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

86
librz/core/canalysis.c
View file

@ -1,5 +1,7 @@
// SPDX-License-Identifier: LGPL-3.0-only // SPDX-License-Identifier: LGPL-3.0-only
#include <string.h>
#include <rz_types.h> #include <rz_types.h>
#include <rz_list.h> #include <rz_list.h>
#include <rz_flag.h> #include <rz_flag.h>
@ -8,7 +10,7 @@
#include <ht_uu.h> #include <ht_uu.h>
#include <rz_util/rz_graph_drawable.h> #include <rz_util/rz_graph_drawable.h>
#include <string.h> #include "core_private.h"
HEAPTYPE(ut64); HEAPTYPE(ut64);
@ -361,6 +363,58 @@ RZ_API ut64 rz_core_analysis_address(RzCore *core, ut64 addr) {
return types; return types;
} }
RZ_IPI int rz_core_analysis_set_reg(RzCore *core, const char *regname, ut64 val) {
int bits = (core->analysis->bits & RZ_SYS_BITS_64) ? 64 : 32;
RzRegItem *r = rz_reg_get(core->dbg->reg, regname, -1);
if (!r) {
int role = rz_reg_get_name_idx(regname);
if (role != -1) {
const char *alias = rz_reg_get_name(core->dbg->reg, role);
if (alias) {
r = rz_reg_get(core->dbg->reg, alias, -1);
}
}
}
if (!r) {
eprintf("ar: Unknown register '%s'\n", regname);
return -1;
}
rz_reg_set_value(core->dbg->reg, r, val);
rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_ALL, true);
rz_core_debug_regs2flags(core, bits);
return 0;
}
RZ_IPI void rz_core_analysis_esil_init(RzCore *core) {
RzAnalysisEsil *esil = core->analysis->esil;
unsigned int addrsize = rz_config_get_i(core->config, "esil.addr.size");
int stacksize = rz_config_get_i(core->config, "esil.stack.depth");
int iotrap = rz_config_get_i(core->config, "esil.iotrap");
int romem = rz_config_get_i(core->config, "esil.romem");
int stats = rz_config_get_i(core->config, "esil.stats");
int noNULL = rz_config_get_i(core->config, "esil.noNULL");
rz_analysis_esil_free(esil);
// reinitialize
const char *pc = rz_reg_get_name(core->analysis->reg, RZ_REG_NAME_PC);
if (pc && rz_reg_getv(core->analysis->reg, pc) == 0LL) {
rz_core_analysis_set_reg(core, "PC", core->offset);
}
if (!(esil = core->analysis->esil = rz_analysis_esil_new(stacksize, iotrap, addrsize))) {
return;
}
rz_analysis_esil_setup(esil, core->analysis, romem, stats, noNULL); // setup io
esil->verbose = (int)rz_config_get_i(core->config, "esil.verbose");
const char *s = rz_config_get(core->config, "cmd.esil.intr");
if (s) {
char *my = strdup(s);
if (my) {
rz_config_set(core->config, "cmd.esil.intr", my);
free(my);
}
}
}
static bool blacklisted_word(char *name) { static bool blacklisted_word(char *name) {
const char *list[] = { const char *list[] = {
"__stack_chk_guard", "__stack_chk_guard",
@ -6064,3 +6118,33 @@ RZ_API void rz_core_analysis_esil_graph(RzCore *core, const char *expr) {
rz_analysis_esil_dfg_free(edf); rz_analysis_esil_dfg_free(edf);
} }
RZ_IPI bool rz_core_analysis_var_rename(RzCore *core, const char *name, const char *newname) {
RzAnalysisOp *op = rz_core_analysis_op(core, core->offset, RZ_ANALYSIS_OP_MASK_BASIC);
if (!name) {
RzAnalysisVar *var = op ? rz_analysis_get_used_function_var(core->analysis, op->addr) : NULL;
if (var) {
name = var->name;
} else {
eprintf("Cannot find var @ 0x%08" PFMT64x "\n", core->offset);
rz_analysis_op_free(op);
return false;
}
}
RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, -1);
if (fcn) {
RzAnalysisVar *v1 = rz_analysis_function_get_var_byname(fcn, name);
if (v1) {
rz_analysis_var_rename(v1, newname, true);
} else {
eprintf("Cant find var by name\n");
return false;
}
} else {
eprintf("afv: Cannot find function in 0x%08" PFMT64x "\n", core->offset);
rz_analysis_op_free(op);
return false;
}
rz_analysis_op_free(op);
return true;
}

104
librz/core/cdebug.c
View file

@ -199,6 +199,38 @@ RZ_IPI void rz_core_debug_regs2flags(RzCore *core, int bits) {
} }
} }
RZ_IPI bool rz_core_debug_reg_set(RzCore *core, const char *regname, ut64 val, const char *strval) {
int bits = (core->dbg->bits & RZ_SYS_BITS_64) ? 64 : 32;
RzRegItem *r = rz_reg_get(core->dbg->reg, regname, -1);
if (!r) {
int role = rz_reg_get_name_idx(regname);
if (role != -1) {
const char *alias = rz_reg_get_name(core->dbg->reg, role);
if (alias) {
r = rz_reg_get(core->dbg->reg, alias, -1);
}
}
}
if (!r) {
eprintf("Unknown register '%s'\n", regname);
return false;
}
if (r->flags) {
if (strval) {
rz_reg_set_bvalue(core->dbg->reg, r, strval);
} else {
eprintf("String value cannot be NULL\n");
return false;
}
} else {
rz_reg_set_value(core->dbg->reg, r, val);
}
rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_ALL, true);
rz_core_debug_regs2flags(core, bits);
return true;
}
RZ_IPI bool rz_core_debug_reg_list(RzCore *core, int type, int size, PJ *pj, int rad, const char *use_color) { RZ_IPI bool rz_core_debug_reg_list(RzCore *core, int type, int size, PJ *pj, int rad, const char *use_color) {
RzDebug *dbg = core->dbg; RzDebug *dbg = core->dbg;
int delta, cols, n = 0; int delta, cols, n = 0;
@ -407,3 +439,75 @@ beach:
} }
return n != 0; return n != 0;
} }
HEAPTYPE(ut64);
static int regcmp(const void *a, const void *b) {
const ut64 *A = (const ut64 *)a;
const ut64 *B = (const ut64 *)b;
if (*A > *B) {
return 1;
}
if (*A == *B) {
return 0;
}
return -1;
}
static bool regcb(void *u, const ut64 k, const void *v) {
RzList *sorted = (RzList *)u;
ut64 *n = ut64_new(k);
rz_list_add_sorted(sorted, n, regcmp);
return true;
}
RZ_API void rz_core_debug_ri(RzCore *core, RzReg *reg, int mode) {
const RzList *list = rz_reg_get_list(reg, RZ_REG_TYPE_GPR);
RzListIter *iter;
RzRegItem *r;
HtUP *db = ht_up_new0();
rz_list_foreach (list, iter, r) {
if (r->size != core->rasm->bits) {
continue;
}
ut64 value = rz_reg_get_value(reg, r);
RzList *list = ht_up_find(db, value, NULL);
if (!list) {
list = rz_list_newf(NULL);
ht_up_update(db, value, list);
}
rz_list_append(list, r->name);
}
RzList *sorted = rz_list_newf(free);
ht_up_foreach(db, regcb, sorted);
ut64 *addr;
rz_list_foreach (sorted, iter, addr) {
int rwx = 0;
RzDebugMap *map = rz_debug_map_get(core->dbg, *addr);
if (map) {
rwx = map->perm;
}
rz_cons_printf(" %s ", rz_str_rwx_i(rwx));
rz_cons_printf("0x%08" PFMT64x " ", *addr);
RzList *list = ht_up_find(db, *addr, NULL);
if (list) {
RzListIter *iter;
const char *r;
rz_cons_strcat(Color_YELLOW);
rz_list_foreach (list, iter, r) {
rz_cons_printf(" %s", r);
}
rz_cons_strcat(Color_RESET);
char *rrstr = rz_core_analysis_hasrefs(core, *addr, true);
if (rrstr && *rrstr && strchr(rrstr, 'R')) {
rz_cons_printf(" ;%s" Color_RESET, rrstr);
}
rz_cons_newline();
}
}
rz_list_free(sorted);
ht_up_free(db);
}

84
librz/core/cmd_analysis.c
View file

@ -7,6 +7,8 @@
#define MAX_SCAN_SIZE 0x7ffffff #define MAX_SCAN_SIZE 0x7ffffff
HEAPTYPE(ut64);
static const char *help_msg_a[] = { static const char *help_msg_a[] = {
"Usage:", "a", "[abdefFghoprxstc] [...]", "Usage:", "a", "[abdefFghoprxstc] [...]",
"a", "", "alias for aai - analysis information", "a", "", "alias for aai - analysis information",
@ -1213,43 +1215,19 @@ static int var_cmd(RzCore *core, const char *str) {
} }
case 'n': // "afvn" case 'n': // "afvn"
if (str[1]) { if (str[1]) {
RzAnalysisOp *op = rz_core_analysis_op(core, core->offset, RZ_ANALYSIS_OP_MASK_BASIC);
const char *new_name = rz_str_trim_head_ro(strchr(ostr, ' ')); const char *new_name = rz_str_trim_head_ro(strchr(ostr, ' '));
if (!new_name) { if (!new_name) {
rz_analysis_op_free(op);
free(ostr); free(ostr);
return false; return false;
} }
char *old_name = strchr(new_name, ' '); char *old_name = strchr(new_name, ' ');
if (!old_name) { if (old_name) {
RzAnalysisVar *var = op ? rz_analysis_get_used_function_var(core->analysis, op->addr) : NULL;
if (var) {
old_name = var->name;
} else {
eprintf("Cannot find var @ 0x%08" PFMT64x "\n", core->offset);
rz_analysis_op_free(op);
free(ostr);
return false;
}
} else {
*old_name++ = 0; *old_name++ = 0;
rz_str_trim(old_name); rz_str_trim(old_name);
} }
if (fcn) { bool result = rz_core_analysis_var_rename(core, old_name, new_name);
v1 = rz_analysis_function_get_var_byname(fcn, old_name);
if (v1) {
rz_analysis_var_rename(v1, new_name, true);
} else {
eprintf("Cant find var by name\n");
}
} else {
eprintf("afv: Cannot find function in 0x%08" PFMT64x "\n", core->offset);
rz_analysis_op_free(op);
free(ostr);
return false;
}
rz_analysis_op_free(op);
free(ostr); free(ostr);
return result;
} else { } else {
RzListIter *iter; RzListIter *iter;
RzAnalysisVar *v; RzAnalysisVar *v;
@ -3999,28 +3977,6 @@ static void __analysis_reg_list(RzCore *core, int type, int bits, char mode) {
core->dbg->reg = hack; core->dbg->reg = hack;
} }
RZ_IPI int rz_core_analysis_set_reg(RzCore *core, const char *regname, ut64 val) {
int bits = (core->analysis->bits & RZ_SYS_BITS_64) ? 64 : 32;
RzRegItem *r = rz_reg_get(core->dbg->reg, regname, -1);
if (!r) {
int role = rz_reg_get_name_idx(regname);
if (role != -1) {
const char *alias = rz_reg_get_name(core->dbg->reg, role);
if (alias) {
r = rz_reg_get(core->dbg->reg, alias, -1);
}
}
}
if (!r) {
eprintf("ar: Unknown register '%s'\n", regname);
return -1;
}
rz_reg_set_value(core->dbg->reg, r, val);
rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_ALL, true);
rz_core_debug_regs2flags(core, bits);
return 0;
}
// XXX dup from drp :OOO // XXX dup from drp :OOO
void cmd_analysis_reg(RzCore *core, const char *str) { void cmd_analysis_reg(RzCore *core, const char *str) {
if (0) { if (0) {
@ -5596,36 +5552,6 @@ static void __analysis_esil_function(RzCore *core, ut64 addr) {
rz_analysis_esil_free(core->analysis->esil); rz_analysis_esil_free(core->analysis->esil);
} }
RZ_IPI void rz_core_analysis_esil_init(RzCore *core) {
RzAnalysisEsil *esil = core->analysis->esil;
unsigned int addrsize = rz_config_get_i(core->config, "esil.addr.size");
int stacksize = rz_config_get_i(core->config, "esil.stack.depth");
int iotrap = rz_config_get_i(core->config, "esil.iotrap");
int romem = rz_config_get_i(core->config, "esil.romem");
int stats = rz_config_get_i(core->config, "esil.stats");
int noNULL = rz_config_get_i(core->config, "esil.noNULL");
rz_analysis_esil_free(esil);
// reinitialize
const char *pc = rz_reg_get_name(core->analysis->reg, RZ_REG_NAME_PC);
if (pc && rz_reg_getv(core->analysis->reg, pc) == 0LL) {
rz_core_analysis_set_reg(core, "PC", core->offset);
}
if (!(esil = core->analysis->esil = rz_analysis_esil_new(stacksize, iotrap, addrsize))) {
return;
}
rz_analysis_esil_setup(esil, core->analysis, romem, stats, noNULL); // setup io
esil->verbose = (int)rz_config_get_i(core->config, "esil.verbose");
const char *s = rz_config_get(core->config, "cmd.esil.intr");
if (s) {
char *my = strdup(s);
if (my) {
rz_config_set(core->config, "cmd.esil.intr", my);
free(my);
}
}
}
static void cmd_analysis_esil(RzCore *core, const char *input) { static void cmd_analysis_esil(RzCore *core, const char *input) {
RzAnalysisEsil *esil = core->analysis->esil; RzAnalysisEsil *esil = core->analysis->esil;
ut64 addr = core->offset; ut64 addr = core->offset;

106
librz/core/cmd_debug.c
View file

@ -1809,78 +1809,6 @@ static int cmd_debug_map(RzCore *core, const char *input) {
#include "windows_heap.c" #include "windows_heap.c"
#endif #endif
HEAPTYPE(ut64);
static int regcmp(const void *a, const void *b) {
const ut64 *A = (const ut64 *)a;
const ut64 *B = (const ut64 *)b;
if (*A > *B) {
return 1;
}
if (*A == *B) {
return 0;
}
return -1;
}
static bool regcb(void *u, const ut64 k, const void *v) {
RzList *sorted = (RzList *)u;
ut64 *n = ut64_new(k);
rz_list_add_sorted(sorted, n, regcmp);
return true;
}
RZ_API void rz_core_debug_ri(RzCore *core, RzReg *reg, int mode) {
const RzList *list = rz_reg_get_list(reg, RZ_REG_TYPE_GPR);
RzListIter *iter;
RzRegItem *r;
HtUP *db = ht_up_new0();
rz_list_foreach (list, iter, r) {
if (r->size != core->rasm->bits) {
continue;
}
ut64 value = rz_reg_get_value(reg, r);
RzList *list = ht_up_find(db, value, NULL);
if (!list) {
list = rz_list_newf(NULL);
ht_up_update(db, value, list);
}
rz_list_append(list, r->name);
}
RzList *sorted = rz_list_newf(free);
ht_up_foreach(db, regcb, sorted);
ut64 *addr;
rz_list_foreach (sorted, iter, addr) {
int rwx = 0;
RzDebugMap *map = rz_debug_map_get(core->dbg, *addr);
if (map) {
rwx = map->perm;
}
rz_cons_printf(" %s ", rz_str_rwx_i(rwx));
rz_cons_printf("0x%08" PFMT64x " ", *addr);
RzList *list = ht_up_find(db, *addr, NULL);
if (list) {
RzListIter *iter;
const char *r;
rz_cons_strcat(Color_YELLOW);
rz_list_foreach (list, iter, r) {
rz_cons_printf(" %s", r);
}
rz_cons_strcat(Color_RESET);
char *rrstr = rz_core_analysis_hasrefs(core, *addr, true);
if (rrstr && *rrstr && strchr(rrstr, 'R')) {
rz_cons_printf(" ;%s" Color_RESET, rrstr);
}
rz_cons_newline();
}
}
rz_list_free(sorted);
ht_up_free(db);
}
static void foreach_reg_set_or_clear(RzCore *core, bool set) { static void foreach_reg_set_or_clear(RzCore *core, bool set) {
RzReg *reg = rz_config_get_i(core->config, "cfg.debug") RzReg *reg = rz_config_get_i(core->config, "cfg.debug")
? core->dbg->reg ? core->dbg->reg
@ -2899,35 +2827,11 @@ static void cmd_debug_reg(RzCore *core, const char *str) {
arg = strchr(str + 1, '='); arg = strchr(str + 1, '=');
if (arg) { if (arg) {
*arg = 0; *arg = 0;
char *string = rz_str_trim_dup(str + 1); char *ostr = rz_str_trim_dup(str + 1);
const char *regname = rz_reg_get_name(core->dbg->reg, rz_reg_get_name_idx(string)); char *regname = rz_str_trim_nc(ostr);
if (!regname) { ut64 regval = rz_num_math(core->num, arg + 1);
regname = string; rz_core_debug_reg_set(core, regname, regval, ostr);
} free(ostr);
r = rz_reg_get(core->dbg->reg, regname, -1); //RZ_REG_TYPE_GPR);
if (r) {
if (r->flags) {
rz_cons_printf("0x%08" PFMT64x " ->",
rz_reg_get_value(core->dbg->reg, r));
rz_reg_set_bvalue(core->dbg->reg, r, arg + 1);
rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_ALL, true);
rz_cons_printf("0x%08" PFMT64x "\n",
rz_reg_get_value(core->dbg->reg, r));
} else {
rz_cons_printf("0x%08" PFMT64x " ->",
rz_reg_get_value(core->dbg->reg, r));
rz_reg_set_value(core->dbg->reg, r,
rz_num_math(core->num, arg + 1));
rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_ALL, true);
rz_cons_printf("0x%08" PFMT64x "\n",
rz_reg_get_value(core->dbg->reg, r));
}
} else {
eprintf("unknown register '%s'\n", string);
}
free(string);
// update flags here
rz_core_debug_regs2flags(core, bits);
return; return;
} }

6
librz/core/core_private.h
View file

@ -6,8 +6,12 @@
RZ_IPI int rz_core_analysis_set_reg(RzCore *core, const char *regname, ut64 val); RZ_IPI int rz_core_analysis_set_reg(RzCore *core, const char *regname, ut64 val);
RZ_IPI void rz_core_analysis_esil_init(RzCore *core); RZ_IPI void rz_core_analysis_esil_init(RzCore *core);
RZ_IPI bool rz_core_analysis_var_rename(RzCore *core, const char *name, const char *newname);
/* cdebug.c */
RZ_IPI bool rz_core_debug_reg_set(RzCore *core, const char *regname, ut64 val, const char *strval);
RZ_IPI bool rz_core_debug_reg_list(RzCore *core, int type, int size, PJ *pj, int rad, const char *use_color); RZ_IPI bool rz_core_debug_reg_list(RzCore *core, int type, int size, PJ *pj, int rad, const char *use_color);
RZ_IPI void rz_core_debug_regs2flags(RzCore *core, int bits); RZ_IPI void rz_core_debug_regs2flags(RzCore *core, int bits);
RZ_IPI void rz_core_regs2flags(RzCore *core); RZ_IPI void rz_core_regs2flags(RzCore *core);
#endif #endif

71
librz/core/visual.c
View file

@ -1325,7 +1325,7 @@ static void addComment(RzCore *core, ut64 addr) {
if (rz_cons_fgets(buf, sizeof(buf), 0, NULL) < 0) { if (rz_cons_fgets(buf, sizeof(buf), 0, NULL) < 0) {
buf[0] = '\0'; buf[0] = '\0';
} }
rz_core_cmdf(core, "\"CC %s\"@0x%08" PFMT64x, buf, addr); rz_meta_set_string(core->analysis, RZ_META_TYPE_COMMENT, addr, buf);
rz_core_visual_showcursor(core, false); rz_core_visual_showcursor(core, false);
rz_cons_set_raw(true); rz_cons_set_raw(true);
} }
@ -2524,9 +2524,9 @@ RZ_API int rz_core_visual_cmd(RzCore *core, const char *arg) {
break; break;
case '$': case '$':
if (core->print->cur_enabled) { if (core->print->cur_enabled) {
rz_core_cmdf(core, "dr PC=$$+%d", core->print->cur); rz_core_debug_reg_set(core, "PC", core->offset + core->print->cur, NULL);
} else { } else {
rz_core_cmd0(core, "dr PC=$$"); rz_core_debug_reg_set(core, "PC", core->offset, NULL);
} }
break; break;
case '@': case '@':
@ -2572,11 +2572,16 @@ RZ_API int rz_core_visual_cmd(RzCore *core, const char *arg) {
if (!strcmp(n, "-")) { if (!strcmp(n, "-")) {
rz_flag_unset_off(core->flags, core->offset + core->print->cur); rz_flag_unset_off(core->flags, core->offset + core->print->cur);
} else if (*n == '.') { } else if (*n == '.') {
if (n[1] == '-') { RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset + min, 0);
//unset if (fcn) {
rz_core_cmdf(core, "f.-%s@0x%" PFMT64x, n + 1, core->offset + min); if (n[1] == '-') {
// Unset the local label (flag)
rz_analysis_function_delete_label(fcn, n + 1);
} else {
rz_analysis_function_set_label(fcn, n + 1, core->offset + min);
}
} else { } else {
rz_core_cmdf(core, "f.%s@0x%" PFMT64x, n + 1, core->offset + min); eprintf("Cannot find function at 0x%08" PFMT64x "\n", core->offset + min);
} }
} else if (*n == '-') { } else if (*n == '-') {
if (*n) { if (*n) {
@ -2587,15 +2592,13 @@ RZ_API int rz_core_visual_cmd(RzCore *core, const char *arg) {
range = 1; range = 1;
} }
if (*n) { if (*n) {
rz_flag_set(core->flags, n, rz_flag_set(core->flags, n, core->offset + min, range);
core->offset + min, range);
} }
} }
} }
rz_cons_enable_mouse(mouse_state && rz_config_get_b(core->config, "scr.wheel")); rz_cons_enable_mouse(mouse_state && rz_config_get_b(core->config, "scr.wheel"));
}
rz_core_visual_showcursor(core, false); rz_core_visual_showcursor(core, false);
break; } break;
case ',': case ',':
visual_comma(core); visual_comma(core);
break; break;
@ -2771,25 +2774,21 @@ RZ_API int rz_core_visual_cmd(RzCore *core, const char *arg) {
visual_refresh(core); visual_refresh(core);
break; break;
case ' ': case ' ':
case 'V': case 'V': {
if (rz_config_get_b(core->config, "graph.web")) { RzAnalysisFunction *fun = rz_analysis_get_fcn_in(core->analysis, core->offset, RZ_ANALYSIS_FCN_TYPE_NULL);
rz_core_cmd0(core, "agv $$"); int ocolor = rz_config_get_i(core->config, "scr.color");
} else { if (!fun) {
RzAnalysisFunction *fun = rz_analysis_get_fcn_in(core->analysis, core->offset, RZ_ANALYSIS_FCN_TYPE_NULL); rz_cons_message("Not in a function. Type 'df' to define it here");
int ocolor = rz_config_get_i(core->config, "scr.color"); break;
if (!fun) { } else if (rz_list_empty(fun->bbs)) {
rz_cons_message("Not in a function. Type 'df' to define it here"); rz_cons_message("No basic blocks in this function. You may want to use 'afb+'.");
break; break;
} else if (rz_list_empty(fun->bbs)) {
rz_cons_message("No basic blocks in this function. You may want to use 'afb+'.");
break;
}
reset_print_cur(core->print);
eprintf("\rRendering graph...");
rz_core_visual_graph(core, NULL, NULL, true);
rz_config_set_i(core->config, "scr.color", ocolor);
} }
break; reset_print_cur(core->print);
eprintf("\rRendering graph...");
rz_core_visual_graph(core, NULL, NULL, true);
rz_config_set_i(core->config, "scr.color", ocolor);
} break;
case 'v': case 'v':
rz_core_visual_analysis(core, NULL); rz_core_visual_analysis(core, NULL);
break; break;
@ -3109,7 +3108,8 @@ RZ_API int rz_core_visual_cmd(RzCore *core, const char *arg) {
if (core->seltab) { if (core->seltab) {
const char *creg = core->dbg->creg; const char *creg = core->dbg->creg;
if (creg) { if (creg) {
rz_core_cmdf(core, "dr %s = %s-1\n", creg, creg); ut64 cregval = rz_debug_reg_get(core->dbg, creg);
rz_core_debug_reg_set(core, creg, cregval - 1, NULL);
} }
} else { } else {
int w = rz_config_get_i(core->config, "hex.cols"); int w = rz_config_get_i(core->config, "hex.cols");
@ -3137,7 +3137,8 @@ RZ_API int rz_core_visual_cmd(RzCore *core, const char *arg) {
if (core->seltab) { if (core->seltab) {
const char *creg = core->dbg->creg; const char *creg = core->dbg->creg;
if (creg) { if (creg) {
rz_core_cmdf(core, "dr %s = %s+1\n", creg, creg); ut64 cregval = rz_debug_reg_get(core->dbg, creg);
rz_core_debug_reg_set(core, creg, cregval + 1, NULL);
} }
} else { } else {
int w = rz_config_get_i(core->config, "hex.cols"); int w = rz_config_get_i(core->config, "hex.cols");
@ -3167,7 +3168,8 @@ RZ_API int rz_core_visual_cmd(RzCore *core, const char *arg) {
const char *creg = core->dbg->creg; const char *creg = core->dbg->creg;
if (creg) { if (creg) {
int delta = core->rasm->bits / 8; int delta = core->rasm->bits / 8;
rz_core_cmdf(core, "dr %s = %s-%d\n", creg, creg, delta); ut64 cregval = rz_debug_reg_get(core->dbg, creg);
rz_core_debug_reg_set(core, creg, cregval - delta, NULL);
} }
} else { } else {
int w = rz_config_get_i(core->config, "hex.cols"); int w = rz_config_get_i(core->config, "hex.cols");
@ -3203,7 +3205,8 @@ RZ_API int rz_core_visual_cmd(RzCore *core, const char *arg) {
const char *creg = core->dbg->creg; const char *creg = core->dbg->creg;
if (creg) { if (creg) {
int delta = core->rasm->bits / 8; int delta = core->rasm->bits / 8;
rz_core_cmdf(core, "dr %s = %s+%d\n", creg, creg, delta); ut64 cregval = rz_debug_reg_get(core->dbg, creg);
rz_core_debug_reg_set(core, creg, cregval + delta, NULL);
} }
} else { } else {
int w = rz_config_get_i(core->config, "hex.cols"); int w = rz_config_get_i(core->config, "hex.cols");
@ -3211,7 +3214,7 @@ RZ_API int rz_core_visual_cmd(RzCore *core, const char *arg) {
rz_config_get_i(core->config, "stack.size") + w); rz_config_get_i(core->config, "stack.size") + w);
} }
} else { } else {
rz_core_cmdf(core, "dr PC=0x%08" PFMT64x, core->offset + core->print->cur); rz_core_debug_reg_set(core, "PC", core->offset + core->print->cur, NULL);
} }
} else if (!autoblocksize) { } else if (!autoblocksize) {
rz_core_block_size(core, core->blocksize + cols); rz_core_block_size(core, core->blocksize + cols);

32
librz/core/vmenus.c
View file

@ -1,8 +1,11 @@
// SPDX-License-Identifier: LGPL-3.0-only // SPDX-License-Identifier: LGPL-3.0-only
#include <string.h>
#include <rz_core.h> #include <rz_core.h>
#include <rz_util.h> #include <rz_util.h>
#include <string.h>
#include "core_private.h"
#define MAX_FORMAT 3 #define MAX_FORMAT 3
@ -1229,7 +1232,8 @@ RZ_API int rz_core_visual_classes(RzCore *core) {
case 'p': case 'p':
if (mode == 'm' && mur) { if (mode == 'm' && mur) {
rz_core_seek(core, mur->vaddr, true); rz_core_seek(core, mur->vaddr, true);
rz_core_cmd0(core, "af;pdf~.."); rz_core_analysis_function_add(core, NULL, core->offset, false);
rz_core_cmd0(core, "pdf~..");
} }
break; break;
case 'm': // methods case 'm': // methods
@ -1745,8 +1749,7 @@ RZ_API int rz_core_visual_view_rop(RzCore *core) {
rz_line_set_prompt("comment: "); rz_line_set_prompt("comment: ");
const char *line = rz_line_readline(); const char *line = rz_line_readline();
if (line && *line) { if (line && *line) {
// XXX code injection bug here rz_meta_set_string(core->analysis, RZ_META_TYPE_COMMENT, addr + delta, line);
rz_core_cmdf(core, "CC %s @ 0x%08" PFMT64x, line, addr + delta);
} }
} break; } break;
case '.': case '.':
@ -2229,7 +2232,7 @@ RZ_API int rz_core_visual_comments(RzCore *core) {
case ' ': case ' ':
case '\r': case '\r':
case '\n': case '\n':
rz_core_cmdf(core, "s 0x%" PFMT64x, from); rz_core_seek_and_save(core, from, true);
RZ_FREE(p); RZ_FREE(p);
return true; return true;
case 'Q': case 'Q':
@ -2517,7 +2520,7 @@ static void variable_rename(RzCore *core, ut64 addr, int vindex, const char *nam
rz_list_foreach (list, iter, var) { rz_list_foreach (list, iter, var) {
if (i == vindex) { if (i == vindex) {
rz_core_seek(core, addr, false); rz_core_seek(core, addr, false);
rz_core_cmd_strf(core, "afvn %s %s", name, var->name); rz_core_analysis_var_rename(core, name, var->name);
rz_core_seek(core, a_tmp, false); rz_core_seek(core, a_tmp, false);
break; break;
} }
@ -2881,7 +2884,7 @@ RZ_API void rz_core_visual_debugtraces(RzCore *core, const char *input) {
rz_core_cmdf(core, ".dte %d", i); rz_core_cmdf(core, ".dte %d", i);
} }
rz_core_cmd0(core, "x 64@r:SP"); rz_core_cmd0(core, "x 64@r:SP");
rz_core_cmd0(core, "dri"); rz_core_debug_ri(core, core->dbg->reg, 0);
// limit by rows here // limit by rows here
//int rows = rz_cons_get_size (NULL); //int rows = rz_cons_get_size (NULL);
rz_core_cmdf(core, "dtd %d", delta); rz_core_cmdf(core, "dtd %d", delta);
@ -3045,7 +3048,12 @@ RZ_API void rz_core_visual_analysis(RzCore *core, const char *input) {
case 'a': case 'a':
switch (level) { switch (level) {
case 0: case 0:
rz_core_cmd0(core, "af-$$;af"); // reanalize // Remove the old function information
rz_core_analysis_undefine(core, core->offset);
rz_analysis_fcn_del_locs(core->analysis, core->offset);
rz_analysis_fcn_del(core->analysis, core->offset);
// Reanalyze and create function from scratch
rz_core_analysis_function_add(core, NULL, core->offset, false);
break; break;
case 1: { case 1: {
eprintf("Select variable source ('r'egister, 's'tackptr or 'b'aseptr): "); eprintf("Select variable source ('r'egister, 's'tackptr or 'b'aseptr): ");
@ -3127,7 +3135,10 @@ RZ_API void rz_core_visual_analysis(RzCore *core, const char *input) {
case '-': case '-':
switch (level) { switch (level) {
case 0: case 0:
rz_core_cmdf(core, "af- 0x%" PFMT64x, addr); // Remove the old function information
rz_core_analysis_undefine(core, addr);
rz_analysis_fcn_del_locs(core->analysis, addr);
rz_analysis_fcn_del(core->analysis, addr);
break; break;
} }
break; break;
@ -3701,7 +3712,8 @@ onemoretime:
rz_analysis_function_resize(fcn, core->offset - fcn->addr); rz_analysis_function_resize(fcn, core->offset - fcn->addr);
} }
rz_cons_break_push(NULL, NULL); rz_cons_break_push(NULL, NULL);
rz_core_cmdf(core, "af @ 0x%08" PFMT64x, off); // required for thumb autodetection // required for thumb autodetection
rz_core_analysis_function_add(core, NULL, off, false);
rz_cons_break_pop(); rz_cons_break_pop();
} break; } break;
case 'v': { case 'v': {

1
librz/include/rz_core.h
View file

@ -546,6 +546,7 @@ RZ_API ut32 rz_core_file_cur_fd(RzCore *core);
RZ_API bool rz_core_debug_step_one(RzCore *core, int times); RZ_API bool rz_core_debug_step_one(RzCore *core, int times);
RZ_API bool rz_core_debug_continue_until(RzCore *core, ut64 addr, ut64 to); RZ_API bool rz_core_debug_continue_until(RzCore *core, ut64 addr, ut64 to);
RZ_API void rz_core_debug_ri(RzCore *core, RzReg *reg, int mode);
RZ_API void rz_core_debug_rr(RzCore *core, RzReg *reg, int mode); RZ_API void rz_core_debug_rr(RzCore *core, RzReg *reg, int mode);
RZ_API void rz_core_debug_set_register_flags(RzCore *core); RZ_API void rz_core_debug_set_register_flags(RzCore *core);
RZ_API void rz_core_debug_clear_register_flags(RzCore *core); RZ_API void rz_core_debug_clear_register_flags(RzCore *core);