X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;ds=sidebyside;f=src%2Ftarget%2Ftarget.c;h=d9552a58a0448eb76b472dee6fac5463aecb745c;hb=cb8d567b7524b96d034344a2027e33d7f44f48ec;hp=0b2438c3cd9f01440ee694443674682471c788d8;hpb=f4788652e45662d1e43933dc0620561bc4cddae0;p=openocd.git

diff --git a/src/target/target.c b/src/target/target.c
index 0b2438c3cd..d9552a58a0 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -65,6 +65,7 @@ extern struct target_type cortexa8_target;
 extern struct target_type arm11_target;
 extern struct target_type mips_m4k_target;
 extern struct target_type avr_target;
+extern struct target_type testee_target;
 
 struct target_type *target_types[] =
 {
@@ -83,6 +84,7 @@ struct target_type *target_types[] =
 	&arm11_target,
 	&mips_m4k_target,
 	&avr_target,
+	&testee_target,
 	NULL,
 };
 
@@ -145,6 +147,7 @@ static const Jim_Nvp nvp_target_event[] = {
 	{ .value = TARGET_EVENT_RESET_START, .name = "reset-start" },
 
 	{ .value = TARGET_EVENT_RESET_ASSERT_PRE,    .name = "reset-assert-pre" },
+	{ .value = TARGET_EVENT_RESET_ASSERT,        .name = "reset-assert" },
 	{ .value = TARGET_EVENT_RESET_ASSERT_POST,   .name = "reset-assert-post" },
 	{ .value = TARGET_EVENT_RESET_DEASSERT_PRE,  .name = "reset-deassert-pre" },
 	{ .value = TARGET_EVENT_RESET_DEASSERT_POST, .name = "reset-deassert-post" },
@@ -152,8 +155,8 @@ static const Jim_Nvp nvp_target_event[] = {
 	{ .value = TARGET_EVENT_RESET_HALT_POST,     .name = "reset-halt-post" },
 	{ .value = TARGET_EVENT_RESET_WAIT_PRE,      .name = "reset-wait-pre" },
 	{ .value = TARGET_EVENT_RESET_WAIT_POST,     .name = "reset-wait-post" },
-	{ .value = TARGET_EVENT_RESET_INIT , .name = "reset-init" },
-	{ .value = TARGET_EVENT_RESET_END, .name = "reset-end" },
+	{ .value = TARGET_EVENT_RESET_INIT,          .name = "reset-init" },
+	{ .value = TARGET_EVENT_RESET_END,           .name = "reset-end" },
 
 	{ .value = TARGET_EVENT_EXAMINE_START, .name = "examine-start" },
 	{ .value = TARGET_EVENT_EXAMINE_END, .name = "examine-end" },
@@ -520,7 +523,7 @@ int target_examine(void)
 	}
 	return retval;
 }
-const char *target_get_name(struct target *target)
+const char *target_type_name(struct target *target)
 {
 	return target->type->name;
 }
@@ -554,7 +557,7 @@ static int target_soft_reset_halt_imp(struct target *target)
 	}
 	if (!target->type->soft_reset_halt_imp) {
 		LOG_ERROR("Target %s does not support soft_reset_halt",
-				target->cmd_name);
+				target_name(target));
 		return ERROR_FAIL;
 	}
 	return target->type->soft_reset_halt_imp(target);
@@ -603,6 +606,10 @@ int target_bulk_write_memory(struct target *target,
 int target_add_breakpoint(struct target *target,
 		struct breakpoint *breakpoint)
 {
+	if (target->state != TARGET_HALTED) {
+		LOG_WARNING("target %s is not halted", target->cmd_name);
+		return ERROR_TARGET_NOT_HALTED;
+	}
 	return target->type->add_breakpoint(target, breakpoint);
 }
 int target_remove_breakpoint(struct target *target,
@@ -614,6 +621,10 @@ int target_remove_breakpoint(struct target *target,
 int target_add_watchpoint(struct target *target,
 		struct watchpoint *watchpoint)
 {
+	if (target->state != TARGET_HALTED) {
+		LOG_WARNING("target %s is not halted", target->cmd_name);
+		return ERROR_TARGET_NOT_HALTED;
+	}
 	return target->type->add_watchpoint(target, watchpoint);
 }
 int target_remove_watchpoint(struct target *target,
@@ -764,7 +775,7 @@ int target_init(struct command_context *cmd_ctx)
 
 		if ((retval = target->type->init_target(cmd_ctx, target)) != ERROR_OK)
 		{
-			LOG_ERROR("target '%s' init failed", target_get_name(target));
+			LOG_ERROR("target '%s' init failed", target_name(target));
 			return retval;
 		}
 
@@ -777,12 +788,14 @@ int target_init(struct command_context *cmd_ctx)
 			target->type->mcr = default_mcr;
 		} else
 		{
-			/* FIX! multiple targets will generally register global commands
-			 * multiple times. Only register this one if *one* of the
-			 * targets need the command. Hmm... make it a command on the
-			 * Jim Tcl target object?
-			 */
-			register_jim(cmd_ctx, "mcr", jim_mcrmrc, "write coprocessor <cpnum> <op1> <op2> <CRn> <CRm> <value>");
+			const struct command_registration mcr_cmd = {
+				.name = "mcr",
+				.mode = COMMAND_EXEC,
+				.jim_handler = &jim_mcrmrc,
+				.help = "write coprocessor",
+				.usage = "<cpnum> <op1> <op2> <CRn> <CRm> <value>",
+			};
+			register_command(cmd_ctx, NULL, &mcr_cmd);
 		}
 
 		if (target->type->mrc == NULL)
@@ -790,7 +803,13 @@ int target_init(struct command_context *cmd_ctx)
 			target->type->mrc = default_mrc;
 		} else
 		{
-			register_jim(cmd_ctx, "mrc", jim_mcrmrc, "read coprocessor <cpnum> <op1> <op2> <CRn> <CRm>");
+			const struct command_registration mrc_cmd = {
+				.name = "mrc",
+				.jim_handler = &jim_mcrmrc,
+				.help = "read coprocessor",
+				.usage = "<cpnum> <op1> <op2> <CRn> <CRm>",
+			};
+			register_command(cmd_ctx, NULL, &mrc_cmd);
 		}
 
 
@@ -1648,28 +1667,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,15 +1699,15 @@ 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,
-					  target_get_name(target),
+					  target_name(target),
+					  target_type_name(target),
 					  Jim_Nvp_value2name_simple(nvp_target_endian,
 								target->endianness)->name,
 					  target->tap->dotted_name,
@@ -1860,24 +1879,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 +1906,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 +1915,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 +1927,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,24 +1952,24 @@ 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)
@@ -1958,21 +1977,21 @@ COMMAND_HANDLER(handle_reg_command)
 			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);
 
 		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);
@@ -1980,7 +1999,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;
 }
@@ -1988,13 +2007,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)
@@ -2003,23 +2022,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;
 	}
@@ -2029,23 +2039,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);
 }
 
@@ -2098,15 +2108,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)
@@ -2118,7 +2128,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");
 
@@ -2129,14 +2139,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;
 		}
@@ -2144,26 +2154,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;
 	}
 
@@ -2172,23 +2182,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);
 }
@@ -2244,48 +2254,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);
 
@@ -2294,40 +2303,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;
@@ -2357,18 +2365,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;
 	}
@@ -2377,13 +2385,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;
 	}
@@ -2404,17 +2412,17 @@ COMMAND_HANDLER(handle_load_image_command)
 	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;
 	}
@@ -2426,7 +2434,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;
@@ -2464,7 +2472,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);
 		}
@@ -2474,7 +2482,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));
 	}
@@ -2493,20 +2501,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;
 	}
@@ -2540,7 +2548,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));
 	}
@@ -2560,9 +2568,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;
 	}
@@ -2576,10 +2584,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;
 	}
@@ -2591,7 +2599,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;
 	}
@@ -2603,7 +2611,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;
@@ -2631,7 +2639,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);
 
@@ -2651,7 +2659,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],
@@ -2672,7 +2680,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 			}
 		} else
 		{
-			command_print(cmd_ctx, "address 0x%08" PRIx32 " length 0x%08zx",
+			command_print(CMD_CTX, "address 0x%08" PRIx32 " length 0x%08zx",
 						  image.sections[i].base_address,
 						  buf_cnt);
 		}
@@ -2683,7 +2691,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));
 	}
@@ -2745,41 +2753,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;
@@ -2787,15 +2795,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,
@@ -2815,16 +2823,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;
@@ -2836,17 +2844,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;
 	}
@@ -2861,13 +2869,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;
@@ -2882,17 +2890,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;
 }
@@ -3016,20 +3024,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);
@@ -3061,7 +3069,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;
 		}
@@ -3073,7 +3081,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);
@@ -3088,8 +3096,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;
 		}
 	}
@@ -3156,7 +3164,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;
 
@@ -3238,14 +3245,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);
@@ -3279,6 +3292,8 @@ static int target_mem2array(Jim_Interp *interp, struct target *target, int argc,
 		}
 	}
 
+	free(buffer);
+
 	Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
 
 	return JIM_OK;
@@ -3342,7 +3357,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;
 
@@ -3426,12 +3440,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 */
@@ -3465,6 +3485,8 @@ static int target_array2mem(Jim_Interp *interp, struct target *target, int argc,
 		}
 	}
 
+	free(buffer);
+
 	Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
 
 	return JIM_OK;
@@ -3497,8 +3519,8 @@ void target_handle_event(struct target *target, enum target_event e)
 		if (teap->event == e) {
 			LOG_DEBUG("target: (%d) %s (%s) event: %d (%s) action: %s",
 					   target->target_number,
-					   target->cmd_name,
-					   target_get_name(target),
+					   target_name(target),
+					   target_type_name(target),
 					   e,
 					   Jim_Nvp_value2name_simple(nvp_target_event, e)->name,
 					   Jim_GetString(teap->body, NULL));
@@ -3510,6 +3532,20 @@ void target_handle_event(struct target *target, enum target_event e)
 	}
 }
 
+/**
+ * Returns true only if the target has a handler for the specified event.
+ */
+bool target_has_event_action(struct target *target, enum target_event event)
+{
+	struct target_event_action *teap;
+
+	for (teap = target->event_action; teap != NULL; teap = teap->next) {
+		if (teap->event == event)
+			return true;
+	}
+	return false;
+}
+
 enum target_cfg_param {
 	TCFG_TYPE,
 	TCFG_EVENT,
@@ -3572,16 +3608,20 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 		case TCFG_TYPE:
 			/* not setable */
 			if (goi->isconfigure) {
-				Jim_SetResult_sprintf(goi->interp, "not setable: %s", n->name);
+				Jim_SetResult_sprintf(goi->interp,
+						"not settable: %s", n->name);
 				return JIM_ERR;
 			} else {
 			no_params:
 				if (goi->argc != 0) {
-					Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "NO PARAMS");
+					Jim_WrongNumArgs(goi->interp,
+							goi->argc, goi->argv,
+							"NO PARAMS");
 					return JIM_ERR;
 				}
 			}
-			Jim_SetResultString(goi->interp, target_get_name(target), -1);
+			Jim_SetResultString(goi->interp,
+					target_type_name(target), -1);
 			/* loop for more */
 			break;
 		case TCFG_EVENT:
@@ -4122,7 +4162,7 @@ static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 				|| !target->type->deassert_reset) {
 			Jim_SetResult_sprintf(interp,
 					"No target-specific reset for %s",
-					target->cmd_name);
+					target_name(target));
 			return JIM_ERR;
 		}
 		/* determine if we should halt or not. */
@@ -4166,10 +4206,9 @@ static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		e = target_wait_state(target, n->value, a);
 		if (e != ERROR_OK) {
 			Jim_SetResult_sprintf(goi.interp,
-								   "target: %s wait %s fails (%d) %s",
-								   target->cmd_name,
-								   n->name,
-								   e, target_strerror_safe(e));
+					"target: %s wait %s fails (%d) %s",
+					target_name(target), n->name,
+					e, target_strerror_safe(e));
 			return JIM_ERR;
 		} else {
 			return JIM_OK;
@@ -4181,9 +4220,10 @@ static int tcl_target_func(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 		{
 			struct target_event_action *teap;
 			teap = target->event_action;
-			command_print(cmd_ctx, "Event actions for target (%d) %s\n",
-						   target->target_number,
-						   target->cmd_name);
+			command_print(cmd_ctx,
+					"Event actions for target (%d) %s\n",
+					target->target_number,
+					target_name(target));
 			command_print(cmd_ctx, "%-25s | Body", "Event");
 			command_print(cmd_ctx, "------------------------- | ----------------------------------------");
 			while (teap) {
@@ -4350,9 +4390,14 @@ static int target_create(Jim_GetOptInfo *goi)
 	if (!target->variant)
 		target->variant = strdup("");
 
+	cp = Jim_GetString(new_cmd, NULL);
+	target->cmd_name = strdup(cp);
+
 	/* create the target specific commands */
-	if (target->type->register_commands) {
-		(*(target->type->register_commands))(cmd_ctx);
+	if (target->type->commands) {
+		e = register_commands(cmd_ctx, NULL, target->type->commands);
+		if (ERROR_OK != e)
+			LOG_ERROR("unable to register '%s' commands", cp);
 	}
 	if (target->type->target_create) {
 		(*(target->type->target_create))(target, goi->interp);
@@ -4368,140 +4413,167 @@ static int target_create(Jim_GetOptInfo *goi)
 		*tpp = target;
 	}
 
-	cp = Jim_GetString(new_cmd, NULL);
-	target->cmd_name = strdup(cp);
-
 	/* now - create the new target name command */
-	e = Jim_CreateCommand(goi->interp,
-						   /* name */
-						   cp,
-						   tcl_target_func, /* C function */
-						   target, /* private data */
-						   NULL); /* no del proc */
-
-	return e;
+	const struct command_registration target_command = {
+		.name = cp,
+		.jim_handler = &tcl_target_func,
+		.jim_handler_data = target,
+		.help = "target command group",
+	};
+	struct command *c = register_command(cmd_ctx, NULL, &target_command);
+	return (NULL != c) ? ERROR_OK : ERROR_FAIL;
 }
 
-static int jim_target(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+static int jim_target_current(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 {
-	int x,r,e;
-	jim_wide w;
-	struct command_context *cmd_ctx;
-	struct target *target;
-	Jim_GetOptInfo goi;
-	enum tcmd {
-		/* TG = target generic */
-		TG_CMD_CREATE,
-		TG_CMD_TYPES,
-		TG_CMD_NAMES,
-		TG_CMD_CURRENT,
-		TG_CMD_NUMBER,
-		TG_CMD_COUNT,
-	};
-	const char *target_cmds[] = {
-		"create", "types", "names", "current", "number",
-		"count",
-		NULL /* terminate */
-	};
-
-	LOG_DEBUG("Target command params:");
-	LOG_DEBUG("%s", Jim_Debug_ArgvString(interp, argc, argv));
-
-	cmd_ctx = Jim_GetAssocData(interp, "context");
+	if (argc != 1)
+	{
+		Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
+		return JIM_ERR;
+	}
+	struct command_context *cmd_ctx = Jim_GetAssocData(interp, "context");
+	Jim_SetResultString(interp, get_current_target(cmd_ctx)->cmd_name, -1);
+	return JIM_OK;
+}
 
-	Jim_GetOpt_Setup(&goi, interp, argc-1, argv + 1);
+static int jim_target_types(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	if (argc != 1)
+	{
+		Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
+		return JIM_ERR;
+	}
+	Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
+	for (unsigned x = 0; NULL != target_types[x]; x++)
+	{
+		Jim_ListAppendElement(interp, Jim_GetResult(interp),
+			Jim_NewStringObj(interp, target_types[x]->name, -1));
+	}
+	return JIM_OK;
+}
 
-	if (goi.argc == 0) {
-		Jim_WrongNumArgs(interp, 1, argv, "missing: command ...");
+static int jim_target_names(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	if (argc != 1)
+	{
+		Jim_WrongNumArgs(interp, 1, argv, "Too many parameters");
 		return JIM_ERR;
 	}
+	Jim_SetResult(interp, Jim_NewListObj(interp, NULL, 0));
+	struct target *target = all_targets;
+	while (target)
+	{
+		Jim_ListAppendElement(interp, Jim_GetResult(interp),
+			Jim_NewStringObj(interp, target_name(target), -1));
+		target = target->next;
+	}
+	return JIM_OK;
+}
 
-	/* Jim_GetOpt_Debug(&goi); */
-	r = Jim_GetOpt_Enum(&goi, target_cmds, &x);
-	if (r != JIM_OK) {
-		return r;
+static int jim_target_create(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	Jim_GetOptInfo goi;
+	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
+	if (goi.argc < 3)
+	{
+		Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv,
+			"<name> <target_type> [<target_options> ...]");
+		return JIM_ERR;
 	}
+	return target_create(&goi);
+}
 
-	switch (x) {
-	default:
-		Jim_Panic(goi.interp,"Why am I here?");
+static int jim_target_number(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	Jim_GetOptInfo goi;
+	Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1);
+
+	/* It's OK to remove this mechanism sometime after August 2010 or so */
+	LOG_WARNING("don't use numbers as target identifiers; use names");
+	if (goi.argc != 1)
+	{
+		Jim_SetResult_sprintf(goi.interp, "usage: target number <number>");
 		return JIM_ERR;
-	case TG_CMD_CURRENT:
-		if (goi.argc != 0) {
-			Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
-			return JIM_ERR;
-		}
-		Jim_SetResultString(goi.interp, get_current_target(cmd_ctx)->cmd_name, -1);
-		return JIM_OK;
-	case TG_CMD_TYPES:
-		if (goi.argc != 0) {
-			Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
-			return JIM_ERR;
-		}
-		Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
-		for (x = 0 ; target_types[x] ; x++) {
-			Jim_ListAppendElement(goi.interp,
-								   Jim_GetResult(goi.interp),
-								   Jim_NewStringObj(goi.interp, target_types[x]->name, -1));
-		}
-		return JIM_OK;
-	case TG_CMD_NAMES:
-		if (goi.argc != 0) {
-			Jim_WrongNumArgs(goi.interp, 1, goi.argv, "Too many parameters");
-			return JIM_ERR;
-		}
-		Jim_SetResult(goi.interp, Jim_NewListObj(goi.interp, NULL, 0));
-		target = all_targets;
-		while (target) {
-			Jim_ListAppendElement(goi.interp,
-								   Jim_GetResult(goi.interp),
-								   Jim_NewStringObj(goi.interp, target->cmd_name, -1));
-			target = target->next;
-		}
-		return JIM_OK;
-	case TG_CMD_CREATE:
-		if (goi.argc < 3) {
-			Jim_WrongNumArgs(goi.interp, goi.argc, goi.argv, "?name  ... config options ...");
-			return JIM_ERR;
-		}
-		return target_create(&goi);
-		break;
-	case TG_CMD_NUMBER:
-		/* It's OK to remove this mechanism sometime after August 2010 or so */
-		LOG_WARNING("don't use numbers as target identifiers; use names");
-		if (goi.argc != 1) {
-			Jim_SetResult_sprintf(goi.interp, "expected: target number ?NUMBER?");
-			return JIM_ERR;
-		}
-		e = Jim_GetOpt_Wide(&goi, &w);
-		if (e != JIM_OK) {
-			return JIM_ERR;
-		}
-		for (x = 0, target = all_targets; target; target = target->next, x++) {
-			if (target->target_number == w)
-				break;
-		}
-		if (target == NULL) {
-			Jim_SetResult_sprintf(goi.interp,
-					"Target: number %d does not exist", (int)(w));
-			return JIM_ERR;
-		}
-		Jim_SetResultString(goi.interp, target->cmd_name, -1);
-		return JIM_OK;
-	case TG_CMD_COUNT:
-		if (goi.argc != 0) {
-			Jim_WrongNumArgs(goi.interp, 0, goi.argv, "<no parameters>");
-			return JIM_ERR;
-		}
-		for (x = 0, target = all_targets; target; target = target->next, x++)
+	}
+	jim_wide w;
+	int e = Jim_GetOpt_Wide(&goi, &w);
+	if (e != JIM_OK)
+		return JIM_ERR;
+
+	struct target *target;
+	for (target = all_targets; NULL != target; target = target->next)
+	{
+		if (target->target_number != w)
 			continue;
-		Jim_SetResult(goi.interp, Jim_NewIntObj(goi.interp, x));
+
+		Jim_SetResultString(goi.interp, target_name(target), -1);
 		return JIM_OK;
 	}
-
+	Jim_SetResult_sprintf(goi.interp,
+			"Target: number %d does not exist", (int)(w));
 	return JIM_ERR;
 }
 
+static int jim_target_count(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
+{
+	if (argc != 1)
+	{
+		Jim_WrongNumArgs(interp, 1, argv, "<no parameters>");
+		return JIM_ERR;
+	}
+	unsigned count = 0;
+	struct target *target = all_targets;
+	while (NULL != target)
+	{
+		target = target->next;
+		count++;
+	}
+	Jim_SetResult(interp, Jim_NewIntObj(interp, count));
+	return JIM_OK;
+}
+
+static const struct command_registration target_subcommand_handlers[] = {
+	{
+		.name = "create",
+		.mode = COMMAND_ANY,
+		.jim_handler = &jim_target_create,
+		.usage = "<name> <type> ...",
+		.help = "Returns the currently selected target",
+	},
+	{
+		.name = "current",
+		.mode = COMMAND_ANY,
+		.jim_handler = &jim_target_current,
+		.help = "Returns the currently selected target",
+	},
+	{
+		.name = "types",
+		.mode = COMMAND_ANY,
+		.jim_handler = &jim_target_types,
+		.help = "Returns the available target types as a list of strings",
+	},
+	{
+		.name = "names",
+		.mode = COMMAND_ANY,
+		.jim_handler = &jim_target_names,
+		.help = "Returns the names of all targets as a list of strings",
+	},
+	{
+		.name = "number",
+		.mode = COMMAND_ANY,
+		.jim_handler = &jim_target_number,
+		.usage = "<number>",
+		.help = "Returns the name of target <n>",
+	},
+	{
+		.name = "count",
+		.mode = COMMAND_ANY,
+		.jim_handler = &jim_target_count,
+		.help = "Returns the number of targets as an integer",
+	},
+	COMMAND_REGISTRATION_DONE
+};
+
 
 struct FastLoad
 {
@@ -4543,7 +4615,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;
@@ -4551,7 +4623,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;
 	}
@@ -4571,7 +4643,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;
 		}
@@ -4614,7 +4686,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)));
 		}
@@ -4624,11 +4696,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.");
 	}
@@ -4645,7 +4717,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)
 	{
@@ -4658,8 +4730,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)
@@ -4669,7 +4741,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;
 }
 
@@ -4759,19 +4831,233 @@ static int jim_mcrmrc(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	return JIM_OK;
 }
 
-int target_register_commands(struct command_context *cmd_ctx)
-{
-
-	register_command(cmd_ctx, NULL, "targets",
-			handle_targets_command, COMMAND_EXEC,
-			"change current command line target (one parameter) "
-			"or list targets (no parameters)");
+static const struct command_registration target_command_handlers[] = {
+	{
+		.name = "targets",
+		.handler = &handle_targets_command,
+		.mode = COMMAND_ANY,
+		.help = "change current command line target (one parameter) "
+			"or list targets (no parameters)",
+		.usage = "[<new_current_target>]",
+	},
+	{
+		.name = "target",
+		.mode = COMMAND_CONFIG,
+		.help = "configure target",
 
-	register_jim(cmd_ctx, "target", jim_target, "configure target");
+		.chain = target_subcommand_handlers,
+	},
+	COMMAND_REGISTRATION_DONE
+};
 
-	return ERROR_OK;
+int target_register_commands(struct command_context *cmd_ctx)
+{
+	return register_commands(cmd_ctx, NULL, target_command_handlers);
 }
 
+static const struct command_registration target_exec_command_handlers[] = {
+	{
+		.name = "fast_load_image",
+		.handler = &handle_fast_load_image_command,
+		.mode = COMMAND_ANY,
+		.help = "Load image into memory, mainly for profiling purposes",
+		.usage = "<file> <address> ['bin'|'ihex'|'elf'|'s19'] "
+			"[min_address] [max_length]",
+	},
+	{
+		.name = "fast_load",
+		.handler = &handle_fast_load_command,
+		.mode = COMMAND_ANY,
+		.help = "loads active fast load image to current target "
+			"- mainly for profiling purposes",
+	},
+	{
+		.name = "profile",
+		.handler = &handle_profile_command,
+		.mode = COMMAND_EXEC,
+		.help = "profiling samples the CPU PC",
+	},
+	/** @todo don't register virt2phys() unless target supports it */
+	{
+		.name = "virt2phys",
+		.handler = &handle_virt2phys_command,
+		.mode = COMMAND_ANY,
+		.help = "translate a virtual address into a physical address",
+	},
+
+	{
+		.name = "reg",
+		.handler = &handle_reg_command,
+		.mode = COMMAND_EXEC,
+		.help = "display or set a register",
+	},
+
+	{
+		.name = "poll",
+		.handler = &handle_poll_command,
+		.mode = COMMAND_EXEC,
+		.help = "poll target state",
+	},
+	{
+		.name = "wait_halt",
+		.handler = &handle_wait_halt_command,
+		.mode = COMMAND_EXEC,
+		.help = "wait for target halt",
+		.usage = "[time (s)]",
+	},
+	{
+		.name = "halt",
+		.handler = &handle_halt_command,
+		.mode = COMMAND_EXEC,
+		.help = "halt target",
+	},
+	{
+		.name = "resume",
+		.handler = &handle_resume_command,
+		.mode = COMMAND_EXEC,
+		.help = "resume target",
+		.usage = "[<address>]",
+	},
+	{
+		.name = "reset",
+		.handler = &handle_reset_command,
+		.mode = COMMAND_EXEC,
+		.usage = "[run|halt|init]",
+		.help = "Reset all targets into the specified mode."
+			"Default reset mode is run, if not given.",
+	},
+	{
+		.name = "soft_reset_halt",
+		.handler = &handle_soft_reset_halt_command,
+		.mode = COMMAND_EXEC,
+		.help = "halt the target and do a soft reset",
+	},
+	{
+
+		.name = "step",
+		.handler = &handle_step_command,
+		.mode = COMMAND_EXEC,
+		.help =	"step one instruction from current PC or [addr]",
+		.usage = "[<address>]",
+	},
+	{
+
+		.name = "mdw",
+		.handler = &handle_md_command,
+		.mode = COMMAND_EXEC,
+		.help = "display memory words",
+		.usage = "[phys] <addr> [count]",
+	},
+	{
+		.name = "mdh",
+		.handler = &handle_md_command,
+		.mode = COMMAND_EXEC,
+		.help = "display memory half-words",
+		.usage = "[phys] <addr> [count]",
+	},
+	{
+		.name = "mdb",
+		.handler = &handle_md_command,
+		.mode = COMMAND_EXEC,
+		.help = "display memory bytes",
+		.usage = "[phys] <addr> [count]",
+	},
+	{
+
+		.name = "mww",
+		.handler = &handle_mw_command,
+		.mode = COMMAND_EXEC,
+		.help = "write memory word",
+		.usage = "[phys]  <addr> <value> [count]",
+	},
+	{
+		.name = "mwh",
+		.handler = &handle_mw_command,
+		.mode = COMMAND_EXEC,
+		.help = "write memory half-word",
+		.usage = "[phys] <addr> <value> [count]",
+	},
+	{
+		.name = "mwb",
+		.handler = &handle_mw_command,
+		.mode = COMMAND_EXEC,
+		.help = "write memory byte",
+		.usage = "[phys] <addr> <value> [count]",
+	},
+	{
+
+		.name = "bp",
+		.handler = &handle_bp_command,
+		.mode = COMMAND_EXEC,
+		.help = "list or set breakpoint",
+		.usage = "[<address> <length> [hw]]",
+	},
+	{
+		.name = "rbp",
+		.handler = &handle_rbp_command,
+		.mode = COMMAND_EXEC,
+		.help = "remove breakpoint",
+		.usage = "<address>",
+	},
+	{
+
+		.name = "wp",
+		.handler = &handle_wp_command,
+		.mode = COMMAND_EXEC,
+		.help = "list or set watchpoint",
+		.usage = "[<address> <length> <r/w/a> [value] [mask]]",
+	},
+	{
+		.name = "rwp",
+		.handler = &handle_rwp_command,
+		.mode = COMMAND_EXEC,
+		.help = "remove watchpoint",
+		.usage = "<address>",
+
+	},
+	{
+		.name = "load_image",
+		.handler = &handle_load_image_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<file> <address> ['bin'|'ihex'|'elf'|'s19'] "
+			"[min_address] [max_length]",
+	},
+	{
+		.name = "dump_image",
+		.handler = &handle_dump_image_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<file> <address> <size>",
+	},
+	{
+		.name = "verify_image",
+		.handler = &handle_verify_image_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<file> [offset] [type]",
+	},
+	{
+		.name = "test_image",
+		.handler = &handle_test_image_command,
+		.mode = COMMAND_EXEC,
+		.usage = "<file> [offset] [type]",
+	},
+	{
+		.name = "ocd_mem2array",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_mem2array,
+		.help = "read memory and return as a TCL array "
+			"for script processing",
+		.usage = "<arrayname> <width=32|16|8> <address> <count>",
+	},
+	{
+		.name = "ocd_array2mem",
+		.mode = COMMAND_EXEC,
+		.jim_handler = &jim_array2mem,
+		.help = "convert a TCL array to memory locations "
+			"and write the values",
+		.usage = "<arrayname> <width=32|16|8> <address> <count>",
+	},
+	COMMAND_REGISTRATION_DONE
+};
 int target_register_user_commands(struct command_context *cmd_ctx)
 {
 	int retval = ERROR_OK;
@@ -4781,108 +5067,6 @@ 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",
-			handle_profile_command, COMMAND_EXEC,
-			"profiling samples the CPU PC");
-
-	register_jim(cmd_ctx, "ocd_mem2array", jim_mem2array,
-			"read memory and return as a TCL array for script processing "
-			"<ARRAYNAME> <WIDTH = 32/16/8> <ADDRESS> <COUNT>");
-
-	register_jim(cmd_ctx, "ocd_array2mem", jim_array2mem,
-			"convert a TCL array to memory locations and write the values "
-			"<ARRAYNAME> <WIDTH = 32/16/8> <ADDRESS> <COUNT>");
 
-	register_command(cmd_ctx, NULL, "fast_load_image",
-			handle_fast_load_image_command, COMMAND_ANY,
-			"same args as load_image, image stored in memory "
-			"- mainly for profiling purposes");
-
-	register_command(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",
-			handle_virt2phys_command, COMMAND_ANY,
-			"translate a virtual address into a physical address");
-
-	register_command(cmd_ctx,  NULL, "reg",
-			handle_reg_command, COMMAND_EXEC,
-			"display or set a register");
-
-	register_command(cmd_ctx,  NULL, "poll",
-			handle_poll_command, COMMAND_EXEC,
-			"poll target state");
-	register_command(cmd_ctx,  NULL, "wait_halt",
-			handle_wait_halt_command, COMMAND_EXEC,
-			"wait for target halt [time (s)]");
-	register_command(cmd_ctx,  NULL, "halt",
-			handle_halt_command, COMMAND_EXEC,
-			"halt target");
-	register_command(cmd_ctx,  NULL, "resume",
-			handle_resume_command, COMMAND_EXEC,
-			"resume target [addr]");
-	register_command(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",
-			handle_soft_reset_halt_command, COMMAND_EXEC,
-			"halt the target and do a soft reset");
-
-	register_command(cmd_ctx,  NULL, "step",
-			handle_step_command, COMMAND_EXEC,
-			"step one instruction from current PC or [addr]");
-
-	register_command(cmd_ctx,  NULL, "mdw",
-			handle_md_command, COMMAND_EXEC,
-			"display memory words [phys] <addr> [count]");
-	register_command(cmd_ctx,  NULL, "mdh",
-			handle_md_command, COMMAND_EXEC,
-			"display memory half-words [phys] <addr> [count]");
-	register_command(cmd_ctx,  NULL, "mdb",
-			handle_md_command, COMMAND_EXEC,
-			"display memory bytes [phys] <addr> [count]");
-
-	register_command(cmd_ctx,  NULL, "mww",
-			handle_mw_command, COMMAND_EXEC,
-			"write memory word [phys]  <addr> <value> [count]");
-	register_command(cmd_ctx,  NULL, "mwh",
-			handle_mw_command, COMMAND_EXEC,
-			"write memory half-word [phys]  <addr> <value> [count]");
-	register_command(cmd_ctx,  NULL, "mwb",
-			handle_mw_command, COMMAND_EXEC,
-			"write memory byte [phys] <addr> <value> [count]");
-
-	register_command(cmd_ctx,  NULL, "bp",
-			handle_bp_command, COMMAND_EXEC,
-			"list or set breakpoint [<address> <length> [hw]]");
-	register_command(cmd_ctx,  NULL, "rbp",
-			handle_rbp_command, COMMAND_EXEC,
-			"remove breakpoint <address>");
-
-	register_command(cmd_ctx,  NULL, "wp",
-			handle_wp_command, COMMAND_EXEC,
-			"list or set watchpoint "
-				"[<address> <length> <r/w/a> [value] [mask]]");
-	register_command(cmd_ctx,  NULL, "rwp",
-			handle_rwp_command, COMMAND_EXEC,
-			"remove watchpoint <address>");
-
-	register_command(cmd_ctx,  NULL, "load_image",
-			handle_load_image_command, COMMAND_EXEC,
-			"load_image <file> <address> "
-			"['bin'|'ihex'|'elf'|'s19'] [min_address] [max_length]");
-	register_command(cmd_ctx,  NULL, "dump_image",
-			handle_dump_image_command, COMMAND_EXEC,
-			"dump_image <file> <address> <size>");
-	register_command(cmd_ctx,  NULL, "verify_image",
-			handle_verify_image_command, COMMAND_EXEC,
-			"verify_image <file> [offset] [type]");
-	register_command(cmd_ctx,  NULL, "test_image",
-			handle_test_image_command, COMMAND_EXEC,
-			"test_image <file> [offset] [type]");
-
-	return ERROR_OK;
+	return register_commands(cmd_ctx, NULL, target_exec_command_handlers);
 }