X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Ftarget%2Ftarget.c;h=c87c88986c9f22678666af6d5611d1f81904a540;hp=d768fda7ea1b03b42d36fae21bc46fc62d7eac78;hb=41124ea992b383f214d7a34766ae3c6cac74428c;hpb=5d80b365526537d2e8705e8bf4de1485b4bb6be6

diff --git a/src/target/target.c b/src/target/target.c
index d768fda7ea..c87c88986c 100644
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -36,7 +36,7 @@
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
- *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
  ***************************************************************************/
 
 #ifdef HAVE_CONFIG_H
@@ -55,16 +55,26 @@
 #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,
 		int argc, Jim_Obj * const *argv);
 static int target_register_user_commands(struct command_context *cmd_ctx);
+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;
@@ -78,8 +88,9 @@ 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;
 extern struct target_type avr_target;
@@ -88,6 +99,11 @@ extern struct target_type dsp5680xx_target;
 extern struct target_type testee_target;
 extern struct target_type avr32_ap7k_target;
 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,
@@ -101,8 +117,9 @@ 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,
 	&avr_target,
@@ -111,6 +128,11 @@ static struct target_type *target_types[] = {
 	&testee_target,
 	&avr32_ap7k_target,
 	&hla_target,
+	&nds32_v2_target,
+	&nds32_v3_target,
+	&nds32_v3m_target,
+	&or1k_target,
+	&quark_x10xx_target,
 	NULL,
 };
 
@@ -213,6 +235,7 @@ static const Jim_Nvp nvp_target_debug_reason[] = {
 	{ .name = "watchpoint-and-breakpoint", .value = DBG_REASON_WPTANDBKPT },
 	{ .name = "single-step"              , .value = DBG_REASON_SINGLESTEP },
 	{ .name = "target-not-halted"        , .value = DBG_REASON_NOTHALTED  },
+	{ .name = "program-exit"             , .value = DBG_REASON_EXIT },
 	{ .name = "undefined"                , .value = DBG_REASON_UNDEFINED },
 	{ .name = NULL, .value = -1 },
 };
@@ -274,6 +297,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)
 {
@@ -307,6 +339,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)
 {
@@ -340,6 +381,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)
 {
@@ -356,8 +405,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++)
@@ -365,7 +422,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++)
@@ -379,9 +436,9 @@ struct target *get_target(const char *id)
 
 	/* try as tcltarget name */
 	for (target = all_targets; target; target = target->next) {
-		if (target->cmd_name == NULL)
+		if (target_name(target) == NULL)
 			continue;
-		if (strcmp(id, target->cmd_name) == 0)
+		if (strcmp(id, target_name(target)) == 0)
 			return target;
 	}
 
@@ -395,7 +452,7 @@ struct target *get_target(const char *id)
 	for (target = all_targets; target; target = target->next) {
 		if (target->target_number == (int)num) {
 			LOG_WARNING("use '%s' as target identifier, not '%u'",
-					target->cmd_name, num);
+					target_name(target), num);
 			return target;
 		}
 	}
@@ -448,7 +505,7 @@ int target_poll(struct target *target)
 			target->halt_issued = false;
 		else {
 			long long t = timeval_ms() - target->halt_issued_time;
-			if (t > 1000) {
+			if (t > DEFAULT_HALT_TIMEOUT) {
 				target->halt_issued = false;
 				LOG_INFO("Halt timed out, wake up GDB.");
 				target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT);
@@ -567,8 +624,10 @@ static int target_process_reset(struct command_context *cmd_ctx, enum target_res
 	retval = target_call_timer_callbacks_now();
 
 	struct target *target;
-	for (target = all_targets; target; target = target->next)
+	for (target = all_targets; target; target = target->next) {
 		target->type->check_reset(target);
+		target->running_alg = false;
+	}
 
 	return retval;
 }
@@ -657,38 +716,18 @@ const char *target_type_name(struct target *target)
 	return target->type->name;
 }
 
-static int target_write_memory_imp(struct target *target, uint32_t address,
-		uint32_t size, uint32_t count, const uint8_t *buffer)
+static int target_soft_reset_halt(struct target *target)
 {
 	if (!target_was_examined(target)) {
 		LOG_ERROR("Target not examined yet");
 		return ERROR_FAIL;
 	}
-	return target->type->write_memory_imp(target, address, size, count, buffer);
-}
-
-static int target_read_memory_imp(struct target *target, uint32_t address,
-		uint32_t size, uint32_t count, uint8_t *buffer)
-{
-	if (!target_was_examined(target)) {
-		LOG_ERROR("Target not examined yet");
-		return ERROR_FAIL;
-	}
-	return target->type->read_memory_imp(target, address, size, count, buffer);
-}
-
-static int target_soft_reset_halt_imp(struct target *target)
-{
-	if (!target_was_examined(target)) {
-		LOG_ERROR("Target not examined yet");
-		return ERROR_FAIL;
-	}
-	if (!target->type->soft_reset_halt_imp) {
+	if (!target->type->soft_reset_halt) {
 		LOG_ERROR("Target %s does not support soft_reset_halt",
 				target_name(target));
 		return ERROR_FAIL;
 	}
-	return target->type->soft_reset_halt_imp(target);
+	return target->type->soft_reset_halt(target);
 }
 
 /**
@@ -815,7 +854,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,
@@ -824,6 +863,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;
@@ -864,7 +905,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");
@@ -951,38 +993,48 @@ int target_run_flash_async_algorithm(struct target *target,
 int target_read_memory(struct target *target,
 		uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
 {
+	if (!target_was_examined(target)) {
+		LOG_ERROR("Target not examined yet");
+		return ERROR_FAIL;
+	}
 	return target->type->read_memory(target, address, size, count, buffer);
 }
 
-static int target_read_phys_memory(struct target *target,
+int target_read_phys_memory(struct target *target,
 		uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
 {
+	if (!target_was_examined(target)) {
+		LOG_ERROR("Target not examined yet");
+		return ERROR_FAIL;
+	}
 	return target->type->read_phys_memory(target, address, size, count, buffer);
 }
 
 int target_write_memory(struct target *target,
 		uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
 {
+	if (!target_was_examined(target)) {
+		LOG_ERROR("Target not examined yet");
+		return ERROR_FAIL;
+	}
 	return target->type->write_memory(target, address, size, count, buffer);
 }
 
-static int target_write_phys_memory(struct target *target,
+int target_write_phys_memory(struct target *target,
 		uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
 {
+	if (!target_was_examined(target)) {
+		LOG_ERROR("Target not examined yet");
+		return ERROR_FAIL;
+	}
 	return target->type->write_phys_memory(target, address, size, count, buffer);
 }
 
-int target_bulk_write_memory(struct target *target,
-		uint32_t address, uint32_t count, const uint8_t *buffer)
-{
-	return target->type->bulk_write_memory(target, address, count, buffer);
-}
-
 int target_add_breakpoint(struct target *target,
 		struct breakpoint *breakpoint)
 {
 	if ((target->state != TARGET_HALTED) && (breakpoint->type != BKPT_HARD)) {
-		LOG_WARNING("target %s is not halted", target->cmd_name);
+		LOG_WARNING("target %s is not halted", target_name(target));
 		return ERROR_TARGET_NOT_HALTED;
 	}
 	return target->type->add_breakpoint(target, breakpoint);
@@ -992,7 +1044,7 @@ int target_add_context_breakpoint(struct target *target,
 		struct breakpoint *breakpoint)
 {
 	if (target->state != TARGET_HALTED) {
-		LOG_WARNING("target %s is not halted", target->cmd_name);
+		LOG_WARNING("target %s is not halted", target_name(target));
 		return ERROR_TARGET_NOT_HALTED;
 	}
 	return target->type->add_context_breakpoint(target, breakpoint);
@@ -1002,7 +1054,7 @@ int target_add_hybrid_breakpoint(struct target *target,
 		struct breakpoint *breakpoint)
 {
 	if (target->state != TARGET_HALTED) {
-		LOG_WARNING("target %s is not halted", target->cmd_name);
+		LOG_WARNING("target %s is not halted", target_name(target));
 		return ERROR_TARGET_NOT_HALTED;
 	}
 	return target->type->add_hybrid_breakpoint(target, breakpoint);
@@ -1018,7 +1070,7 @@ 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);
+		LOG_WARNING("target %s is not halted", target_name(target));
 		return ERROR_TARGET_NOT_HALTED;
 	}
 	return target->type->add_watchpoint(target, watchpoint);
@@ -1028,11 +1080,29 @@ int target_remove_watchpoint(struct target *target,
 {
 	return target->type->remove_watchpoint(target, watchpoint);
 }
+int target_hit_watchpoint(struct target *target,
+		struct watchpoint **hit_watchpoint)
+{
+	if (target->state != TARGET_HALTED) {
+		LOG_WARNING("target %s is not halted", target->cmd_name);
+		return ERROR_TARGET_NOT_HALTED;
+	}
+
+	if (target->type->hit_watchpoint == NULL) {
+		/* For backward compatible, if hit_watchpoint is not implemented,
+		 * return ERROR_FAIL such that gdb_server will not take the nonsense
+		 * information. */
+		return ERROR_FAIL;
+	}
+
+	return target->type->hit_watchpoint(target, hit_watchpoint);
+}
 
 int target_get_gdb_reg_list(struct target *target,
-		struct reg **reg_list[], int *reg_list_size)
+		struct reg **reg_list[], int *reg_list_size,
+		enum target_register_class reg_class)
 {
-	return target->type->get_gdb_reg_list(target, reg_list, reg_list_size);
+	return target->type->get_gdb_reg_list(target, reg_list, reg_list_size, reg_class);
 }
 int target_step(struct target *target,
 		int current, uint32_t address, int handle_breakpoints)
@@ -1040,6 +1110,35 @@ int target_step(struct target *target,
 	return target->type->step(target, current, address, handle_breakpoints);
 }
 
+int target_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fileio_info)
+{
+	if (target->state != TARGET_HALTED) {
+		LOG_WARNING("target %s is not halted", target->cmd_name);
+		return ERROR_TARGET_NOT_HALTED;
+	}
+	return target->type->get_gdb_fileio_info(target, fileio_info);
+}
+
+int target_gdb_fileio_end(struct target *target, int retcode, int fileio_errno, bool ctrl_c)
+{
+	if (target->state != TARGET_HALTED) {
+		LOG_WARNING("target %s is not halted", target->cmd_name);
+		return ERROR_TARGET_NOT_HALTED;
+	}
+	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.
@@ -1085,23 +1184,6 @@ static int target_init_one(struct command_context *cmd_ctx,
 		return retval;
 	}
 
-	/**
-	 * @todo get rid of those *memory_imp() methods, now that all
-	 * callers are using target_*_memory() accessors ... and make
-	 * sure the "physical" paths handle the same issues.
-	 */
-	/* a non-invasive way(in terms of patches) to add some code that
-	 * runs before the type->write/read_memory implementation
-	 */
-	type->write_memory_imp = target->type->write_memory;
-	type->write_memory = target_write_memory_imp;
-
-	type->read_memory_imp = target->type->read_memory;
-	type->read_memory = target_read_memory_imp;
-
-	type->soft_reset_halt_imp = target->type->soft_reset_halt;
-	type->soft_reset_halt = target_soft_reset_halt_imp;
-
 	/* Sanity-check MMU support ... stub in what we must, to help
 	 * implement it in stages, but warn if we need to do so.
 	 */
@@ -1140,6 +1222,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->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;
 }
 
@@ -1187,6 +1278,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;
@@ -1274,7 +1369,7 @@ 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_timer_callback(int (*callback)(void *priv), void *priv)
 {
 	struct target_timer_callback **p = &target_timer_callbacks;
 	struct target_timer_callback *c = target_timer_callbacks;
@@ -1689,6 +1784,71 @@ int target_arch_state(struct target *target)
 	return retval;
 }
 
+static int target_get_gdb_fileio_info_default(struct target *target,
+		struct gdb_fileio_info *fileio_info)
+{
+	/* 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)
+{
+	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
@@ -1717,57 +1877,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;
+	uint32_t size;
 
-		retval = target_write_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);
-
-		/* 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
@@ -1798,58 +1938,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;
-
-	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;
+	uint32_t size;
 
-		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;
@@ -1911,6 +2027,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];
@@ -1961,12 +2101,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,
@@ -1980,6 +2121,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;
@@ -2225,6 +2387,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;
 
@@ -2256,8 +2422,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;
 		}
 	}
@@ -2419,13 +2595,11 @@ COMMAND_HANDLER(handle_wait_halt_command)
 	if (CMD_ARGC > 1)
 		return ERROR_COMMAND_SYNTAX_ERROR;
 
-	unsigned ms = 5000;
+	unsigned ms = DEFAULT_HALT_TIMEOUT;
 	if (1 == CMD_ARGC) {
 		int retval = parse_uint(CMD_ARGV[0], &ms);
 		if (ERROR_OK != retval)
 			return ERROR_COMMAND_SYNTAX_ERROR;
-		/* convert seconds (given) to milliseconds (needed) */
-		ms *= 1000;
 	}
 
 	struct target *target = get_current_target(CMD_CTX);
@@ -2498,7 +2672,7 @@ COMMAND_HANDLER(handle_soft_reset_halt_command)
 
 	LOG_USER("requesting target halt and executing a soft reset");
 
-	target->type->soft_reset_halt(target);
+	target_soft_reset_halt(target);
 
 	return ERROR_OK;
 }
@@ -2676,12 +2850,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,
@@ -2746,7 +2914,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;
 
@@ -3036,7 +3204,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;
@@ -3142,9 +3310,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 {
@@ -3152,7 +3321,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 {
@@ -3160,7 +3333,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 {
@@ -3343,14 +3520,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)
@@ -3358,59 +3533,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);
@@ -3418,9 +3613,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)
@@ -3429,7 +3624,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);
@@ -3442,84 +3637,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;
 }
 
@@ -3697,6 +3878,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;
 		}
 	}
 
@@ -3890,6 +4072,7 @@ static int target_array2mem(Jim_Interp *interp, struct target *target,
 			e = JIM_ERR;
 			break;
 		}
+		addr += count * width;
 	}
 
 	free(buffer);
@@ -3945,7 +4128,6 @@ enum target_cfg_param {
 	TCFG_WORK_AREA_SIZE,
 	TCFG_WORK_AREA_BACKUP,
 	TCFG_ENDIAN,
-	TCFG_VARIANT,
 	TCFG_COREID,
 	TCFG_CHAIN_POSITION,
 	TCFG_DBGBASE,
@@ -3960,7 +4142,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 },
@@ -3973,7 +4154,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 ... */
@@ -4182,28 +4362,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);
@@ -4302,7 +4460,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) {
@@ -4901,6 +5059,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)) {
@@ -4939,9 +5106,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));
 
@@ -5006,10 +5174,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);
 
@@ -5032,7 +5196,7 @@ static int target_create(Jim_GetOptInfo *goi)
 	}
 
 	/* now - create the new target name command */
-	const const struct command_registration target_subcommands[] = {
+	const struct command_registration target_subcommands[] = {
 		{
 			.chain = target_instance_command_handlers,
 		},
@@ -5041,7 +5205,7 @@ static int target_create(Jim_GetOptInfo *goi)
 		},
 		COMMAND_REGISTRATION_DONE
 	};
-	const const struct command_registration target_commands[] = {
+	const struct command_registration target_commands[] = {
 		{
 			.name = cp,
 			.mode = COMMAND_ANY,
@@ -5071,7 +5235,7 @@ static int jim_target_current(Jim_Interp *interp, int argc, Jim_Obj *const *argv
 	struct command_context *cmd_ctx = current_command_context(interp);
 	assert(cmd_ctx != NULL);
 
-	Jim_SetResultString(interp, get_current_target(cmd_ctx)->cmd_name, -1);
+	Jim_SetResultString(interp, target_name(get_current_target(cmd_ctx)), -1);
 	return JIM_OK;
 }
 
@@ -5169,55 +5333,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",
@@ -5252,21 +5367,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,
@@ -5327,7 +5427,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);
@@ -5369,7 +5469,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;
@@ -5492,6 +5592,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",
@@ -5514,7 +5806,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 */
@@ -5529,9 +5821,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",
@@ -5545,7 +5837,7 @@ static const struct command_registration target_exec_command_handlers[] = {
 		.handler = handle_wait_halt_command,
 		.mode = COMMAND_EXEC,
 		.help = "wait up to the specified number of milliseconds "
-			"(default 5) for a previously requested halt",
+			"(default 5000) for a previously requested halt",
 		.usage = "[milliseconds]",
 	},
 	{
@@ -5553,7 +5845,7 @@ static const struct command_registration target_exec_command_handlers[] = {
 		.handler = handle_halt_command,
 		.mode = COMMAND_EXEC,
 		.help = "request target to halt, then wait up to the specified"
-			"number of milliseconds (default 5) for it to complete",
+			"number of milliseconds (default 5000) for it to complete",
 		.usage = "[milliseconds]",
 	},
 	{
@@ -5711,6 +6003,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
 };