X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=2e933820caa7f74dc2f9c4d008df2a58f53cbd1e;hp=f141e933f3865214290ef2ae03ddafb1e0058460;hb=833e7f5248778bcb31b4db1a1b91160995415203;hpb=69df712d1d06b2c698bed3de086b9f734de73b7e diff --git a/src/target/target.c b/src/target/target.c index f141e933f3..2e933820ca 100644 --- a/src/target/target.c +++ b/src/target/target.c @@ -1648,28 +1648,28 @@ COMMAND_HANDLER(handle_targets_command) { struct target *target = all_targets; - if (argc == 1) + if (CMD_ARGC == 1) { - target = get_target(args[0]); + target = get_target(CMD_ARGV[0]); if (target == NULL) { - command_print(cmd_ctx,"Target: %s is unknown, try one of:\n", args[0]); + command_print(CMD_CTX,"Target: %s is unknown, try one of:\n", CMD_ARGV[0]); goto DumpTargets; } if (!target->tap->enabled) { - command_print(cmd_ctx,"Target: TAP %s is disabled, " + command_print(CMD_CTX,"Target: TAP %s is disabled, " "can't be the current target\n", target->tap->dotted_name); return ERROR_FAIL; } - cmd_ctx->current_target = target->target_number; + CMD_CTX->current_target = target->target_number; return ERROR_OK; } DumpTargets: target = all_targets; - command_print(cmd_ctx, " TargetName Type Endian TapName State "); - command_print(cmd_ctx, "-- ------------------ ---------- ------ ------------------ ------------"); + command_print(CMD_CTX, " TargetName Type Endian TapName State "); + command_print(CMD_CTX, "-- ------------------ ---------- ------ ------------------ ------------"); while (target) { const char *state; @@ -1680,11 +1680,11 @@ DumpTargets: else state = "tap-disabled"; - if (cmd_ctx->current_target == target->target_number) + if (CMD_CTX->current_target == target->target_number) marker = '*'; /* keep columns lined up to match the headers above */ - command_print(cmd_ctx, "%2d%c %-18s %-10s %-6s %-18s %s", + command_print(CMD_CTX, "%2d%c %-18s %-10s %-6s %-18s %s", target->target_number, marker, target->cmd_name, @@ -1860,24 +1860,24 @@ COMMAND_HANDLER(handle_reg_command) { struct target *target; struct reg *reg = NULL; - int count = 0; + unsigned count = 0; char *value; LOG_DEBUG("-"); - target = get_current_target(cmd_ctx); + target = get_current_target(CMD_CTX); /* list all available registers for the current target */ - if (argc == 0) + if (CMD_ARGC == 0) { struct reg_cache *cache = target->reg_cache; count = 0; while (cache) { - int i; + unsigned i; - command_print(cmd_ctx, "===== %s", cache->name); + command_print(CMD_CTX, "===== %s", cache->name); for (i = 0, reg = cache->reg_list; i < cache->num_regs; @@ -1887,7 +1887,7 @@ COMMAND_HANDLER(handle_reg_command) if (reg->valid) { value = buf_to_str(reg->value, reg->size, 16); - command_print(cmd_ctx, + command_print(CMD_CTX, "(%i) %s (/%" PRIu32 "): 0x%s%s", count, reg->name, reg->size, value, @@ -1896,7 +1896,7 @@ COMMAND_HANDLER(handle_reg_command) : ""); free(value); } else { - command_print(cmd_ctx, "(%i) %s (/%" PRIu32 ")", + command_print(CMD_CTX, "(%i) %s (/%" PRIu32 ")", count, reg->name, reg->size) ; } @@ -1908,19 +1908,19 @@ COMMAND_HANDLER(handle_reg_command) } /* access a single register by its ordinal number */ - if ((args[0][0] >= '0') && (args[0][0] <= '9')) + if ((CMD_ARGV[0][0] >= '0') && (CMD_ARGV[0][0] <= '9')) { unsigned num; - COMMAND_PARSE_NUMBER(uint, args[0], num); + COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num); struct reg_cache *cache = target->reg_cache; count = 0; while (cache) { - int i; + unsigned i; for (i = 0; i < cache->num_regs; i++) { - if (count++ == (int)num) + if (count++ == num) { reg = &cache->reg_list[i]; break; @@ -1933,48 +1933,46 @@ COMMAND_HANDLER(handle_reg_command) if (!reg) { - command_print(cmd_ctx, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1); + command_print(CMD_CTX, "%i is out of bounds, the current target has only %i registers (0 - %i)", num, count, count - 1); return ERROR_OK; } } else /* access a single register by its name */ { - reg = register_get_by_name(target->reg_cache, args[0], 1); + reg = register_get_by_name(target->reg_cache, CMD_ARGV[0], 1); if (!reg) { - command_print(cmd_ctx, "register %s not found in current target", args[0]); + command_print(CMD_CTX, "register %s not found in current target", CMD_ARGV[0]); return ERROR_OK; } } /* display a register */ - if ((argc == 1) || ((argc == 2) && !((args[1][0] >= '0') && (args[1][0] <= '9')))) + if ((CMD_ARGC == 1) || ((CMD_ARGC == 2) && !((CMD_ARGV[1][0] >= '0') && (CMD_ARGV[1][0] <= '9')))) { - if ((argc == 2) && (strcmp(args[1], "force") == 0)) + if ((CMD_ARGC == 2) && (strcmp(CMD_ARGV[1], "force") == 0)) reg->valid = 0; if (reg->valid == 0) { - struct reg_arch_type *arch_type = register_get_arch_type(reg->arch_type); - arch_type->get(reg); + reg->type->get(reg); } value = buf_to_str(reg->value, reg->size, 16); - command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value); + command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value); free(value); return ERROR_OK; } /* set register value */ - if (argc == 2) + if (CMD_ARGC == 2) { uint8_t *buf = malloc(DIV_ROUND_UP(reg->size, 8)); - str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0); + str_to_buf(CMD_ARGV[1], strlen(CMD_ARGV[1]), buf, reg->size, 0); - struct reg_arch_type *arch_type = register_get_arch_type(reg->arch_type); - arch_type->set(reg, buf); + reg->type->set(reg, buf); value = buf_to_str(reg->value, reg->size, 16); - command_print(cmd_ctx, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value); + command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value); free(value); free(buf); @@ -1982,7 +1980,7 @@ COMMAND_HANDLER(handle_reg_command) return ERROR_OK; } - command_print(cmd_ctx, "usage: reg <#|name> [value]"); + command_print(CMD_CTX, "usage: reg <#|name> [value]"); return ERROR_OK; } @@ -1990,13 +1988,13 @@ COMMAND_HANDLER(handle_reg_command) COMMAND_HANDLER(handle_poll_command) { int retval = ERROR_OK; - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); - if (argc == 0) + if (CMD_ARGC == 0) { - command_print(cmd_ctx, "background polling: %s", + command_print(CMD_CTX, "background polling: %s", jtag_poll_get_enabled() ? "on" : "off"); - command_print(cmd_ctx, "TAP: %s (%s)", + command_print(CMD_CTX, "TAP: %s (%s)", target->tap->dotted_name, target->tap->enabled ? "enabled" : "disabled"); if (!target->tap->enabled) @@ -2005,23 +2003,14 @@ COMMAND_HANDLER(handle_poll_command) return retval; if ((retval = target_arch_state(target)) != ERROR_OK) return retval; - } - else if (argc == 1) + else if (CMD_ARGC == 1) { - if (strcmp(args[0], "on") == 0) - { - jtag_poll_set_enabled(true); - } - else if (strcmp(args[0], "off") == 0) - { - jtag_poll_set_enabled(false); - } - else - { - command_print(cmd_ctx, "arg is \"on\" or \"off\""); - } - } else + bool enable; + COMMAND_PARSE_ON_OFF(CMD_ARGV[0], enable); + jtag_poll_set_enabled(enable); + } + else { return ERROR_COMMAND_SYNTAX_ERROR; } @@ -2031,23 +2020,23 @@ COMMAND_HANDLER(handle_poll_command) COMMAND_HANDLER(handle_wait_halt_command) { - if (argc > 1) + if (CMD_ARGC > 1) return ERROR_COMMAND_SYNTAX_ERROR; unsigned ms = 5000; - if (1 == argc) + if (1 == CMD_ARGC) { - int retval = parse_uint(args[0], &ms); + int retval = parse_uint(CMD_ARGV[0], &ms); if (ERROR_OK != retval) { - command_print(cmd_ctx, "usage: %s [seconds]", CMD_NAME); + command_print(CMD_CTX, "usage: %s [seconds]", CMD_NAME); return ERROR_COMMAND_SYNTAX_ERROR; } // convert seconds (given) to milliseconds (needed) ms *= 1000; } - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); return target_wait_state(target, TARGET_HALTED, ms); } @@ -2100,15 +2089,15 @@ COMMAND_HANDLER(handle_halt_command) { LOG_DEBUG("-"); - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); int retval = target_halt(target); if (ERROR_OK != retval) return retval; - if (argc == 1) + if (CMD_ARGC == 1) { unsigned wait; - retval = parse_uint(args[0], &wait); + retval = parse_uint(CMD_ARGV[0], &wait); if (ERROR_OK != retval) return ERROR_COMMAND_SYNTAX_ERROR; if (!wait) @@ -2120,7 +2109,7 @@ COMMAND_HANDLER(handle_halt_command) COMMAND_HANDLER(handle_soft_reset_halt_command) { - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); LOG_USER("requesting target halt and executing a soft reset"); @@ -2131,14 +2120,14 @@ COMMAND_HANDLER(handle_soft_reset_halt_command) COMMAND_HANDLER(handle_reset_command) { - if (argc > 1) + if (CMD_ARGC > 1) return ERROR_COMMAND_SYNTAX_ERROR; enum target_reset_mode reset_mode = RESET_RUN; - if (argc == 1) + if (CMD_ARGC == 1) { const Jim_Nvp *n; - n = Jim_Nvp_name2value_simple(nvp_reset_modes, args[0]); + n = Jim_Nvp_name2value_simple(nvp_reset_modes, CMD_ARGV[0]); if ((n->name == NULL) || (n->value == RESET_UNKNOWN)) { return ERROR_COMMAND_SYNTAX_ERROR; } @@ -2146,26 +2135,26 @@ COMMAND_HANDLER(handle_reset_command) } /* reset *all* targets */ - return target_process_reset(cmd_ctx, reset_mode); + return target_process_reset(CMD_CTX, reset_mode); } COMMAND_HANDLER(handle_resume_command) { int current = 1; - if (argc > 1) + if (CMD_ARGC > 1) return ERROR_COMMAND_SYNTAX_ERROR; - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); target_handle_event(target, TARGET_EVENT_OLD_pre_resume); - /* with no args, resume from current pc, addr = 0, - * with one arguments, addr = args[0], + /* with no CMD_ARGV, resume from current pc, addr = 0, + * with one arguments, addr = CMD_ARGV[0], * handle breakpoints, not debugging */ uint32_t addr = 0; - if (argc == 1) + if (CMD_ARGC == 1) { - COMMAND_PARSE_NUMBER(u32, args[0], addr); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr); current = 0; } @@ -2174,23 +2163,23 @@ COMMAND_HANDLER(handle_resume_command) COMMAND_HANDLER(handle_step_command) { - if (argc > 1) + if (CMD_ARGC > 1) return ERROR_COMMAND_SYNTAX_ERROR; LOG_DEBUG("-"); - /* with no args, step from current pc, addr = 0, - * with one argument addr = args[0], + /* with no CMD_ARGV, step from current pc, addr = 0, + * with one argument addr = CMD_ARGV[0], * handle breakpoints, debugging */ uint32_t addr = 0; int current_pc = 1; - if (argc == 1) + if (CMD_ARGC == 1) { - COMMAND_PARSE_NUMBER(u32, args[0], addr); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr); current_pc = 0; } - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); return target->type->step(target, current_pc, addr, 1); } @@ -2246,48 +2235,47 @@ static void handle_md_output(struct command_context *cmd_ctx, COMMAND_HANDLER(handle_md_command) { - if (argc < 1) + if (CMD_ARGC < 1) return ERROR_COMMAND_SYNTAX_ERROR; unsigned size = 0; - const char *cmd_name = CMD_NAME; - switch (cmd_name[6]) { + switch (CMD_NAME[2]) { case 'w': size = 4; break; case 'h': size = 2; break; case 'b': size = 1; break; default: return ERROR_COMMAND_SYNTAX_ERROR; } - bool physical=strcmp(args[0], "phys")==0; + bool physical=strcmp(CMD_ARGV[0], "phys")==0; int (*fn)(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer); if (physical) { - argc--; - args++; + CMD_ARGC--; + CMD_ARGV++; fn=target_read_phys_memory; } else { fn=target_read_memory; } - if ((argc < 1) || (argc > 2)) + if ((CMD_ARGC < 1) || (CMD_ARGC > 2)) { return ERROR_COMMAND_SYNTAX_ERROR; } uint32_t address; - COMMAND_PARSE_NUMBER(u32, args[0], address); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address); unsigned count = 1; - if (argc == 2) - COMMAND_PARSE_NUMBER(uint, args[1], count); + if (CMD_ARGC == 2) + COMMAND_PARSE_NUMBER(uint, CMD_ARGV[1], count); uint8_t *buffer = calloc(count, size); - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); int retval = fn(target, address, size, count, buffer); if (ERROR_OK == retval) - handle_md_output(cmd_ctx, target, address, size, count, buffer); + handle_md_output(CMD_CTX, target, address, size, count, buffer); free(buffer); @@ -2296,40 +2284,39 @@ COMMAND_HANDLER(handle_md_command) COMMAND_HANDLER(handle_mw_command) { - if (argc < 2) + if (CMD_ARGC < 2) { return ERROR_COMMAND_SYNTAX_ERROR; } - bool physical=strcmp(args[0], "phys")==0; + bool physical=strcmp(CMD_ARGV[0], "phys")==0; int (*fn)(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer); - const char *cmd_name = CMD_NAME; if (physical) { - argc--; - args++; + CMD_ARGC--; + CMD_ARGV++; fn=target_write_phys_memory; } else { fn=target_write_memory; } - if ((argc < 2) || (argc > 3)) + if ((CMD_ARGC < 2) || (CMD_ARGC > 3)) return ERROR_COMMAND_SYNTAX_ERROR; uint32_t address; - COMMAND_PARSE_NUMBER(u32, args[0], address); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address); uint32_t value; - COMMAND_PARSE_NUMBER(u32, args[1], value); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value); unsigned count = 1; - if (argc == 3) - COMMAND_PARSE_NUMBER(uint, args[2], count); + if (CMD_ARGC == 3) + COMMAND_PARSE_NUMBER(uint, CMD_ARGV[2], count); - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); unsigned wordsize; uint8_t value_buf[4]; - switch (cmd_name[6]) + switch (CMD_NAME[2]) { case 'w': wordsize = 4; @@ -2359,18 +2346,18 @@ COMMAND_HANDLER(handle_mw_command) } -static COMMAND_HELPER(parse_load_image_command_args, struct image *image, +static COMMAND_HELPER(parse_load_image_command_CMD_ARGV, struct image *image, uint32_t *min_address, uint32_t *max_address) { - if (argc < 1 || argc > 5) + if (CMD_ARGC < 1 || CMD_ARGC > 5) return ERROR_COMMAND_SYNTAX_ERROR; /* a base address isn't always necessary, * default to 0x0 (i.e. don't relocate) */ - if (argc >= 2) + if (CMD_ARGC >= 2) { uint32_t addr; - COMMAND_PARSE_NUMBER(u32, args[1], addr); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr); image->base_address = addr; image->base_address_set = 1; } @@ -2379,13 +2366,13 @@ static COMMAND_HELPER(parse_load_image_command_args, struct image *image, image->start_address_set = 0; - if (argc >= 4) + if (CMD_ARGC >= 4) { - COMMAND_PARSE_NUMBER(u32, args[3], *min_address); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], *min_address); } - if (argc == 5) + if (CMD_ARGC == 5) { - COMMAND_PARSE_NUMBER(u32, args[4], *max_address); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], *max_address); // use size (given) to find max (required) *max_address += *min_address; } @@ -2399,24 +2386,24 @@ static COMMAND_HELPER(parse_load_image_command_args, struct image *image, COMMAND_HANDLER(handle_load_image_command) { uint8_t *buffer; - uint32_t buf_cnt; + size_t buf_cnt; uint32_t image_size; uint32_t min_address = 0; uint32_t max_address = 0xffffffff; int i; struct image image; - int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args, + int retval = CALL_COMMAND_HANDLER(parse_load_image_command_CMD_ARGV, &image, &min_address, &max_address); if (ERROR_OK != retval) return retval; - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); struct duration bench; duration_start(&bench); - if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK) + if (image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL) != ERROR_OK) { return ERROR_OK; } @@ -2428,7 +2415,7 @@ COMMAND_HANDLER(handle_load_image_command) buffer = malloc(image.sections[i].size); if (buffer == NULL) { - command_print(cmd_ctx, + command_print(CMD_CTX, "error allocating buffer for section (%d bytes)", (int)(image.sections[i].size)); break; @@ -2466,7 +2453,7 @@ COMMAND_HANDLER(handle_load_image_command) break; } image_size += length; - command_print(cmd_ctx, "%u bytes written at address 0x%8.8" PRIx32 "", + command_print(CMD_CTX, "%u bytes written at address 0x%8.8" PRIx32 "", (unsigned int)length, image.sections[i].base_address + offset); } @@ -2476,7 +2463,7 @@ COMMAND_HANDLER(handle_load_image_command) if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) { - command_print(cmd_ctx, "downloaded %" PRIu32 " bytes " + command_print(CMD_CTX, "downloaded %" PRIu32 " bytes " "in %fs (%0.3f kb/s)", image_size, duration_elapsed(&bench), duration_kbps(&bench, image_size)); } @@ -2495,20 +2482,20 @@ COMMAND_HANDLER(handle_dump_image_command) int retvaltemp; - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); - if (argc != 3) + if (CMD_ARGC != 3) { - command_print(cmd_ctx, "usage: dump_image
"); + command_print(CMD_CTX, "usage: dump_image
"); return ERROR_OK; } uint32_t address; - COMMAND_PARSE_NUMBER(u32, args[1], address); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], address); uint32_t size; - COMMAND_PARSE_NUMBER(u32, args[2], size); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], size); - if (fileio_open(&fileio, args[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK) + if (fileio_open(&fileio, CMD_ARGV[0], FILEIO_WRITE, FILEIO_BINARY) != ERROR_OK) { return ERROR_OK; } @@ -2519,7 +2506,7 @@ COMMAND_HANDLER(handle_dump_image_command) int retval = ERROR_OK; while (size > 0) { - uint32_t size_written; + size_t size_written; uint32_t this_run_size = (size > 560) ? 560 : size; retval = target_read_buffer(target, address, this_run_size, buffer); if (retval != ERROR_OK) @@ -2542,7 +2529,7 @@ COMMAND_HANDLER(handle_dump_image_command) if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) { - command_print(cmd_ctx, + command_print(CMD_CTX, "dumped %zu bytes in %fs (%0.3f kb/s)", fileio.size, duration_elapsed(&bench), duration_kbps(&bench, fileio.size)); } @@ -2553,7 +2540,7 @@ COMMAND_HANDLER(handle_dump_image_command) static COMMAND_HELPER(handle_verify_image_command_internal, int verify) { uint8_t *buffer; - uint32_t buf_cnt; + size_t buf_cnt; uint32_t image_size; int i; int retval; @@ -2562,9 +2549,9 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify) struct image image; - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); - if (argc < 1) + if (CMD_ARGC < 1) { return ERROR_COMMAND_SYNTAX_ERROR; } @@ -2578,10 +2565,10 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify) struct duration bench; duration_start(&bench); - if (argc >= 2) + if (CMD_ARGC >= 2) { uint32_t addr; - COMMAND_PARSE_NUMBER(u32, args[1], addr); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr); image.base_address = addr; image.base_address_set = 1; } @@ -2593,7 +2580,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify) image.start_address_set = 0; - if ((retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL)) != ERROR_OK) + if ((retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL)) != ERROR_OK) { return retval; } @@ -2605,7 +2592,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify) buffer = malloc(image.sections[i].size); if (buffer == NULL) { - command_print(cmd_ctx, + command_print(CMD_CTX, "error allocating buffer for section (%d bytes)", (int)(image.sections[i].size)); break; @@ -2633,7 +2620,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify) /* failed crc checksum, fall back to a binary compare */ uint8_t *data; - command_print(cmd_ctx, "checksum mismatch - attempting binary compare"); + command_print(CMD_CTX, "checksum mismatch - attempting binary compare"); data = (uint8_t*)malloc(buf_cnt); @@ -2653,7 +2640,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify) { if (data[t] != buffer[t]) { - command_print(cmd_ctx, + command_print(CMD_CTX, "Verify operation failed address 0x%08x. Was 0x%02x instead of 0x%02x\n", (unsigned)(t + image.sections[i].base_address), data[t], @@ -2674,7 +2661,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify) } } else { - command_print(cmd_ctx, "address 0x%08" PRIx32 " length 0x%08" PRIx32 "", + command_print(CMD_CTX, "address 0x%08" PRIx32 " length 0x%08zx", image.sections[i].base_address, buf_cnt); } @@ -2685,7 +2672,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify) done: if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) { - command_print(cmd_ctx, "verified %" PRIu32 " bytes " + command_print(CMD_CTX, "verified %" PRIu32 " bytes " "in %fs (%0.3f kb/s)", image_size, duration_elapsed(&bench), duration_kbps(&bench, image_size)); } @@ -2747,41 +2734,41 @@ static int handle_bp_command_set(struct command_context *cmd_ctx, COMMAND_HANDLER(handle_bp_command) { - if (argc == 0) - return handle_bp_command_list(cmd_ctx); + if (CMD_ARGC == 0) + return handle_bp_command_list(CMD_CTX); - if (argc < 2 || argc > 3) + if (CMD_ARGC < 2 || CMD_ARGC > 3) { - command_print(cmd_ctx, "usage: bp
['hw']"); + command_print(CMD_CTX, "usage: bp
['hw']"); return ERROR_COMMAND_SYNTAX_ERROR; } uint32_t addr; - COMMAND_PARSE_NUMBER(u32, args[0], addr); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr); uint32_t length; - COMMAND_PARSE_NUMBER(u32, args[1], length); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length); int hw = BKPT_SOFT; - if (argc == 3) + if (CMD_ARGC == 3) { - if (strcmp(args[2], "hw") == 0) + if (strcmp(CMD_ARGV[2], "hw") == 0) hw = BKPT_HARD; else return ERROR_COMMAND_SYNTAX_ERROR; } - return handle_bp_command_set(cmd_ctx, addr, length, hw); + return handle_bp_command_set(CMD_CTX, addr, length, hw); } COMMAND_HANDLER(handle_rbp_command) { - if (argc != 1) + if (CMD_ARGC != 1) return ERROR_COMMAND_SYNTAX_ERROR; uint32_t addr; - COMMAND_PARSE_NUMBER(u32, args[0], addr); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr); - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); breakpoint_remove(target, addr); return ERROR_OK; @@ -2789,15 +2776,15 @@ COMMAND_HANDLER(handle_rbp_command) COMMAND_HANDLER(handle_wp_command) { - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); - if (argc == 0) + if (CMD_ARGC == 0) { struct watchpoint *watchpoint = target->watchpoints; while (watchpoint) { - command_print(cmd_ctx, "address: 0x%8.8" PRIx32 + command_print(CMD_CTX, "address: 0x%8.8" PRIx32 ", len: 0x%8.8" PRIx32 ", r/w/a: %i, value: 0x%8.8" PRIx32 ", mask: 0x%8.8" PRIx32, @@ -2817,16 +2804,16 @@ COMMAND_HANDLER(handle_wp_command) uint32_t data_value = 0x0; uint32_t data_mask = 0xffffffff; - switch (argc) + switch (CMD_ARGC) { case 5: - COMMAND_PARSE_NUMBER(u32, args[4], data_mask); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], data_mask); // fall through case 4: - COMMAND_PARSE_NUMBER(u32, args[3], data_value); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], data_value); // fall through case 3: - switch (args[2][0]) + switch (CMD_ARGV[2][0]) { case 'r': type = WPT_READ; @@ -2838,17 +2825,17 @@ COMMAND_HANDLER(handle_wp_command) type = WPT_ACCESS; break; default: - LOG_ERROR("invalid watchpoint mode ('%c')", args[2][0]); + LOG_ERROR("invalid watchpoint mode ('%c')", CMD_ARGV[2][0]); return ERROR_COMMAND_SYNTAX_ERROR; } // fall through case 2: - COMMAND_PARSE_NUMBER(u32, args[1], length); - COMMAND_PARSE_NUMBER(u32, args[0], addr); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr); break; default: - command_print(cmd_ctx, "usage: wp [address length " + command_print(CMD_CTX, "usage: wp [address length " "[(r|w|a) [value [mask]]]]"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -2863,13 +2850,13 @@ COMMAND_HANDLER(handle_wp_command) COMMAND_HANDLER(handle_rwp_command) { - if (argc != 1) + if (CMD_ARGC != 1) return ERROR_COMMAND_SYNTAX_ERROR; uint32_t addr; - COMMAND_PARSE_NUMBER(u32, args[0], addr); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr); - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); watchpoint_remove(target, addr); return ERROR_OK; @@ -2884,17 +2871,17 @@ COMMAND_HANDLER(handle_rwp_command) */ COMMAND_HANDLER(handle_virt2phys_command) { - if (argc != 1) + if (CMD_ARGC != 1) return ERROR_COMMAND_SYNTAX_ERROR; uint32_t va; - COMMAND_PARSE_NUMBER(u32, args[0], va); + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], va); uint32_t pa; - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); int retval = target->type->virt2phys(target, va, &pa); if (retval == ERROR_OK) - command_print(cmd_ctx, "Physical address 0x%08" PRIx32 "", pa); + command_print(CMD_CTX, "Physical address 0x%08" PRIx32 "", pa); return retval; } @@ -3018,20 +3005,20 @@ static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filenam /* profiling samples the CPU PC as quickly as OpenOCD is able, which will be used as a random sampling of PC */ COMMAND_HANDLER(handle_profile_command) { - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(CMD_CTX); struct timeval timeout, now; gettimeofday(&timeout, NULL); - if (argc != 2) + if (CMD_ARGC != 2) { return ERROR_COMMAND_SYNTAX_ERROR; } unsigned offset; - COMMAND_PARSE_NUMBER(uint, args[0], offset); + COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], offset); timeval_add_time(&timeout, offset, 0); - command_print(cmd_ctx, "Starting profiling. Halting and resuming the target as often as we can..."); + command_print(CMD_CTX, "Starting profiling. Halting and resuming the target as often as we can..."); static const int maxSample = 10000; uint32_t *samples = malloc(sizeof(uint32_t)*maxSample); @@ -3063,7 +3050,7 @@ COMMAND_HANDLER(handle_profile_command) } } else { - command_print(cmd_ctx, "Target not halted or running"); + command_print(CMD_CTX, "Target not halted or running"); retval = ERROR_OK; break; } @@ -3075,7 +3062,7 @@ COMMAND_HANDLER(handle_profile_command) gettimeofday(&now, NULL); if ((numSamples >= maxSample) || ((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))) { - command_print(cmd_ctx, "Profiling completed. %d samples.", numSamples); + command_print(CMD_CTX, "Profiling completed. %d samples.", numSamples); if ((retval = target_poll(target)) != ERROR_OK) { free(samples); @@ -3090,8 +3077,8 @@ COMMAND_HANDLER(handle_profile_command) free(samples); return retval; } - writeGmon(samples, numSamples, args[1]); - command_print(cmd_ctx, "Wrote %s", args[1]); + writeGmon(samples, numSamples, CMD_ARGV[1]); + command_print(CMD_CTX, "Wrote %s", CMD_ARGV[1]); break; } } @@ -3158,7 +3145,6 @@ static int target_mem2array(Jim_Interp *interp, struct target *target, int argc, uint32_t count; uint32_t v; const char *varname; - uint8_t buffer[4096]; int n, e, retval; uint32_t i; @@ -3240,14 +3226,20 @@ static int target_mem2array(Jim_Interp *interp, struct target *target, int argc, /* index counter */ n = 0; + + size_t buffersize = 4096; + uint8_t *buffer = malloc(buffersize); + if (buffer == NULL) + return JIM_ERR; + /* assume ok */ e = JIM_OK; while (len) { /* Slurp... in buffer size chunks */ count = len; /* in objects.. */ - if (count > (sizeof(buffer)/width)) { - count = (sizeof(buffer)/width); + if (count > (buffersize/width)) { + count = (buffersize/width); } retval = target_read_memory(target, addr, width, count, buffer); @@ -3281,6 +3273,8 @@ static int target_mem2array(Jim_Interp *interp, struct target *target, int argc, } } + free(buffer); + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); return JIM_OK; @@ -3344,7 +3338,6 @@ static int target_array2mem(Jim_Interp *interp, struct target *target, int argc, uint32_t count; uint32_t v; const char *varname; - uint8_t buffer[4096]; int n, e, retval; uint32_t i; @@ -3428,12 +3421,18 @@ static int target_array2mem(Jim_Interp *interp, struct target *target, int argc, n = 0; /* assume ok */ e = JIM_OK; + + size_t buffersize = 4096; + uint8_t *buffer = malloc(buffersize); + if (buffer == NULL) + return JIM_ERR; + while (len) { /* Slurp... in buffer size chunks */ count = len; /* in objects.. */ - if (count > (sizeof(buffer)/width)) { - count = (sizeof(buffer)/width); + if (count > (buffersize/width)) { + count = (buffersize/width); } v = 0; /* shut up gcc */ @@ -3467,6 +3466,8 @@ static int target_array2mem(Jim_Interp *interp, struct target *target, int argc, } } + free(buffer); + Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); return JIM_OK; @@ -4537,7 +4538,7 @@ static void free_fastload(void) COMMAND_HANDLER(handle_fast_load_image_command) { uint8_t *buffer; - uint32_t buf_cnt; + size_t buf_cnt; uint32_t image_size; uint32_t min_address = 0; uint32_t max_address = 0xffffffff; @@ -4545,7 +4546,7 @@ COMMAND_HANDLER(handle_fast_load_image_command) struct image image; - int retval = CALL_COMMAND_HANDLER(parse_load_image_command_args, + int retval = CALL_COMMAND_HANDLER(parse_load_image_command_CMD_ARGV, &image, &min_address, &max_address); if (ERROR_OK != retval) return retval; @@ -4553,7 +4554,7 @@ COMMAND_HANDLER(handle_fast_load_image_command) struct duration bench; duration_start(&bench); - if (image_open(&image, args[0], (argc >= 3) ? args[2] : NULL) != ERROR_OK) + if (image_open(&image, CMD_ARGV[0], (CMD_ARGC >= 3) ? CMD_ARGV[2] : NULL) != ERROR_OK) { return ERROR_OK; } @@ -4573,7 +4574,7 @@ COMMAND_HANDLER(handle_fast_load_image_command) buffer = malloc(image.sections[i].size); if (buffer == NULL) { - command_print(cmd_ctx, "error allocating buffer for section (%d bytes)", + command_print(CMD_CTX, "error allocating buffer for section (%d bytes)", (int)(image.sections[i].size)); break; } @@ -4616,7 +4617,7 @@ COMMAND_HANDLER(handle_fast_load_image_command) fastload[i].length = length; image_size += length; - command_print(cmd_ctx, "%u bytes written at address 0x%8.8x", + command_print(CMD_CTX, "%u bytes written at address 0x%8.8x", (unsigned int)length, ((unsigned int)(image.sections[i].base_address + offset))); } @@ -4626,11 +4627,11 @@ COMMAND_HANDLER(handle_fast_load_image_command) if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) { - command_print(cmd_ctx, "Loaded %" PRIu32 " bytes " + command_print(CMD_CTX, "Loaded %" PRIu32 " bytes " "in %fs (%0.3f kb/s)", image_size, duration_elapsed(&bench), duration_kbps(&bench, image_size)); - command_print(cmd_ctx, + command_print(CMD_CTX, "WARNING: image has not been loaded to target!" "You can issue a 'fast_load' to finish loading."); } @@ -4647,7 +4648,7 @@ COMMAND_HANDLER(handle_fast_load_image_command) COMMAND_HANDLER(handle_fast_load_command) { - if (argc > 0) + if (CMD_ARGC > 0) return ERROR_COMMAND_SYNTAX_ERROR; if (fastload == NULL) { @@ -4660,8 +4661,8 @@ COMMAND_HANDLER(handle_fast_load_command) int retval = ERROR_OK; for (i = 0; i < fastload_num;i++) { - struct target *target = get_current_target(cmd_ctx); - command_print(cmd_ctx, "Write to 0x%08x, length 0x%08x", + struct target *target = get_current_target(CMD_CTX); + command_print(CMD_CTX, "Write to 0x%08x, length 0x%08x", (unsigned int)(fastload[i].address), (unsigned int)(fastload[i].length)); if (retval == ERROR_OK) @@ -4671,7 +4672,7 @@ COMMAND_HANDLER(handle_fast_load_command) size += fastload[i].length; } int after = timeval_ms(); - command_print(cmd_ctx, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0)); + command_print(CMD_CTX, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0)); return retval; } @@ -4764,7 +4765,7 @@ static int jim_mcrmrc(Jim_Interp *interp, int argc, Jim_Obj *const *argv) int target_register_commands(struct command_context *cmd_ctx) { - register_command(cmd_ctx, NULL, "targets", + COMMAND_REGISTER(cmd_ctx, NULL, "targets", handle_targets_command, COMMAND_EXEC, "change current command line target (one parameter) " "or list targets (no parameters)"); @@ -4783,7 +4784,7 @@ int target_register_user_commands(struct command_context *cmd_ctx) if ((retval = trace_register_commands(cmd_ctx)) != ERROR_OK) return retval; - register_command(cmd_ctx, NULL, "profile", + COMMAND_REGISTER(cmd_ctx, NULL, "profile", handle_profile_command, COMMAND_EXEC, "profiling samples the CPU PC"); @@ -4795,94 +4796,94 @@ int target_register_user_commands(struct command_context *cmd_ctx) "convert a TCL array to memory locations and write the values " "
"); - register_command(cmd_ctx, NULL, "fast_load_image", + COMMAND_REGISTER(cmd_ctx, NULL, "fast_load_image", handle_fast_load_image_command, COMMAND_ANY, - "same args as load_image, image stored in memory " + "same CMD_ARGV as load_image, image stored in memory " "- mainly for profiling purposes"); - register_command(cmd_ctx, NULL, "fast_load", + COMMAND_REGISTER(cmd_ctx, NULL, "fast_load", handle_fast_load_command, COMMAND_ANY, "loads active fast load image to current target " "- mainly for profiling purposes"); /** @todo don't register virt2phys() unless target supports it */ - register_command(cmd_ctx, NULL, "virt2phys", + COMMAND_REGISTER(cmd_ctx, NULL, "virt2phys", handle_virt2phys_command, COMMAND_ANY, "translate a virtual address into a physical address"); - register_command(cmd_ctx, NULL, "reg", + COMMAND_REGISTER(cmd_ctx, NULL, "reg", handle_reg_command, COMMAND_EXEC, "display or set a register"); - register_command(cmd_ctx, NULL, "poll", + COMMAND_REGISTER(cmd_ctx, NULL, "poll", handle_poll_command, COMMAND_EXEC, "poll target state"); - register_command(cmd_ctx, NULL, "wait_halt", + COMMAND_REGISTER(cmd_ctx, NULL, "wait_halt", handle_wait_halt_command, COMMAND_EXEC, "wait for target halt [time (s)]"); - register_command(cmd_ctx, NULL, "halt", + COMMAND_REGISTER(cmd_ctx, NULL, "halt", handle_halt_command, COMMAND_EXEC, "halt target"); - register_command(cmd_ctx, NULL, "resume", + COMMAND_REGISTER(cmd_ctx, NULL, "resume", handle_resume_command, COMMAND_EXEC, "resume target [addr]"); - register_command(cmd_ctx, NULL, "reset", + COMMAND_REGISTER(cmd_ctx, NULL, "reset", handle_reset_command, COMMAND_EXEC, "reset target [run | halt | init] - default is run"); - register_command(cmd_ctx, NULL, "soft_reset_halt", + COMMAND_REGISTER(cmd_ctx, NULL, "soft_reset_halt", handle_soft_reset_halt_command, COMMAND_EXEC, "halt the target and do a soft reset"); - register_command(cmd_ctx, NULL, "step", + COMMAND_REGISTER(cmd_ctx, NULL, "step", handle_step_command, COMMAND_EXEC, "step one instruction from current PC or [addr]"); - register_command(cmd_ctx, NULL, "mdw", + COMMAND_REGISTER(cmd_ctx, NULL, "mdw", handle_md_command, COMMAND_EXEC, "display memory words [phys] [count]"); - register_command(cmd_ctx, NULL, "mdh", + COMMAND_REGISTER(cmd_ctx, NULL, "mdh", handle_md_command, COMMAND_EXEC, "display memory half-words [phys] [count]"); - register_command(cmd_ctx, NULL, "mdb", + COMMAND_REGISTER(cmd_ctx, NULL, "mdb", handle_md_command, COMMAND_EXEC, "display memory bytes [phys] [count]"); - register_command(cmd_ctx, NULL, "mww", + COMMAND_REGISTER(cmd_ctx, NULL, "mww", handle_mw_command, COMMAND_EXEC, "write memory word [phys] [count]"); - register_command(cmd_ctx, NULL, "mwh", + COMMAND_REGISTER(cmd_ctx, NULL, "mwh", handle_mw_command, COMMAND_EXEC, "write memory half-word [phys] [count]"); - register_command(cmd_ctx, NULL, "mwb", + COMMAND_REGISTER(cmd_ctx, NULL, "mwb", handle_mw_command, COMMAND_EXEC, "write memory byte [phys] [count]"); - register_command(cmd_ctx, NULL, "bp", + COMMAND_REGISTER(cmd_ctx, NULL, "bp", handle_bp_command, COMMAND_EXEC, "list or set breakpoint [
[hw]]"); - register_command(cmd_ctx, NULL, "rbp", + COMMAND_REGISTER(cmd_ctx, NULL, "rbp", handle_rbp_command, COMMAND_EXEC, "remove breakpoint
"); - register_command(cmd_ctx, NULL, "wp", + COMMAND_REGISTER(cmd_ctx, NULL, "wp", handle_wp_command, COMMAND_EXEC, "list or set watchpoint " "[
[value] [mask]]"); - register_command(cmd_ctx, NULL, "rwp", + COMMAND_REGISTER(cmd_ctx, NULL, "rwp", handle_rwp_command, COMMAND_EXEC, "remove watchpoint
"); - register_command(cmd_ctx, NULL, "load_image", + COMMAND_REGISTER(cmd_ctx, NULL, "load_image", handle_load_image_command, COMMAND_EXEC, "load_image
" "['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]"); - register_command(cmd_ctx, NULL, "dump_image", + COMMAND_REGISTER(cmd_ctx, NULL, "dump_image", handle_dump_image_command, COMMAND_EXEC, "dump_image
"); - register_command(cmd_ctx, NULL, "verify_image", + COMMAND_REGISTER(cmd_ctx, NULL, "verify_image", handle_verify_image_command, COMMAND_EXEC, "verify_image [offset] [type]"); - register_command(cmd_ctx, NULL, "test_image", + COMMAND_REGISTER(cmd_ctx, NULL, "test_image", handle_test_image_command, COMMAND_EXEC, "test_image [offset] [type]");