#include "target.h"
#include "target_type.h"
#include "target_request.h"
+#include "breakpoints.h"
#include "time_support.h"
#include "register.h"
#include "trace.h"
entry_point, exit_point, timeout_ms, arch_info);
}
-/// @returns @c true if the target has been examined.
-bool target_was_examined(struct target *target)
-{
- return target->type->examined;
-}
-/// Sets the @c examined flag for the given target.
-void target_set_examined(struct target *target)
-{
- target->type->examined = true;
-}
-// Reset the @c examined flag for the given target.
-void target_reset_examined(struct target *target)
+/**
+ * Reset the @c examined flag for the given target.
+ * Pure paranoia -- targets are zeroed on allocation.
+ */
+static void target_reset_examined(struct target *target)
{
- target->type->examined = false;
+ target->examined = false;
}
{
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;
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,
{
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;
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,
: "");
free(value);
} else {
- command_print(cmd_ctx, "(%i) %s (/%" PRIu32 ")",
+ command_print(CMD_CTX, "(%i) %s (/%" PRIu32 ")",
count, reg->name,
reg->size) ;
}
}
/* 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;
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(CEIL(reg->size, 8));
- str_to_buf(args[1], strlen(args[1]), buf, reg->size, 0);
+ uint8_t *buf = malloc(DIV_ROUND_UP(reg->size, 8));
+ 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);
return ERROR_OK;
}
- command_print(cmd_ctx, "usage: reg <#|name> [value]");
+ command_print(CMD_CTX, "usage: reg <#|name> [value]");
return ERROR_OK;
}
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)
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;
}
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);
}
{
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)
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");
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;
}
}
/* 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;
}
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);
}
COMMAND_HANDLER(handle_md_command)
{
- if (argc < 1)
+ if (CMD_ARGC < 1)
return ERROR_COMMAND_SYNTAX_ERROR;
unsigned size = 0;
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);
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;
}
-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;
}
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;
}
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;
}
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;
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);
}
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));
}
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 <filename> <address> <size>");
+ command_print(
CMD_CTX, "usage: dump_image <filename> <address> <size>");
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;
}
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)
if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
{
- command_print(cmd_ctx,
- "dumped %lld bytes in %fs (%0.3f kb/s)", fileio.size,
+ command_print(CMD_CTX,
+ "dumped %zu bytes in %fs (%0.3f kb/s)", fileio.size,
duration_elapsed(&bench), duration_kbps(&bench, fileio.size));
}
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;
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;
}
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;
}
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;
}
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;
/* 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);
{
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],
}
} 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);
}
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));
}
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 <address> <length> ['hw']");
+ command_print(
CMD_CTX, "usage: bp <address> <length> ['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;
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,
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;
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;
}
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;
*/
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;
}
/* 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);
}
} else
{
- command_print(cmd_ctx, "Target not halted or running");
+ command_print(CMD_CTX, "Target not halted or running");
retval = ERROR_OK;
break;
}
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);
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;
}
}
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;
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 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;
}
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;
}
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)));
}
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.");
}
COMMAND_HANDLER(handle_fast_load_command)
{
- if (argc > 0)
+ if (CMD_ARGC > 0)
return ERROR_COMMAND_SYNTAX_ERROR;
if (fastload == NULL)
{
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)
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;
}
register_command(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",
Code Review / openocd.git / blobdiff