From 52260857b5994897f13d258a30964630cabf089a Mon Sep 17 00:00:00 2001 From: Anton Kochkov Date: Fri, 16 Sep 2022 03:09:15 +0800 Subject: [PATCH] Convert some of the `a` commands to the rzshell (#3025) * Remove `ap` command * Convert `ad` commands to rzshell * Convert `aF` command to the rzshell --- librz/core/cmd/cmd_analysis.c | 307 +++++++++---------------- librz/core/cmd_descs/cmd_analysis.yaml | 44 +++- librz/core/cmd_descs/cmd_descs.c | 102 ++++++++ librz/core/cmd_descs/cmd_descs.h | 6 + test/db/analysis/msp430 | 8 +- test/db/cmd/cmd_ad | 27 +++ 6 files changed, 296 insertions(+), 198 deletions(-) create mode 100644 test/db/cmd/cmd_ad diff --git a/librz/core/cmd/cmd_analysis.c b/librz/core/cmd/cmd_analysis.c index 88b0879197..a1e88c36ff 100644 --- a/librz/core/cmd/cmd_analysis.c +++ b/librz/core/cmd/cmd_analysis.c @@ -38,18 +38,6 @@ static const char *help_msg_a[] = { NULL }; -static const char *help_msg_ad[] = { - "Usage:", "ad", "[kt] [...]", - "ad", " [N] [D]", "analyze N data words at D depth", - "ad4", " [N] [D]", "analyze N data words at D depth (asm.bits=32)", - "ad8", " [N] [D]", "analyze N data words at D depth (asm.bits=64)", - "adf", "", "analyze data in function (use like .adf @@=`afl~[0]`", - "adfg", "", "analyze data in function gaps", - "adt", "", "analyze data trampolines (wip)", - "adk", "", "analyze data kind (code, text, data, invalid, ...)", - NULL -}; - static const char *help_msg_ae[] = { "Usage:", "ae[idesr?] [arg]", "ESIL code emulation", "ae", " [expr]", "evaluate ESIL expression", @@ -372,41 +360,17 @@ static bool core_analysis_name_print(RzCore *core, RzCmdStateOutput *state) { return true; } -static void print_trampolines(RzCore *core, ut64 a, ut64 b, size_t element_size) { - int i; - for (i = 0; i < core->blocksize; i += element_size) { - ut32 n; - memcpy(&n, core->block + i, sizeof(ut32)); - if (n >= a && n <= b) { - if (element_size == 4) { - rz_cons_printf("f trampoline.%x @ 0x%" PFMT64x "\n", n, core->offset + i); - } else { - rz_cons_printf("f trampoline.%" PFMT32x " @ 0x%" PFMT64x "\n", n, core->offset + i); - } - rz_cons_printf("Cd %zu @ 0x%" PFMT64x ":%zu\n", element_size, core->offset + i, element_size); - // TODO: add data xrefs +static void print_trampolines(RzCore *core, ut64 minimum, ut64 maximum, + size_t element_size) { + bool big_endian = rz_config_get_b(core->config, "cfg.big_endian"); + for (int i = 0; i < core->blocksize; i += element_size) { + ut32 n = rz_read_ble32(core->block + i, big_endian); + if (n < minimum || n > maximum) { + continue; } - } -} - -static void cmd_analysis_trampoline(RzCore *core, const char *input) { - int bits = rz_config_get_i(core->config, "asm.bits"); - char *p, *inp = strdup(input); - p = strchr(inp, ' '); - if (p) { - *p = 0; - } - ut64 a = rz_num_math(core->num, inp); - ut64 b = p ? rz_num_math(core->num, p + 1) : 0; - free(inp); - - switch (bits) { - case 32: - print_trampolines(core, a, b, 4); - break; - case 64: - print_trampolines(core, a, b, 8); - break; + rz_cons_printf("f trampoline.%" PFMT32x " @ 0x%" PFMT64x "\n", n, core->offset + i); + rz_cons_printf("Cd %zu @ 0x%" PFMT64x ":%zu\n", element_size, core->offset + i, element_size); + // TODO: add data xrefs } } @@ -1946,76 +1910,6 @@ static inline RzFlagItem *core_flag_get_at_as_ref_type(RzCore *core, RzAnalysisX } } -#define var_ref_list(a, d, t) sdb_fmt("var.0x%" PFMT64x ".%d.%d.%s", \ - a, 1, d, (t == 'R') ? "reads" : "writes"); - -static bool analysis_fcn_data(RzCore *core, const char *input) { - RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, RZ_ANALYSIS_FCN_TYPE_ANY); - if (fcn) { - int i; - bool gap = false; - ut64 gap_addr = UT64_MAX; - ut32 fcn_size = rz_analysis_function_size_from_entry(fcn); - char *bitmap = calloc(1, fcn_size); - if (bitmap) { - RzAnalysisBlock *b; - RzListIter *iter; - rz_list_foreach (fcn->bbs, iter, b) { - int f = b->addr - fcn->addr; - int t = RZ_MIN(f + b->size, fcn_size); - if (f >= 0) { - while (f < t) { - bitmap[f++] = 1; - } - } - } - } - for (i = 0; i < fcn_size; i++) { - ut64 here = fcn->addr + i; - if (bitmap && bitmap[i]) { - if (gap) { - rz_cons_printf("Cd %" PFMT64u " @ 0x%08" PFMT64x "\n", here - gap_addr, gap_addr); - gap = false; - } - gap_addr = UT64_MAX; - } else { - if (!gap) { - gap = true; - gap_addr = here; - } - } - } - if (gap) { - rz_cons_printf("Cd %" PFMT64u " @ 0x%08" PFMT64x "\n", fcn->addr + fcn_size - gap_addr, gap_addr); - } - free(bitmap); - return true; - } - return false; -} - -static bool analysis_fcn_data_gaps(RzCore *core, const char *input) { - ut64 end = UT64_MAX; - RzAnalysisFunction *fcn; - RzListIter *iter; - int i, wordsize = (core->rasm->bits == 64) ? 8 : 4; - rz_list_sort(core->analysis->fcns, cmpaddr); - rz_list_foreach (core->analysis->fcns, iter, fcn) { - if (end != UT64_MAX) { - int range = fcn->addr - end; - if (range > 0) { - for (i = 0; i + wordsize < range; i += wordsize) { - rz_cons_printf("Cd %d @ 0x%08" PFMT64x "\n", wordsize, end + i); - } - rz_cons_printf("Cd %d @ 0x%08" PFMT64x "\n", range - i, end + i); - // rz_cons_printf ("Cd %d @ 0x%08"PFMT64x"\n", range, end); - } - } - end = fcn->addr + rz_analysis_function_size_from_entry(fcn); - } - return true; -} - RZ_IPI RzCmdStatus rz_analysis_list_vtables_handler(RzCore *core, int argc, const char **argv, RzOutputMode mode) { rz_analysis_list_vtables(core->analysis, mode); return RZ_CMD_STATUS_OK; @@ -2128,92 +2022,15 @@ RZ_IPI RzCmdStatus rz_analysis_global_variable_retype_handler(RzCore *core, int } RZ_IPI int rz_cmd_analysis(void *data, const char *input) { - const char *r; RzCore *core = (RzCore *)data; ut32 tbs = core->blocksize; switch (input[0]) { - case 'p': // "ap" - { - const ut8 *prelude = (const ut8 *)"\xe9\x2d"; //: fffff000"; - const int prelude_sz = 2; - const int bufsz = 4096; - ut8 *buf = calloc(1, bufsz); - ut64 off = core->offset; - if (input[1] == ' ') { - off = rz_num_math(core->num, input + 1); - rz_io_read_at(core->io, off - bufsz + prelude_sz, buf, bufsz); - } else { - rz_io_read_at(core->io, off - bufsz + prelude_sz, buf, bufsz); - } - // const char *prelude = "\x2d\xe9\xf0\x47"; //:fffff000"; - rz_mem_reverse(buf, bufsz); - // rz_print_hexdump (NULL, off, buf, bufsz, 16, -16); - const ut8 *pos = rz_mem_mem(buf, bufsz, prelude, prelude_sz); - if (pos) { - int delta = (size_t)(pos - buf); - RZ_LOG_DEBUG("core: POS = %d\n", delta); - RZ_LOG_DEBUG("core: HIT = 0x%" PFMT64x "\n", off - delta); - rz_cons_printf("0x%08" PFMT64x "\n", off - delta); - } else { - RZ_LOG_ERROR("core: Cannot find prelude\n"); - } - free(buf); - } break; case 'e': cmd_analysis_esil(core, input + 1); break; // "ae" - case 'F': // "aF" - rz_core_analysis_fcn(core, core->offset, UT64_MAX, RZ_ANALYSIS_XREF_TYPE_NULL, 1); - break; case '*': // "a*" rz_core_cmd0_rzshell(core, "afl*"); rz_core_cmd0_rzshell(core, "ah*"); rz_core_cmd0_rzshell(core, "ax*"); break; - case 'd': // "ad" - switch (input[1]) { - case 'f': // "adf" - if (input[2] == 'g') { - analysis_fcn_data_gaps(core, rz_str_trim_head_ro(input + 1)); - } else { - analysis_fcn_data(core, input + 1); - } - break; - case 't': // "adt" - cmd_analysis_trampoline(core, input + 2); - break; - case ' ': { // "ad" - const int default_depth = 1; - const char *p; - int a, b; - a = rz_num_math(core->num, input + 2); - p = strchr(input + 2, ' '); - b = p ? rz_num_math(core->num, p + 1) : default_depth; - if (a < 1) { - a = 1; - } - if (b < 1) { - b = 1; - } - rz_core_analysis_data(core, core->offset, a, b, 0); - } break; - case 'k': // "adk" - r = rz_analysis_data_kind(core->analysis, - core->offset, core->block, core->blocksize); - rz_cons_println(r); - break; - case '\0': // "ad" - rz_core_analysis_data(core, core->offset, 2 + (core->blocksize / 4), 1, 0); - break; - case '4': // "ad4" - rz_core_analysis_data(core, core->offset, 2 + (core->blocksize / 4), 1, 4); - break; - case '8': // "ad8" - rz_core_analysis_data(core, core->offset, 2 + (core->blocksize / 4), 1, 8); - break; - default: - rz_core_cmd_help(core, help_msg_ad); - break; - } - break; default: rz_core_cmd_help(core, help_msg_a); break; @@ -4614,6 +4431,11 @@ RZ_IPI RzCmdStatus rz_analysis_function_describe_offset_handler(RzCore *core, in return RZ_CMD_STATUS_OK; } +RZ_IPI RzCmdStatus rz_analysis_function_add_nodepth_handler(RzCore *core, int argc, const char **argv) { + rz_core_analysis_fcn(core, core->offset, UT64_MAX, RZ_ANALYSIS_XREF_TYPE_NULL, 1); + return RZ_CMD_STATUS_OK; +} + RZ_IPI RzCmdStatus rz_analysis_function_add_recu_handler(RzCore *core, int argc, const char **argv) { const char *name = argc == 2 ? argv[1] : NULL; bool analyze_recursively = true; @@ -6528,3 +6350,102 @@ RZ_IPI RzCmdStatus rz_delete_global_imports_handler(RzCore *core, int argc, cons rz_analysis_purge_imports(core->analysis); return RZ_CMD_STATUS_OK; } + +RZ_IPI RzCmdStatus rz_analysis_data_handler(RzCore *core, int argc, const char **argv) { + int count = argc > 1 ? rz_num_math(core->num, argv[1]) : 2 + (core->blocksize / 4); + if (count < 1) { + RZ_LOG_ERROR("Count could not be negative or zero\n"); + return RZ_CMD_STATUS_ERROR; + } + int depth = argc > 2 ? rz_num_math(core->num, argv[2]) : 1; + if (depth < 1) { + RZ_LOG_ERROR("Depth could not be negative or zero\n"); + return RZ_CMD_STATUS_ERROR; + } + int wordsize = argc > 3 ? rz_num_math(core->num, argv[3]) : 0; + rz_core_analysis_data(core, core->offset, count, depth, wordsize); + return RZ_CMD_STATUS_OK; +} + +RZ_IPI RzCmdStatus rz_analysis_data_function_handler(RzCore *core, int argc, const char **argv) { + RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, RZ_ANALYSIS_FCN_TYPE_ANY); + if (!fcn) { + RZ_LOG_ERROR("Function not found at the 0x%08" PFMT64x " offset\n", core->offset); + return RZ_CMD_STATUS_ERROR; + } + int i; + bool gap = false; + ut64 gap_addr = UT64_MAX; + ut32 fcn_size = rz_analysis_function_size_from_entry(fcn); + char *bitmap = calloc(1, fcn_size); + if (bitmap) { + RzAnalysisBlock *b; + RzListIter *iter; + rz_list_foreach (fcn->bbs, iter, b) { + int f = b->addr - fcn->addr; + int t = RZ_MIN(f + b->size, fcn_size); + if (f >= 0) { + while (f < t) { + bitmap[f++] = 1; + } + } + } + } + for (i = 0; i < fcn_size; i++) { + ut64 here = fcn->addr + i; + if (bitmap && bitmap[i]) { + if (gap) { + rz_cons_printf("Cd %" PFMT64u " @ 0x%08" PFMT64x "\n", here - gap_addr, gap_addr); + gap = false; + } + gap_addr = UT64_MAX; + } else { + if (!gap) { + gap = true; + gap_addr = here; + } + } + } + if (gap) { + rz_cons_printf("Cd %" PFMT64u " @ 0x%08" PFMT64x "\n", fcn->addr + fcn_size - gap_addr, gap_addr); + } + free(bitmap); + return RZ_CMD_STATUS_OK; +} + +RZ_IPI RzCmdStatus rz_analysis_data_function_gaps_handler(RzCore *core, int argc, const char **argv) { + ut64 end = UT64_MAX; + RzAnalysisFunction *fcn; + RzListIter *iter; + int i, wordsize = core->rasm->bits / 8; + rz_list_sort(core->analysis->fcns, cmpaddr); + rz_list_foreach (core->analysis->fcns, iter, fcn) { + if (end != UT64_MAX) { + int range = fcn->addr - end; + if (range > 0) { + for (i = 0; i + wordsize < range; i += wordsize) { + rz_cons_printf("Cd %d @ 0x%08" PFMT64x "\n", wordsize, end + i); + } + rz_cons_printf("Cd %d @ 0x%08" PFMT64x "\n", range - i, end + i); + } + } + end = fcn->addr + rz_analysis_function_size_from_entry(fcn); + } + return RZ_CMD_STATUS_OK; +} + +RZ_IPI RzCmdStatus rz_analysis_data_kind_handler(RzCore *core, int argc, const char **argv) { + const char *kind = rz_analysis_data_kind(core->analysis, + core->offset, core->block, core->blocksize); + rz_cons_println(kind); + return RZ_CMD_STATUS_OK; +} + +RZ_IPI RzCmdStatus rz_analysis_data_trampoline_handler(RzCore *core, int argc, const char **argv) { + ut64 minimum = rz_num_math(core->num, argv[1]); + ut64 maximum = rz_num_math(core->num, argv[2]); + + int bits = rz_config_get_i(core->config, "asm.bits"); + print_trampolines(core, minimum, maximum, bits / 8); + return RZ_CMD_STATUS_OK; +} diff --git a/librz/core/cmd_descs/cmd_analysis.yaml b/librz/core/cmd_descs/cmd_analysis.yaml index 96e29df552..dc9f8c9803 100644 --- a/librz/core/cmd_descs/cmd_analysis.yaml +++ b/librz/core/cmd_descs/cmd_analysis.yaml @@ -170,6 +170,44 @@ commands: - RZ_OUTPUT_MODE_STANDARD - RZ_OUTPUT_MODE_RIZIN args: [] + - name: ad + summary: Analyze data + subcommands: + - name: ad + summary: Analyze data words with + cname: analysis_data + args: + - name: count + type: RZ_CMD_ARG_TYPE_RZNUM + optional: true + - name: depth + type: RZ_CMD_ARG_TYPE_RZNUM + optional: true + - name: wordsize + type: RZ_CMD_ARG_TYPE_RZNUM + optional: true + - name: adf + summary: Analyze data in function + cname: analysis_data_function + args: [] + - name: adfg + summary: Analyze data in function gaps + cname: analysis_data_function_gaps + args: [] + - name: adk + summary: Analyze data kind (code, text, data, invalid, etc) + cname: analysis_data_kind + args: [] + - name: adt + summary: Analyze data trampolines + cname: analysis_data_trampoline + args: + - name: minimum + type: RZ_CMD_ARG_TYPE_RZNUM + default_value: 0 + - name: maximum + type: RZ_CMD_ARG_TYPE_RZNUM + default_value: 0 - name: af summary: Analyze Functions commands subcommands: @@ -775,6 +813,10 @@ commands: summary: Show function + delta for given offset cname: analysis_function_describe_offset args: [] + - name: aF + summary: Analyze function non-recursively + cname: analysis_function_add_nodepth + args: [] - name: aeC summary: appcall in esil cname: analysis_appcall @@ -2319,4 +2361,4 @@ commands: type: RZ_CMD_DESC_TYPE_ARGV_STATE modes: - RZ_OUTPUT_MODE_STANDARD - - RZ_OUTPUT_MODE_JSON \ No newline at end of file + - RZ_OUTPUT_MODE_JSON diff --git a/librz/core/cmd_descs/cmd_descs.c b/librz/core/cmd_descs/cmd_descs.c index d1079300ab..2435b5e237 100644 --- a/librz/core/cmd_descs/cmd_descs.c +++ b/librz/core/cmd_descs/cmd_descs.c @@ -97,6 +97,8 @@ static const RzCmdDescArg analyze_xrefs_section_bytes_args[2]; static const RzCmdDescArg analyze_function_linked_offsets_args[2]; static const RzCmdDescArg print_commands_after_traps_args[2]; static const RzCmdDescArg print_areas_no_functions_args[2]; +static const RzCmdDescArg analysis_data_args[4]; +static const RzCmdDescArg analysis_data_trampoline_args[3]; static const RzCmdDescArg analysis_function_add_recu_args[2]; static const RzCmdDescArg analysis_function_add_recu_force_args[2]; static const RzCmdDescArg analysis_function_create_args[4]; @@ -1603,6 +1605,81 @@ static const RzCmdDescHelp analyze_value_to_maps_help = { .args = analyze_value_to_maps_args, }; +static const RzCmdDescHelp ad_help = { + .summary = "Analyze data", +}; +static const RzCmdDescArg analysis_data_args[] = { + { + .name = "count", + .type = RZ_CMD_ARG_TYPE_RZNUM, + .optional = true, + + }, + { + .name = "depth", + .type = RZ_CMD_ARG_TYPE_RZNUM, + .optional = true, + + }, + { + .name = "wordsize", + .type = RZ_CMD_ARG_TYPE_RZNUM, + .flags = RZ_CMD_ARG_FLAG_LAST, + .optional = true, + + }, + { 0 }, +}; +static const RzCmdDescHelp analysis_data_help = { + .summary = "Analyze data words with ", + .args = analysis_data_args, +}; + +static const RzCmdDescArg analysis_data_function_args[] = { + { 0 }, +}; +static const RzCmdDescHelp analysis_data_function_help = { + .summary = "Analyze data in function", + .args = analysis_data_function_args, +}; + +static const RzCmdDescArg analysis_data_function_gaps_args[] = { + { 0 }, +}; +static const RzCmdDescHelp analysis_data_function_gaps_help = { + .summary = "Analyze data in function gaps", + .args = analysis_data_function_gaps_args, +}; + +static const RzCmdDescArg analysis_data_kind_args[] = { + { 0 }, +}; +static const RzCmdDescHelp analysis_data_kind_help = { + .summary = "Analyze data kind (code, text, data, invalid, etc)", + .args = analysis_data_kind_args, +}; + +static const RzCmdDescArg analysis_data_trampoline_args[] = { + { + .name = "minimum", + .type = RZ_CMD_ARG_TYPE_RZNUM, + .default_value = "0", + + }, + { + .name = "maximum", + .type = RZ_CMD_ARG_TYPE_RZNUM, + .flags = RZ_CMD_ARG_FLAG_LAST, + .default_value = "0", + + }, + { 0 }, +}; +static const RzCmdDescHelp analysis_data_trampoline_help = { + .summary = "Analyze data trampolines", + .args = analysis_data_trampoline_args, +}; + static const RzCmdDescHelp af_help = { .summary = "Analyze Functions commands", }; @@ -2642,6 +2719,14 @@ static const RzCmdDescHelp analysis_function_describe_offset_help = { .args = analysis_function_describe_offset_args, }; +static const RzCmdDescArg analysis_function_add_nodepth_args[] = { + { 0 }, +}; +static const RzCmdDescHelp analysis_function_add_nodepth_help = { + .summary = "Analyze function non-recursively", + .args = analysis_function_add_nodepth_args, +}; + static const RzCmdDescDetailEntry analysis_appcall_Examples_detail_entries[] = { { .text = "aeC", .arg_str = " 1 2 @ sym._add", .comment = "Call sym._add(1,2)" }, { 0 }, @@ -15226,6 +15311,20 @@ RZ_IPI void rzshell_cmddescs_init(RzCore *core) { RzCmdDesc *analyze_value_to_maps_cd = rz_cmd_desc_argv_state_new(core->rcmd, aa_cd, "aav", RZ_OUTPUT_MODE_STANDARD | RZ_OUTPUT_MODE_RIZIN, rz_analyze_value_to_maps_handler, &analyze_value_to_maps_help); rz_warn_if_fail(analyze_value_to_maps_cd); + RzCmdDesc *ad_cd = rz_cmd_desc_group_new(core->rcmd, cmd_analysis_cd, "ad", rz_analysis_data_handler, &analysis_data_help, &ad_help); + rz_warn_if_fail(ad_cd); + RzCmdDesc *analysis_data_function_cd = rz_cmd_desc_argv_new(core->rcmd, ad_cd, "adf", rz_analysis_data_function_handler, &analysis_data_function_help); + rz_warn_if_fail(analysis_data_function_cd); + + RzCmdDesc *analysis_data_function_gaps_cd = rz_cmd_desc_argv_new(core->rcmd, ad_cd, "adfg", rz_analysis_data_function_gaps_handler, &analysis_data_function_gaps_help); + rz_warn_if_fail(analysis_data_function_gaps_cd); + + RzCmdDesc *analysis_data_kind_cd = rz_cmd_desc_argv_new(core->rcmd, ad_cd, "adk", rz_analysis_data_kind_handler, &analysis_data_kind_help); + rz_warn_if_fail(analysis_data_kind_cd); + + RzCmdDesc *analysis_data_trampoline_cd = rz_cmd_desc_argv_new(core->rcmd, ad_cd, "adt", rz_analysis_data_trampoline_handler, &analysis_data_trampoline_help); + rz_warn_if_fail(analysis_data_trampoline_cd); + RzCmdDesc *af_cd = rz_cmd_desc_group_new(core->rcmd, cmd_analysis_cd, "af", rz_analysis_function_add_recu_handler, &analysis_function_add_recu_help, &af_help); rz_warn_if_fail(af_cd); RzCmdDesc *analysis_function_add_recu_force_cd = rz_cmd_desc_argv_new(core->rcmd, af_cd, "afr", rz_analysis_function_add_recu_handler, &analysis_function_add_recu_force_help); @@ -15437,6 +15536,9 @@ RZ_IPI void rzshell_cmddescs_init(RzCore *core) { RzCmdDesc *analysis_function_describe_offset_cd = rz_cmd_desc_argv_new(core->rcmd, af_cd, "afd", rz_analysis_function_describe_offset_handler, &analysis_function_describe_offset_help); rz_warn_if_fail(analysis_function_describe_offset_cd); + RzCmdDesc *analysis_function_add_nodepth_cd = rz_cmd_desc_argv_new(core->rcmd, cmd_analysis_cd, "aF", rz_analysis_function_add_nodepth_handler, &analysis_function_add_nodepth_help); + rz_warn_if_fail(analysis_function_add_nodepth_cd); + RzCmdDesc *analysis_appcall_cd = rz_cmd_desc_argv_new(core->rcmd, cmd_analysis_cd, "aeC", rz_analysis_appcall_handler, &analysis_appcall_help); rz_warn_if_fail(analysis_appcall_cd); diff --git a/librz/core/cmd_descs/cmd_descs.h b/librz/core/cmd_descs/cmd_descs.h index faa02b76f6..731bc7c8d9 100644 --- a/librz/core/cmd_descs/cmd_descs.h +++ b/librz/core/cmd_descs/cmd_descs.h @@ -79,6 +79,11 @@ RZ_IPI RzCmdStatus rz_analyze_function_linked_offsets_handler(RzCore *core, int RZ_IPI RzCmdStatus rz_print_commands_after_traps_handler(RzCore *core, int argc, const char **argv); RZ_IPI RzCmdStatus rz_print_areas_no_functions_handler(RzCore *core, int argc, const char **argv); RZ_IPI RzCmdStatus rz_analyze_value_to_maps_handler(RzCore *core, int argc, const char **argv, RzCmdStateOutput *state); +RZ_IPI RzCmdStatus rz_analysis_data_handler(RzCore *core, int argc, const char **argv); +RZ_IPI RzCmdStatus rz_analysis_data_function_handler(RzCore *core, int argc, const char **argv); +RZ_IPI RzCmdStatus rz_analysis_data_function_gaps_handler(RzCore *core, int argc, const char **argv); +RZ_IPI RzCmdStatus rz_analysis_data_kind_handler(RzCore *core, int argc, const char **argv); +RZ_IPI RzCmdStatus rz_analysis_data_trampoline_handler(RzCore *core, int argc, const char **argv); RZ_IPI RzCmdStatus rz_analysis_function_add_recu_handler(RzCore *core, int argc, const char **argv); RZ_IPI RzCmdStatus rz_analysis_function_create_handler(RzCore *core, int argc, const char **argv); RZ_IPI RzCmdStatus rz_analysis_function_del_handler(RzCore *core, int argc, const char **argv); @@ -152,6 +157,7 @@ RZ_IPI RzCmdStatus rz_analysis_function_cc_list_handler(RzCore *core, int argc, RZ_IPI RzCmdStatus rz_analysis_function_cc_load_handler(RzCore *core, int argc, const char **argv); RZ_IPI RzCmdStatus rz_analysis_function_cc_reg_usage_handler(RzCore *core, int argc, const char **argv, RzCmdStateOutput *state); RZ_IPI RzCmdStatus rz_analysis_function_describe_offset_handler(RzCore *core, int argc, const char **argv); +RZ_IPI RzCmdStatus rz_analysis_function_add_nodepth_handler(RzCore *core, int argc, const char **argv); RZ_IPI RzCmdStatus rz_analysis_appcall_handler(RzCore *core, int argc, const char **argv); RZ_IPI RzCmdStatus rz_analysis_continue_until_except_handler(RzCore *core, int argc, const char **argv); RZ_IPI RzCmdStatus rz_analysis_continue_until_breakpoint_handler(RzCore *core, int argc, const char **argv); diff --git a/test/db/analysis/msp430 b/test/db/analysis/msp430 index d1e92a70f0..427c4a4ddb 100644 --- a/test/db/analysis/msp430 +++ b/test/db/analysis/msp430 @@ -1,8 +1,8 @@ -NAME=aFr on ELF +NAME=aF on ELF FILE=bins/elf/msp430.elf CMDS=<