X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=ef4568564694e7bffa701deeac68ad60fd1643a0;hp=e4235ed26ab5d2e4c52f55e488826be24a52b519;hb=b71ae9b1a704a9631698d7d4a92b1dfdfc9a0f69;hpb=01dde68a4b4c362f64b7b5f2223ee08029bcc019

diff --git a/src/target/target.c b/src/target/target.c
index e4235ed26a..ef45685646 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -55,14 +55,15 @@
 #include "trace.h"
 #include "image.h"
 #include "rtos/rtos.h"
+#include "transport/transport.h"
 
 /* default halt wait timeout (ms) */
 #define DEFAULT_HALT_TIMEOUT 5000
 
 static int target_read_buffer_default(struct target *target, uint32_t address,
-		uint32_t size, uint8_t *buffer);
+		uint32_t count, uint8_t *buffer);
 static int target_write_buffer_default(struct target *target, uint32_t address,
-		uint32_t size, const uint8_t *buffer);
+		uint32_t count, const uint8_t *buffer);
 static int target_array2mem(Jim_Interp *interp, struct target *target,
 		int argc, Jim_Obj * const *argv);
 static int target_mem2array(Jim_Interp *interp, struct target *target,
@@ -72,6 +73,8 @@ static int target_get_gdb_fileio_info_default(struct target *target,
 		struct gdb_fileio_info *fileio_info);
 static int target_gdb_fileio_end_default(struct target *target, int retcode,
 		int fileio_errno, bool ctrl_c);
+static int target_profiling_default(struct target *target, uint32_t *samples,
+		uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds);
 
 /* targets */
 extern struct target_type arm7tdmi_target;
@@ -85,8 +88,8 @@ extern struct target_type fa526_target;
 extern struct target_type feroceon_target;
 extern struct target_type dragonite_target;
 extern struct target_type xscale_target;
-extern struct target_type cortexm3_target;
-extern struct target_type cortexa8_target;
+extern struct target_type cortexm_target;
+extern struct target_type cortexa_target;
 extern struct target_type cortexr4_target;
 extern struct target_type arm11_target;
 extern struct target_type mips_m4k_target;
@@ -99,6 +102,8 @@ extern struct target_type hla_target;
 extern struct target_type nds32_v2_target;
 extern struct target_type nds32_v3_target;
 extern struct target_type nds32_v3m_target;
+extern struct target_type or1k_target;
+extern struct target_type quark_x10xx_target;
 
 static struct target_type *target_types[] = {
 	&arm7tdmi_target,
@@ -112,8 +117,8 @@ static struct target_type *target_types[] = {
 	&feroceon_target,
 	&dragonite_target,
 	&xscale_target,
-	&cortexm3_target,
-	&cortexa8_target,
+	&cortexm_target,
+	&cortexa_target,
 	&cortexr4_target,
 	&arm11_target,
 	&mips_m4k_target,
@@ -126,12 +131,15 @@ static struct target_type *target_types[] = {
 	&nds32_v2_target,
 	&nds32_v3_target,
 	&nds32_v3m_target,
+	&or1k_target,
+	&quark_x10xx_target,
 	NULL,
 };
 
 struct target *all_targets;
 static struct target_event_callback *target_event_callbacks;
 static struct target_timer_callback *target_timer_callbacks;
+LIST_HEAD(target_reset_callback_list);
 static const int polling_interval = 100;
 
 static const Jim_Nvp nvp_assert[] = {
@@ -273,6 +281,28 @@ const char *target_state_name(struct target *t)
 	return cp;
 }
 
+const char *target_event_name(enum target_event event)
+{
+	const char *cp;
+	cp = Jim_Nvp_value2name_simple(nvp_target_event, event)->name;
+	if (!cp) {
+		LOG_ERROR("Invalid target event: %d", (int)(event));
+		cp = "(*BUG*unknown*BUG*)";
+	}
+	return cp;
+}
+
+const char *target_reset_mode_name(enum target_reset_mode reset_mode)
+{
+	const char *cp;
+	cp = Jim_Nvp_value2name_simple(nvp_reset_modes, reset_mode)->name;
+	if (!cp) {
+		LOG_ERROR("Invalid target reset mode: %d", (int)(reset_mode));
+		cp = "(*BUG*unknown*BUG*)";
+	}
+	return cp;
+}
+
 /* determine the number of the new target */
 static int new_target_number(void)
 {
@@ -290,6 +320,15 @@ static int new_target_number(void)
 	return x + 1;
 }
 
+/* read a uint64_t from a buffer in target memory endianness */
+uint64_t target_buffer_get_u64(struct target *target, const uint8_t *buffer)
+{
+	if (target->endianness == TARGET_LITTLE_ENDIAN)
+		return le_to_h_u64(buffer);
+	else
+		return be_to_h_u64(buffer);
+}
+
 /* read a uint32_t from a buffer in target memory endianness */
 uint32_t target_buffer_get_u32(struct target *target, const uint8_t *buffer)
 {
@@ -323,6 +362,15 @@ static uint8_t target_buffer_get_u8(struct target *target, const uint8_t *buffer
 	return *buffer & 0x0ff;
 }
 
+/* write a uint64_t to a buffer in target memory endianness */
+void target_buffer_set_u64(struct target *target, uint8_t *buffer, uint64_t value)
+{
+	if (target->endianness == TARGET_LITTLE_ENDIAN)
+		h_u64_to_le(buffer, value);
+	else
+		h_u64_to_be(buffer, value);
+}
+
 /* write a uint32_t to a buffer in target memory endianness */
 void target_buffer_set_u32(struct target *target, uint8_t *buffer, uint32_t value)
 {
@@ -356,6 +404,14 @@ static void target_buffer_set_u8(struct target *target, uint8_t *buffer, uint8_t
 	*buffer = value;
 }
 
+/* write a uint64_t array to a buffer in target memory endianness */
+void target_buffer_get_u64_array(struct target *target, const uint8_t *buffer, uint32_t count, uint64_t *dstbuf)
+{
+	uint32_t i;
+	for (i = 0; i < count; i++)
+		dstbuf[i] = target_buffer_get_u64(target, &buffer[i * 8]);
+}
+
 /* write a uint32_t array to a buffer in target memory endianness */
 void target_buffer_get_u32_array(struct target *target, const uint8_t *buffer, uint32_t count, uint32_t *dstbuf)
 {
@@ -372,8 +428,16 @@ void target_buffer_get_u16_array(struct target *target, const uint8_t *buffer, u
 		dstbuf[i] = target_buffer_get_u16(target, &buffer[i * 2]);
 }
 
+/* write a uint64_t array to a buffer in target memory endianness */
+void target_buffer_set_u64_array(struct target *target, uint8_t *buffer, uint32_t count, const uint64_t *srcbuf)
+{
+	uint32_t i;
+	for (i = 0; i < count; i++)
+		target_buffer_set_u64(target, &buffer[i * 8], srcbuf[i]);
+}
+
 /* write a uint32_t array to a buffer in target memory endianness */
-void target_buffer_set_u32_array(struct target *target, uint8_t *buffer, uint32_t count, uint32_t *srcbuf)
+void target_buffer_set_u32_array(struct target *target, uint8_t *buffer, uint32_t count, const uint32_t *srcbuf)
 {
 	uint32_t i;
 	for (i = 0; i < count; i++)
@@ -381,7 +445,7 @@ void target_buffer_set_u32_array(struct target *target, uint8_t *buffer, uint32_
 }
 
 /* write a uint16_t array to a buffer in target memory endianness */
-void target_buffer_set_u16_array(struct target *target, uint8_t *buffer, uint32_t count, uint16_t *srcbuf)
+void target_buffer_set_u16_array(struct target *target, uint8_t *buffer, uint32_t count, const uint16_t *srcbuf)
 {
 	uint32_t i;
 	for (i = 0; i < count; i++)
@@ -560,6 +624,10 @@ static int target_process_reset(struct command_context *cmd_ctx, enum target_res
 		return ERROR_FAIL;
 	}
 
+	struct target *target;
+	for (target = all_targets; target; target = target->next)
+		target_call_reset_callbacks(target, reset_mode);
+
 	/* disable polling during reset to make reset event scripts
 	 * more predictable, i.e. dr/irscan & pathmove in events will
 	 * not have JTAG operations injected into the middle of a sequence.
@@ -582,7 +650,6 @@ static int target_process_reset(struct command_context *cmd_ctx, enum target_res
 	/* We want any events to be processed before the prompt */
 	retval = target_call_timer_callbacks_now();
 
-	struct target *target;
 	for (target = all_targets; target; target = target->next) {
 		target->type->check_reset(target);
 		target->running_alg = false;
@@ -813,7 +880,7 @@ done:
  */
 
 int target_run_flash_async_algorithm(struct target *target,
-		uint8_t *buffer, uint32_t count, int block_size,
+		const uint8_t *buffer, uint32_t count, int block_size,
 		int num_mem_params, struct mem_param *mem_params,
 		int num_reg_params, struct reg_param *reg_params,
 		uint32_t buffer_start, uint32_t buffer_size,
@@ -822,6 +889,8 @@ int target_run_flash_async_algorithm(struct target *target,
 	int retval;
 	int timeout = 0;
 
+	const uint8_t *buffer_orig = buffer;
+
 	/* Set up working area. First word is write pointer, second word is read pointer,
 	 * rest is fifo data area. */
 	uint32_t wp_addr = buffer_start;
@@ -862,7 +931,8 @@ int target_run_flash_async_algorithm(struct target *target,
 			break;
 		}
 
-		LOG_DEBUG("count 0x%" PRIx32 " wp 0x%" PRIx32 " rp 0x%" PRIx32, count, wp, rp);
+		LOG_DEBUG("offs 0x%zx count 0x%" PRIx32 " wp 0x%" PRIx32 " rp 0x%" PRIx32,
+			(size_t) (buffer - buffer_orig), count, wp, rp);
 
 		if (rp == 0) {
 			LOG_ERROR("flash write algorithm aborted by target");
@@ -986,12 +1056,6 @@ int target_write_phys_memory(struct target *target,
 	return target->type->write_phys_memory(target, address, size, count, buffer);
 }
 
-static int target_bulk_write_memory_default(struct target *target,
-		uint32_t address, uint32_t count, const uint8_t *buffer)
-{
-	return target_write_memory(target, address, 4, count, buffer);
-}
-
 int target_add_breakpoint(struct target *target,
 		struct breakpoint *breakpoint)
 {
@@ -1090,6 +1154,17 @@ int target_gdb_fileio_end(struct target *target, int retcode, int fileio_errno,
 	return target->type->gdb_fileio_end(target, retcode, fileio_errno, ctrl_c);
 }
 
+int target_profiling(struct target *target, uint32_t *samples,
+			uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
+{
+	if (target->state != TARGET_HALTED) {
+		LOG_WARNING("target %s is not halted", target->cmd_name);
+		return ERROR_TARGET_NOT_HALTED;
+	}
+	return target->type->profiling(target, samples, max_num_samples,
+			num_samples, seconds);
+}
+
 /**
  * Reset the @c examined flag for the given target.
  * Pure paranoia -- targets are zeroed on allocation.
@@ -1173,15 +1248,15 @@ static int target_init_one(struct command_context *cmd_ctx,
 	if (target->type->write_buffer == NULL)
 		target->type->write_buffer = target_write_buffer_default;
 
-	if (target->type->bulk_write_memory == NULL)
-		target->type->bulk_write_memory = target_bulk_write_memory_default;
-
 	if (target->type->get_gdb_fileio_info == NULL)
 		target->type->get_gdb_fileio_info = target_get_gdb_fileio_info_default;
 
 	if (target->type->gdb_fileio_end == NULL)
 		target->type->gdb_fileio_end = target_gdb_fileio_end_default;
 
+	if (target->type->profiling == NULL)
+		target->type->profiling = target_profiling_default;
+
 	return ERROR_OK;
 }
 
@@ -1229,6 +1304,10 @@ COMMAND_HANDLER(handle_target_init_command)
 	if (ERROR_OK != retval)
 		return retval;
 
+	retval = command_run_line(CMD_CTX, "init_target_events");
+	if (ERROR_OK != retval)
+		return retval;
+
 	retval = command_run_line(CMD_CTX, "init_board");
 	if (ERROR_OK != retval)
 		return retval;
@@ -1259,6 +1338,28 @@ int target_register_event_callback(int (*callback)(struct target *target,
 	return ERROR_OK;
 }
 
+int target_register_reset_callback(int (*callback)(struct target *target,
+		enum target_reset_mode reset_mode, void *priv), void *priv)
+{
+	struct target_reset_callback *entry;
+
+	if (callback == NULL)
+		return ERROR_COMMAND_SYNTAX_ERROR;
+
+	entry = malloc(sizeof(struct target_reset_callback));
+	if (entry == NULL) {
+		LOG_ERROR("error allocating buffer for reset callback entry");
+		return ERROR_COMMAND_SYNTAX_ERROR;
+	}
+
+	entry->callback = callback;
+	entry->priv = priv;
+	list_add(&entry->list, &target_reset_callback_list);
+
+
+	return ERROR_OK;
+}
+
 int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int periodic, void *priv)
 {
 	struct target_timer_callback **callbacks_p = &target_timer_callbacks;
@@ -1277,6 +1378,7 @@ int target_register_timer_callback(int (*callback)(void *priv), int time_ms, int
 	(*callbacks_p)->callback = callback;
 	(*callbacks_p)->periodic = periodic;
 	(*callbacks_p)->time_ms = time_ms;
+	(*callbacks_p)->removed = false;
 
 	gettimeofday(&now, NULL);
 	(*callbacks_p)->when.tv_usec = now.tv_usec + (time_ms % 1000) * 1000;
@@ -1316,26 +1418,39 @@ int target_unregister_event_callback(int (*callback)(struct target *target,
 	return ERROR_OK;
 }
 
-static int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
+int target_unregister_reset_callback(int (*callback)(struct target *target,
+		enum target_reset_mode reset_mode, void *priv), void *priv)
 {
-	struct target_timer_callback **p = &target_timer_callbacks;
-	struct target_timer_callback *c = target_timer_callbacks;
+	struct target_reset_callback *entry;
 
 	if (callback == NULL)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	while (c) {
-		struct target_timer_callback *next = c->next;
+	list_for_each_entry(entry, &target_reset_callback_list, list) {
+		if (entry->callback == callback && entry->priv == priv) {
+			list_del(&entry->list);
+			free(entry);
+			break;
+		}
+	}
+
+	return ERROR_OK;
+}
+
+int target_unregister_timer_callback(int (*callback)(void *priv), void *priv)
+{
+	if (callback == NULL)
+		return ERROR_COMMAND_SYNTAX_ERROR;
+
+	for (struct target_timer_callback *c = target_timer_callbacks;
+	     c; c = c->next) {
 		if ((c->callback == callback) && (c->priv == priv)) {
-			*p = next;
-			free(c);
+			c->removed = true;
 			return ERROR_OK;
-		} else
-			p = &(c->next);
-		c = next;
+		}
 	}
 
-	return ERROR_OK;
+	return ERROR_FAIL;
 }
 
 int target_call_event_callbacks(struct target *target, enum target_event event)
@@ -1362,6 +1477,19 @@ int target_call_event_callbacks(struct target *target, enum target_event event)
 	return ERROR_OK;
 }
 
+int target_call_reset_callbacks(struct target *target, enum target_reset_mode reset_mode)
+{
+	struct target_reset_callback *callback;
+
+	LOG_DEBUG("target reset %i (%s)", reset_mode,
+			Jim_Nvp_value2name_simple(nvp_reset_modes, reset_mode)->name);
+
+	list_for_each_entry(callback, &target_reset_callback_list, list)
+		callback->callback(target, reset_mode, callback->priv);
+
+	return ERROR_OK;
+}
+
 static int target_timer_callback_periodic_restart(
 		struct target_timer_callback *cb, struct timeval *now)
 {
@@ -1389,31 +1517,44 @@ static int target_call_timer_callback(struct target_timer_callback *cb,
 
 static int target_call_timer_callbacks_check_time(int checktime)
 {
+	static bool callback_processing;
+
+	/* Do not allow nesting */
+	if (callback_processing)
+		return ERROR_OK;
+
+	callback_processing = true;
+
 	keep_alive();
 
 	struct timeval now;
 	gettimeofday(&now, NULL);
 
-	struct target_timer_callback *callback = target_timer_callbacks;
-	while (callback) {
-		/* cleaning up may unregister and free this callback */
-		struct target_timer_callback *next_callback = callback->next;
+	/* Store an address of the place containing a pointer to the
+	 * next item; initially, that's a standalone "root of the
+	 * list" variable. */
+	struct target_timer_callback **callback = &target_timer_callbacks;
+	while (*callback) {
+		if ((*callback)->removed) {
+			struct target_timer_callback *p = *callback;
+			*callback = (*callback)->next;
+			free(p);
+			continue;
+		}
 
-		bool call_it = callback->callback &&
-			((!checktime && callback->periodic) ||
-			  now.tv_sec > callback->when.tv_sec ||
-			 (now.tv_sec == callback->when.tv_sec &&
-			  now.tv_usec >= callback->when.tv_usec));
+		bool call_it = (*callback)->callback &&
+			((!checktime && (*callback)->periodic) ||
+			 now.tv_sec > (*callback)->when.tv_sec ||
+			 (now.tv_sec == (*callback)->when.tv_sec &&
+			  now.tv_usec >= (*callback)->when.tv_usec));
 
-		if (call_it) {
-			int retval = target_call_timer_callback(callback, &now);
-			if (retval != ERROR_OK)
-				return retval;
-		}
+		if (call_it)
+			target_call_timer_callback(*callback, &now);
 
-		callback = next_callback;
+		callback = &(*callback)->next;
 	}
 
+	callback_processing = false;
 	return ERROR_OK;
 }
 
@@ -1734,17 +1875,68 @@ int target_arch_state(struct target *target)
 static int target_get_gdb_fileio_info_default(struct target *target,
 		struct gdb_fileio_info *fileio_info)
 {
-	LOG_ERROR("Not implemented: %s", __func__);
+	/* If target does not support semi-hosting function, target
+	   has no need to provide .get_gdb_fileio_info callback.
+	   It just return ERROR_FAIL and gdb_server will return "Txx"
+	   as target halted every time.  */
 	return ERROR_FAIL;
 }
 
 static int target_gdb_fileio_end_default(struct target *target,
 		int retcode, int fileio_errno, bool ctrl_c)
 {
-	LOG_ERROR("Not implemented: %s", __func__);
 	return ERROR_OK;
 }
 
+static int target_profiling_default(struct target *target, uint32_t *samples,
+		uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
+{
+	struct timeval timeout, now;
+
+	gettimeofday(&timeout, NULL);
+	timeval_add_time(&timeout, seconds, 0);
+
+	LOG_INFO("Starting profiling. Halting and resuming the"
+			" target as often as we can...");
+
+	uint32_t sample_count = 0;
+	/* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
+	struct reg *reg = register_get_by_name(target->reg_cache, "pc", 1);
+
+	int retval = ERROR_OK;
+	for (;;) {
+		target_poll(target);
+		if (target->state == TARGET_HALTED) {
+			uint32_t t = buf_get_u32(reg->value, 0, 32);
+			samples[sample_count++] = t;
+			/* current pc, addr = 0, do not handle breakpoints, not debugging */
+			retval = target_resume(target, 1, 0, 0, 0);
+			target_poll(target);
+			alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
+		} else if (target->state == TARGET_RUNNING) {
+			/* We want to quickly sample the PC. */
+			retval = target_halt(target);
+		} else {
+			LOG_INFO("Target not halted or running");
+			retval = ERROR_OK;
+			break;
+		}
+
+		if (retval != ERROR_OK)
+			break;
+
+		gettimeofday(&now, NULL);
+		if ((sample_count >= max_num_samples) ||
+			((now.tv_sec >= timeout.tv_sec) && (now.tv_usec >= timeout.tv_usec))) {
+			LOG_INFO("Profiling completed. %" PRIu32 " samples.", sample_count);
+			break;
+		}
+	}
+
+	*num_samples = sample_count;
+	return retval;
+}
+
 /* Single aligned words are guaranteed to use 16 or 32 bit access
  * mode respectively, otherwise data is handled as quickly as
  * possible
@@ -1773,57 +1965,37 @@ int target_write_buffer(struct target *target, uint32_t address, uint32_t size,
 	return target->type->write_buffer(target, address, size, buffer);
 }
 
-static int target_write_buffer_default(struct target *target, uint32_t address, uint32_t size, const uint8_t *buffer)
+static int target_write_buffer_default(struct target *target, uint32_t address, uint32_t count, const uint8_t *buffer)
 {
-	int retval = ERROR_OK;
-
-	if (((address % 2) == 0) && (size == 2))
-		return target_write_memory(target, address, 2, 1, buffer);
-
-	/* handle unaligned head bytes */
-	if (address % 4) {
-		uint32_t unaligned = 4 - (address % 4);
-
-		if (unaligned > size)
-			unaligned = size;
-
-		retval = target_write_memory(target, address, 1, unaligned, buffer);
-		if (retval != ERROR_OK)
-			return retval;
-
-		buffer += unaligned;
-		address += unaligned;
-		size -= unaligned;
-	}
+	uint32_t size;
 
-	/* handle aligned words */
-	if (size >= 4) {
-		int aligned = size - (size % 4);
-
-		/* use bulk writes above a certain limit. This may have to be changed */
-		if (aligned > 128) {
-			retval = target->type->bulk_write_memory(target, address, aligned / 4, buffer);
-			if (retval != ERROR_OK)
-				return retval;
-		} else {
-			retval = target_write_memory(target, address, 4, aligned / 4, buffer);
+	/* Align up to maximum 4 bytes. The loop condition makes sure the next pass
+	 * will have something to do with the size we leave to it. */
+	for (size = 1; size < 4 && count >= size * 2 + (address & size); size *= 2) {
+		if (address & size) {
+			int retval = target_write_memory(target, address, size, 1, buffer);
 			if (retval != ERROR_OK)
 				return retval;
+			address += size;
+			count -= size;
+			buffer += size;
 		}
-
-		buffer += aligned;
-		address += aligned;
-		size -= aligned;
 	}
 
-	/* handle tail writes of less than 4 bytes */
-	if (size > 0) {
-		retval = target_write_memory(target, address, 1, size, buffer);
-		if (retval != ERROR_OK)
-			return retval;
+	/* Write the data with as large access size as possible. */
+	for (; size > 0; size /= 2) {
+		uint32_t aligned = count - count % size;
+		if (aligned > 0) {
+			int retval = target_write_memory(target, address, size, aligned / size, buffer);
+			if (retval != ERROR_OK)
+				return retval;
+			address += aligned;
+			count -= aligned;
+			buffer += aligned;
+		}
 	}
 
-	return retval;
+	return ERROR_OK;
 }
 
 /* Single aligned words are guaranteed to use 16 or 32 bit access
@@ -1854,58 +2026,34 @@ int target_read_buffer(struct target *target, uint32_t address, uint32_t size, u
 	return target->type->read_buffer(target, address, size, buffer);
 }
 
-static int target_read_buffer_default(struct target *target, uint32_t address, uint32_t size, uint8_t *buffer)
+static int target_read_buffer_default(struct target *target, uint32_t address, uint32_t count, uint8_t *buffer)
 {
-	int retval = ERROR_OK;
+	uint32_t size;
 
-	if (((address % 2) == 0) && (size == 2))
-		return target_read_memory(target, address, 2, 1, buffer);
-
-	/* handle unaligned head bytes */
-	if (address % 4) {
-		uint32_t unaligned = 4 - (address % 4);
-
-		if (unaligned > size)
-			unaligned = size;
-
-		retval = target_read_memory(target, address, 1, unaligned, buffer);
-		if (retval != ERROR_OK)
-			return retval;
-
-		buffer += unaligned;
-		address += unaligned;
-		size -= unaligned;
-	}
-
-	/* handle aligned words */
-	if (size >= 4) {
-		int aligned = size - (size % 4);
-
-		retval = target_read_memory(target, address, 4, aligned / 4, buffer);
-		if (retval != ERROR_OK)
-			return retval;
-
-		buffer += aligned;
-		address += aligned;
-		size -= aligned;
+	/* Align up to maximum 4 bytes. The loop condition makes sure the next pass
+	 * will have something to do with the size we leave to it. */
+	for (size = 1; size < 4 && count >= size * 2 + (address & size); size *= 2) {
+		if (address & size) {
+			int retval = target_read_memory(target, address, size, 1, buffer);
+			if (retval != ERROR_OK)
+				return retval;
+			address += size;
+			count -= size;
+			buffer += size;
+		}
 	}
 
-	/*prevent byte access when possible (avoid AHB access limitations in some cases)*/
-	if (size	>= 2) {
-		int aligned = size - (size % 2);
-		retval = target_read_memory(target, address, 2, aligned / 2, buffer);
-		if (retval != ERROR_OK)
-			return retval;
-
-		buffer += aligned;
-		address += aligned;
-		size -= aligned;
-	}
-	/* handle tail writes of less than 4 bytes */
-	if (size > 0) {
-		retval = target_read_memory(target, address, 1, size, buffer);
-		if (retval != ERROR_OK)
-			return retval;
+	/* Read the data with as large access size as possible. */
+	for (; size > 0; size /= 2) {
+		uint32_t aligned = count - count % size;
+		if (aligned > 0) {
+			int retval = target_read_memory(target, address, size, aligned / size, buffer);
+			if (retval != ERROR_OK)
+				return retval;
+			address += aligned;
+			count -= aligned;
+			buffer += aligned;
+		}
 	}
 
 	return ERROR_OK;
@@ -1967,6 +2115,30 @@ int target_blank_check_memory(struct target *target, uint32_t address, uint32_t
 	return retval;
 }
 
+int target_read_u64(struct target *target, uint64_t address, uint64_t *value)
+{
+	uint8_t value_buf[8];
+	if (!target_was_examined(target)) {
+		LOG_ERROR("Target not examined yet");
+		return ERROR_FAIL;
+	}
+
+	int retval = target_read_memory(target, address, 8, 1, value_buf);
+
+	if (retval == ERROR_OK) {
+		*value = target_buffer_get_u64(target, value_buf);
+		LOG_DEBUG("address: 0x%" PRIx64 ", value: 0x%16.16" PRIx64 "",
+				  address,
+				  *value);
+	} else {
+		*value = 0x0;
+		LOG_DEBUG("address: 0x%" PRIx64 " failed",
+				  address);
+	}
+
+	return retval;
+}
+
 int target_read_u32(struct target *target, uint32_t address, uint32_t *value)
 {
 	uint8_t value_buf[4];
@@ -2017,12 +2189,13 @@ int target_read_u16(struct target *target, uint32_t address, uint16_t *value)
 
 int target_read_u8(struct target *target, uint32_t address, uint8_t *value)
 {
-	int retval = target_read_memory(target, address, 1, 1, value);
 	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
 
+	int retval = target_read_memory(target, address, 1, 1, value);
+
 	if (retval == ERROR_OK) {
 		LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%2.2x",
 				  address,
@@ -2036,6 +2209,27 @@ int target_read_u8(struct target *target, uint32_t address, uint8_t *value)
 	return retval;
 }
 
+int target_write_u64(struct target *target, uint64_t address, uint64_t value)
+{
+	int retval;
+	uint8_t value_buf[8];
+	if (!target_was_examined(target)) {
+		LOG_ERROR("Target not examined yet");
+		return ERROR_FAIL;
+	}
+
+	LOG_DEBUG("address: 0x%" PRIx64 ", value: 0x%16.16" PRIx64 "",
+			  address,
+			  value);
+
+	target_buffer_set_u64(target, value_buf, value);
+	retval = target_write_memory(target, address, 8, 1, value_buf);
+	if (retval != ERROR_OK)
+		LOG_DEBUG("failed: %i", retval);
+
+	return retval;
+}
+
 int target_write_u32(struct target *target, uint32_t address, uint32_t value)
 {
 	int retval;
@@ -2281,6 +2475,10 @@ static int handle_target(void *priv)
 	for (struct target *target = all_targets;
 			is_jtag_poll_safe() && target;
 			target = target->next) {
+
+		if (!target_was_examined(target))
+			continue;
+
 		if (!target->tap->enabled)
 			continue;
 
@@ -2312,8 +2510,18 @@ static int handle_target(void *priv)
 				return retval;
 			}
 			/* Since we succeeded, we reset backoff count */
-			if (target->backoff.times > 0)
-				LOG_USER("Polling target %s succeeded again", target_name(target));
+			if (target->backoff.times > 0) {
+				LOG_USER("Polling target %s succeeded again, trying to reexamine", target_name(target));
+				target_reset_examined(target);
+				retval = target_examine_one(target);
+				/* Target examination could have failed due to unstable connection,
+				 * but we set the examined flag anyway to repoll it later */
+				if (retval != ERROR_OK) {
+					target->examined = true;
+					return retval;
+				}
+			}
+
 			target->backoff.times = 0;
 		}
 	}
@@ -2730,12 +2938,6 @@ COMMAND_HANDLER(handle_md_command)
 typedef int (*target_write_fn)(struct target *target,
 		uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
 
-static int target_write_memory_fast(struct target *target,
-		uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
-{
-	return target_write_buffer(target, address, size * count, buffer);
-}
-
 static int target_fill_mem(struct target *target,
 		uint32_t address,
 		target_write_fn fn,
@@ -2800,7 +3002,7 @@ COMMAND_HANDLER(handle_mw_command)
 		CMD_ARGV++;
 		fn = target_write_phys_memory;
 	} else
-		fn = target_write_memory_fast;
+		fn = target_write_memory;
 	if ((CMD_ARGC < 2) || (CMD_ARGC > 3))
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
@@ -3090,7 +3292,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, int verify)
 				if (diffs == 0)
 					LOG_ERROR("checksum mismatch - attempting binary compare");
 
-				data = (uint8_t *)malloc(buf_cnt);
+				data = malloc(buf_cnt);
 
 				/* Can we use 32bit word accesses? */
 				int size = 1;
@@ -3196,9 +3398,10 @@ static int handle_bp_command_set(struct command_context *cmd_ctx,
 		uint32_t addr, uint32_t asid, uint32_t length, int hw)
 {
 	struct target *target = get_current_target(cmd_ctx);
+	int retval;
 
 	if (asid == 0) {
-		int retval = breakpoint_add(target, addr, length, hw);
+		retval = breakpoint_add(target, addr, length, hw);
 		if (ERROR_OK == retval)
 			command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr);
 		else {
@@ -3206,7 +3409,11 @@ static int handle_bp_command_set(struct command_context *cmd_ctx,
 			return retval;
 		}
 	} else if (addr == 0) {
-		int retval = context_breakpoint_add(target, asid, length, hw);
+		if (target->type->add_context_breakpoint == NULL) {
+			LOG_WARNING("Context breakpoint not available");
+			return ERROR_OK;
+		}
+		retval = context_breakpoint_add(target, asid, length, hw);
 		if (ERROR_OK == retval)
 			command_print(cmd_ctx, "Context breakpoint set at 0x%8.8" PRIx32 "", asid);
 		else {
@@ -3214,7 +3421,11 @@ static int handle_bp_command_set(struct command_context *cmd_ctx,
 			return retval;
 		}
 	} else {
-		int retval = hybrid_breakpoint_add(target, addr, asid, length, hw);
+		if (target->type->add_hybrid_breakpoint == NULL) {
+			LOG_WARNING("Hybrid breakpoint not available");
+			return ERROR_OK;
+		}
+		retval = hybrid_breakpoint_add(target, addr, asid, length, hw);
 		if (ERROR_OK == retval)
 			command_print(cmd_ctx, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid);
 		else {
@@ -3397,14 +3608,12 @@ static void writeData(FILE *f, const void *data, size_t len)
 		LOG_ERROR("failed to write %zu bytes: %s", len, strerror(errno));
 }
 
-static void writeLong(FILE *f, int l)
+static void writeLong(FILE *f, int l, struct target *target)
 {
-	int i;
-	for (i = 0; i < 4; i++) {
-		char c = (l >> (i*8))&0xff;
-		writeData(f, &c, 1);
-	}
+	uint8_t val[4];
 
+	target_buffer_set_u32(target, val, l);
+	writeData(f, val, 4);
 }
 
 static void writeString(FILE *f, char *s)
@@ -3412,59 +3621,79 @@ static void writeString(FILE *f, char *s)
 	writeData(f, s, strlen(s));
 }
 
+typedef unsigned char UNIT[2];  /* unit of profiling */
+
 /* Dump a gmon.out histogram file. */
-static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filename)
+static void write_gmon(uint32_t *samples, uint32_t sampleNum, const char *filename, bool with_range,
+			uint32_t start_address, uint32_t end_address, struct target *target)
 {
 	uint32_t i;
 	FILE *f = fopen(filename, "w");
 	if (f == NULL)
 		return;
 	writeString(f, "gmon");
-	writeLong(f, 0x00000001); /* Version */
-	writeLong(f, 0); /* padding */
-	writeLong(f, 0); /* padding */
-	writeLong(f, 0); /* padding */
+	writeLong(f, 0x00000001, target); /* Version */
+	writeLong(f, 0, target); /* padding */
+	writeLong(f, 0, target); /* padding */
+	writeLong(f, 0, target); /* padding */
 
 	uint8_t zero = 0;  /* GMON_TAG_TIME_HIST */
 	writeData(f, &zero, 1);
 
 	/* figure out bucket size */
-	uint32_t min = samples[0];
-	uint32_t max = samples[0];
-	for (i = 0; i < sampleNum; i++) {
-		if (min > samples[i])
-			min = samples[i];
-		if (max < samples[i])
-			max = samples[i];
+	uint32_t min;
+	uint32_t max;
+	if (with_range) {
+		min = start_address;
+		max = end_address;
+	} else {
+		min = samples[0];
+		max = samples[0];
+		for (i = 0; i < sampleNum; i++) {
+			if (min > samples[i])
+				min = samples[i];
+			if (max < samples[i])
+				max = samples[i];
+		}
+
+		/* max should be (largest sample + 1)
+		 * Refer to binutils/gprof/hist.c (find_histogram_for_pc) */
+		max++;
 	}
 
-	int addressSpace = (max - min + 1);
+	int addressSpace = max - min;
 	assert(addressSpace >= 2);
 
-	static const uint32_t maxBuckets = 16 * 1024; /* maximum buckets. */
-	uint32_t length = addressSpace;
-	if (length > maxBuckets)
-		length = maxBuckets;
-	int *buckets = malloc(sizeof(int)*length);
+	/* FIXME: What is the reasonable number of buckets?
+	 * The profiling result will be more accurate if there are enough buckets. */
+	static const uint32_t maxBuckets = 128 * 1024; /* maximum buckets. */
+	uint32_t numBuckets = addressSpace / sizeof(UNIT);
+	if (numBuckets > maxBuckets)
+		numBuckets = maxBuckets;
+	int *buckets = malloc(sizeof(int) * numBuckets);
 	if (buckets == NULL) {
 		fclose(f);
 		return;
 	}
-	memset(buckets, 0, sizeof(int) * length);
+	memset(buckets, 0, sizeof(int) * numBuckets);
 	for (i = 0; i < sampleNum; i++) {
 		uint32_t address = samples[i];
+
+		if ((address < min) || (max <= address))
+			continue;
+
 		long long a = address - min;
-		long long b = length - 1;
-		long long c = addressSpace - 1;
+		long long b = numBuckets;
+		long long c = addressSpace;
 		int index_t = (a * b) / c; /* danger!!!! int32 overflows */
 		buckets[index_t]++;
 	}
 
 	/* append binary memory gmon.out &profile_hist_hdr ((char*)&profile_hist_hdr + sizeof(struct gmon_hist_hdr)) */
-	writeLong(f, min);			/* low_pc */
-	writeLong(f, max);			/* high_pc */
-	writeLong(f, length);		/* # of samples */
-	writeLong(f, 100);			/* KLUDGE! We lie, ca. 100Hz best case. */
+	writeLong(f, min, target);			/* low_pc */
+	writeLong(f, max, target);			/* high_pc */
+	writeLong(f, numBuckets, target);	/* # of buckets */
+	writeLong(f, 100, target);			/* KLUDGE! We lie, ca. 100Hz best case. */
 	writeString(f, "seconds");
 	for (i = 0; i < (15-strlen("seconds")); i++)
 		writeData(f, &zero, 1);
@@ -3472,9 +3701,9 @@ static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filenam
 
 	/*append binary memory gmon.out profile_hist_data (profile_hist_data + profile_hist_hdr.hist_size) */
 
-	char *data = malloc(2 * length);
+	char *data = malloc(2 * numBuckets);
 	if (data != NULL) {
-		for (i = 0; i < length; i++) {
+		for (i = 0; i < numBuckets; i++) {
 			int val;
 			val = buckets[i];
 			if (val > 65535)
@@ -3483,7 +3712,7 @@ static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filenam
 			data[i * 2 + 1] = (val >> 8) & 0xff;
 		}
 		free(buckets);
-		writeData(f, data, length * 2);
+		writeData(f, data, numBuckets * 2);
 		free(data);
 	} else
 		free(buckets);
@@ -3496,84 +3725,70 @@ static void writeGmon(uint32_t *samples, uint32_t sampleNum, const char *filenam
 COMMAND_HANDLER(handle_profile_command)
 {
 	struct target *target = get_current_target(CMD_CTX);
-	struct timeval timeout, now;
 
-	gettimeofday(&timeout, NULL);
-	if (CMD_ARGC != 2)
+	if ((CMD_ARGC != 2) && (CMD_ARGC != 4))
 		return ERROR_COMMAND_SYNTAX_ERROR;
-	unsigned offset;
-	COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], offset);
 
-	timeval_add_time(&timeout, offset, 0);
+	const uint32_t MAX_PROFILE_SAMPLE_NUM = 10000;
+	uint32_t offset;
+	uint32_t num_of_samples;
+	int retval = ERROR_OK;
+
+	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], offset);
+
+	uint32_t *samples = malloc(sizeof(uint32_t) * MAX_PROFILE_SAMPLE_NUM);
+	if (samples == NULL) {
+		LOG_ERROR("No memory to store samples.");
+		return ERROR_FAIL;
+	}
 
 	/**
-	 * @todo: Some cores let us sample the PC without the
+	 * Some cores let us sample the PC without the
 	 * annoying halt/resume step; for example, ARMv7 PCSR.
 	 * Provide a way to use that more efficient mechanism.
 	 */
+	retval = target_profiling(target, samples, MAX_PROFILE_SAMPLE_NUM,
+				&num_of_samples, offset);
+	if (retval != ERROR_OK) {
+		free(samples);
+		return retval;
+	}
 
-	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);
-	if (samples == NULL)
-		return ERROR_OK;
-
-	int numSamples = 0;
-	/* hopefully it is safe to cache! We want to stop/restart as quickly as possible. */
-	struct reg *reg = register_get_by_name(target->reg_cache, "pc", 1);
+	assert(num_of_samples <= MAX_PROFILE_SAMPLE_NUM);
 
-	int retval = ERROR_OK;
-	for (;;) {
-		target_poll(target);
-		if (target->state == TARGET_HALTED) {
-			uint32_t t = *((uint32_t *)reg->value);
-			samples[numSamples++] = t;
-			/* current pc, addr = 0, do not handle breakpoints, not debugging */
-			retval = target_resume(target, 1, 0, 0, 0);
-			target_poll(target);
-			alive_sleep(10); /* sleep 10ms, i.e. <100 samples/second. */
-		} else if (target->state == TARGET_RUNNING) {
-			/* We want to quickly sample the PC. */
-			retval = target_halt(target);
-			if (retval != ERROR_OK) {
-				free(samples);
-				return retval;
-			}
-		} else {
-			command_print(CMD_CTX, "Target not halted or running");
-			retval = ERROR_OK;
-			break;
+	retval = target_poll(target);
+	if (retval != ERROR_OK) {
+		free(samples);
+		return retval;
+	}
+	if (target->state == TARGET_RUNNING) {
+		retval = target_halt(target);
+		if (retval != ERROR_OK) {
+			free(samples);
+			return retval;
 		}
-		if (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);
-			retval = target_poll(target);
-			if (retval != ERROR_OK) {
-				free(samples);
-				return retval;
-			}
-			if (target->state == TARGET_HALTED) {
-				/* current pc, addr = 0, do not handle
-				 * breakpoints, not debugging */
-				target_resume(target, 1, 0, 0, 0);
-			}
-			retval = target_poll(target);
-			if (retval != ERROR_OK) {
-				free(samples);
-				return retval;
-			}
-			writeGmon(samples, numSamples, CMD_ARGV[1]);
-			command_print(CMD_CTX, "Wrote %s", CMD_ARGV[1]);
-			break;
-		}
+	retval = target_poll(target);
+	if (retval != ERROR_OK) {
+		free(samples);
+		return retval;
+	}
+
+	uint32_t start_address = 0;
+	uint32_t end_address = 0;
+	bool with_range = false;
+	if (CMD_ARGC == 4) {
+		with_range = true;
+		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], start_address);
+		COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], end_address);
 	}
-	free(samples);
 
+	write_gmon(samples, num_of_samples, CMD_ARGV[1],
+		   with_range, start_address, end_address, target);
+	command_print(CMD_CTX, "Wrote %s", CMD_ARGV[1]);
+
+	free(samples);
 	return retval;
 }
 
@@ -3751,6 +3966,7 @@ static int target_mem2array(Jim_Interp *interp, struct target *target, int argc,
 				new_int_array_element(interp, varname, n, v);
 			}
 			len -= count;
+			addr += count * width;
 		}
 	}
 
@@ -3944,6 +4160,7 @@ static int target_array2mem(Jim_Interp *interp, struct target *target,
 			e = JIM_ERR;
 			break;
 		}
+		addr += count * width;
 	}
 
 	free(buffer);
@@ -3999,7 +4216,6 @@ enum target_cfg_param {
 	TCFG_WORK_AREA_SIZE,
 	TCFG_WORK_AREA_BACKUP,
 	TCFG_ENDIAN,
-	TCFG_VARIANT,
 	TCFG_COREID,
 	TCFG_CHAIN_POSITION,
 	TCFG_DBGBASE,
@@ -4014,7 +4230,6 @@ static Jim_Nvp nvp_config_opts[] = {
 	{ .name = "-work-area-size",   .value = TCFG_WORK_AREA_SIZE },
 	{ .name = "-work-area-backup", .value = TCFG_WORK_AREA_BACKUP },
 	{ .name = "-endian" ,          .value = TCFG_ENDIAN },
-	{ .name = "-variant",          .value = TCFG_VARIANT },
 	{ .name = "-coreid",           .value = TCFG_COREID },
 	{ .name = "-chain-position",   .value = TCFG_CHAIN_POSITION },
 	{ .name = "-dbgbase",          .value = TCFG_DBGBASE },
@@ -4027,7 +4242,6 @@ static int target_configure(Jim_GetOptInfo *goi, struct target *target)
 	Jim_Nvp *n;
 	Jim_Obj *o;
 	jim_wide w;
-	char *cp;
 	int e;
 
 	/* parse config or cget options ... */
@@ -4236,28 +4450,6 @@ no_params:
 			/* loop for more */
 			break;
 
-		case TCFG_VARIANT:
-			if (goi->isconfigure) {
-				if (goi->argc < 1) {
-					Jim_SetResultFormatted(goi->interp,
-										   "%s ?STRING?",
-										   n->name);
-					return JIM_ERR;
-				}
-				if (target->variant)
-					free((void *)(target->variant));
-				e = Jim_GetOpt_String(goi, &cp, NULL);
-				if (e != JIM_OK)
-					return e;
-				target->variant = strdup(cp);
-			} else {
-				if (goi->argc != 0)
-					goto no_params;
-			}
-			Jim_SetResultString(goi->interp, target->variant, -1);
-			/* loop for more */
-			break;
-
 		case TCFG_COREID:
 			if (goi->isconfigure) {
 				e = Jim_GetOpt_Wide(goi, &w);
@@ -4356,7 +4548,7 @@ static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	}
 
 	target_write_fn fn;
-	fn = target_write_memory_fast;
+	fn = target_write_memory;
 
 	int e;
 	if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0) {
@@ -4955,6 +5147,15 @@ static int target_create(Jim_GetOptInfo *goi)
 	if (e != JIM_OK)
 		return e;
 	cp = cp2;
+	struct transport *tr = get_current_transport();
+	if (tr->override_target) {
+		e = tr->override_target(&cp);
+		if (e != ERROR_OK) {
+			LOG_ERROR("The selected transport doesn't support this target");
+			return JIM_ERR;
+		}
+		LOG_INFO("The selected transport took over low-level target control. The results might differ compared to plain JTAG/SWD");
+	}
 	/* now does target type exist */
 	for (x = 0 ; target_types[x] ; x++) {
 		if (0 == strcmp(cp, target_types[x]->name)) {
@@ -4993,9 +5194,10 @@ static int target_create(Jim_GetOptInfo *goi)
 	target = calloc(1, sizeof(struct target));
 	/* set target number */
 	target->target_number = new_target_number();
+	cmd_ctx->current_target = target->target_number;
 
 	/* allocate memory for each unique target type */
-	target->type = (struct target_type *)calloc(1, sizeof(struct target_type));
+	target->type = calloc(1, sizeof(struct target_type));
 
 	memcpy(target->type, target_types[x], sizeof(struct target_type));
 
@@ -5060,10 +5262,6 @@ static int target_create(Jim_GetOptInfo *goi)
 		target->endianness = TARGET_LITTLE_ENDIAN;
 	}
 
-	/* incase variant is not set */
-	if (!target->variant)
-		target->variant = strdup("");
-
 	cp = Jim_GetString(new_cmd, NULL);
 	target->cmd_name = strdup(cp);
 
@@ -5223,55 +5421,6 @@ static int jim_target_create(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 	return target_create(&goi);
 }
 
-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_SetResultFormatted(goi.interp, "usage: target number <number>");
-		return JIM_ERR;
-	}
-	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_SetResultString(goi.interp, target_name(target), -1);
-		return JIM_OK;
-	}
-	{
-		Jim_Obj *wObj = Jim_NewIntObj(goi.interp, w);
-		Jim_SetResultFormatted(goi.interp,
-			"Target: number %#s does not exist", wObj);
-		Jim_FreeNewObj(interp, wObj);
-	}
-	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 = "init",
@@ -5306,21 +5455,6 @@ static const struct command_registration target_subcommand_handlers[] = {
 		.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 the numbered target "
-			"(DEPRECATED)",
-	},
-	{
-		.name = "count",
-		.mode = COMMAND_ANY,
-		.jim_handler = jim_target_count,
-		.help = "Returns the number of targets as an integer "
-			"(DEPRECATED)",
-	},
 	{
 		.name = "smp",
 		.mode = COMMAND_ANY,
@@ -5381,7 +5515,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 	image_size = 0x0;
 	retval = ERROR_OK;
 	fastload_num = image.num_sections;
-	fastload = (struct FastLoad *)malloc(sizeof(struct FastLoad)*image.num_sections);
+	fastload = malloc(sizeof(struct FastLoad)*image.num_sections);
 	if (fastload == NULL) {
 		command_print(CMD_CTX, "out of memory");
 		image_close(&image);
@@ -5423,7 +5557,7 @@ COMMAND_HANDLER(handle_fast_load_image_command)
 			fastload[i].data = malloc(length);
 			if (fastload[i].data == NULL) {
 				free(buffer);
-				command_print(CMD_CTX, "error allocating buffer for section (%d bytes)",
+				command_print(CMD_CTX, "error allocating buffer for section (%" PRIu32 " bytes)",
 							  length);
 				retval = ERROR_FAIL;
 				break;
@@ -5546,6 +5680,198 @@ COMMAND_HANDLER(handle_ps_command)
 	}
 }
 
+static void binprint(struct command_context *cmd_ctx, const char *text, const uint8_t *buf, int size)
+{
+	if (text != NULL)
+		command_print_sameline(cmd_ctx, "%s", text);
+	for (int i = 0; i < size; i++)
+		command_print_sameline(cmd_ctx, " %02x", buf[i]);
+	command_print(cmd_ctx, " ");
+}
+
+COMMAND_HANDLER(handle_test_mem_access_command)
+{
+	struct target *target = get_current_target(CMD_CTX);
+	uint32_t test_size;
+	int retval = ERROR_OK;
+
+	if (target->state != TARGET_HALTED) {
+		LOG_INFO("target not halted !!");
+		return ERROR_FAIL;
+	}
+
+	if (CMD_ARGC != 1)
+		return ERROR_COMMAND_SYNTAX_ERROR;
+
+	COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], test_size);
+
+	/* Test reads */
+	size_t num_bytes = test_size + 4;
+
+	struct working_area *wa = NULL;
+	retval = target_alloc_working_area(target, num_bytes, &wa);
+	if (retval != ERROR_OK) {
+		LOG_ERROR("Not enough working area");
+		return ERROR_FAIL;
+	}
+
+	uint8_t *test_pattern = malloc(num_bytes);
+
+	for (size_t i = 0; i < num_bytes; i++)
+		test_pattern[i] = rand();
+
+	retval = target_write_memory(target, wa->address, 1, num_bytes, test_pattern);
+	if (retval != ERROR_OK) {
+		LOG_ERROR("Test pattern write failed");
+		goto out;
+	}
+
+	for (int host_offset = 0; host_offset <= 1; host_offset++) {
+		for (int size = 1; size <= 4; size *= 2) {
+			for (int offset = 0; offset < 4; offset++) {
+				uint32_t count = test_size / size;
+				size_t host_bufsiz = (count + 2) * size + host_offset;
+				uint8_t *read_ref = malloc(host_bufsiz);
+				uint8_t *read_buf = malloc(host_bufsiz);
+
+				for (size_t i = 0; i < host_bufsiz; i++) {
+					read_ref[i] = rand();
+					read_buf[i] = read_ref[i];
+				}
+				command_print_sameline(CMD_CTX,
+						"Test read %" PRIu32 " x %d @ %d to %saligned buffer: ", count,
+						size, offset, host_offset ? "un" : "");
+
+				struct duration bench;
+				duration_start(&bench);
+
+				retval = target_read_memory(target, wa->address + offset, size, count,
+						read_buf + size + host_offset);
+
+				duration_measure(&bench);
+
+				if (retval == ERROR_TARGET_UNALIGNED_ACCESS) {
+					command_print(CMD_CTX, "Unsupported alignment");
+					goto next;
+				} else if (retval != ERROR_OK) {
+					command_print(CMD_CTX, "Memory read failed");
+					goto next;
+				}
+
+				/* replay on host */
+				memcpy(read_ref + size + host_offset, test_pattern + offset, count * size);
+
+				/* check result */
+				int result = memcmp(read_ref, read_buf, host_bufsiz);
+				if (result == 0) {
+					command_print(CMD_CTX, "Pass in %fs (%0.3f KiB/s)",
+							duration_elapsed(&bench),
+							duration_kbps(&bench, count * size));
+				} else {
+					command_print(CMD_CTX, "Compare failed");
+					binprint(CMD_CTX, "ref:", read_ref, host_bufsiz);
+					binprint(CMD_CTX, "buf:", read_buf, host_bufsiz);
+				}
+next:
+				free(read_ref);
+				free(read_buf);
+			}
+		}
+	}
+
+out:
+	free(test_pattern);
+
+	if (wa != NULL)
+		target_free_working_area(target, wa);
+
+	/* Test writes */
+	num_bytes = test_size + 4 + 4 + 4;
+
+	retval = target_alloc_working_area(target, num_bytes, &wa);
+	if (retval != ERROR_OK) {
+		LOG_ERROR("Not enough working area");
+		return ERROR_FAIL;
+	}
+
+	test_pattern = malloc(num_bytes);
+
+	for (size_t i = 0; i < num_bytes; i++)
+		test_pattern[i] = rand();
+
+	for (int host_offset = 0; host_offset <= 1; host_offset++) {
+		for (int size = 1; size <= 4; size *= 2) {
+			for (int offset = 0; offset < 4; offset++) {
+				uint32_t count = test_size / size;
+				size_t host_bufsiz = count * size + host_offset;
+				uint8_t *read_ref = malloc(num_bytes);
+				uint8_t *read_buf = malloc(num_bytes);
+				uint8_t *write_buf = malloc(host_bufsiz);
+
+				for (size_t i = 0; i < host_bufsiz; i++)
+					write_buf[i] = rand();
+				command_print_sameline(CMD_CTX,
+						"Test write %" PRIu32 " x %d @ %d from %saligned buffer: ", count,
+						size, offset, host_offset ? "un" : "");
+
+				retval = target_write_memory(target, wa->address, 1, num_bytes, test_pattern);
+				if (retval != ERROR_OK) {
+					command_print(CMD_CTX, "Test pattern write failed");
+					goto nextw;
+				}
+
+				/* replay on host */
+				memcpy(read_ref, test_pattern, num_bytes);
+				memcpy(read_ref + size + offset, write_buf + host_offset, count * size);
+
+				struct duration bench;
+				duration_start(&bench);
+
+				retval = target_write_memory(target, wa->address + size + offset, size, count,
+						write_buf + host_offset);
+
+				duration_measure(&bench);
+
+				if (retval == ERROR_TARGET_UNALIGNED_ACCESS) {
+					command_print(CMD_CTX, "Unsupported alignment");
+					goto nextw;
+				} else if (retval != ERROR_OK) {
+					command_print(CMD_CTX, "Memory write failed");
+					goto nextw;
+				}
+
+				/* read back */
+				retval = target_read_memory(target, wa->address, 1, num_bytes, read_buf);
+				if (retval != ERROR_OK) {
+					command_print(CMD_CTX, "Test pattern write failed");
+					goto nextw;
+				}
+
+				/* check result */
+				int result = memcmp(read_ref, read_buf, num_bytes);
+				if (result == 0) {
+					command_print(CMD_CTX, "Pass in %fs (%0.3f KiB/s)",
+							duration_elapsed(&bench),
+							duration_kbps(&bench, count * size));
+				} else {
+					command_print(CMD_CTX, "Compare failed");
+					binprint(CMD_CTX, "ref:", read_ref, num_bytes);
+					binprint(CMD_CTX, "buf:", read_buf, num_bytes);
+				}
+nextw:
+				free(read_ref);
+				free(read_buf);
+			}
+		}
+	}
+
+	free(test_pattern);
+
+	if (wa != NULL)
+		target_free_working_area(target, wa);
+	return retval;
+}
+
 static const struct command_registration target_exec_command_handlers[] = {
 	{
 		.name = "fast_load_image",
@@ -5568,7 +5894,7 @@ static const struct command_registration target_exec_command_handlers[] = {
 		.name = "profile",
 		.handler = handle_profile_command,
 		.mode = COMMAND_EXEC,
-		.usage = "seconds filename",
+		.usage = "seconds filename [start end]",
 		.help = "profiling samples the CPU PC",
 	},
 	/** @todo don't register virt2phys() unless target supports it */
@@ -5583,9 +5909,9 @@ static const struct command_registration target_exec_command_handlers[] = {
 		.name = "reg",
 		.handler = handle_reg_command,
 		.mode = COMMAND_EXEC,
-		.help = "display or set a register; with no arguments, "
-			"displays all registers and their values",
-		.usage = "[(register_name|register_number) [value]]",
+		.help = "display (reread from target with \"force\") or set a register; "
+			"with no arguments, displays all registers and their values",
+		.usage = "[(register_number|register_name) [(value|'force')]]",
 	},
 	{
 		.name = "poll",
@@ -5765,6 +6091,13 @@ static const struct command_registration target_exec_command_handlers[] = {
 		.help = "list all tasks ",
 		.usage = " ",
 	},
+	{
+		.name = "test_mem_access",
+		.handler = handle_test_mem_access_command,
+		.mode = COMMAND_EXEC,
+		.help = "Test the target's memory access functions",
+		.usage = "size",
+	},
 
 	COMMAND_REGISTRATION_DONE
 };