X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=98e7a40346303f9faad88a317ee41102786c7be5;hb=59f32cbe53ccd8725e01968fcbc716cc5768a36b;hp=85c228a0c97308b97c35d8df5081f11814515f8d;hpb=98723c4ecdbe06f90c66f3abec27b792c3b38e34;p=openocd.git

diff --git a/src/target/target.c b/src/target/target.c
index 85c228a0c9..98e7a40346 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -36,6 +36,7 @@
 #include "target.h"
 #include "target_type.h"
 #include "target_request.h"
+#include "breakpoints.h"
 #include "time_support.h"
 #include "register.h"
 #include "trace.h"
@@ -644,20 +645,13 @@ int target_run_algorithm(struct target *target,
 			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;
 }
 
 
@@ -1654,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;
@@ -1686,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,
@@ -1871,10 +1865,10 @@ COMMAND_HANDLER(handle_reg_command)
 
 	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;
 
@@ -1883,7 +1877,7 @@ COMMAND_HANDLER(handle_reg_command)
 		{
 			int 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;
@@ -1893,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,
@@ -1902,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) ;
 				}
@@ -1914,10 +1908,10 @@ 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;
@@ -1939,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(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);
@@ -1988,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;
 }
@@ -1996,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)
@@ -2013,19 +2005,19 @@ COMMAND_HANDLER(handle_poll_command)
 			return retval;
 
 	}
-	else if (argc == 1)
+	else if (CMD_ARGC == 1)
 	{
-		if (strcmp(args[0], "on") == 0)
+		if (strcmp(CMD_ARGV[0], "on") == 0)
 		{
 			jtag_poll_set_enabled(true);
 		}
-		else if (strcmp(args[0], "off") == 0)
+		else if (strcmp(CMD_ARGV[0], "off") == 0)
 		{
 			jtag_poll_set_enabled(false);
 		}
 		else
 		{
-			command_print(cmd_ctx, "arg is \"on\" or \"off\"");
+			command_print(CMD_CTX, "arg is \"on\" or \"off\"");
 		}
 	} else
 	{
@@ -2037,23 +2029,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);
 }
 
@@ -2106,15 +2098,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)
@@ -2126,7 +2118,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");
 
@@ -2137,14 +2129,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;
 		}
@@ -2152,26 +2144,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;
 	}
 
@@ -2180,23 +2172,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);
 }
@@ -2252,7 +2244,7 @@ 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;
@@ -2263,36 +2255,36 @@ COMMAND_HANDLER(handle_md_command)
 	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);
 
@@ -2301,36 +2293,36 @@ 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);
 	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[2])
@@ -2363,18 +2355,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;
 	}
@@ -2383,13 +2375,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;
 	}
@@ -2403,24 +2395,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;
 	}
@@ -2432,7 +2424,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;
@@ -2470,7 +2462,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);
 		}
@@ -2480,7 +2472,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));
 	}
@@ -2499,20 +2491,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 <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;
 	}
@@ -2523,7 +2515,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)
@@ -2546,8 +2538,8 @@ COMMAND_HANDLER(handle_dump_image_command)
 
 	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));
 	}
 
@@ -2557,7 +2549,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;
@@ -2566,9 +2558,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;
 	}
@@ -2582,10 +2574,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;
 	}
@@ -2597,7 +2589,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;
 	}
@@ -2609,7 +2601,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;
@@ -2637,7 +2629,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);
 
@@ -2657,7 +2649,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],
@@ -2678,7 +2670,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);
 		}
@@ -2689,7 +2681,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));
 	}
@@ -2751,41 +2743,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 <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;
@@ -2793,21 +2785,23 @@ 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 ", len: 0x%8.8x, r/w/a: %i, value: 0x%8.8" PRIx32 ", mask: 0x%8.8" PRIx32 "",
-						  watchpoint->address,
-						  watchpoint->length,
-						  (int)(watchpoint->rw),
-						  watchpoint->value,
-						  watchpoint->mask);
+			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,
+					watchpoint->address,
+					watchpoint->length,
+					(int)watchpoint->rw,
+					watchpoint->value,
+					watchpoint->mask);
 			watchpoint = watchpoint->next;
 		}
 		return ERROR_OK;
@@ -2819,16 +2813,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;
@@ -2840,17 +2834,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;
 	}
@@ -2865,13 +2859,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;
@@ -2886,17 +2880,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;
 }
@@ -3020,20 +3014,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);
@@ -3065,7 +3059,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;
 		}
@@ -3077,7 +3071,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);
@@ -3092,8 +3086,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;
 		}
 	}
@@ -4539,7 +4533,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;
@@ -4547,7 +4541,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;
@@ -4555,7 +4549,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;
 	}
@@ -4575,7 +4569,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;
 		}
@@ -4618,7 +4612,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)));
 		}
@@ -4628,11 +4622,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.");
 	}
@@ -4649,7 +4643,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)
 	{
@@ -4662,8 +4656,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)
@@ -4673,7 +4667,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;
 }
 
@@ -4799,7 +4793,7 @@ int target_register_user_commands(struct command_context *cmd_ctx)
 
 	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",