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

Move 'afv' commands to newshell

Browse source
This commit is contained in:
Riccardo Schirone 2021-02-19 11:01:17 +01:00 committed by Anton Kochkov
parent e52fa69571
commit e283f5098e
8 changed files with 1100 additions and 1 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
librz/core/canalysis.c
View file

@ -7239,4 +7239,4 @@ RZ_IPI void rz_core_analysis_function_until(RzCore *core, ut64 addr_end) {
rz_config_set_i(core->config, "analysis.from", a);
rz_config_set_i(core->config, "analysis.to", b);
rz_config_set(core->config, "analysis.limits", c ? c : "");
}
}

408
librz/core/cmd_analysis.c
View file

@ -9544,4 +9544,412 @@ RZ_IPI RzCmdStatus rz_analysis_function_until_handler(RzCore *core, int argc, co
}
rz_core_analysis_function_until(core, addr_end);
return RZ_CMD_STATUS_OK;
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_handler(RzCore *core, int argc, const char **argv, RzOutputMode mode) {
RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, -1);
if (!fcn) {
eprintf("Cannot find function in 0x%08" PFMT64x "\n", core->offset);
return RZ_CMD_STATUS_ERROR;
}
PJ *pj = NULL;
const char *bp = NULL;
RzList *list;
RzListIter *iter;
RzAnalysisVar *var;
switch (mode) {
case RZ_OUTPUT_MODE_STANDARD:
rz_analysis_var_list_show(core->analysis, fcn, RZ_ANALYSIS_VAR_KIND_SPV, '\0', NULL);
rz_analysis_var_list_show(core->analysis, fcn, RZ_ANALYSIS_VAR_KIND_BPV, '\0', NULL);
rz_analysis_var_list_show(core->analysis, fcn, RZ_ANALYSIS_VAR_KIND_REG, '\0', NULL);
break;
case RZ_OUTPUT_MODE_RIZIN:
bp = rz_reg_get_name(core->analysis->reg, RZ_REG_NAME_BP);
rz_cons_printf("f-fcnvar*\n");
list = rz_analysis_var_all_list(core->analysis, fcn);
rz_list_foreach (list, iter, var) {
rz_cons_printf("f fcnvar.%s @ %s%s%d\n", var->name, bp,
var->delta >= 0 ? "+" : "", var->delta);
}
break;
case RZ_OUTPUT_MODE_JSON:
pj = rz_core_pj_new(core);
if (!pj) {
return RZ_CMD_STATUS_ERROR;
}
pj_o(pj);
pj_k(pj, "sp");
rz_analysis_var_list_show(core->analysis, fcn, RZ_ANALYSIS_VAR_KIND_SPV, 'j', pj);
pj_k(pj, "bp");
rz_analysis_var_list_show(core->analysis, fcn, RZ_ANALYSIS_VAR_KIND_BPV, 'j', pj);
pj_k(pj, "reg");
rz_analysis_var_list_show(core->analysis, fcn, RZ_ANALYSIS_VAR_KIND_REG, 'j', pj);
pj_end(pj);
rz_cons_println(pj_string(pj));
pj_free(pj);
break;
default:
rz_return_val_if_reached(RZ_CMD_STATUS_ERROR);
}
return RZ_CMD_STATUS_OK;
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_dis_refs_handler(RzCore *core, int argc, const char **argv) {
RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, -1);
if (!fcn) {
eprintf("Cannot find function in 0x%08" PFMT64x "\n", core->offset);
return RZ_CMD_STATUS_ERROR;
}
ut64 oaddr = core->offset;
RzListIter *iter;
RzAnalysisVar *var;
RzList *list = rz_analysis_var_all_list(core->analysis, fcn);
rz_list_foreach (list, iter, var) {
rz_cons_printf("* %s\n", var->name);
RzAnalysisVarAccess *acc;
rz_vector_foreach(&var->accesses, acc) {
if (!(acc->type & RZ_ANALYSIS_VAR_ACCESS_TYPE_READ)) {
continue;
}
rz_cons_printf("R 0x%" PFMT64x " ", fcn->addr + acc->offset);
rz_core_seek(core, fcn->addr + acc->offset, 1);
rz_core_print_disasm_instructions(core, 0, 1);
}
rz_vector_foreach(&var->accesses, acc) {
if (!(acc->type & RZ_ANALYSIS_VAR_ACCESS_TYPE_WRITE)) {
continue;
}
rz_cons_printf("W 0x%" PFMT64x " ", fcn->addr + acc->offset);
rz_core_seek(core, fcn->addr + acc->offset, 1);
rz_core_print_disasm_instructions(core, 0, 1);
}
}
rz_core_seek(core, oaddr, 0);
rz_list_free(list);
return RZ_CMD_STATUS_OK;
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_del_handler(RzCore *core, int argc, const char **argv) {
RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, -1);
if (!fcn) {
eprintf("Cannot find function in 0x%08" PFMT64x "\n", core->offset);
return RZ_CMD_STATUS_ERROR;
}
function_delete_var_cmd(core, fcn, RZ_ANALYSIS_VAR_KIND_SPV, argv[1]);
function_delete_var_cmd(core, fcn, RZ_ANALYSIS_VAR_KIND_BPV, argv[1]);
function_delete_var_cmd(core, fcn, RZ_ANALYSIS_VAR_KIND_REG, argv[1]);
return RZ_CMD_STATUS_OK;
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_detect_handler(RzCore *core, int argc, const char **argv) {
RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, -1);
if (!fcn) {
eprintf("Cannot find function in 0x%08" PFMT64x "\n", core->offset);
return RZ_CMD_STATUS_ERROR;
}
rz_analysis_function_delete_all_vars(fcn);
rz_core_recover_vars(core, fcn, false);
return RZ_CMD_STATUS_OK;
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_display_handler(RzCore *core, int argc, const char **argv) {
RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, -1);
if (!fcn) {
eprintf("Cannot find function in 0x%08" PFMT64x "\n", core->offset);
return RZ_CMD_STATUS_ERROR;
}
RzAnalysisVar *v;
char *r = NULL;
switch (argc) {
case 1:
r = rz_core_analysis_all_vars_display(core, fcn, true);
break;
case 2:
v = rz_analysis_function_get_var_byname(fcn, argv[1]);
if (!v) {
eprintf("Cannot find variable '%s' in current function\n", argv[1]);
return RZ_CMD_STATUS_ERROR;
}
r = rz_core_analysis_var_display(core, v, true);
break;
default:
rz_return_val_if_reached(RZ_CMD_STATUS_ERROR);
}
rz_cons_print(r);
free(r);
return RZ_CMD_STATUS_OK;
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_stackframe_handler(RzCore *core, int argc, const char **argv) {
__cmd_afvf(core, NULL);
return RZ_CMD_STATUS_OK;
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_rename_handler(RzCore *core, int argc, const char **argv) {
const char *newname = argv[1];
const char *oldname = argv[2];
bool result = rz_core_analysis_var_rename(core, oldname, newname);
return result ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_OK;
}
static RzCmdStatus analysis_function_vars_accesses(RzCore *core, int access_type, const char *varname) {
RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, -1);
if (!fcn) {
eprintf("Cannot find function in 0x%08" PFMT64x "\n", core->offset);
return RZ_CMD_STATUS_ERROR;
}
if (!varname) {
RzList *list = rz_analysis_var_all_list(core->analysis, fcn);
RzListIter *iter;
RzAnalysisVar *var;
rz_list_foreach (list, iter, var) {
var_accesses_list(fcn, var, NULL, access_type, var->name);
}
rz_list_free(list);
} else {
RzAnalysisVar *var = rz_analysis_function_get_var_byname(fcn, varname);
if (!var) {
eprintf("Cannot find variable %s\n", varname);
return RZ_CMD_STATUS_ERROR;
}
var_accesses_list(fcn, var, NULL, access_type, var->name);
}
return RZ_CMD_STATUS_OK;
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_reads_handler(RzCore *core, int argc, const char **argv) {
return analysis_function_vars_accesses(core, RZ_ANALYSIS_VAR_ACCESS_TYPE_READ, argv[1]);
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_writes_handler(RzCore *core, int argc, const char **argv) {
return analysis_function_vars_accesses(core, RZ_ANALYSIS_VAR_ACCESS_TYPE_WRITE, argv[1]);
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_type_handler(RzCore *core, int argc, const char **argv) {
RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, -1);
if (!fcn) {
eprintf("Cannot find function in 0x%08" PFMT64x "\n", core->offset);
return RZ_CMD_STATUS_ERROR;
}
RzAnalysisVar *v = rz_analysis_function_get_var_byname(fcn, argv[1]);
if (!v) {
eprintf("Cannot find variable %s\n", argv[1]);
return RZ_CMD_STATUS_ERROR;
}
rz_analysis_var_set_type(v, argv[2]);
return RZ_CMD_STATUS_OK;
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_xrefs_handler(RzCore *core, int argc, const char **argv, RzOutputMode mode) {
RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, -1);
if (!fcn) {
eprintf("Cannot find function in 0x%08" PFMT64x "\n", core->offset);
return RZ_CMD_STATUS_ERROR;
}
PJ *pj = NULL;
if (mode == RZ_OUTPUT_MODE_JSON) {
pj = pj_new();
pj_o(pj);
pj_k(pj, "reads");
} else {
rz_cons_printf("afvR\n");
}
list_vars(core, fcn, pj, 'R', argv[1]);
if (mode == RZ_OUTPUT_MODE_JSON) {
pj_k(pj, "writes");
} else {
rz_cons_printf("afvW\n");
}
list_vars(core, fcn, pj, 'W', argv[1]);
if (mode == RZ_OUTPUT_MODE_JSON) {
pj_end(pj);
char *j = pj_drain(pj);
rz_cons_printf("%s\n", j);
free(j);
}
return RZ_CMD_STATUS_OK;
}
static RzCmdStatus analysis_function_vars_kind_list(RzCore *core, RzAnalysisFunction *fcn, RzAnalysisVarKind kind, RzOutputMode mode) {
PJ *pj = NULL;
if (mode == RZ_OUTPUT_MODE_JSON) {
pj = rz_core_pj_new(core);
if (!pj) {
return RZ_CMD_STATUS_ERROR;
}
}
int type = rz_output_mode_to_char(mode);
rz_analysis_var_list_show(core->analysis, fcn, kind, type, pj);
if (mode == RZ_OUTPUT_MODE_JSON) {
rz_cons_println(pj_string(pj));
pj_free(pj);
}
return RZ_CMD_STATUS_OK;
}
static RzCmdStatus analysis_function_vars_del(RzCore *core, RzAnalysisVarKind kind, const char *varname) {
RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, -1);
if (!fcn) {
eprintf("Cannot find function in 0x%08" PFMT64x "\n", core->offset);
return RZ_CMD_STATUS_ERROR;
}
function_delete_var_cmd(core, fcn, kind, varname);
return RZ_CMD_STATUS_OK;
}
static RzCmdStatus analysis_function_vars_getsetref(RzCore *core, int delta, ut64 addr, RzAnalysisVarKind kind, RzAnalysisVarAccessType access_type) {
RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, -1);
if (!fcn) {
eprintf("Cannot find function in 0x%08" PFMT64x "\n", core->offset);
return RZ_CMD_STATUS_ERROR;
}
RzAnalysisVar *var = rz_analysis_function_get_var(fcn, kind, delta);
if (!var) {
eprintf("Cannot find variable with delta %d\n", delta);
return RZ_CMD_STATUS_ERROR;
}
RzAnalysisOp *op = rz_core_analysis_op(core, addr, 0);
const char *ireg = op ? op->ireg : NULL;
if (kind == RZ_ANALYSIS_VAR_KIND_SPV) {
delta -= fcn->maxstack;
}
rz_analysis_var_set_access(var, ireg, addr, access_type, delta);
rz_analysis_op_free(op);
return RZ_CMD_STATUS_OK;
}
/// --------- Base pointer based variable handlers -------------
RZ_IPI RzCmdStatus rz_analysis_function_vars_bp_handler(RzCore *core, int argc, const char **argv, RzOutputMode mode) {
RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, -1);
if (!fcn) {
eprintf("Cannot find function in 0x%08" PFMT64x "\n", core->offset);
return RZ_CMD_STATUS_ERROR;
}
if (argc == 1) {
return analysis_function_vars_kind_list(core, fcn, RZ_ANALYSIS_VAR_KIND_BPV, mode);
} else {
const char *varname = argv[2];
const char *vartype = argc > 3 ? argv[3] : "int";
int delta = (int)rz_num_math(core->num, argv[1]) - fcn->bp_off;
bool isarg = delta > 0;
rz_analysis_function_set_var(fcn, delta, RZ_ANALYSIS_VAR_KIND_BPV, vartype, 4, isarg, varname);
}
return RZ_CMD_STATUS_OK;
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_bp_del_handler(RzCore *core, int argc, const char **argv) {
return analysis_function_vars_del(core, RZ_ANALYSIS_VAR_KIND_BPV, argv[1]);
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_bp_getref_handler(RzCore *core, int argc, const char **argv) {
int delta = (int)rz_num_math(core->num, argv[1]);
ut64 addr = rz_num_math(core->num, argv[2]);
return analysis_function_vars_getsetref(core, delta, addr, RZ_ANALYSIS_VAR_KIND_BPV, RZ_ANALYSIS_VAR_ACCESS_TYPE_READ);
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_bp_setref_handler(RzCore *core, int argc, const char **argv) {
int delta = (int)rz_num_math(core->num, argv[1]);
ut64 addr = rz_num_math(core->num, argv[2]);
return analysis_function_vars_getsetref(core, delta, addr, RZ_ANALYSIS_VAR_KIND_BPV, RZ_ANALYSIS_VAR_ACCESS_TYPE_WRITE);
}
/// --------- Register-based variable handlers -------------
RZ_IPI RzCmdStatus rz_analysis_function_vars_regs_handler(RzCore *core, int argc, const char **argv, RzOutputMode mode) {
RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, -1);
if (!fcn) {
eprintf("Cannot find function in 0x%08" PFMT64x "\n", core->offset);
return RZ_CMD_STATUS_ERROR;
}
if (argc == 1) {
return analysis_function_vars_kind_list(core, fcn, RZ_ANALYSIS_VAR_KIND_REG, mode);
} else {
const char *varname = argv[2];
const char *vartype = argc > 3 ? argv[3] : "int";
RzRegItem *i = rz_reg_get(core->analysis->reg, argv[1], -1);
if (!i) {
eprintf("Register not found");
return RZ_CMD_STATUS_ERROR;
}
int delta = i->index;
bool isarg = true;
rz_analysis_function_set_var(fcn, delta, RZ_ANALYSIS_VAR_KIND_REG, vartype, 4, isarg, varname);
}
return RZ_CMD_STATUS_OK;
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_regs_del_handler(RzCore *core, int argc, const char **argv) {
return analysis_function_vars_del(core, RZ_ANALYSIS_VAR_KIND_REG, argv[1]);
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_regs_getref_handler(RzCore *core, int argc, const char **argv) {
RzRegItem *i = rz_reg_get(core->analysis->reg, argv[1], -1);
if (!i) {
eprintf("Register not found");
return RZ_CMD_STATUS_ERROR;
}
int delta = i->index;
ut64 addr = rz_num_math(core->num, argv[2]);
return analysis_function_vars_getsetref(core, delta, addr, RZ_ANALYSIS_VAR_KIND_REG, RZ_ANALYSIS_VAR_ACCESS_TYPE_READ);
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_regs_setref_handler(RzCore *core, int argc, const char **argv) {
RzRegItem *i = rz_reg_get(core->analysis->reg, argv[1], -1);
if (!i) {
eprintf("Register not found");
return RZ_CMD_STATUS_ERROR;
}
int delta = i->index;
ut64 addr = rz_num_math(core->num, argv[2]);
return analysis_function_vars_getsetref(core, delta, addr, RZ_ANALYSIS_VAR_KIND_REG, RZ_ANALYSIS_VAR_ACCESS_TYPE_WRITE);
}
/// --------- Stack-based variable handlers -------------
RZ_IPI RzCmdStatus rz_analysis_function_vars_sp_handler(RzCore *core, int argc, const char **argv, RzOutputMode mode) {
RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, -1);
if (!fcn) {
eprintf("Cannot find function in 0x%08" PFMT64x "\n", core->offset);
return RZ_CMD_STATUS_ERROR;
}
if (argc == 1) {
return analysis_function_vars_kind_list(core, fcn, RZ_ANALYSIS_VAR_KIND_SPV, mode);
} else {
const char *varname = argv[2];
const char *vartype = argc > 3 ? argv[3] : "int";
int delta = (int)rz_num_math(core->num, argv[1]);
bool isarg = delta > fcn->maxstack;
rz_analysis_function_set_var(fcn, delta, RZ_ANALYSIS_VAR_KIND_SPV, vartype, 4, isarg, varname);
}
return RZ_CMD_STATUS_OK;
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_sp_del_handler(RzCore *core, int argc, const char **argv) {
return analysis_function_vars_del(core, RZ_ANALYSIS_VAR_KIND_SPV, argv[1]);
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_sp_getref_handler(RzCore *core, int argc, const char **argv) {
int delta = (int)rz_num_math(core->num, argv[1]);
ut64 addr = rz_num_math(core->num, argv[2]);
return analysis_function_vars_getsetref(core, delta, addr, RZ_ANALYSIS_VAR_KIND_SPV, RZ_ANALYSIS_VAR_ACCESS_TYPE_READ);
}
RZ_IPI RzCmdStatus rz_analysis_function_vars_sp_setref_handler(RzCore *core, int argc, const char **argv) {
int delta = (int)rz_num_math(core->num, argv[1]);
ut64 addr = rz_num_math(core->num, argv[2]);
return analysis_function_vars_getsetref(core, delta, addr, RZ_ANALYSIS_VAR_KIND_SPV, RZ_ANALYSIS_VAR_ACCESS_TYPE_WRITE);
}

10
librz/core/cmd_api.c
View file

@ -66,6 +66,16 @@ static const struct argv_modes_t {
{ "t", " (table mode)", RZ_OUTPUT_MODE_TABLE },
};
RZ_IPI int rz_output_mode_to_char(RzOutputMode mode) {
size_t i;
for (i = 0; i < RZ_ARRAY_SIZE(argv_modes); i++) {
if (argv_modes[i].mode == mode) {
return argv_modes[i].suffix[0];
}
}
return -1;
}
static int value = 0;
#define NCMDS (sizeof(cmd->cmds) / sizeof(*cmd->cmds))

456
librz/core/cmd_descs.c
View file

@ -62,6 +62,25 @@ static const RzCmdDescArg analysis_function_signature_args[2];
static const RzCmdDescArg analysis_function_signature_type_args[2];
static const RzCmdDescArg analysis_function_until_args[2];
static const RzCmdDescArg analysis_function_stacksz_args[2];
static const RzCmdDescArg analysis_function_vars_del_args[2];
static const RzCmdDescArg analysis_function_vars_display_args[2];
static const RzCmdDescArg analysis_function_vars_rename_args[3];
static const RzCmdDescArg analysis_function_vars_reads_args[2];
static const RzCmdDescArg analysis_function_vars_writes_args[2];
static const RzCmdDescArg analysis_function_vars_type_args[3];
static const RzCmdDescArg analysis_function_vars_xrefs_args[2];
static const RzCmdDescArg analysis_function_vars_bp_args[4];
static const RzCmdDescArg analysis_function_vars_bp_del_args[2];
static const RzCmdDescArg analysis_function_vars_bp_getref_args[3];
static const RzCmdDescArg analysis_function_vars_bp_setref_args[3];
static const RzCmdDescArg analysis_function_vars_regs_args[4];
static const RzCmdDescArg analysis_function_vars_regs_del_args[2];
static const RzCmdDescArg analysis_function_vars_regs_getref_args[3];
static const RzCmdDescArg analysis_function_vars_regs_setref_args[3];
static const RzCmdDescArg analysis_function_vars_sp_args[4];
static const RzCmdDescArg analysis_function_vars_sp_del_args[2];
static const RzCmdDescArg analysis_function_vars_sp_getref_args[3];
static const RzCmdDescArg analysis_function_vars_sp_setref_args[3];
static const RzCmdDescArg eval_getset_args[2];
static const RzCmdDescArg eval_list_args[2];
static const RzCmdDescArg eval_bool_invert_args[2];
@ -931,6 +950,378 @@ static const RzCmdDescHelp analysis_function_stacksz_help = {
.args = analysis_function_stacksz_args,
};
static const RzCmdDescHelp afv_help = {
.summary = "Manipulate arguments/variables in a function",
};
static const RzCmdDescArg analysis_function_vars_args[] = {
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_help = {
.summary = "List all variables and arguments of the current function",
.args = analysis_function_vars_args,
};
static const RzCmdDescArg analysis_function_vars_dis_refs_args[] = {
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_dis_refs_help = {
.summary = "List function variables and arguments with disasm refs",
.args = analysis_function_vars_dis_refs_args,
};
static const RzCmdDescArg analysis_function_vars_del_args[] = {
{
.name = "varname|*",
.type = RZ_CMD_ARG_TYPE_FCN_VAR,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_del_help = {
.summary = "Remove all variables/arguments or just the specified one",
.args = analysis_function_vars_del_args,
};
static const RzCmdDescArg analysis_function_vars_detect_args[] = {
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_detect_help = {
.summary = "Analyze function arguments/locals",
.args = analysis_function_vars_detect_args,
};
static const RzCmdDescArg analysis_function_vars_display_args[] = {
{
.name = "varname",
.type = RZ_CMD_ARG_TYPE_FCN_VAR,
.optional = true,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_display_help = {
.summary = "Display the value of arguments/variables",
.args = analysis_function_vars_display_args,
};
static const RzCmdDescArg analysis_function_vars_stackframe_args[] = {
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_stackframe_help = {
.summary = "Show BP relative stackframe variables",
.args = analysis_function_vars_stackframe_args,
};
static const RzCmdDescArg analysis_function_vars_rename_args[] = {
{
.name = "new_name",
.type = RZ_CMD_ARG_TYPE_STRING,
},
{
.name = "old_name",
.type = RZ_CMD_ARG_TYPE_FCN_VAR,
.optional = true,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_rename_help = {
.summary = "Rename argument/variable in current function",
.args = analysis_function_vars_rename_args,
};
static const RzCmdDescArg analysis_function_vars_reads_args[] = {
{
.name = "varname",
.type = RZ_CMD_ARG_TYPE_FCN_VAR,
.optional = true,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_reads_help = {
.summary = "List addresses where vars are accessed (READ)",
.args = analysis_function_vars_reads_args,
};
static const RzCmdDescArg analysis_function_vars_writes_args[] = {
{
.name = "varname",
.type = RZ_CMD_ARG_TYPE_FCN_VAR,
.optional = true,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_writes_help = {
.summary = "List addresses where vars are accessed (WRITE)",
.args = analysis_function_vars_writes_args,
};
static const RzCmdDescArg analysis_function_vars_type_args[] = {
{
.name = "varname",
.type = RZ_CMD_ARG_TYPE_FCN_VAR,
},
{
.name = "type",
.type = RZ_CMD_ARG_TYPE_STRING,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_type_help = {
.summary = "Change type for given argument/local",
.args = analysis_function_vars_type_args,
};
static const RzCmdDescArg analysis_function_vars_xrefs_args[] = {
{
.name = "varname",
.type = RZ_CMD_ARG_TYPE_FCN_VAR,
.optional = true,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_xrefs_help = {
.summary = "Show function variable xrefs (same as afvR+afvW)",
.args = analysis_function_vars_xrefs_args,
};
static const RzCmdDescHelp afvb_help = {
.summary = "Manipulate BP based arguments/locals",
};
static const RzCmdDescArg analysis_function_vars_bp_args[] = {
{
.name = "delta",
.type = RZ_CMD_ARG_TYPE_RZNUM,
.optional = true,
},
{
.name = "name",
.type = RZ_CMD_ARG_TYPE_STRING,
},
{
.name = "type",
.type = RZ_CMD_ARG_TYPE_STRING,
.optional = true,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_bp_help = {
.summary = "List base pointer based arguments and locals / Define a new one",
.args = analysis_function_vars_bp_args,
};
static const RzCmdDescArg analysis_function_vars_bp_del_args[] = {
{
.name = "varname",
.type = RZ_CMD_ARG_TYPE_FCN_VAR,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_bp_del_help = {
.summary = "Delete argument/local with the given name",
.args = analysis_function_vars_bp_del_args,
};
static const RzCmdDescArg analysis_function_vars_bp_getref_args[] = {
{
.name = "delta",
.type = RZ_CMD_ARG_TYPE_RZNUM,
},
{
.name = "addr",
.type = RZ_CMD_ARG_TYPE_RZNUM,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_bp_getref_help = {
.summary = "Define var get reference",
.args = analysis_function_vars_bp_getref_args,
};
static const RzCmdDescArg analysis_function_vars_bp_setref_args[] = {
{
.name = "delta",
.type = RZ_CMD_ARG_TYPE_RZNUM,
},
{
.name = "addr",
.type = RZ_CMD_ARG_TYPE_RZNUM,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_bp_setref_help = {
.summary = "Define var set reference",
.args = analysis_function_vars_bp_setref_args,
};
static const RzCmdDescHelp afvr_help = {
.summary = "Manipulate register-based arguments/locals",
};
static const RzCmdDescArg analysis_function_vars_regs_args[] = {
{
.name = "reg",
.type = RZ_CMD_ARG_TYPE_STRING,
.optional = true,
},
{
.name = "name",
.type = RZ_CMD_ARG_TYPE_STRING,
},
{
.name = "type",
.type = RZ_CMD_ARG_TYPE_STRING,
.optional = true,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_regs_help = {
.summary = "List register-based arguments and locals / Define a new one",
.args = analysis_function_vars_regs_args,
};
static const RzCmdDescArg analysis_function_vars_regs_del_args[] = {
{
.name = "varname",
.type = RZ_CMD_ARG_TYPE_FCN_VAR,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_regs_del_help = {
.summary = "Delete register-based argument/local with the given name",
.args = analysis_function_vars_regs_del_args,
};
static const RzCmdDescArg analysis_function_vars_regs_getref_args[] = {
{
.name = "reg",
.type = RZ_CMD_ARG_TYPE_STRING,
},
{
.name = "addr",
.type = RZ_CMD_ARG_TYPE_RZNUM,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_regs_getref_help = {
.summary = "Define register-based arguments and locals get references",
.args = analysis_function_vars_regs_getref_args,
};
static const RzCmdDescArg analysis_function_vars_regs_setref_args[] = {
{
.name = "reg",
.type = RZ_CMD_ARG_TYPE_STRING,
},
{
.name = "addr",
.type = RZ_CMD_ARG_TYPE_RZNUM,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_regs_setref_help = {
.summary = "Define register-based arguments and locals set references",
.args = analysis_function_vars_regs_setref_args,
};
static const RzCmdDescHelp afvs_help = {
.summary = "Manipulate SP based arguments/locals",
};
static const RzCmdDescArg analysis_function_vars_sp_args[] = {
{
.name = "delta",
.type = RZ_CMD_ARG_TYPE_RZNUM,
.optional = true,
},
{
.name = "name",
.type = RZ_CMD_ARG_TYPE_STRING,
},
{
.name = "type",
.type = RZ_CMD_ARG_TYPE_STRING,
.optional = true,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_sp_help = {
.summary = "List stack based arguments and locals / Define a new one",
.args = analysis_function_vars_sp_args,
};
static const RzCmdDescArg analysis_function_vars_sp_del_args[] = {
{
.name = "varname",
.type = RZ_CMD_ARG_TYPE_FCN_VAR,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_sp_del_help = {
.summary = "Delete argument/local with the given name",
.args = analysis_function_vars_sp_del_args,
};
static const RzCmdDescArg analysis_function_vars_sp_getref_args[] = {
{
.name = "delta",
.type = RZ_CMD_ARG_TYPE_RZNUM,
},
{
.name = "addr",
.type = RZ_CMD_ARG_TYPE_RZNUM,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_sp_getref_help = {
.summary = "Define var get reference",
.args = analysis_function_vars_sp_getref_args,
};
static const RzCmdDescArg analysis_function_vars_sp_setref_args[] = {
{
.name = "delta",
.type = RZ_CMD_ARG_TYPE_RZNUM,
},
{
.name = "addr",
.type = RZ_CMD_ARG_TYPE_RZNUM,
},
{ 0 },
};
static const RzCmdDescHelp analysis_function_vars_sp_setref_help = {
.summary = "Define var set reference",
.args = analysis_function_vars_sp_setref_args,
};
static const RzCmdDescHelp cmd_bsize_help = {
.summary = "Display or change the block size",
};
@ -2799,6 +3190,71 @@ RZ_IPI void newshell_cmddescs_init(RzCore *core) {
RzCmdDesc *analysis_function_stacksz_cd = rz_cmd_desc_argv_new(core->rcmd, cmd_analysis_fcn_cd, "afS", rz_analysis_function_stacksz_handler, &analysis_function_stacksz_help);
rz_warn_if_fail(analysis_function_stacksz_cd);
RzCmdDesc *afv_cd = rz_cmd_desc_group_modes_new(core->rcmd, cmd_analysis_fcn_cd, "afv", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON | RZ_OUTPUT_MODE_RIZIN, rz_analysis_function_vars_handler, &analysis_function_vars_help, &afv_help);
rz_warn_if_fail(afv_cd);
RzCmdDesc *analysis_function_vars_dis_refs_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afv=", rz_analysis_function_vars_dis_refs_handler, &analysis_function_vars_dis_refs_help);
rz_warn_if_fail(analysis_function_vars_dis_refs_cd);
RzCmdDesc *analysis_function_vars_del_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afv-", rz_analysis_function_vars_del_handler, &analysis_function_vars_del_help);
rz_warn_if_fail(analysis_function_vars_del_cd);
RzCmdDesc *analysis_function_vars_detect_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afva", rz_analysis_function_vars_detect_handler, &analysis_function_vars_detect_help);
rz_warn_if_fail(analysis_function_vars_detect_cd);
RzCmdDesc *analysis_function_vars_display_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afvd", rz_analysis_function_vars_display_handler, &analysis_function_vars_display_help);
rz_warn_if_fail(analysis_function_vars_display_cd);
RzCmdDesc *analysis_function_vars_stackframe_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afvf", rz_analysis_function_vars_stackframe_handler, &analysis_function_vars_stackframe_help);
rz_warn_if_fail(analysis_function_vars_stackframe_cd);
RzCmdDesc *analysis_function_vars_rename_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afvn", rz_analysis_function_vars_rename_handler, &analysis_function_vars_rename_help);
rz_warn_if_fail(analysis_function_vars_rename_cd);
RzCmdDesc *analysis_function_vars_reads_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afvR", rz_analysis_function_vars_reads_handler, &analysis_function_vars_reads_help);
rz_warn_if_fail(analysis_function_vars_reads_cd);
RzCmdDesc *analysis_function_vars_writes_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afvW", rz_analysis_function_vars_writes_handler, &analysis_function_vars_writes_help);
rz_warn_if_fail(analysis_function_vars_writes_cd);
RzCmdDesc *analysis_function_vars_type_cd = rz_cmd_desc_argv_new(core->rcmd, afv_cd, "afvt", rz_analysis_function_vars_type_handler, &analysis_function_vars_type_help);
rz_warn_if_fail(analysis_function_vars_type_cd);
RzCmdDesc *analysis_function_vars_xrefs_cd = rz_cmd_desc_argv_modes_new(core->rcmd, afv_cd, "afvx", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_JSON, rz_analysis_function_vars_xrefs_handler, &analysis_function_vars_xrefs_help);
rz_warn_if_fail(analysis_function_vars_xrefs_cd);
RzCmdDesc *afvb_cd = rz_cmd_desc_group_modes_new(core->rcmd, afv_cd, "afvb", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON, rz_analysis_function_vars_bp_handler, &analysis_function_vars_bp_help, &afvb_help);
rz_warn_if_fail(afvb_cd);
RzCmdDesc *analysis_function_vars_bp_del_cd = rz_cmd_desc_argv_new(core->rcmd, afvb_cd, "afvb-", rz_analysis_function_vars_bp_del_handler, &analysis_function_vars_bp_del_help);
rz_warn_if_fail(analysis_function_vars_bp_del_cd);
RzCmdDesc *analysis_function_vars_bp_getref_cd = rz_cmd_desc_argv_new(core->rcmd, afvb_cd, "afvbg", rz_analysis_function_vars_bp_getref_handler, &analysis_function_vars_bp_getref_help);
rz_warn_if_fail(analysis_function_vars_bp_getref_cd);
RzCmdDesc *analysis_function_vars_bp_setref_cd = rz_cmd_desc_argv_new(core->rcmd, afvb_cd, "afvbs", rz_analysis_function_vars_bp_setref_handler, &analysis_function_vars_bp_setref_help);
rz_warn_if_fail(analysis_function_vars_bp_setref_cd);
RzCmdDesc *afvr_cd = rz_cmd_desc_group_modes_new(core->rcmd, afv_cd, "afvr", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON, rz_analysis_function_vars_regs_handler, &analysis_function_vars_regs_help, &afvr_help);
rz_warn_if_fail(afvr_cd);
RzCmdDesc *analysis_function_vars_regs_del_cd = rz_cmd_desc_argv_new(core->rcmd, afvr_cd, "afvr-", rz_analysis_function_vars_regs_del_handler, &analysis_function_vars_regs_del_help);
rz_warn_if_fail(analysis_function_vars_regs_del_cd);
RzCmdDesc *analysis_function_vars_regs_getref_cd = rz_cmd_desc_argv_new(core->rcmd, afvr_cd, "afvrg", rz_analysis_function_vars_regs_getref_handler, &analysis_function_vars_regs_getref_help);
rz_warn_if_fail(analysis_function_vars_regs_getref_cd);
RzCmdDesc *analysis_function_vars_regs_setref_cd = rz_cmd_desc_argv_new(core->rcmd, afvr_cd, "afvrs", rz_analysis_function_vars_regs_setref_handler, &analysis_function_vars_regs_setref_help);
rz_warn_if_fail(analysis_function_vars_regs_setref_cd);
RzCmdDesc *afvs_cd = rz_cmd_desc_group_modes_new(core->rcmd, afv_cd, "afvs", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN | RZ_OUTPUT_MODE_JSON, rz_analysis_function_vars_sp_handler, &analysis_function_vars_sp_help, &afvs_help);
rz_warn_if_fail(afvs_cd);
RzCmdDesc *analysis_function_vars_sp_del_cd = rz_cmd_desc_argv_new(core->rcmd, afvs_cd, "afvs-", rz_analysis_function_vars_sp_del_handler, &analysis_function_vars_sp_del_help);
rz_warn_if_fail(analysis_function_vars_sp_del_cd);
RzCmdDesc *analysis_function_vars_sp_getref_cd = rz_cmd_desc_argv_new(core->rcmd, afvs_cd, "afvsg", rz_analysis_function_vars_sp_getref_handler, &analysis_function_vars_sp_getref_help);
rz_warn_if_fail(analysis_function_vars_sp_getref_cd);
RzCmdDesc *analysis_function_vars_sp_setref_cd = rz_cmd_desc_argv_new(core->rcmd, afvs_cd, "afvss", rz_analysis_function_vars_sp_setref_handler, &analysis_function_vars_sp_setref_help);
rz_warn_if_fail(analysis_function_vars_sp_setref_cd);
RzCmdDesc *cmd_bsize_cd = rz_cmd_desc_oldinput_new(core->rcmd, root_cd, "b", rz_cmd_bsize, &cmd_bsize_help);
rz_warn_if_fail(cmd_bsize_cd);

23
librz/core/cmd_descs.h
View file

@ -68,6 +68,29 @@ RZ_IPI RzCmdStatus rz_analysis_function_address_handler(RzCore *core, int argc,
RZ_IPI RzCmdStatus rz_analysis_function_until_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_xrefs_handler(RzCore *core, int argc, const char **argv, RzOutputMode mode);
RZ_IPI RzCmdStatus rz_analysis_function_stacksz_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_handler(RzCore *core, int argc, const char **argv, RzOutputMode mode);
RZ_IPI RzCmdStatus rz_analysis_function_vars_dis_refs_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_del_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_detect_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_display_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_stackframe_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_rename_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_reads_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_writes_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_type_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_xrefs_handler(RzCore *core, int argc, const char **argv, RzOutputMode mode);
RZ_IPI RzCmdStatus rz_analysis_function_vars_bp_handler(RzCore *core, int argc, const char **argv, RzOutputMode mode);
RZ_IPI RzCmdStatus rz_analysis_function_vars_bp_del_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_bp_getref_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_bp_setref_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_regs_handler(RzCore *core, int argc, const char **argv, RzOutputMode mode);
RZ_IPI RzCmdStatus rz_analysis_function_vars_regs_del_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_regs_getref_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_regs_setref_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_sp_handler(RzCore *core, int argc, const char **argv, RzOutputMode mode);
RZ_IPI RzCmdStatus rz_analysis_function_vars_sp_del_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_sp_getref_handler(RzCore *core, int argc, const char **argv);
RZ_IPI RzCmdStatus rz_analysis_function_vars_sp_setref_handler(RzCore *core, int argc, const char **argv);
RZ_IPI int rz_cmd_analysis_fcn(void *data, const char *input);
RZ_IPI int rz_cmd_analysis(void *data, const char *input);
RZ_IPI int rz_cmd_bsize(void *data, const char *input);

200
librz/core/cmd_descs.yaml
View file

@ -544,6 +544,206 @@
- name: size
type: RZ_CMD_ARG_TYPE_NUM
flags: RZ_CMD_ARG_FLAG_LAST
- name: afv
summary: Manipulate arguments/variables in a function
subcommands:
- name: afv
cname: analysis_function_vars
summary: List all variables and arguments of the current function
modes:
- RZ_OUTPUT_MODE_STANDARD
- RZ_OUTPUT_MODE_JSON
- RZ_OUTPUT_MODE_RIZIN
args: []
- name: afv=
cname: analysis_function_vars_dis_refs
summary: List function variables and arguments with disasm refs
args: []
- name: afv-
cname: analysis_function_vars_del
summary: Remove all variables/arguments or just the specified one
args:
- name: varname|*
type: RZ_CMD_ARG_TYPE_FCN_VAR
- name: afva
cname: analysis_function_vars_detect
summary: Analyze function arguments/locals
args: []
- name: afvd
cname: analysis_function_vars_display
summary: Display the value of arguments/variables
args:
- name: varname
type: RZ_CMD_ARG_TYPE_FCN_VAR
optional: true
- name: afvf
cname: analysis_function_vars_stackframe
summary: Show BP relative stackframe variables
args: []
- name: afvn
cname: analysis_function_vars_rename
summary: Rename argument/variable in current function
args:
- name: new_name
type: RZ_CMD_ARG_TYPE_STRING
- name: old_name
type: RZ_CMD_ARG_TYPE_FCN_VAR
optional: true
- name: afvR
cname: analysis_function_vars_reads
summary: List addresses where vars are accessed (READ)
args:
- name: varname
type: RZ_CMD_ARG_TYPE_FCN_VAR
optional: true
- name: afvW
cname: analysis_function_vars_writes
summary: List addresses where vars are accessed (WRITE)
args:
- name: varname
type: RZ_CMD_ARG_TYPE_FCN_VAR
optional: true
- name: afvt
cname: analysis_function_vars_type
summary: Change type for given argument/local
args:
- name: varname
type: RZ_CMD_ARG_TYPE_FCN_VAR
- name: type
type: RZ_CMD_ARG_TYPE_STRING
- name: afvx
cname: analysis_function_vars_xrefs
summary: Show function variable xrefs (same as afvR+afvW)
modes:
- RZ_OUTPUT_MODE_STANDARD
- RZ_OUTPUT_MODE_JSON
args:
- name: varname
type: RZ_CMD_ARG_TYPE_FCN_VAR
optional: true
- name: afvb
summary: Manipulate BP based arguments/locals
subcommands:
- name: afvb
cname: analysis_function_vars_bp
summary: List base pointer based arguments and locals / Define a new one
modes:
- RZ_OUTPUT_MODE_STANDARD
- RZ_OUTPUT_MODE_RIZIN
- RZ_OUTPUT_MODE_JSON
args:
- name: delta
type: RZ_CMD_ARG_TYPE_RZNUM
optional: true
- name: name
type: RZ_CMD_ARG_TYPE_STRING
- name: type
type: RZ_CMD_ARG_TYPE_STRING
optional: true
- name: afvb-
cname: analysis_function_vars_bp_del
summary: Delete argument/local with the given name
args:
- name: varname
type: RZ_CMD_ARG_TYPE_FCN_VAR
- name: afvbg
cname: analysis_function_vars_bp_getref
summary: Define var get reference
args:
- name: delta
type: RZ_CMD_ARG_TYPE_RZNUM
- name: addr
type: RZ_CMD_ARG_TYPE_RZNUM
- name: afvbs
cname: analysis_function_vars_bp_setref
summary: Define var set reference
args:
- name: delta
type: RZ_CMD_ARG_TYPE_RZNUM
- name: addr
type: RZ_CMD_ARG_TYPE_RZNUM
- name: afvr
summary: Manipulate register-based arguments/locals
subcommands:
- name: afvr
cname: analysis_function_vars_regs
summary: List register-based arguments and locals / Define a new one
modes:
- RZ_OUTPUT_MODE_STANDARD
- RZ_OUTPUT_MODE_RIZIN
- RZ_OUTPUT_MODE_JSON
args:
- name: reg
type: RZ_CMD_ARG_TYPE_STRING
optional: true
- name: name
type: RZ_CMD_ARG_TYPE_STRING
- name: type
type: RZ_CMD_ARG_TYPE_STRING
optional: true
- name: afvr-
cname: analysis_function_vars_regs_del
summary: Delete register-based argument/local with the given name
args:
- name: varname
type: RZ_CMD_ARG_TYPE_FCN_VAR
- name: afvrg
cname: analysis_function_vars_regs_getref
summary: Define register-based arguments and locals get references
args:
- name: reg
type: RZ_CMD_ARG_TYPE_STRING
- name: addr
type: RZ_CMD_ARG_TYPE_RZNUM
- name: afvrs
cname: analysis_function_vars_regs_setref
summary: Define register-based arguments and locals set references
args:
- name: reg
type: RZ_CMD_ARG_TYPE_STRING
- name: addr
type: RZ_CMD_ARG_TYPE_RZNUM
- name: afvs
summary: Manipulate SP based arguments/locals
subcommands:
- name: afvs
cname: analysis_function_vars_sp
summary: List stack based arguments and locals / Define a new one
modes:
- RZ_OUTPUT_MODE_STANDARD
- RZ_OUTPUT_MODE_RIZIN
- RZ_OUTPUT_MODE_JSON
args:
- name: delta
type: RZ_CMD_ARG_TYPE_RZNUM
optional: true
- name: name
type: RZ_CMD_ARG_TYPE_STRING
- name: type
type: RZ_CMD_ARG_TYPE_STRING
optional: true
- name: afvs-
cname: analysis_function_vars_sp_del
summary: Delete argument/local with the given name
args:
- name: varname
type: RZ_CMD_ARG_TYPE_FCN_VAR
- name: afvsg
cname: analysis_function_vars_sp_getref
summary: Define var get reference
args:
- name: delta
type: RZ_CMD_ARG_TYPE_RZNUM
- name: addr
type: RZ_CMD_ARG_TYPE_RZNUM
- name: afvss
cname: analysis_function_vars_sp_setref
summary: Define var set reference
args:
- name: delta
type: RZ_CMD_ARG_TYPE_RZNUM
- name: addr
type: RZ_CMD_ARG_TYPE_RZNUM
- name: b
cname: cmd_bsize
summary: Display or change the block size

1
librz/core/core_private.h
View file

@ -5,6 +5,7 @@
#include <rz_core.h>
RZ_IPI void rz_core_kuery_print(RzCore *core, const char *k);
RZ_IPI int rz_output_mode_to_char(RzOutputMode mode);
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);

1
librz/include/rz_cmd.h
View file

@ -49,6 +49,7 @@ typedef enum rz_cmd_arg_type_t {
RZ_CMD_ARG_TYPE_MACRO, ///< Argument is the name of a pre-defined macro
RZ_CMD_ARG_TYPE_EVAL_KEY, ///< Argument is the name of a evaluable variable (e.g. `et` command)
RZ_CMD_ARG_TYPE_EVAL_FULL, ///< Argument is the name+(optional)value of a evaluable variable (e.g. `e` command)
RZ_CMD_ARG_TYPE_FCN_VAR, ///< Argument is the name of a function variable/argument
} RzCmdArgType;
/**