From e283f5098e4b9fbcf6c23acb75897b8ec19f0010 Mon Sep 17 00:00:00 2001 From: Riccardo Schirone Date: Fri, 19 Feb 2021 11:01:17 +0100 Subject: [PATCH] Move 'afv' commands to newshell --- librz/core/canalysis.c | 2 +- librz/core/cmd_analysis.c | 408 ++++++++++++++++++++++++++++++++++ librz/core/cmd_api.c | 10 + librz/core/cmd_descs.c | 456 ++++++++++++++++++++++++++++++++++++++ librz/core/cmd_descs.h | 23 ++ librz/core/cmd_descs.yaml | 200 +++++++++++++++++ librz/core/core_private.h | 1 + librz/include/rz_cmd.h | 1 + 8 files changed, 1100 insertions(+), 1 deletion(-) diff --git a/librz/core/canalysis.c b/librz/core/canalysis.c index ac24582a73..5c5a3a09c2 100644 --- a/librz/core/canalysis.c +++ b/librz/core/canalysis.c @@ -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 : ""); -} +} \ No newline at end of file diff --git a/librz/core/cmd_analysis.c b/librz/core/cmd_analysis.c index 4074d0d21c..f06a98205b 100644 --- a/librz/core/cmd_analysis.c +++ b/librz/core/cmd_analysis.c @@ -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); } \ No newline at end of file diff --git a/librz/core/cmd_api.c b/librz/core/cmd_api.c index f7b7d4eca2..49e4410199 100644 --- a/librz/core/cmd_api.c +++ b/librz/core/cmd_api.c @@ -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)) diff --git a/librz/core/cmd_descs.c b/librz/core/cmd_descs.c index fe087d7e88..05d55625f3 100644 --- a/librz/core/cmd_descs.c +++ b/librz/core/cmd_descs.c @@ -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); diff --git a/librz/core/cmd_descs.h b/librz/core/cmd_descs.h index 6ddfe8be83..198383bdb7 100644 --- a/librz/core/cmd_descs.h +++ b/librz/core/cmd_descs.h @@ -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); diff --git a/librz/core/cmd_descs.yaml b/librz/core/cmd_descs.yaml index 4c0fac1353..73e7a6b101 100644 --- a/librz/core/cmd_descs.yaml +++ b/librz/core/cmd_descs.yaml @@ -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 diff --git a/librz/core/core_private.h b/librz/core/core_private.h index 29c3b451ad..64931731c6 100644 --- a/librz/core/core_private.h +++ b/librz/core/core_private.h @@ -5,6 +5,7 @@ #include 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); diff --git a/librz/include/rz_cmd.h b/librz/include/rz_cmd.h index af9ecf291a..453d7731bc 100644 --- a/librz/include/rz_cmd.h +++ b/librz/include/rz_cmd.h @@ -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; /**