target: Add 64-bit target address support

Define a target_addr_t type to support 32-bit and 64-bit addresses at
the same time. Also define matching TARGET_PRI*ADDR format macros as
well as a convenient TARGET_ADDR_FMT.

In targets that are 32-bit (avr32, nds32, arm7/9/11, fm4, xmc1000)
be least invasive by leaving the formatting unchanged apart from the
type;
for generic code adopt TARGET_ADDR_FMT as unified address format.

Don't silently change gdb formatting here, leave that to later.

Add COMMAND_PARSE_ADDRESS() macro to abstract the address type.
Implement it using its own parse_target_addr() function, in the hopes
of catching pointer type mismatches better.

Add '--disable-target64' configure option to revert to previous 32-bit
target address behavior.

Change-Id: I2e91d205862ceb14f94b3e72a7e99ee0373a85d5
Signed-off-by: Dongxue Zhang <elta.era@gmail.com>
Signed-off-by: David Ung <david.ung.42@gmail.com>
[AF: Default to enabling (Paul Fertser), rename macros, simplify]
Signed-off-by: Andreas Färber <afaerber@suse.de>
Signed-off-by: Matthias Welwarsky <matthias.welwarsky@sysgo.com>

diff --git a/configure.ac b/configure.ac
index 2543eca3a0b63ee106b98b5d1ff6acee95187109..6e60733eaf358dd56009068c0786c0192b421f34 100644 (file)
--- a/configure.ac
+++ b/configure.ac
@@ -339,6 +339,10 @@ AC_ARG_ENABLE([internal-libjaylink],
   [Disable building internal libjaylink]),
   [use_internal_libjaylink=$enableval], [use_internal_libjaylink=yes])
 
   [Disable building internal libjaylink]),
   [use_internal_libjaylink=$enableval], [use_internal_libjaylink=yes])
 

+AC_ARG_ENABLE([target64],
+  AS_HELP_STRING([--disable-target64], [Disable 64-bit target address]),
+    [build_target64=$enableval], [build_target64=yes])
+

 build_minidriver=no
 AC_MSG_CHECKING([whether to enable ZY1000 minidriver])
 AS_IF([test "x$build_zy1000" = "xyes"], [
 build_minidriver=no
 AC_MSG_CHECKING([whether to enable ZY1000 minidriver])
 AS_IF([test "x$build_zy1000" = "xyes"], [


@@ -572,6 +576,13 @@ AS_IF([test "x$build_sysfsgpio" = "xyes"], [
   AC_DEFINE([BUILD_SYSFSGPIO], [0], [0 if you don't want SysfsGPIO driver.])
 ])
 
   AC_DEFINE([BUILD_SYSFSGPIO], [0], [0 if you don't want SysfsGPIO driver.])
 ])
 

+AS_IF([test "x$build_target64" = "xyes"], [
+  AC_DEFINE([BUILD_TARGET64], [1], [1 if you want 64-bit addresses.])
+], [
+  AC_DEFINE([BUILD_TARGET64], [0], [0 if you don't want 64-bit addresses.])
+])
+
+

 PKG_CHECK_MODULES([LIBUSB1], [libusb-1.0], [
        use_libusb1=yes
        AC_DEFINE([HAVE_LIBUSB1], [1], [Define if you have libusb-1.x])
 PKG_CHECK_MODULES([LIBUSB1], [libusb-1.0], [
        use_libusb1=yes
        AC_DEFINE([HAVE_LIBUSB1], [1], [Define if you have libusb-1.x])


@@ -689,6 +700,7 @@ AM_CONDITIONAL([BITQ], [test "x$build_bitq" = "xyes"])
 AM_CONDITIONAL([USE_LIBFTDI], [test "x$use_libftdi" = "xyes"])
 AM_CONDITIONAL([USE_HIDAPI], [test "x$use_hidapi" = "xyes"])
 AM_CONDITIONAL([USE_LIBJAYLINK], [test "x$use_libjaylink" = "xyes"])
 AM_CONDITIONAL([USE_LIBFTDI], [test "x$use_libftdi" = "xyes"])
 AM_CONDITIONAL([USE_HIDAPI], [test "x$use_hidapi" = "xyes"])
 AM_CONDITIONAL([USE_LIBJAYLINK], [test "x$use_libjaylink" = "xyes"])

+AM_CONDITIONAL([TARGET64], [test "x$build_target64" = "xyes"])

 
 AM_CONDITIONAL([MINIDRIVER], [test "x$build_minidriver" = "xyes"])
 AM_CONDITIONAL([MINIDRIVER_DUMMY], [test "x$build_minidriver_dummy" = "xyes"])
 
 AM_CONDITIONAL([MINIDRIVER], [test "x$build_minidriver" = "xyes"])
 AM_CONDITIONAL([MINIDRIVER_DUMMY], [test "x$build_minidriver_dummy" = "xyes"])

diff --git a/src/flash/nor/cfi.c b/src/flash/nor/cfi.c
index f7d8a90f181303e76873746bd4c56b7882e24936..dca33f6a092240307b2855616428c1c8eceff551 100644 (file)
--- a/src/flash/nor/cfi.c
+++ b/src/flash/nor/cfi.c
@@ -1312,7 +1312,7 @@ static int cfi_intel_write_block(struct flash_bank *bank, const uint8_t *buffer,
        busy_pattern_val  = cfi_command_val(bank, 0x80);
        error_pattern_val = cfi_command_val(bank, 0x7e);
 
        busy_pattern_val  = cfi_command_val(bank, 0x80);
        error_pattern_val = cfi_command_val(bank, 0x7e);
 

-       LOG_DEBUG("Using target buffer at 0x%08" PRIx32 " and of size 0x%04" PRIx32,
+       LOG_DEBUG("Using target buffer at " TARGET_ADDR_FMT " and of size 0x%04" PRIx32,

                source->address, buffer_size);
 
        /* Programming main loop */
                source->address, buffer_size);
 
        /* Programming main loop */

diff --git a/src/flash/nor/fm4.c b/src/flash/nor/fm4.c
index c348c1d61344655ec851495e2af466d210a1e3dd..c8fe8b66f72bd0ecc7c2b1d8db8b117573de292f 100644 (file)
--- a/src/flash/nor/fm4.c
+++ b/src/flash/nor/fm4.c
@@ -272,7 +272,7 @@ static int fm4_flash_write(struct flash_bank *bank, const uint8_t *buffer,
                uint32_t halfwords = MIN(halfword_count, data_workarea->size / 2);
                uint32_t addr = bank->base + offset;
 
                uint32_t halfwords = MIN(halfword_count, data_workarea->size / 2);
                uint32_t addr = bank->base + offset;
 

-               LOG_DEBUG("copying %" PRId32 " bytes to SRAM 0x%08" PRIx32,
+               LOG_DEBUG("copying %" PRId32 " bytes to SRAM 0x%08" TARGET_PRIxADDR,

                        MIN(halfwords * 2, byte_count), data_workarea->address);
 
                retval = target_write_buffer(target, data_workarea->address,
                        MIN(halfwords * 2, byte_count), data_workarea->address);
 
                retval = target_write_buffer(target, data_workarea->address,

diff --git a/src/flash/nor/lpc2000.c b/src/flash/nor/lpc2000.c
index 190684af12ac30054f95d0407d60c28e93dbec59..9da5da2cac282eebbb7e262df4483e3d7972f0e9 100644 (file)
--- a/src/flash/nor/lpc2000.c
+++ b/src/flash/nor/lpc2000.c
@@ -688,7 +688,7 @@ static int lpc2000_iap_working_area_init(struct flash_bank *bank, struct working
 
        int retval = target_write_memory(target, (*iap_working_area)->address, 4, 2, jump_gate);
        if (retval != ERROR_OK) {
 
        int retval = target_write_memory(target, (*iap_working_area)->address, 4, 2, jump_gate);
        if (retval != ERROR_OK) {

-               LOG_ERROR("Write memory at address 0x%8.8" PRIx32 " failed (check work_area definition)",
+               LOG_ERROR("Write memory at address 0x%8.8" TARGET_PRIxADDR " failed (check work_area definition)",

                                (*iap_working_area)->address);
                target_free_working_area(target, *iap_working_area);
        }
                                (*iap_working_area)->address);
                target_free_working_area(target, *iap_working_area);
        }

diff --git a/src/flash/nor/lpcspifi.c b/src/flash/nor/lpcspifi.c
index 4eb6cc38ae90d2f3600dc7aed79ac1b779fadc86..943c151e22f0df37d174ddacfd0458e5a40602a2 100644 (file)
--- a/src/flash/nor/lpcspifi.c
+++ b/src/flash/nor/lpcspifi.c
@@ -186,7 +186,7 @@ static int lpcspifi_set_hw_mode(struct flash_bank *bank)
                return retval;
        }
 
                return retval;
        }
 

-       LOG_DEBUG("Writing algorithm to working area at 0x%08" PRIx32,
+       LOG_DEBUG("Writing algorithm to working area at 0x%08" TARGET_PRIxADDR,

                spifi_init_algorithm->address);
        /* Write algorithm to working area */
        retval = target_write_buffer(target,
                spifi_init_algorithm->address);
        /* Write algorithm to working area */
        retval = target_write_buffer(target,

diff --git a/src/flash/nor/xmc1xxx.c b/src/flash/nor/xmc1xxx.c
index bb2ec1272a34d8e49859ef642801145d7f54534a..0a76b216d4c6e6124a50bb429ea65482c8002a79 100644 (file)
--- a/src/flash/nor/xmc1xxx.c
+++ b/src/flash/nor/xmc1xxx.c
@@ -305,7 +305,7 @@ static int xmc1xxx_write(struct flash_bank *bank, const uint8_t *buffer,
                uint32_t blocks = MIN(block_count, data_workarea->size / NVM_BLOCK_SIZE);
                uint32_t addr = bank->base + offset;
 
                uint32_t blocks = MIN(block_count, data_workarea->size / NVM_BLOCK_SIZE);
                uint32_t addr = bank->base + offset;
 

-               LOG_DEBUG("copying %" PRId32 " bytes to SRAM 0x%08" PRIx32,
+               LOG_DEBUG("copying %" PRId32 " bytes to SRAM 0x%08" TARGET_PRIxADDR,

                        MIN(blocks * NVM_BLOCK_SIZE, byte_count),
                        data_workarea->address);
 
                        MIN(blocks * NVM_BLOCK_SIZE, byte_count),
                        data_workarea->address);
 

diff --git a/src/helper/command.c b/src/helper/command.c
index fc4aac72edf7c158c290118ab2ae4d41cf554828..5deaee859342ae03ad1fa1e7253ed925faff88f4 100644 (file)
--- a/src/helper/command.c
+++ b/src/helper/command.c
@@ -1410,6 +1410,8 @@ DEFINE_PARSE_ULONGLONG(_u32,  uint32_t, 0, UINT32_MAX)
 DEFINE_PARSE_ULONGLONG(_u16,  uint16_t, 0, UINT16_MAX)
 DEFINE_PARSE_ULONGLONG(_u8,   uint8_t,  0, UINT8_MAX)
 
 DEFINE_PARSE_ULONGLONG(_u16,  uint16_t, 0, UINT16_MAX)
 DEFINE_PARSE_ULONGLONG(_u8,   uint8_t,  0, UINT8_MAX)
 

+DEFINE_PARSE_ULONGLONG(_target_addr, target_addr_t, 0, TARGET_ADDR_MAX)
+

 #define DEFINE_PARSE_LONGLONG(name, type, min, max) \
        DEFINE_PARSE_WRAPPER(name, type, min, max, long long, _llong)
 DEFINE_PARSE_LONGLONG(_int, int,     n < INT_MIN,   INT_MAX)
 #define DEFINE_PARSE_LONGLONG(name, type, min, max) \
        DEFINE_PARSE_WRAPPER(name, type, min, max, long long, _llong)
 DEFINE_PARSE_LONGLONG(_int, int,     n < INT_MIN,   INT_MAX)

diff --git a/src/helper/command.h b/src/helper/command.h
index 5c39660115c2110b6b4ae3fd0469a93b7d82d984..bd24156e31af1d27d9ff7af8329d7be11b7bc89d 100644 (file)
--- a/src/helper/command.h
+++ b/src/helper/command.h
@@ -357,10 +357,13 @@ DECLARE_PARSE_WRAPPER(_u16, uint16_t);
 DECLARE_PARSE_WRAPPER(_u8, uint8_t);
 
 DECLARE_PARSE_WRAPPER(_int, int);
 DECLARE_PARSE_WRAPPER(_u8, uint8_t);
 
 DECLARE_PARSE_WRAPPER(_int, int);

+DECLARE_PARSE_WRAPPER(_s64, int64_t);

 DECLARE_PARSE_WRAPPER(_s32, int32_t);
 DECLARE_PARSE_WRAPPER(_s16, int16_t);
 DECLARE_PARSE_WRAPPER(_s8, int8_t);
 
 DECLARE_PARSE_WRAPPER(_s32, int32_t);
 DECLARE_PARSE_WRAPPER(_s16, int16_t);
 DECLARE_PARSE_WRAPPER(_s8, int8_t);
 

+DECLARE_PARSE_WRAPPER(_target_addr, target_addr_t);
+

 /**
  * @brief parses the string @a in into @a out as a @a type, or prints
  * a command error and passes the error code to the caller.  If an error
 /**
  * @brief parses the string @a in into @a out as a @a type, or prints
  * a command error and passes the error code to the caller.  If an error


@@ -382,6 +385,9 @@ DECLARE_PARSE_WRAPPER(_s8, int8_t);
                } \
        } while (0)
 
                } \
        } while (0)
 

+#define COMMAND_PARSE_ADDRESS(in, out) \
+       COMMAND_PARSE_NUMBER(target_addr, in, out)
+

 /**
  * Parse the string @c as a binary parameter, storing the boolean value
  * in @c out.  The strings @c on and @c off are used to match different
 /**
  * Parse the string @c as a binary parameter, storing the boolean value
  * in @c out.  The strings @c on and @c off are used to match different

diff --git a/src/helper/types.h b/src/helper/types.h
index 1854ba85bee2deff7bed3ce6e039b509e5af7870..58c9e724579e3082c84d21d132a92e050a2e2e64 100644 (file)
--- a/src/helper/types.h
+++ b/src/helper/types.h
@@ -296,14 +296,21 @@ static inline int parity_u32(uint32_t x)
  */
 
 #if !defined(_STDINT_H)
  */
 
 #if !defined(_STDINT_H)

-#define PRIx32 "x"

 #define PRId32 "d"
 #define PRId32 "d"

-#define SCNx32 "x"

 #define PRIi32 "i"
 #define PRIi32 "i"

+#define PRIo32 "o"

 #define PRIu32 "u"
 #define PRIu32 "u"

+#define PRIx32 "x"
+#define PRIX32 "X"
+#define SCNx32 "x"

 #define PRId8 PRId32
 #define SCNx64 "llx"
 #define PRId8 PRId32
 #define SCNx64 "llx"

+#define PRId64 "lld"
+#define PRIi64 "lli"
+#define PRIo64 "llo"
+#define PRIu64 "llu"

 #define PRIx64 "llx"
 #define PRIx64 "llx"

+#define PRIX64 "llX"

 
 typedef CYG_ADDRWORD intptr_t;
 typedef int64_t intmax_t;
 
 typedef CYG_ADDRWORD intptr_t;
 typedef int64_t intmax_t;


@@ -337,4 +344,23 @@ typedef uint64_t uintmax_t;
 
 #endif
 
 
 #endif
 

+#if BUILD_TARGET64
+typedef uint64_t target_addr_t;
+#define TARGET_ADDR_MAX UINT64_MAX
+#define TARGET_PRIdADDR PRId64
+#define TARGET_PRIuADDR PRIu64
+#define TARGET_PRIoADDR PRIo64
+#define TARGET_PRIxADDR PRIx64
+#define TARGET_PRIXADDR PRIX64
+#else
+typedef uint32_t target_addr_t;
+#define TARGET_ADDR_MAX UINT32_MAX
+#define TARGET_PRIdADDR PRId32
+#define TARGET_PRIuADDR PRIu32
+#define TARGET_PRIoADDR PRIo32
+#define TARGET_PRIxADDR PRIx32
+#define TARGET_PRIXADDR PRIX32
+#endif
+#define TARGET_ADDR_FMT "0x%8.8" TARGET_PRIxADDR
+

 #endif /* OPENOCD_HELPER_TYPES_H */
 #endif /* OPENOCD_HELPER_TYPES_H */

diff --git a/src/jtag/aice/aice_pipe.c b/src/jtag/aice/aice_pipe.c
index 18ad40eaa4ad822fc84f4830cf6f0742e113ae54..bdc8c090a5a22b5489eab01f7c4d7ffa9fb79790 100644 (file)
--- a/src/jtag/aice/aice_pipe.c
+++ b/src/jtag/aice/aice_pipe.c
@@ -786,8 +786,8 @@ static int aice_pipe_memory_mode(uint32_t coreid, enum nds_memory_select mem_sel
                return ERROR_FAIL;
 }
 
                return ERROR_FAIL;
 }
 

-static int aice_pipe_read_tlb(uint32_t coreid, uint32_t virtual_address,
-               uint32_t *physical_address)
+static int aice_pipe_read_tlb(uint32_t coreid, target_addr_t virtual_address,
+               target_addr_t *physical_address)

 {
        char line[AICE_PIPE_MAXLINE];
        char command[AICE_PIPE_MAXLINE];
 {
        char line[AICE_PIPE_MAXLINE];
        char command[AICE_PIPE_MAXLINE];

diff --git a/src/jtag/aice/aice_port.h b/src/jtag/aice/aice_port.h
index 4568ce121bf8c0338d17d0589c098916de5e1e56..d3d6a1a2c9c29aa007930e0dab1c3f9e88b34b1f 100644 (file)
--- a/src/jtag/aice/aice_port.h
+++ b/src/jtag/aice/aice_port.h
@@ -180,7 +180,7 @@ struct aice_port_api_s {
        int (*memory_mode)(uint32_t coreid, enum nds_memory_select mem_select);
 
        /** */
        int (*memory_mode)(uint32_t coreid, enum nds_memory_select mem_select);
 
        /** */

-       int (*read_tlb)(uint32_t coreid, uint32_t virtual_address, uint32_t *physical_address);
+       int (*read_tlb)(uint32_t coreid, target_addr_t virtual_address, target_addr_t *physical_address);

 
        /** */
        int (*cache_ctl)(uint32_t coreid, uint32_t subtype, uint32_t address);
 
        /** */
        int (*cache_ctl)(uint32_t coreid, uint32_t subtype, uint32_t address);

diff --git a/src/jtag/aice/aice_usb.c b/src/jtag/aice/aice_usb.c
index b27f7200466e3b2149a2a5405a574939abe943f4..b36e3900cb7fe77a14c7c1e2301b153ea6f8fa7b 100644 (file)
--- a/src/jtag/aice/aice_usb.c
+++ b/src/jtag/aice/aice_usb.c
@@ -3424,10 +3424,10 @@ static int aice_usb_memory_mode(uint32_t coreid, enum nds_memory_select mem_sele
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int aice_usb_read_tlb(uint32_t coreid, uint32_t virtual_address,
-               uint32_t *physical_address)
+static int aice_usb_read_tlb(uint32_t coreid, target_addr_t virtual_address,
+               target_addr_t *physical_address)

 {
 {

-       LOG_DEBUG("aice_usb_read_tlb, virtual address: 0x%08" PRIx32, virtual_address);
+       LOG_DEBUG("aice_usb_read_tlb, virtual address: 0x%08" TARGET_PRIxADDR, virtual_address);

 
        uint32_t instructions[4];
        uint32_t probe_result;
 
        uint32_t instructions[4];
        uint32_t probe_result;

diff --git a/src/rtos/linux.c b/src/rtos/linux.c
index e5a4efcde697e202b175fd46c70ad1f4e6ec2ac5..3efaab133f97bc6dad71aa6a2cd7785cee5eca92 100644 (file)
--- a/src/rtos/linux.c
+++ b/src/rtos/linux.c
@@ -105,11 +105,11 @@ static int linux_os_dummy_update(struct rtos *rtos)
        return 0;
 }
 
        return 0;
 }
 

-static int linux_compute_virt2phys(struct target *target, uint32_t address)
+static int linux_compute_virt2phys(struct target *target, target_addr_t address)

 {
        struct linux_os *linux_os = (struct linux_os *)
                target->rtos->rtos_specific_params;
 {
        struct linux_os *linux_os = (struct linux_os *)
                target->rtos->rtos_specific_params;

-       uint32_t pa = 0;
+       target_addr_t pa = 0;

        int retval = target->type->virt2phys(target, address, &pa);
        if (retval != ERROR_OK) {
                LOG_ERROR("Cannot compute linux virt2phys translation");
        int retval = target->type->virt2phys(target, address, &pa);
        if (retval != ERROR_OK) {
                LOG_ERROR("Cannot compute linux virt2phys translation");

diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c
index fe007444192da0a4dd8e82399fcc1b67665d67ad..c293f5b057235f829bd6228c94b0459c23dff4b9 100644 (file)
--- a/src/server/gdb_server.c
+++ b/src/server/gdb_server.c
@@ -735,22 +735,22 @@ static void gdb_signal_reply(struct target *target, struct connection *connectio
                stop_reason[0] = '\0';
                if (target->debug_reason == DBG_REASON_WATCHPOINT) {
                        enum watchpoint_rw hit_wp_type;
                stop_reason[0] = '\0';
                if (target->debug_reason == DBG_REASON_WATCHPOINT) {
                        enum watchpoint_rw hit_wp_type;

-                       uint32_t hit_wp_address;
+                       target_addr_t hit_wp_address;

 
                        if (watchpoint_hit(target, &hit_wp_type, &hit_wp_address) == ERROR_OK) {
 
                                switch (hit_wp_type) {
                                        case WPT_WRITE:
                                                snprintf(stop_reason, sizeof(stop_reason),
 
                        if (watchpoint_hit(target, &hit_wp_type, &hit_wp_address) == ERROR_OK) {
 
                                switch (hit_wp_type) {
                                        case WPT_WRITE:
                                                snprintf(stop_reason, sizeof(stop_reason),

-                                                               "watch:%08" PRIx32 ";", hit_wp_address);
+                                                               "watch:%08" TARGET_PRIxADDR ";", hit_wp_address);

                                                break;
                                        case WPT_READ:
                                                snprintf(stop_reason, sizeof(stop_reason),
                                                break;
                                        case WPT_READ:
                                                snprintf(stop_reason, sizeof(stop_reason),

-                                                               "rwatch:%08" PRIx32 ";", hit_wp_address);
+                                                               "rwatch:%08" TARGET_PRIxADDR ";", hit_wp_address);

                                                break;
                                        case WPT_ACCESS:
                                                snprintf(stop_reason, sizeof(stop_reason),
                                                break;
                                        case WPT_ACCESS:
                                                snprintf(stop_reason, sizeof(stop_reason),

-                                                               "awatch:%08" PRIx32 ";", hit_wp_address);
+                                                               "awatch:%08" TARGET_PRIxADDR ";", hit_wp_address);

                                                break;
                                        default:
                                                break;
                                                break;
                                        default:
                                                break;

diff --git a/src/target/algorithm.h b/src/target/algorithm.h
index d216a82440950e305f824f1a7b47a85b670d2fd4..8894241c04f207f7543601e6ed4155fdf97f15bc 100644 (file)
--- a/src/target/algorithm.h
+++ b/src/target/algorithm.h
@@ -26,7 +26,7 @@ enum param_direction {
 };
 
 struct mem_param {
 };
 
 struct mem_param {

-       uint32_t address;
+       target_addr_t address;

        uint32_t size;
        uint8_t *value;
        enum param_direction direction;
        uint32_t size;
        uint8_t *value;
        enum param_direction direction;

diff --git a/src/target/arm.h b/src/target/arm.h
index 226dd65689a15add147d39c3ac652b885e6edd09..77a2f7b01b6c9841f418414e96280716e1c7572d 100644 (file)
--- a/src/target/arm.h
+++ b/src/target/arm.h
@@ -231,7 +231,7 @@ int arm_init_arch_info(struct target *target, struct arm *arm);
 int armv4_5_run_algorithm(struct target *target,
                int num_mem_params, struct mem_param *mem_params,
                int num_reg_params, struct reg_param *reg_params,
 int armv4_5_run_algorithm(struct target *target,
                int num_mem_params, struct mem_param *mem_params,
                int num_reg_params, struct reg_param *reg_params,

-               uint32_t entry_point, uint32_t exit_point,
+               target_addr_t entry_point, target_addr_t exit_point,

                int timeout_ms, void *arch_info);
 int armv4_5_run_algorithm_inner(struct target *target,
                int num_mem_params, struct mem_param *mem_params,
                int timeout_ms, void *arch_info);
 int armv4_5_run_algorithm_inner(struct target *target,
                int num_mem_params, struct mem_param *mem_params,


@@ -242,9 +242,9 @@ int armv4_5_run_algorithm_inner(struct target *target,
                                int timeout_ms, void *arch_info));
 
 int arm_checksum_memory(struct target *target,
                                int timeout_ms, void *arch_info));
 
 int arm_checksum_memory(struct target *target,

-               uint32_t address, uint32_t count, uint32_t *checksum);
+               target_addr_t address, uint32_t count, uint32_t *checksum);

 int arm_blank_check_memory(struct target *target,
 int arm_blank_check_memory(struct target *target,

-               uint32_t address, uint32_t count, uint32_t *blank, uint8_t erased_value);
+               target_addr_t address, uint32_t count, uint32_t *blank, uint8_t erased_value);

 
 void arm_set_cpsr(struct arm *arm, uint32_t cpsr);
 struct reg *arm_reg_current(struct arm *arm, unsigned regnum);
 
 void arm_set_cpsr(struct arm *arm, uint32_t cpsr);
 struct reg *arm_reg_current(struct arm *arm, unsigned regnum);

diff --git a/src/target/arm11.c b/src/target/arm11.c
index cbe4d4503f8473e1b00766897fb03486bf7cf407..13fbd207a2f91d7ee54f5ce9ec49b8c3b6f5ba75 100644 (file)
--- a/src/target/arm11.c
+++ b/src/target/arm11.c
@@ -42,7 +42,7 @@
 
 
 static int arm11_step(struct target *target, int current,
 
 
 static int arm11_step(struct target *target, int current,

-               uint32_t address, int handle_breakpoints);
+               target_addr_t address, int handle_breakpoints);

 
 
 /** Check and if necessary take control of the system
 
 
 /** Check and if necessary take control of the system


@@ -449,7 +449,7 @@ static uint32_t arm11_nextpc(struct arm11_common *arm11, int current, uint32_t a
 }
 
 static int arm11_resume(struct target *target, int current,
 }
 
 static int arm11_resume(struct target *target, int current,

-       uint32_t address, int handle_breakpoints, int debug_execution)
+       target_addr_t address, int handle_breakpoints, int debug_execution)

 {
        /*        LOG_DEBUG("current %d  address %08x  handle_breakpoints %d  debug_execution %d", */
        /*      current, address, handle_breakpoints, debug_execution); */
 {
        /*        LOG_DEBUG("current %d  address %08x  handle_breakpoints %d  debug_execution %d", */
        /*      current, address, handle_breakpoints, debug_execution); */


@@ -467,7 +467,7 @@ static int arm11_resume(struct target *target, int current,
 
        address = arm11_nextpc(arm11, current, address);
 
 
        address = arm11_nextpc(arm11, current, address);
 

-       LOG_DEBUG("RESUME PC %08" PRIx32 "%s", address, !current ? "!" : "");
+       LOG_DEBUG("RESUME PC %08" TARGET_PRIxADDR "%s", address, !current ? "!" : "");

 
        /* clear breakpoints/watchpoints and VCR*/
        CHECK_RETVAL(arm11_sc7_clear_vbw(arm11));
 
        /* clear breakpoints/watchpoints and VCR*/
        CHECK_RETVAL(arm11_sc7_clear_vbw(arm11));


@@ -481,7 +481,7 @@ static int arm11_resume(struct target *target, int current,
 
                for (bp = target->breakpoints; bp; bp = bp->next) {
                        if (bp->address == address) {
 
                for (bp = target->breakpoints; bp; bp = bp->next) {
                        if (bp->address == address) {

-                               LOG_DEBUG("must step over %08" PRIx32 "", bp->address);
+                               LOG_DEBUG("must step over %08" TARGET_PRIxADDR "", bp->address);

                                arm11_step(target, 1, 0, 0);
                                break;
                        }
                                arm11_step(target, 1, 0, 0);
                                break;
                        }


@@ -507,7 +507,7 @@ static int arm11_resume(struct target *target, int current,
 
                        CHECK_RETVAL(arm11_sc7_run(arm11, brp, ARRAY_SIZE(brp)));
 
 
                        CHECK_RETVAL(arm11_sc7_run(arm11, brp, ARRAY_SIZE(brp)));
 

-                       LOG_DEBUG("Add BP %d at %08" PRIx32, brp_num,
+                       LOG_DEBUG("Add BP %d at %08" TARGET_PRIxADDR, brp_num,

                                bp->address);
 
                        brp_num++;
                                bp->address);
 
                        brp_num++;


@@ -557,7 +557,7 @@ static int arm11_resume(struct target *target, int current,
 }
 
 static int arm11_step(struct target *target, int current,
 }
 
 static int arm11_step(struct target *target, int current,

-       uint32_t address, int handle_breakpoints)
+       target_addr_t address, int handle_breakpoints)

 {
        LOG_DEBUG("target->state: %s",
                target_state_name(target));
 {
        LOG_DEBUG("target->state: %s",
                target_state_name(target));


@@ -571,7 +571,7 @@ static int arm11_step(struct target *target, int current,
 
        address = arm11_nextpc(arm11, current, address);
 
 
        address = arm11_nextpc(arm11, current, address);
 

-       LOG_DEBUG("STEP PC %08" PRIx32 "%s", address, !current ? "!" : "");
+       LOG_DEBUG("STEP PC %08" TARGET_PRIxADDR "%s", address, !current ? "!" : "");

 
 
        /** \todo TODO: Thumb not supported here */
 
 
        /** \todo TODO: Thumb not supported here */


@@ -583,13 +583,13 @@ static int arm11_step(struct target *target, int current,
        /* skip over BKPT */
        if ((next_instruction & 0xFFF00070) == 0xe1200070) {
                address = arm11_nextpc(arm11, 0, address + 4);
        /* skip over BKPT */
        if ((next_instruction & 0xFFF00070) == 0xe1200070) {
                address = arm11_nextpc(arm11, 0, address + 4);

-               LOG_DEBUG("Skipping BKPT %08" PRIx32, address);
+               LOG_DEBUG("Skipping BKPT %08" TARGET_PRIxADDR, address);

        }
        /* skip over Wait for interrupt / Standby
         * mcr  15, 0, r?, cr7, cr0, {4} */
        else if ((next_instruction & 0xFFFF0FFF) == 0xee070f90) {
                address = arm11_nextpc(arm11, 0, address + 4);
        }
        /* skip over Wait for interrupt / Standby
         * mcr  15, 0, r?, cr7, cr0, {4} */
        else if ((next_instruction & 0xFFFF0FFF) == 0xee070f90) {
                address = arm11_nextpc(arm11, 0, address + 4);

-               LOG_DEBUG("Skipping WFI %08" PRIx32, address);
+               LOG_DEBUG("Skipping WFI %08" TARGET_PRIxADDR, address);

        }
        /* ignore B to self */
        else if ((next_instruction & 0xFEFFFFFF) == 0xeafffffe)
        }
        /* ignore B to self */
        else if ((next_instruction & 0xFEFFFFFF) == 0xeafffffe)


@@ -887,7 +887,7 @@ static int arm11_read_memory_inner(struct target *target,
 }
 
 static int arm11_read_memory(struct target *target,
 }
 
 static int arm11_read_memory(struct target *target,

-       uint32_t address,
+       target_addr_t address,

        uint32_t size,
        uint32_t count,
        uint8_t *buffer)
        uint32_t size,
        uint32_t count,
        uint8_t *buffer)


@@ -1043,7 +1043,7 @@ static int arm11_write_memory_inner(struct target *target,
 }
 
 static int arm11_write_memory(struct target *target,
 }
 
 static int arm11_write_memory(struct target *target,

-       uint32_t address, uint32_t size,
+       target_addr_t address, uint32_t size,

        uint32_t count, const uint8_t *buffer)
 {
        /* pointer increment matters only for multi-unit writes ...
        uint32_t count, const uint8_t *buffer)
 {
        /* pointer increment matters only for multi-unit writes ...

diff --git a/src/target/arm720t.c b/src/target/arm720t.c
index 3991e19f86660dd26bf9168865b1edc19b644841..bcbfa9dff035934a356792abce4e0205ae04daef 100644 (file)
--- a/src/target/arm720t.c
+++ b/src/target/arm720t.c
@@ -271,7 +271,7 @@ static int arm720_mmu(struct target *target, int *enabled)
 }
 
 static int arm720_virt2phys(struct target *target,
 }
 
 static int arm720_virt2phys(struct target *target,

-               uint32_t virtual, uint32_t *physical)
+               target_addr_t virtual, target_addr_t *physical)

 {
        uint32_t cb;
        struct arm720t_common *arm720t = target_to_arm720(target);
 {
        uint32_t cb;
        struct arm720t_common *arm720t = target_to_arm720(target);


@@ -286,7 +286,7 @@ static int arm720_virt2phys(struct target *target,
 }
 
 static int arm720t_read_memory(struct target *target,
 }
 
 static int arm720t_read_memory(struct target *target,

-               uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+               target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)

 {
        int retval;
        struct arm720t_common *arm720t = target_to_arm720(target);
 {
        int retval;
        struct arm720t_common *arm720t = target_to_arm720(target);


@@ -309,7 +309,7 @@ static int arm720t_read_memory(struct target *target,
 }
 
 static int arm720t_read_phys_memory(struct target *target,
 }
 
 static int arm720t_read_phys_memory(struct target *target,

-               uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+               target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)

 {
        struct arm720t_common *arm720t = target_to_arm720(target);
 
 {
        struct arm720t_common *arm720t = target_to_arm720(target);
 


@@ -317,7 +317,7 @@ static int arm720t_read_phys_memory(struct target *target,
 }
 
 static int arm720t_write_phys_memory(struct target *target,
 }
 
 static int arm720t_write_phys_memory(struct target *target,

-               uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
+               target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)

 {
        struct arm720t_common *arm720t = target_to_arm720(target);
 
 {
        struct arm720t_common *arm720t = target_to_arm720(target);
 

diff --git a/src/target/arm7_9_common.c b/src/target/arm7_9_common.c
index c1d5c79445c8b14aa8ad14f7c57df42dd9c68032..7fd1ed9f8cdb7a720bf9dec29a2bcd5c82879848 100644 (file)
--- a/src/target/arm7_9_common.c
+++ b/src/target/arm7_9_common.c
@@ -101,7 +101,8 @@ static void arm7_9_assign_wp(struct arm7_9_common *arm7_9, struct breakpoint *br
                arm7_9->wp_available--;
        } else
                LOG_ERROR("BUG: no hardware comparator available");
                arm7_9->wp_available--;
        } else
                LOG_ERROR("BUG: no hardware comparator available");

-       LOG_DEBUG("BPID: %" PRId32 " (0x%08" PRIx32 ") using hw wp: %d",
+
+       LOG_DEBUG("BPID: %" PRId32 " (0x%08" TARGET_PRIxADDR ") using hw wp: %d",

                        breakpoint->unique_id,
                        breakpoint->address,
                        breakpoint->set);
                        breakpoint->unique_id,
                        breakpoint->address,
                        breakpoint->set);


@@ -187,7 +188,7 @@ static int arm7_9_set_breakpoint(struct target *target, struct breakpoint *break
        struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
        int retval = ERROR_OK;
 
        struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
        int retval = ERROR_OK;
 

-       LOG_DEBUG("BPID: %" PRId32 ", Address: 0x%08" PRIx32 ", Type: %d",
+       LOG_DEBUG("BPID: %" PRId32 ", Address: 0x%08" TARGET_PRIxADDR ", Type: %d",

                breakpoint->unique_id,
                breakpoint->address,
                breakpoint->type);
                breakpoint->unique_id,
                breakpoint->address,
                breakpoint->type);


@@ -244,7 +245,7 @@ static int arm7_9_set_breakpoint(struct target *target, struct breakpoint *break
                        if (retval != ERROR_OK)
                                return retval;
                        if (verify != arm7_9->arm_bkpt) {
                        if (retval != ERROR_OK)
                                return retval;
                        if (verify != arm7_9->arm_bkpt) {

-                               LOG_ERROR("Unable to set 32 bit software breakpoint at address %08" PRIx32
+                               LOG_ERROR("Unable to set 32 bit software breakpoint at address %08" TARGET_PRIxADDR

                                                " - check that memory is read/writable", breakpoint->address);
                                return ERROR_OK;
                        }
                                                " - check that memory is read/writable", breakpoint->address);
                                return ERROR_OK;
                        }


@@ -264,7 +265,7 @@ static int arm7_9_set_breakpoint(struct target *target, struct breakpoint *break
                        if (retval != ERROR_OK)
                                return retval;
                        if (verify != arm7_9->thumb_bkpt) {
                        if (retval != ERROR_OK)
                                return retval;
                        if (verify != arm7_9->thumb_bkpt) {

-                               LOG_ERROR("Unable to set thumb software breakpoint at address %08" PRIx32
+                               LOG_ERROR("Unable to set thumb software breakpoint at address %08" TARGET_PRIxADDR

                                                " - check that memory is read/writable", breakpoint->address);
                                return ERROR_OK;
                        }
                                                " - check that memory is read/writable", breakpoint->address);
                                return ERROR_OK;
                        }


@@ -299,7 +300,7 @@ static int arm7_9_unset_breakpoint(struct target *target, struct breakpoint *bre
        int retval = ERROR_OK;
        struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
 
        int retval = ERROR_OK;
        struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
 

-       LOG_DEBUG("BPID: %" PRId32 ", Address: 0x%08" PRIx32,
+       LOG_DEBUG("BPID: %" PRId32 ", Address: 0x%08" TARGET_PRIxADDR,

                breakpoint->unique_id,
                breakpoint->address);
 
                breakpoint->unique_id,
                breakpoint->address);
 


@@ -1692,7 +1693,7 @@ static void arm7_9_enable_breakpoints(struct target *target)
 
 int arm7_9_resume(struct target *target,
        int current,
 
 int arm7_9_resume(struct target *target,
        int current,

-       uint32_t address,
+       target_addr_t address,

        int handle_breakpoints,
        int debug_execution)
 {
        int handle_breakpoints,
        int debug_execution)
 {


@@ -1724,7 +1725,7 @@ int arm7_9_resume(struct target *target,
                breakpoint = breakpoint_find(target,
                                buf_get_u32(arm->pc->value, 0, 32));
                if (breakpoint != NULL) {
                breakpoint = breakpoint_find(target,
                                buf_get_u32(arm->pc->value, 0, 32));
                if (breakpoint != NULL) {

-                       LOG_DEBUG("unset breakpoint at 0x%8.8" PRIx32 " (id: %" PRId32,
+                       LOG_DEBUG("unset breakpoint at 0x%8.8" TARGET_PRIxADDR " (id: %" PRId32,

                                breakpoint->address,
                                breakpoint->unique_id);
                        retval = arm7_9_unset_breakpoint(target, breakpoint);
                                breakpoint->address,
                                breakpoint->unique_id);
                        retval = arm7_9_unset_breakpoint(target, breakpoint);


@@ -1783,7 +1784,7 @@ int arm7_9_resume(struct target *target,
                        LOG_DEBUG("new PC after step: 0x%8.8" PRIx32,
                                buf_get_u32(arm->pc->value, 0, 32));
 
                        LOG_DEBUG("new PC after step: 0x%8.8" PRIx32,
                                buf_get_u32(arm->pc->value, 0, 32));
 

-                       LOG_DEBUG("set breakpoint at 0x%8.8" PRIx32 "", breakpoint->address);
+                       LOG_DEBUG("set breakpoint at 0x%8.8" TARGET_PRIxADDR "", breakpoint->address);

                        retval = arm7_9_set_breakpoint(target, breakpoint);
                        if (retval != ERROR_OK)
                                return retval;
                        retval = arm7_9_set_breakpoint(target, breakpoint);
                        if (retval != ERROR_OK)
                                return retval;


@@ -1894,7 +1895,7 @@ void arm7_9_disable_eice_step(struct target *target)
        embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE]);
 }
 
        embeddedice_store_reg(&arm7_9->eice_cache->reg_list[EICE_W1_CONTROL_VALUE]);
 }
 

-int arm7_9_step(struct target *target, int current, uint32_t address, int handle_breakpoints)
+int arm7_9_step(struct target *target, int current, target_addr_t address, int handle_breakpoints)

 {
        struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
        struct arm *arm = &arm7_9->arm;
 {
        struct arm7_9_common *arm7_9 = target_to_arm7_9(target);
        struct arm *arm = &arm7_9->arm;


@@ -2094,7 +2095,7 @@ static int arm7_9_write_core_reg(struct target *target, struct reg *r,
 }
 
 int arm7_9_read_memory(struct target *target,
 }
 
 int arm7_9_read_memory(struct target *target,

-       uint32_t address,
+       target_addr_t address,

        uint32_t size,
        uint32_t count,
        uint8_t *buffer)
        uint32_t size,
        uint32_t count,
        uint8_t *buffer)


@@ -2109,7 +2110,7 @@ int arm7_9_read_memory(struct target *target,
        int retval;
        int last_reg = 0;
 
        int retval;
        int last_reg = 0;
 

-       LOG_DEBUG("address: 0x%8.8" PRIx32 ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32 "",
+       LOG_DEBUG("address: 0x%8.8" TARGET_PRIxADDR ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32 "",

                address, size, count);
 
        if (target->state != TARGET_HALTED) {
                address, size, count);
 
        if (target->state != TARGET_HALTED) {


@@ -2247,7 +2248,8 @@ int arm7_9_read_memory(struct target *target,
 
        if (((cpsr & 0x1f) == ARM_MODE_ABT) && (arm->core_mode != ARM_MODE_ABT)) {
                LOG_WARNING(
 
        if (((cpsr & 0x1f) == ARM_MODE_ABT) && (arm->core_mode != ARM_MODE_ABT)) {
                LOG_WARNING(

-                       "memory read caused data abort (address: 0x%8.8" PRIx32 ", size: 0x%" PRIx32 ", count: 0x%" PRIx32 ")",
+                       "memory read caused data abort "
+                       "(address: 0x%8.8" TARGET_PRIxADDR ", size: 0x%" PRIx32 ", count: 0x%" PRIx32 ")",

                        address,
                        size,
                        count);
                        address,
                        size,
                        count);


@@ -2263,7 +2265,7 @@ int arm7_9_read_memory(struct target *target,
 }
 
 int arm7_9_write_memory(struct target *target,
 }
 
 int arm7_9_write_memory(struct target *target,

-       uint32_t address,
+       target_addr_t address,

        uint32_t size,
        uint32_t count,
        const uint8_t *buffer)
        uint32_t size,
        uint32_t count,
        const uint8_t *buffer)


@@ -2460,7 +2462,8 @@ int arm7_9_write_memory(struct target *target,
 
        if (((cpsr & 0x1f) == ARM_MODE_ABT) && (arm->core_mode != ARM_MODE_ABT)) {
                LOG_WARNING(
 
        if (((cpsr & 0x1f) == ARM_MODE_ABT) && (arm->core_mode != ARM_MODE_ABT)) {
                LOG_WARNING(

-                       "memory write caused data abort (address: 0x%8.8" PRIx32 ", size: 0x%" PRIx32 ", count: 0x%" PRIx32 ")",
+                       "memory write caused data abort "
+                       "(address: 0x%8.8" TARGET_PRIxADDR ", size: 0x%" PRIx32 ", count: 0x%" PRIx32 ")",

                        address,
                        size,
                        count);
                        address,
                        size,
                        count);


@@ -2476,7 +2479,7 @@ int arm7_9_write_memory(struct target *target,
 }
 
 int arm7_9_write_memory_opt(struct target *target,
 }
 
 int arm7_9_write_memory_opt(struct target *target,

-       uint32_t address,
+       target_addr_t address,

        uint32_t size,
        uint32_t count,
        const uint8_t *buffer)
        uint32_t size,
        uint32_t count,
        const uint8_t *buffer)


@@ -2576,7 +2579,7 @@ static const uint32_t dcc_code[] = {
 };
 
 int arm7_9_bulk_write_memory(struct target *target,
 };
 
 int arm7_9_bulk_write_memory(struct target *target,

-       uint32_t address,
+       target_addr_t address,

        uint32_t count,
        const uint8_t *buffer)
 {
        uint32_t count,
        const uint8_t *buffer)
 {


@@ -2632,7 +2635,7 @@ int arm7_9_bulk_write_memory(struct target *target,
                uint32_t endaddress = buf_get_u32(reg_params[0].value, 0, 32);
                if (endaddress != (address + count*4)) {
                        LOG_ERROR(
                uint32_t endaddress = buf_get_u32(reg_params[0].value, 0, 32);
                if (endaddress != (address + count*4)) {
                        LOG_ERROR(

-                               "DCC write failed, expected end address 0x%08" PRIx32 " got 0x%0" PRIx32 "",
+                               "DCC write failed, expected end address 0x%08" TARGET_PRIxADDR " got 0x%0" PRIx32 "",

                                (address + count*4),
                                endaddress);
                        retval = ERROR_FAIL;
                                (address + count*4),
                                endaddress);
                        retval = ERROR_FAIL;

diff --git a/src/target/arm7_9_common.h b/src/target/arm7_9_common.h
index 044384b20fd723cb676a3fffbc9abe3ebb21c72f..811f9c593e959c1e135b0c91afc72029dad4c147 100644 (file)
--- a/src/target/arm7_9_common.h
+++ b/src/target/arm7_9_common.h
@@ -122,13 +122,13 @@ struct arm7_9_common {
         * Used as a fallback when bulk writes are unavailable, or for writing data needed to
         * do the bulk writes.
         */
         * Used as a fallback when bulk writes are unavailable, or for writing data needed to
         * do the bulk writes.
         */

-       int (*write_memory)(struct target *target, uint32_t address,
+       int (*write_memory)(struct target *target, target_addr_t address,

                        uint32_t size, uint32_t count, const uint8_t *buffer);
        /**
         * Write target memory in multiples of 4 bytes, optimized for
         * writing large quantities of data.
         */
                        uint32_t size, uint32_t count, const uint8_t *buffer);
        /**
         * Write target memory in multiples of 4 bytes, optimized for
         * writing large quantities of data.
         */

-       int (*bulk_write_memory)(struct target *target, uint32_t address,
+       int (*bulk_write_memory)(struct target *target, target_addr_t address,

                        uint32_t count, const uint8_t *buffer);
 };
 
                        uint32_t count, const uint8_t *buffer);
 };
 


@@ -155,19 +155,19 @@ int arm7_9_early_halt(struct target *target);
 int arm7_9_soft_reset_halt(struct target *target);
 
 int arm7_9_halt(struct target *target);
 int arm7_9_soft_reset_halt(struct target *target);
 
 int arm7_9_halt(struct target *target);

-int arm7_9_resume(struct target *target, int current, uint32_t address,
+int arm7_9_resume(struct target *target, int current, target_addr_t address,

                int handle_breakpoints, int debug_execution);
                int handle_breakpoints, int debug_execution);

-int arm7_9_step(struct target *target, int current, uint32_t address,
+int arm7_9_step(struct target *target, int current, target_addr_t address,

                int handle_breakpoints);
                int handle_breakpoints);

-int arm7_9_read_memory(struct target *target, uint32_t address,
+int arm7_9_read_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, uint8_t *buffer);
                uint32_t size, uint32_t count, uint8_t *buffer);

-int arm7_9_write_memory(struct target *target, uint32_t address,
+int arm7_9_write_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, const uint8_t *buffer);
                uint32_t size, uint32_t count, const uint8_t *buffer);

-int arm7_9_write_memory_opt(struct target *target, uint32_t address,
+int arm7_9_write_memory_opt(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, const uint8_t *buffer);
 int arm7_9_write_memory_no_opt(struct target *target, uint32_t address,
                uint32_t size, uint32_t count, const uint8_t *buffer);
                uint32_t size, uint32_t count, const uint8_t *buffer);
 int arm7_9_write_memory_no_opt(struct target *target, uint32_t address,
                uint32_t size, uint32_t count, const uint8_t *buffer);

-int arm7_9_bulk_write_memory(struct target *target, uint32_t address,
+int arm7_9_bulk_write_memory(struct target *target, target_addr_t address,

                uint32_t count, const uint8_t *buffer);
 
 int arm7_9_run_algorithm(struct target *target, int num_mem_params,
                uint32_t count, const uint8_t *buffer);
 
 int arm7_9_run_algorithm(struct target *target, int num_mem_params,

diff --git a/src/target/arm920t.c b/src/target/arm920t.c
index 2c96d19353ac07d0bfab31a5ca0fd4ac8810ff06..7927a2beade9a75ca93a6e24117830f422b4ddae 100644 (file)
--- a/src/target/arm920t.c
+++ b/src/target/arm920t.c
@@ -553,7 +553,7 @@ static int arm920_mmu(struct target *target, int *enabled)
 }
 
 static int arm920_virt2phys(struct target *target,
 }
 
 static int arm920_virt2phys(struct target *target,

-       uint32_t virt, uint32_t *phys)
+       target_addr_t virt, target_addr_t *phys)

 {
        uint32_t cb;
        struct arm920t_common *arm920t = target_to_arm920(target);
 {
        uint32_t cb;
        struct arm920t_common *arm920t = target_to_arm920(target);


@@ -568,7 +568,7 @@ static int arm920_virt2phys(struct target *target,
 }
 
 /** Reads a buffer, in the specified word size, with current MMU settings. */
 }
 
 /** Reads a buffer, in the specified word size, with current MMU settings. */

-int arm920t_read_memory(struct target *target, uint32_t address,
+int arm920t_read_memory(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        int retval;
        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        int retval;


@@ -580,7 +580,7 @@ int arm920t_read_memory(struct target *target, uint32_t address,
 
 
 static int arm920t_read_phys_memory(struct target *target,
 
 
 static int arm920t_read_phys_memory(struct target *target,

-       uint32_t address, uint32_t size,
+       target_addr_t address, uint32_t size,

        uint32_t count, uint8_t *buffer)
 {
        struct arm920t_common *arm920t = target_to_arm920(target);
        uint32_t count, uint8_t *buffer)
 {
        struct arm920t_common *arm920t = target_to_arm920(target);


@@ -590,7 +590,7 @@ static int arm920t_read_phys_memory(struct target *target,
 }
 
 static int arm920t_write_phys_memory(struct target *target,
 }
 
 static int arm920t_write_phys_memory(struct target *target,

-       uint32_t address, uint32_t size,
+       target_addr_t address, uint32_t size,

        uint32_t count, const uint8_t *buffer)
 {
        struct arm920t_common *arm920t = target_to_arm920(target);
        uint32_t count, const uint8_t *buffer)
 {
        struct arm920t_common *arm920t = target_to_arm920(target);


@@ -600,7 +600,7 @@ static int arm920t_write_phys_memory(struct target *target,
 }
 
 /** Writes a buffer, in the specified word size, with current MMU settings. */
 }
 
 /** Writes a buffer, in the specified word size, with current MMU settings. */

-int arm920t_write_memory(struct target *target, uint32_t address,
+int arm920t_write_memory(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        int retval;
        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        int retval;

diff --git a/src/target/arm920t.h b/src/target/arm920t.h
index 3401b0945c3fdd0c26a90cd8bd3435df436d68e4..2e3b08ca3a31940690e94f92437ec1dbd7c146df 100644 (file)
--- a/src/target/arm920t.h
+++ b/src/target/arm920t.h
@@ -55,9 +55,9 @@ struct arm920t_tlb_entry {
 int arm920t_arch_state(struct target *target);
 int arm920t_soft_reset_halt(struct target *target);
 int arm920t_read_memory(struct target *target,
 int arm920t_arch_state(struct target *target);
 int arm920t_soft_reset_halt(struct target *target);
 int arm920t_read_memory(struct target *target,

-       uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
+       target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer);

 int arm920t_write_memory(struct target *target,
 int arm920t_write_memory(struct target *target,

-       uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
+       target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer);

 int arm920t_post_debug_entry(struct target *target);
 void arm920t_pre_restore_context(struct target *target);
 int arm920t_get_ttb(struct target *target, uint32_t *result);
 int arm920t_post_debug_entry(struct target *target);
 void arm920t_pre_restore_context(struct target *target);
 int arm920t_get_ttb(struct target *target, uint32_t *result);

diff --git a/src/target/arm926ejs.c b/src/target/arm926ejs.c
index d7c043e801bde21820fd9143a5b5c7a675ff929b..58de778500f30caba4610200930713dfd457543b 100644 (file)
--- a/src/target/arm926ejs.c
+++ b/src/target/arm926ejs.c
@@ -594,7 +594,7 @@ int arm926ejs_soft_reset_halt(struct target *target)
 }
 
 /** Writes a buffer, in the specified word size, with current MMU settings. */
 }
 
 /** Writes a buffer, in the specified word size, with current MMU settings. */

-int arm926ejs_write_memory(struct target *target, uint32_t address,
+int arm926ejs_write_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        int retval;
                uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        int retval;


@@ -623,7 +623,7 @@ int arm926ejs_write_memory(struct target *target, uint32_t address,
                                return retval;
                }
 
                                return retval;
                }
 

-               uint32_t pa;
+               target_addr_t pa;

                retval = target->type->virt2phys(target, address, &pa);
                if (retval != ERROR_OK)
                        return retval;
                retval = target->type->virt2phys(target, address, &pa);
                if (retval != ERROR_OK)
                        return retval;


@@ -655,7 +655,7 @@ int arm926ejs_write_memory(struct target *target, uint32_t address,
 }
 
 static int arm926ejs_write_phys_memory(struct target *target,
 }
 
 static int arm926ejs_write_phys_memory(struct target *target,

-               uint32_t address, uint32_t size,
+               target_addr_t address, uint32_t size,

                uint32_t count, const uint8_t *buffer)
 {
        struct arm926ejs_common *arm926ejs = target_to_arm926(target);
                uint32_t count, const uint8_t *buffer)
 {
        struct arm926ejs_common *arm926ejs = target_to_arm926(target);


@@ -665,7 +665,7 @@ static int arm926ejs_write_phys_memory(struct target *target,
 }
 
 static int arm926ejs_read_phys_memory(struct target *target,
 }
 
 static int arm926ejs_read_phys_memory(struct target *target,

-               uint32_t address, uint32_t size,
+               target_addr_t address, uint32_t size,

                uint32_t count, uint8_t *buffer)
 {
        struct arm926ejs_common *arm926ejs = target_to_arm926(target);
                uint32_t count, uint8_t *buffer)
 {
        struct arm926ejs_common *arm926ejs = target_to_arm926(target);


@@ -736,7 +736,7 @@ COMMAND_HANDLER(arm926ejs_handle_cache_info_command)
        return armv4_5_handle_cache_info_command(CMD_CTX, &arm926ejs->armv4_5_mmu.armv4_5_cache);
 }
 
        return armv4_5_handle_cache_info_command(CMD_CTX, &arm926ejs->armv4_5_mmu.armv4_5_cache);
 }
 

-static int arm926ejs_virt2phys(struct target *target, uint32_t virtual, uint32_t *physical)
+static int arm926ejs_virt2phys(struct target *target, target_addr_t virtual, target_addr_t *physical)

 {
        uint32_t cb;
        struct arm926ejs_common *arm926ejs = target_to_arm926(target);
 {
        uint32_t cb;
        struct arm926ejs_common *arm926ejs = target_to_arm926(target);

diff --git a/src/target/arm926ejs.h b/src/target/arm926ejs.h
index 02b4ef849daa5ed27286439624012f66fb216a8e..d4fd0cb6ebf9227c196d3ac8ddd0e02286a9cc56 100644 (file)
--- a/src/target/arm926ejs.h
+++ b/src/target/arm926ejs.h
@@ -47,7 +47,7 @@ int arm926ejs_init_arch_info(struct target *target,
                struct arm926ejs_common *arm926ejs, struct jtag_tap *tap);
 int arm926ejs_arch_state(struct target *target);
 int arm926ejs_write_memory(struct target *target,
                struct arm926ejs_common *arm926ejs, struct jtag_tap *tap);
 int arm926ejs_arch_state(struct target *target);
 int arm926ejs_write_memory(struct target *target,

-               uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
+               target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer);

 int arm926ejs_soft_reset_halt(struct target *target);
 
 extern const struct command_registration arm926ejs_command_handlers[];
 int arm926ejs_soft_reset_halt(struct target *target);
 
 extern const struct command_registration arm926ejs_command_handlers[];

diff --git a/src/target/arm946e.c b/src/target/arm946e.c
index 5ee31cc2f6520f31309856713e53d37089bc63a7..06c9fc30dc41463e31c6453e5c9618fc44c4f6bc 100644 (file)
--- a/src/target/arm946e.c
+++ b/src/target/arm946e.c
@@ -487,7 +487,7 @@ uint32_t arm946e_invalidate_icache(struct target *target, uint32_t address,
 }
 
 /** Writes a buffer, in the specified word size, with current MMU settings. */
 }
 
 /** Writes a buffer, in the specified word size, with current MMU settings. */

-int arm946e_write_memory(struct target *target, uint32_t address,
+int arm946e_write_memory(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        int retval;
        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        int retval;


@@ -535,7 +535,7 @@ int arm946e_write_memory(struct target *target, uint32_t address,
 
 }
 
 
 }
 

-int arm946e_read_memory(struct target *target, uint32_t address,
+int arm946e_read_memory(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        int retval;
        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        int retval;

diff --git a/src/target/armv4_5.c b/src/target/armv4_5.c
index 624a2543db49909dfcc096e91f539d2d00c19fb9..2029ca92a35dbf23ae62dd64286cf75e0190c34c 100644 (file)
--- a/src/target/armv4_5.c
+++ b/src/target/armv4_5.c
@@ -816,7 +816,7 @@ COMMAND_HANDLER(handle_arm_disassemble_command)
        }
 
        struct arm *arm = target_to_arm(target);
        }
 
        struct arm *arm = target_to_arm(target);

-       uint32_t address;
+       target_addr_t address;

        int count = 1;
        int thumb = 0;
 
        int count = 1;
        int thumb = 0;
 


@@ -840,7 +840,7 @@ COMMAND_HANDLER(handle_arm_disassemble_command)
                        COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], count);
                /* FALL THROUGH */
                case 1:
                        COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], count);
                /* FALL THROUGH */
                case 1:

-                       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
+                       COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address);

                        if (address & 0x01) {
                                if (!thumb) {
                                        command_print(CMD_CTX, "Disassemble as Thumb");
                        if (address & 0x01) {
                                if (!thumb) {
                                        command_print(CMD_CTX, "Disassemble as Thumb");


@@ -1434,8 +1434,8 @@ int armv4_5_run_algorithm(struct target *target,
        struct mem_param *mem_params,
        int num_reg_params,
        struct reg_param *reg_params,
        struct mem_param *mem_params,
        int num_reg_params,
        struct reg_param *reg_params,

-       uint32_t entry_point,
-       uint32_t exit_point,
+       target_addr_t entry_point,
+       target_addr_t exit_point,

        int timeout_ms,
        void *arch_info)
 {
        int timeout_ms,
        void *arch_info)
 {


@@ -1444,8 +1444,8 @@ int armv4_5_run_algorithm(struct target *target,
                        mem_params,
                        num_reg_params,
                        reg_params,
                        mem_params,
                        num_reg_params,
                        reg_params,

-                       entry_point,
-                       exit_point,
+                       (uint32_t)entry_point,
+                       (uint32_t)exit_point,

                        timeout_ms,
                        arch_info,
                        armv4_5_run_algorithm_completion);
                        timeout_ms,
                        arch_info,
                        armv4_5_run_algorithm_completion);


@@ -1456,7 +1456,7 @@ int armv4_5_run_algorithm(struct target *target,
  *
  */
 int arm_checksum_memory(struct target *target,
  *
  */
 int arm_checksum_memory(struct target *target,

-       uint32_t address, uint32_t count, uint32_t *checksum)
+       target_addr_t address, uint32_t count, uint32_t *checksum)

 {
        struct working_area *crc_algorithm;
        struct arm_algorithm arm_algo;
 {
        struct working_area *crc_algorithm;
        struct arm_algorithm arm_algo;


@@ -1529,7 +1529,7 @@ cleanup:
  *
  */
 int arm_blank_check_memory(struct target *target,
  *
  */
 int arm_blank_check_memory(struct target *target,

-       uint32_t address, uint32_t count, uint32_t *blank, uint8_t erased_value)
+       target_addr_t address, uint32_t count, uint32_t *blank, uint8_t erased_value)

 {
        struct working_area *check_algorithm;
        struct reg_param reg_params[3];
 {
        struct working_area *check_algorithm;
        struct reg_param reg_params[3];

diff --git a/src/target/armv4_5_mmu.h b/src/target/armv4_5_mmu.h
index 0f521214293f3d3e297e11e1f591c7ab06e82a24..7beaf4ee96323669e12abddaa53a7183d62d4af0 100644 (file)
--- a/src/target/armv4_5_mmu.h
+++ b/src/target/armv4_5_mmu.h
@@ -25,8 +25,9 @@ struct target;
 
 struct armv4_5_mmu_common {
        int (*get_ttb)(struct target *target, uint32_t *result);
 
 struct armv4_5_mmu_common {
        int (*get_ttb)(struct target *target, uint32_t *result);

-       int (*read_memory)(struct target *target, uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
-       int (*write_memory)(struct target *target, uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
+       int (*read_memory)(struct target *target, target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer);
+       int (*write_memory)(struct target *target, target_addr_t address,
+                           uint32_t size, uint32_t count, const uint8_t *buffer);

        int (*disable_mmu_caches)(struct target *target, int mmu, int d_u_cache, int i_cache);
        int (*enable_mmu_caches)(struct target *target, int mmu, int d_u_cache, int i_cache);
        struct armv4_5_cache_common armv4_5_cache;
        int (*disable_mmu_caches)(struct target *target, int mmu, int d_u_cache, int i_cache);
        int (*enable_mmu_caches)(struct target *target, int mmu, int d_u_cache, int i_cache);
        struct armv4_5_cache_common armv4_5_cache;

diff --git a/src/target/armv7a.h b/src/target/armv7a.h
index c5c03c895a667888a047d245d6ee77df006e7594..14112e4ed0267958f2ce392f0044e2dbf83b9078 100644 (file)
--- a/src/target/armv7a.h
+++ b/src/target/armv7a.h
@@ -90,7 +90,7 @@ struct armv7a_mmu_common {
        uint32_t ttbr_mask[2];
        uint32_t ttbr_range[2];
 
        uint32_t ttbr_mask[2];
        uint32_t ttbr_range[2];
 

-       int (*read_physical_memory)(struct target *target, uint32_t address, uint32_t size,
+       int (*read_physical_memory)(struct target *target, target_addr_t address, uint32_t size,

                        uint32_t count, uint8_t *buffer);
        struct armv7a_cache_common armv7a_cache;
        uint32_t mmu_enabled;
                        uint32_t count, uint8_t *buffer);
        struct armv7a_cache_common armv7a_cache;
        uint32_t mmu_enabled;

diff --git a/src/target/armv7a_cache_l2x.c b/src/target/armv7a_cache_l2x.c
index 798843835b09e7c98a822afe44a895bd507db676..e181f268da98562503931948cc4105f1a79763d0 100644 (file)
--- a/src/target/armv7a_cache_l2x.c
+++ b/src/target/armv7a_cache_l2x.c
@@ -63,12 +63,12 @@ int arm7a_l2x_flush_all_data(struct target *target)
 
        l2_way_val = (1 << l2x_cache->way) - 1;
 
 
        l2_way_val = (1 << l2x_cache->way) - 1;
 

-       return target_write_phys_memory(target,
+       return target_write_phys_u32(target,

                        l2x_cache->base + L2X0_CLEAN_INV_WAY,
                        l2x_cache->base + L2X0_CLEAN_INV_WAY,

-                       4, 1, (uint8_t *)&l2_way_val);
+                       l2_way_val);

 }
 
 }
 

-int armv7a_l2x_cache_flush_virt(struct target *target, uint32_t virt,
+int armv7a_l2x_cache_flush_virt(struct target *target, target_addr_t virt,

                                        uint32_t size)
 {
        struct armv7a_common *armv7a = target_to_armv7a(target);
                                        uint32_t size)
 {
        struct armv7a_common *armv7a = target_to_armv7a(target);


@@ -83,16 +83,15 @@ int armv7a_l2x_cache_flush_virt(struct target *target, uint32_t virt,
                return retval;
 
        for (i = 0; i < size; i += linelen) {
                return retval;
 
        for (i = 0; i < size; i += linelen) {

-               uint32_t pa, offs = virt + i;
+               target_addr_t pa, offs = virt + i;

 
                /* FIXME: use less verbose virt2phys? */
                retval = target->type->virt2phys(target, offs, &pa);
                if (retval != ERROR_OK)
                        goto done;
 
 
                /* FIXME: use less verbose virt2phys? */
                retval = target->type->virt2phys(target, offs, &pa);
                if (retval != ERROR_OK)
                        goto done;
 

-               retval = target_write_phys_memory(target,
-                               l2x_cache->base + L2X0_CLEAN_INV_LINE_PA,
-                               4, 1, (uint8_t *)&pa);
+               retval = target_write_phys_u32(target,
+                               l2x_cache->base + L2X0_CLEAN_INV_LINE_PA, pa);

                if (retval != ERROR_OK)
                        goto done;
        }
                if (retval != ERROR_OK)
                        goto done;
        }


@@ -104,7 +103,7 @@ done:
        return retval;
 }
 
        return retval;
 }
 

-static int armv7a_l2x_cache_inval_virt(struct target *target, uint32_t virt,
+static int armv7a_l2x_cache_inval_virt(struct target *target, target_addr_t virt,

                                        uint32_t size)
 {
        struct armv7a_common *armv7a = target_to_armv7a(target);
                                        uint32_t size)
 {
        struct armv7a_common *armv7a = target_to_armv7a(target);


@@ -119,16 +118,15 @@ static int armv7a_l2x_cache_inval_virt(struct target *target, uint32_t virt,
                return retval;
 
        for (i = 0; i < size; i += linelen) {
                return retval;
 
        for (i = 0; i < size; i += linelen) {

-               uint32_t pa, offs = virt + i;
+               target_addr_t pa, offs = virt + i;

 
                /* FIXME: use less verbose virt2phys? */
                retval = target->type->virt2phys(target, offs, &pa);
                if (retval != ERROR_OK)
                        goto done;
 
 
                /* FIXME: use less verbose virt2phys? */
                retval = target->type->virt2phys(target, offs, &pa);
                if (retval != ERROR_OK)
                        goto done;
 

-               retval = target_write_phys_memory(target,
-                               l2x_cache->base + L2X0_INV_LINE_PA,
-                               4, 1, (uint8_t *)&pa);
+               retval = target_write_phys_u32(target,
+                               l2x_cache->base + L2X0_INV_LINE_PA, pa);

                if (retval != ERROR_OK)
                        goto done;
        }
                if (retval != ERROR_OK)
                        goto done;
        }


@@ -140,7 +138,7 @@ done:
        return retval;
 }
 
        return retval;
 }
 

-static int armv7a_l2x_cache_clean_virt(struct target *target, uint32_t virt,
+static int armv7a_l2x_cache_clean_virt(struct target *target, target_addr_t virt,

                                        unsigned int size)
 {
        struct armv7a_common *armv7a = target_to_armv7a(target);
                                        unsigned int size)
 {
        struct armv7a_common *armv7a = target_to_armv7a(target);


@@ -155,16 +153,15 @@ static int armv7a_l2x_cache_clean_virt(struct target *target, uint32_t virt,
                return retval;
 
        for (i = 0; i < size; i += linelen) {
                return retval;
 
        for (i = 0; i < size; i += linelen) {

-               uint32_t pa, offs = virt + i;
+               target_addr_t pa, offs = virt + i;

 
                /* FIXME: use less verbose virt2phys? */
                retval = target->type->virt2phys(target, offs, &pa);
                if (retval != ERROR_OK)
                        goto done;
 
 
                /* FIXME: use less verbose virt2phys? */
                retval = target->type->virt2phys(target, offs, &pa);
                if (retval != ERROR_OK)
                        goto done;
 

-               retval = target_write_phys_memory(target,
-                               l2x_cache->base + L2X0_CLEAN_LINE_PA,
-                               4, 1, (uint8_t *)&pa);
+               retval = target_write_phys_u32(target,
+                               l2x_cache->base + L2X0_CLEAN_LINE_PA, pa);

                if (retval != ERROR_OK)
                        goto done;
        }
                if (retval != ERROR_OK)
                        goto done;
        }


@@ -252,7 +249,8 @@ COMMAND_HANDLER(arm7a_l2x_cache_flush_all_command)
 COMMAND_HANDLER(arm7a_l2x_cache_flush_virt_cmd)
 {
        struct target *target = get_current_target(CMD_CTX);
 COMMAND_HANDLER(arm7a_l2x_cache_flush_virt_cmd)
 {
        struct target *target = get_current_target(CMD_CTX);

-       uint32_t virt, size;
+       target_addr_t virt;
+       uint32_t size;

 
        if (CMD_ARGC == 0 || CMD_ARGC > 2)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        if (CMD_ARGC == 0 || CMD_ARGC > 2)
                return ERROR_COMMAND_SYNTAX_ERROR;


@@ -262,7 +260,7 @@ COMMAND_HANDLER(arm7a_l2x_cache_flush_virt_cmd)
        else
                size = 1;
 
        else
                size = 1;
 

-       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], virt);
+       COMMAND_PARSE_ADDRESS(CMD_ARGV[0], virt);

 
        return armv7a_l2x_cache_flush_virt(target, virt, size);
 }
 
        return armv7a_l2x_cache_flush_virt(target, virt, size);
 }


@@ -270,7 +268,8 @@ COMMAND_HANDLER(arm7a_l2x_cache_flush_virt_cmd)
 COMMAND_HANDLER(arm7a_l2x_cache_inval_virt_cmd)
 {
        struct target *target = get_current_target(CMD_CTX);
 COMMAND_HANDLER(arm7a_l2x_cache_inval_virt_cmd)
 {
        struct target *target = get_current_target(CMD_CTX);

-       uint32_t virt, size;
+       target_addr_t virt;
+       uint32_t size;

 
        if (CMD_ARGC == 0 || CMD_ARGC > 2)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        if (CMD_ARGC == 0 || CMD_ARGC > 2)
                return ERROR_COMMAND_SYNTAX_ERROR;


@@ -280,7 +279,7 @@ COMMAND_HANDLER(arm7a_l2x_cache_inval_virt_cmd)
        else
                size = 1;
 
        else
                size = 1;
 

-       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], virt);
+       COMMAND_PARSE_ADDRESS(CMD_ARGV[0], virt);

 
        return armv7a_l2x_cache_inval_virt(target, virt, size);
 }
 
        return armv7a_l2x_cache_inval_virt(target, virt, size);
 }


@@ -288,7 +287,8 @@ COMMAND_HANDLER(arm7a_l2x_cache_inval_virt_cmd)
 COMMAND_HANDLER(arm7a_l2x_cache_clean_virt_cmd)
 {
        struct target *target = get_current_target(CMD_CTX);
 COMMAND_HANDLER(arm7a_l2x_cache_clean_virt_cmd)
 {
        struct target *target = get_current_target(CMD_CTX);

-       uint32_t virt, size;
+       target_addr_t virt;
+       uint32_t size;

 
        if (CMD_ARGC == 0 || CMD_ARGC > 2)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        if (CMD_ARGC == 0 || CMD_ARGC > 2)
                return ERROR_COMMAND_SYNTAX_ERROR;


@@ -298,7 +298,7 @@ COMMAND_HANDLER(arm7a_l2x_cache_clean_virt_cmd)
        else
                size = 1;
 
        else
                size = 1;
 

-       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], virt);
+       COMMAND_PARSE_ADDRESS(CMD_ARGV[0], virt);

 
        return armv7a_l2x_cache_clean_virt(target, virt, size);
 }
 
        return armv7a_l2x_cache_clean_virt(target, virt, size);
 }

diff --git a/src/target/armv7a_cache_l2x.h b/src/target/armv7a_cache_l2x.h
index 3d9ad8116ed524e2b36f08426c75820ed3d5ba3e..f98b55446570ec950c7d1d6b912ddad4d91a2a2e 100644 (file)
--- a/src/target/armv7a_cache_l2x.h
+++ b/src/target/armv7a_cache_l2x.h
@@ -151,7 +151,7 @@ struct l2c_init_data {
 
 extern const struct command_registration arm7a_l2x_cache_command_handler[];
 
 
 extern const struct command_registration arm7a_l2x_cache_command_handler[];
 

-int armv7a_l2x_cache_flush_virt(struct target *target, uint32_t virt,
+int armv7a_l2x_cache_flush_virt(struct target *target, target_addr_t virt,

                                        uint32_t size);
 int arm7a_l2x_flush_all_data(struct target *target);
 
                                        uint32_t size);
 int arm7a_l2x_flush_all_data(struct target *target);
 

diff --git a/src/target/armv7m.c b/src/target/armv7m.c
index 64d18d75aa800c9848f48adcbde507528f1f6c61..e0911c30f5392118f2f45f0a6433958c030e99c5 100644 (file)
--- a/src/target/armv7m.c
+++ b/src/target/armv7m.c
@@ -318,7 +318,7 @@ int armv7m_get_gdb_reg_list(struct target *target, struct reg **reg_list[],
 int armv7m_run_algorithm(struct target *target,
        int num_mem_params, struct mem_param *mem_params,
        int num_reg_params, struct reg_param *reg_params,
 int armv7m_run_algorithm(struct target *target,
        int num_mem_params, struct mem_param *mem_params,
        int num_reg_params, struct reg_param *reg_params,

-       uint32_t entry_point, uint32_t exit_point,
+       target_addr_t entry_point, target_addr_t exit_point,

        int timeout_ms, void *arch_info)
 {
        int retval;
        int timeout_ms, void *arch_info)
 {
        int retval;


@@ -343,7 +343,7 @@ int armv7m_run_algorithm(struct target *target,
 int armv7m_start_algorithm(struct target *target,
        int num_mem_params, struct mem_param *mem_params,
        int num_reg_params, struct reg_param *reg_params,
 int armv7m_start_algorithm(struct target *target,
        int num_mem_params, struct mem_param *mem_params,
        int num_reg_params, struct reg_param *reg_params,

-       uint32_t entry_point, uint32_t exit_point,
+       target_addr_t entry_point, target_addr_t exit_point,

        void *arch_info)
 {
        struct armv7m_common *armv7m = target_to_armv7m(target);
        void *arch_info)
 {
        struct armv7m_common *armv7m = target_to_armv7m(target);


@@ -431,7 +431,7 @@ int armv7m_start_algorithm(struct target *target,
 int armv7m_wait_algorithm(struct target *target,
        int num_mem_params, struct mem_param *mem_params,
        int num_reg_params, struct reg_param *reg_params,
 int armv7m_wait_algorithm(struct target *target,
        int num_mem_params, struct mem_param *mem_params,
        int num_reg_params, struct reg_param *reg_params,

-       uint32_t exit_point, int timeout_ms,
+       target_addr_t exit_point, int timeout_ms,

        void *arch_info)
 {
        struct armv7m_common *armv7m = target_to_armv7m(target);
        void *arch_info)
 {
        struct armv7m_common *armv7m = target_to_armv7m(target);


@@ -461,7 +461,7 @@ int armv7m_wait_algorithm(struct target *target,
 
        armv7m->load_core_reg_u32(target, 15, &pc);
        if (exit_point && (pc != exit_point)) {
 
        armv7m->load_core_reg_u32(target, 15, &pc);
        if (exit_point && (pc != exit_point)) {

-               LOG_DEBUG("failed algorithm halted at 0x%" PRIx32 ", expected 0x%" PRIx32,
+               LOG_DEBUG("failed algorithm halted at 0x%" PRIx32 ", expected 0x%" TARGET_PRIxADDR,

                        pc,
                        exit_point);
                return ERROR_TARGET_TIMEOUT;
                        pc,
                        exit_point);
                return ERROR_TARGET_TIMEOUT;


@@ -682,7 +682,7 @@ int armv7m_init_arch_info(struct target *target, struct armv7m_common *armv7m)
 
 /** Generates a CRC32 checksum of a memory region. */
 int armv7m_checksum_memory(struct target *target,
 
 /** Generates a CRC32 checksum of a memory region. */
 int armv7m_checksum_memory(struct target *target,

-       uint32_t address, uint32_t count, uint32_t *checksum)
+       target_addr_t address, uint32_t count, uint32_t *checksum)

 {
        struct working_area *crc_algorithm;
        struct armv7m_algorithm armv7m_info;
 {
        struct working_area *crc_algorithm;
        struct armv7m_algorithm armv7m_info;


@@ -733,7 +733,7 @@ cleanup:
 
 /** Checks whether a memory region is erased. */
 int armv7m_blank_check_memory(struct target *target,
 
 /** Checks whether a memory region is erased. */
 int armv7m_blank_check_memory(struct target *target,

-       uint32_t address, uint32_t count, uint32_t *blank, uint8_t erased_value)
+       target_addr_t address, uint32_t count, uint32_t *blank, uint8_t erased_value)

 {
        struct working_area *erase_check_algorithm;
        struct reg_param reg_params[3];
 {
        struct working_area *erase_check_algorithm;
        struct reg_param reg_params[3];

diff --git a/src/target/armv7m.h b/src/target/armv7m.h
index 304c72d3f634fb5f7462f6656590789d7e6a787f..284bb9caa8566e0b573decb77e4898bc4b354598 100644 (file)
--- a/src/target/armv7m.h
+++ b/src/target/armv7m.h
@@ -203,19 +203,19 @@ int armv7m_init_arch_info(struct target *target, struct armv7m_common *armv7m);
 int armv7m_run_algorithm(struct target *target,
                int num_mem_params, struct mem_param *mem_params,
                int num_reg_params, struct reg_param *reg_params,
 int armv7m_run_algorithm(struct target *target,
                int num_mem_params, struct mem_param *mem_params,
                int num_reg_params, struct reg_param *reg_params,

-               uint32_t entry_point, uint32_t exit_point,
+               target_addr_t entry_point, target_addr_t exit_point,

                int timeout_ms, void *arch_info);
 
 int armv7m_start_algorithm(struct target *target,
                int num_mem_params, struct mem_param *mem_params,
                int num_reg_params, struct reg_param *reg_params,
                int timeout_ms, void *arch_info);
 
 int armv7m_start_algorithm(struct target *target,
                int num_mem_params, struct mem_param *mem_params,
                int num_reg_params, struct reg_param *reg_params,

-               uint32_t entry_point, uint32_t exit_point,
+               target_addr_t entry_point, target_addr_t exit_point,

                void *arch_info);
 
 int armv7m_wait_algorithm(struct target *target,
                int num_mem_params, struct mem_param *mem_params,
                int num_reg_params, struct reg_param *reg_params,
                void *arch_info);
 
 int armv7m_wait_algorithm(struct target *target,
                int num_mem_params, struct mem_param *mem_params,
                int num_reg_params, struct reg_param *reg_params,

-               uint32_t exit_point, int timeout_ms,
+               target_addr_t exit_point, int timeout_ms,

                void *arch_info);
 
 int armv7m_invalidate_core_regs(struct target *target);
                void *arch_info);
 
 int armv7m_invalidate_core_regs(struct target *target);


@@ -223,9 +223,9 @@ int armv7m_invalidate_core_regs(struct target *target);
 int armv7m_restore_context(struct target *target);
 
 int armv7m_checksum_memory(struct target *target,
 int armv7m_restore_context(struct target *target);
 
 int armv7m_checksum_memory(struct target *target,

-               uint32_t address, uint32_t count, uint32_t *checksum);
+               target_addr_t address, uint32_t count, uint32_t *checksum);

 int armv7m_blank_check_memory(struct target *target,
 int armv7m_blank_check_memory(struct target *target,

-               uint32_t address, uint32_t count, uint32_t *blank, uint8_t erased_value);
+               target_addr_t address, uint32_t count, uint32_t *blank, uint8_t erased_value);

 
 int armv7m_maybe_skip_bkpt_inst(struct target *target, bool *inst_found);
 
 
 int armv7m_maybe_skip_bkpt_inst(struct target *target, bool *inst_found);
 

diff --git a/src/target/avr32_ap7k.c b/src/target/avr32_ap7k.c
index e5634f2de4e3cc8664657bd5d0cf85a4271da1fb..f8da8d5ac7d8ca24f161bbafd21a95a846aee6cf 100644 (file)
--- a/src/target/avr32_ap7k.c
+++ b/src/target/avr32_ap7k.c
@@ -312,7 +312,7 @@ static int avr32_ap7k_deassert_reset(struct target *target)
 }
 
 static int avr32_ap7k_resume(struct target *target, int current,
 }
 
 static int avr32_ap7k_resume(struct target *target, int current,

-       uint32_t address, int handle_breakpoints, int debug_execution)
+       target_addr_t address, int handle_breakpoints, int debug_execution)

 {
        struct avr32_ap7k_common *ap7k = target_to_ap7k(target);
        struct breakpoint *breakpoint = NULL;
 {
        struct avr32_ap7k_common *ap7k = target_to_ap7k(target);
        struct breakpoint *breakpoint = NULL;


@@ -348,7 +348,7 @@ static int avr32_ap7k_resume(struct target *target, int current,
                /* Single step past breakpoint at current address */
                breakpoint = breakpoint_find(target, resume_pc);
                if (breakpoint) {
                /* Single step past breakpoint at current address */
                breakpoint = breakpoint_find(target, resume_pc);
                if (breakpoint) {

-                       LOG_DEBUG("unset breakpoint at 0x%8.8" PRIx32 "", breakpoint->address);
+                       LOG_DEBUG("unset breakpoint at 0x%8.8" TARGET_PRIxADDR "", breakpoint->address);

 #if 0
                        avr32_ap7k_unset_breakpoint(target, breakpoint);
                        avr32_ap7k_single_step_core(target);
 #if 0
                        avr32_ap7k_unset_breakpoint(target, breakpoint);
                        avr32_ap7k_single_step_core(target);


@@ -394,7 +394,7 @@ static int avr32_ap7k_resume(struct target *target, int current,
 }
 
 static int avr32_ap7k_step(struct target *target, int current,
 }
 
 static int avr32_ap7k_step(struct target *target, int current,

-       uint32_t address, int handle_breakpoints)
+       target_addr_t address, int handle_breakpoints)

 {
        LOG_ERROR("%s: implement me", __func__);
 
 {
        LOG_ERROR("%s: implement me", __func__);
 


@@ -431,12 +431,12 @@ static int avr32_ap7k_remove_watchpoint(struct target *target,
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int avr32_ap7k_read_memory(struct target *target, uint32_t address,
+static int avr32_ap7k_read_memory(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct avr32_ap7k_common *ap7k = target_to_ap7k(target);
 
        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct avr32_ap7k_common *ap7k = target_to_ap7k(target);
 

-       LOG_DEBUG("address: 0x%8.8" PRIx32 ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32 "",
+       LOG_DEBUG("address: 0x%8.8" TARGET_PRIxADDR ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32 "",

                address,
                size,
                count);
                address,
                size,
                count);


@@ -472,12 +472,12 @@ static int avr32_ap7k_read_memory(struct target *target, uint32_t address,
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int avr32_ap7k_write_memory(struct target *target, uint32_t address,
+static int avr32_ap7k_write_memory(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct avr32_ap7k_common *ap7k = target_to_ap7k(target);
 
        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct avr32_ap7k_common *ap7k = target_to_ap7k(target);
 

-       LOG_DEBUG("address: 0x%8.8" PRIx32 ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32 "",
+       LOG_DEBUG("address: 0x%8.8" TARGET_PRIxADDR ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32 "",

                address,
                size,
                count);
                address,
                size,
                count);

diff --git a/src/target/avrt.c b/src/target/avrt.c
index 40a12974f07ca7a97886261a3598551a3cfab147..1e1898c7edf7562da01c83bd3c740ca58a41a5a2 100644 (file)
--- a/src/target/avrt.c
+++ b/src/target/avrt.c
@@ -33,9 +33,9 @@ static int avr_init_target(struct command_context *cmd_ctx, struct target *targe
 static int avr_arch_state(struct target *target);
 static int avr_poll(struct target *target);
 static int avr_halt(struct target *target);
 static int avr_arch_state(struct target *target);
 static int avr_poll(struct target *target);
 static int avr_halt(struct target *target);

-static int avr_resume(struct target *target, int current, uint32_t address,
+static int avr_resume(struct target *target, int current, target_addr_t address,

                int handle_breakpoints, int debug_execution);
                int handle_breakpoints, int debug_execution);

-static int avr_step(struct target *target, int current, uint32_t address,
+static int avr_step(struct target *target, int current, target_addr_t address,

                int handle_breakpoints);
 
 static int avr_assert_reset(struct target *target);
                int handle_breakpoints);
 
 static int avr_assert_reset(struct target *target);


@@ -116,14 +116,14 @@ static int avr_halt(struct target *target)
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int avr_resume(struct target *target, int current, uint32_t address,
+static int avr_resume(struct target *target, int current, target_addr_t address,

                int handle_breakpoints, int debug_execution)
 {
        LOG_DEBUG("%s", __func__);
        return ERROR_OK;
 }
 
                int handle_breakpoints, int debug_execution)
 {
        LOG_DEBUG("%s", __func__);
        return ERROR_OK;
 }
 

-static int avr_step(struct target *target, int current, uint32_t address, int handle_breakpoints)
+static int avr_step(struct target *target, int current, target_addr_t address, int handle_breakpoints)

 {
        LOG_DEBUG("%s", __func__);
        return ERROR_OK;
 {
        LOG_DEBUG("%s", __func__);
        return ERROR_OK;

diff --git a/src/target/breakpoints.c b/src/target/breakpoints.c
index c4a959df3ea949d4a70e93f4375126f70602f02d..7cf4a6957e13e082114a4f03ca788ed808431dc7 100644 (file)
--- a/src/target/breakpoints.c
+++ b/src/target/breakpoints.c
@@ -42,7 +42,7 @@ static const char * const watchpoint_rw_strings[] = {
 static int bpwp_unique_id;
 
 int breakpoint_add_internal(struct target *target,
 static int bpwp_unique_id;
 
 int breakpoint_add_internal(struct target *target,

-       uint32_t address,
+       target_addr_t address,

        uint32_t length,
        enum breakpoint_type type)
 {
        uint32_t length,
        enum breakpoint_type type)
 {


@@ -60,7 +60,7 @@ int breakpoint_add_internal(struct target *target,
                         * breakpoint" ... check all the parameters before
                         * succeeding.
                         */
                         * breakpoint" ... check all the parameters before
                         * succeeding.
                         */

-                       LOG_DEBUG("Duplicate Breakpoint address: 0x%08" PRIx32 " (BP %" PRIu32 ")",
+                       LOG_DEBUG("Duplicate Breakpoint address: " TARGET_ADDR_FMT " (BP %" PRIu32 ")",

                                address, breakpoint->unique_id);
                        return ERROR_OK;
                }
                                address, breakpoint->unique_id);
                        return ERROR_OK;
                }


@@ -98,7 +98,7 @@ fail:
                        return retval;
        }
 
                        return retval;
        }
 

-       LOG_DEBUG("added %s breakpoint at 0x%8.8" PRIx32 " of length 0x%8.8x, (BPID: %" PRIu32 ")",
+       LOG_DEBUG("added %s breakpoint at " TARGET_ADDR_FMT " of length 0x%8.8x, (BPID: %" PRIu32 ")",

                breakpoint_type_strings[(*breakpoint_p)->type],
                (*breakpoint_p)->address, (*breakpoint_p)->length,
                (*breakpoint_p)->unique_id);
                breakpoint_type_strings[(*breakpoint_p)->type],
                (*breakpoint_p)->address, (*breakpoint_p)->length,
                (*breakpoint_p)->unique_id);


@@ -159,7 +159,7 @@ int context_breakpoint_add_internal(struct target *target,
 }
 
 int hybrid_breakpoint_add_internal(struct target *target,
 }
 
 int hybrid_breakpoint_add_internal(struct target *target,

-       uint32_t address,
+       target_addr_t address,

        uint32_t asid,
        uint32_t length,
        enum breakpoint_type type)
        uint32_t asid,
        uint32_t length,
        enum breakpoint_type type)


@@ -180,7 +180,7 @@ int hybrid_breakpoint_add_internal(struct target *target,
                                asid, breakpoint->unique_id);
                        return -1;
                } else if ((breakpoint->address == address) && (breakpoint->asid == 0)) {
                                asid, breakpoint->unique_id);
                        return -1;
                } else if ((breakpoint->address == address) && (breakpoint->asid == 0)) {

-                       LOG_DEBUG("Duplicate Breakpoint IVA: 0x%08" PRIx32 " (BP %" PRIu32 ")",
+                       LOG_DEBUG("Duplicate Breakpoint IVA: " TARGET_ADDR_FMT " (BP %" PRIu32 ")",

                                address, breakpoint->unique_id);
                        return -1;
 
                                address, breakpoint->unique_id);
                        return -1;
 


@@ -208,7 +208,7 @@ int hybrid_breakpoint_add_internal(struct target *target,
                return retval;
        }
        LOG_DEBUG(
                return retval;
        }
        LOG_DEBUG(

-               "added %s Hybrid breakpoint at address 0x%8.8" PRIx32 " of length 0x%8.8x, (BPID: %" PRIu32 ")",
+               "added %s Hybrid breakpoint at address " TARGET_ADDR_FMT " of length 0x%8.8x, (BPID: %" PRIu32 ")",

                breakpoint_type_strings[(*breakpoint_p)->type],
                (*breakpoint_p)->address,
                (*breakpoint_p)->length,
                breakpoint_type_strings[(*breakpoint_p)->type],
                (*breakpoint_p)->address,
                (*breakpoint_p)->length,


@@ -218,7 +218,7 @@ int hybrid_breakpoint_add_internal(struct target *target,
 }
 
 int breakpoint_add(struct target *target,
 }
 
 int breakpoint_add(struct target *target,

-       uint32_t address,
+       target_addr_t address,

        uint32_t length,
        enum breakpoint_type type)
 {
        uint32_t length,
        enum breakpoint_type type)
 {


@@ -263,7 +263,7 @@ int context_breakpoint_add(struct target *target,
                return context_breakpoint_add_internal(target, asid, length, type);
 }
 int hybrid_breakpoint_add(struct target *target,
                return context_breakpoint_add_internal(target, asid, length, type);
 }
 int hybrid_breakpoint_add(struct target *target,

-       uint32_t address,
+       target_addr_t address,

        uint32_t asid,
        uint32_t length,
        enum breakpoint_type type)
        uint32_t asid,
        uint32_t length,
        enum breakpoint_type type)


@@ -310,7 +310,7 @@ static void breakpoint_free(struct target *target, struct breakpoint *breakpoint
        free(breakpoint);
 }
 
        free(breakpoint);
 }
 

-int breakpoint_remove_internal(struct target *target, uint32_t address)
+int breakpoint_remove_internal(struct target *target, target_addr_t address)

 {
        struct breakpoint *breakpoint = target->breakpoints;
 
 {
        struct breakpoint *breakpoint = target->breakpoints;
 


@@ -329,11 +329,11 @@ int breakpoint_remove_internal(struct target *target, uint32_t address)
                return 1;
        } else {
                if (!target->smp)
                return 1;
        } else {
                if (!target->smp)

-                       LOG_ERROR("no breakpoint at address 0x%8.8" PRIx32 " found", address);
+                       LOG_ERROR("no breakpoint at address " TARGET_ADDR_FMT " found", address);

                return 0;
        }
 }
                return 0;
        }
 }

-void breakpoint_remove(struct target *target, uint32_t address)
+void breakpoint_remove(struct target *target, target_addr_t address)

 {
        int found = 0;
        if (target->smp) {
 {
        int found = 0;
        if (target->smp) {


@@ -346,7 +346,7 @@ void breakpoint_remove(struct target *target, uint32_t address)
                        head = head->next;
                }
                if (found == 0)
                        head = head->next;
                }
                if (found == 0)

-                       LOG_ERROR("no breakpoint at address 0x%8.8" PRIx32 " found", address);
+                       LOG_ERROR("no breakpoint at address " TARGET_ADDR_FMT " found", address);

        } else
                breakpoint_remove_internal(target, address);
 }
        } else
                breakpoint_remove_internal(target, address);
 }


@@ -375,7 +375,7 @@ void breakpoint_clear_target(struct target *target)
 
 }
 
 
 }
 

-struct breakpoint *breakpoint_find(struct target *target, uint32_t address)
+struct breakpoint *breakpoint_find(struct target *target, target_addr_t address)

 {
        struct breakpoint *breakpoint = target->breakpoints;
 
 {
        struct breakpoint *breakpoint = target->breakpoints;
 


@@ -388,7 +388,7 @@ struct breakpoint *breakpoint_find(struct target *target, uint32_t address)
        return NULL;
 }
 
        return NULL;
 }
 

-int watchpoint_add(struct target *target, uint32_t address, uint32_t length,
+int watchpoint_add(struct target *target, target_addr_t address, uint32_t length,

        enum watchpoint_rw rw, uint32_t value, uint32_t mask)
 {
        struct watchpoint *watchpoint = target->watchpoints;
        enum watchpoint_rw rw, uint32_t value, uint32_t mask)
 {
        struct watchpoint *watchpoint = target->watchpoints;


@@ -402,7 +402,7 @@ int watchpoint_add(struct target *target, uint32_t address, uint32_t length,
                                || watchpoint->value != value
                                || watchpoint->mask != mask
                                || watchpoint->rw != rw) {
                                || watchpoint->value != value
                                || watchpoint->mask != mask
                                || watchpoint->rw != rw) {

-                               LOG_ERROR("address 0x%8.8" PRIx32
+                               LOG_ERROR("address " TARGET_ADDR_FMT

                                        " already has watchpoint %d",
                                        address, watchpoint->unique_id);
                                return ERROR_FAIL;
                                        " already has watchpoint %d",
                                        address, watchpoint->unique_id);
                                return ERROR_FAIL;


@@ -436,7 +436,7 @@ int watchpoint_add(struct target *target, uint32_t address, uint32_t length,
                default:
                        reason = "unrecognized error";
 bye:
                default:
                        reason = "unrecognized error";
 bye:

-                       LOG_ERROR("can't add %s watchpoint at 0x%8.8" PRIx32 ", %s",
+                       LOG_ERROR("can't add %s watchpoint at " TARGET_ADDR_FMT ", %s",

                                watchpoint_rw_strings[(*watchpoint_p)->rw],
                                address, reason);
                        free(*watchpoint_p);
                                watchpoint_rw_strings[(*watchpoint_p)->rw],
                                address, reason);
                        free(*watchpoint_p);


@@ -444,7 +444,7 @@ bye:
                        return retval;
        }
 
                        return retval;
        }
 

-       LOG_DEBUG("added %s watchpoint at 0x%8.8" PRIx32
+       LOG_DEBUG("added %s watchpoint at " TARGET_ADDR_FMT

                " of length 0x%8.8" PRIx32 " (WPID: %d)",
                watchpoint_rw_strings[(*watchpoint_p)->rw],
                (*watchpoint_p)->address,
                " of length 0x%8.8" PRIx32 " (WPID: %d)",
                watchpoint_rw_strings[(*watchpoint_p)->rw],
                (*watchpoint_p)->address,


@@ -475,7 +475,7 @@ static void watchpoint_free(struct target *target, struct watchpoint *watchpoint
        free(watchpoint);
 }
 
        free(watchpoint);
 }
 

-void watchpoint_remove(struct target *target, uint32_t address)
+void watchpoint_remove(struct target *target, target_addr_t address)

 {
        struct watchpoint *watchpoint = target->watchpoints;
 
 {
        struct watchpoint *watchpoint = target->watchpoints;
 


@@ -488,7 +488,7 @@ void watchpoint_remove(struct target *target, uint32_t address)
        if (watchpoint)
                watchpoint_free(target, watchpoint);
        else
        if (watchpoint)
                watchpoint_free(target, watchpoint);
        else

-               LOG_ERROR("no watchpoint at address 0x%8.8" PRIx32 " found", address);
+               LOG_ERROR("no watchpoint at address " TARGET_ADDR_FMT " found", address);

 }
 
 void watchpoint_clear_target(struct target *target)
 }
 
 void watchpoint_clear_target(struct target *target)


@@ -499,7 +499,8 @@ void watchpoint_clear_target(struct target *target)
                watchpoint_free(target, target->watchpoints);
 }
 
                watchpoint_free(target, target->watchpoints);
 }
 

-int watchpoint_hit(struct target *target, enum watchpoint_rw *rw, uint32_t *address)
+int watchpoint_hit(struct target *target, enum watchpoint_rw *rw,
+                  target_addr_t *address)

 {
        int retval;
        struct watchpoint *hit_watchpoint;
 {
        int retval;
        struct watchpoint *hit_watchpoint;


@@ -511,7 +512,7 @@ int watchpoint_hit(struct target *target, enum watchpoint_rw *rw, uint32_t *addr
        *rw = hit_watchpoint->rw;
        *address = hit_watchpoint->address;
 
        *rw = hit_watchpoint->rw;
        *address = hit_watchpoint->address;
 

-       LOG_DEBUG("Found hit watchpoint at 0x%8.8" PRIx32 " (WPID: %d)",
+       LOG_DEBUG("Found hit watchpoint at " TARGET_ADDR_FMT " (WPID: %d)",

                hit_watchpoint->address,
                hit_watchpoint->unique_id);
 
                hit_watchpoint->address,
                hit_watchpoint->unique_id);
 

diff --git a/src/target/breakpoints.h b/src/target/breakpoints.h
index 842fc18afad7501f2b77a7087d983b36bb90aa77..51bd05abd83c2be21145396a418b5a54e1fcaf56 100644 (file)
--- a/src/target/breakpoints.h
+++ b/src/target/breakpoints.h
@@ -33,7 +33,7 @@ enum watchpoint_rw {
 };
 
 struct breakpoint {
 };
 
 struct breakpoint {

-       uint32_t address;
+       target_addr_t address;

        uint32_t asid;
        int length;
        enum breakpoint_type type;
        uint32_t asid;
        int length;
        enum breakpoint_type type;


@@ -45,7 +45,7 @@ struct breakpoint {
 };
 
 struct watchpoint {
 };
 
 struct watchpoint {

-       uint32_t address;
+       target_addr_t address;

        uint32_t length;
        uint32_t mask;
        uint32_t value;
        uint32_t length;
        uint32_t mask;
        uint32_t value;


@@ -57,22 +57,23 @@ struct watchpoint {
 
 void breakpoint_clear_target(struct target *target);
 int breakpoint_add(struct target *target,
 
 void breakpoint_clear_target(struct target *target);
 int breakpoint_add(struct target *target,

-               uint32_t address, uint32_t length, enum breakpoint_type type);
+               target_addr_t address, uint32_t length, enum breakpoint_type type);

 int context_breakpoint_add(struct target *target,
                uint32_t asid, uint32_t length, enum breakpoint_type type);
 int hybrid_breakpoint_add(struct target *target,
 int context_breakpoint_add(struct target *target,
                uint32_t asid, uint32_t length, enum breakpoint_type type);
 int hybrid_breakpoint_add(struct target *target,

-               uint32_t address, uint32_t asid, uint32_t length, enum breakpoint_type type);
-void breakpoint_remove(struct target *target, uint32_t address);
+               target_addr_t address, uint32_t asid, uint32_t length, enum breakpoint_type type);
+void breakpoint_remove(struct target *target, target_addr_t address);

 
 

-struct breakpoint *breakpoint_find(struct target *target, uint32_t address);
+struct breakpoint *breakpoint_find(struct target *target, target_addr_t address);

 
 void watchpoint_clear_target(struct target *target);
 int watchpoint_add(struct target *target,
 
 void watchpoint_clear_target(struct target *target);
 int watchpoint_add(struct target *target,

-               uint32_t address, uint32_t length,
+               target_addr_t address, uint32_t length,

                enum watchpoint_rw rw, uint32_t value, uint32_t mask);
                enum watchpoint_rw rw, uint32_t value, uint32_t mask);

-void watchpoint_remove(struct target *target, uint32_t address);
+void watchpoint_remove(struct target *target, target_addr_t address);

 
 /* report type and address of just hit watchpoint */
 
 /* report type and address of just hit watchpoint */

-int watchpoint_hit(struct target *target, enum watchpoint_rw *rw, uint32_t *address);
+int watchpoint_hit(struct target *target, enum watchpoint_rw *rw,
+               target_addr_t *address);

 
 #endif /* OPENOCD_TARGET_BREAKPOINTS_H */
 
 #endif /* OPENOCD_TARGET_BREAKPOINTS_H */

diff --git a/src/target/cortex_a.c b/src/target/cortex_a.c
index 8c8a2b79ea5719ebbf5e8a7f30a2ac2951f7af7d..62ac361e6374e0a4a5a07637261d0e096719356e 100644 (file)
--- a/src/target/cortex_a.c
+++ b/src/target/cortex_a.c
@@ -75,7 +75,7 @@ static int cortex_a_dap_write_coreregister_u32(struct target *target,
 static int cortex_a_mmu(struct target *target, int *enabled);
 static int cortex_a_mmu_modify(struct target *target, int enable);
 static int cortex_a_virt2phys(struct target *target,
 static int cortex_a_mmu(struct target *target, int *enabled);
 static int cortex_a_mmu_modify(struct target *target, int enable);
 static int cortex_a_virt2phys(struct target *target,

-       uint32_t virt, uint32_t *phys);
+       target_addr_t virt, target_addr_t *phys);

 static int cortex_a_read_cpu_memory(struct target *target,
        uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
 
 static int cortex_a_read_cpu_memory(struct target *target,
        uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
 


@@ -937,7 +937,7 @@ static int cortex_a_halt(struct target *target)
 }
 
 static int cortex_a_internal_restore(struct target *target, int current,
 }
 
 static int cortex_a_internal_restore(struct target *target, int current,

-       uint32_t *address, int handle_breakpoints, int debug_execution)
+       target_addr_t *address, int handle_breakpoints, int debug_execution)

 {
        struct armv7a_common *armv7a = target_to_armv7a(target);
        struct arm *arm = &armv7a->arm;
 {
        struct armv7a_common *armv7a = target_to_armv7a(target);
        struct arm *arm = &armv7a->arm;


@@ -1092,7 +1092,7 @@ static int cortex_a_restore_smp(struct target *target, int handle_breakpoints)
        int retval = 0;
        struct target_list *head;
        struct target *curr;
        int retval = 0;
        struct target_list *head;
        struct target *curr;

-       uint32_t address;
+       target_addr_t address;

        head = target->head;
        while (head != (struct target_list *)NULL) {
                curr = head->target;
        head = target->head;
        while (head != (struct target_list *)NULL) {
                curr = head->target;


@@ -1110,7 +1110,7 @@ static int cortex_a_restore_smp(struct target *target, int handle_breakpoints)
 }
 
 static int cortex_a_resume(struct target *target, int current,
 }
 
 static int cortex_a_resume(struct target *target, int current,

-       uint32_t address, int handle_breakpoints, int debug_execution)
+       target_addr_t address, int handle_breakpoints, int debug_execution)

 {
        int retval = 0;
        /* dummy resume for smp toggle in order to reduce gdb impact  */
 {
        int retval = 0;
        /* dummy resume for smp toggle in order to reduce gdb impact  */


@@ -1134,11 +1134,11 @@ static int cortex_a_resume(struct target *target, int current,
        if (!debug_execution) {
                target->state = TARGET_RUNNING;
                target_call_event_callbacks(target, TARGET_EVENT_RESUMED);
        if (!debug_execution) {
                target->state = TARGET_RUNNING;
                target_call_event_callbacks(target, TARGET_EVENT_RESUMED);

-               LOG_DEBUG("target resumed at 0x%" PRIx32, address);
+               LOG_DEBUG("target resumed at " TARGET_ADDR_FMT, address);

        } else {
                target->state = TARGET_DEBUG_RUNNING;
                target_call_event_callbacks(target, TARGET_EVENT_DEBUG_RESUMED);
        } else {
                target->state = TARGET_DEBUG_RUNNING;
                target_call_event_callbacks(target, TARGET_EVENT_DEBUG_RESUMED);

-               LOG_DEBUG("target debug resumed at 0x%" PRIx32, address);
+               LOG_DEBUG("target debug resumed at " TARGET_ADDR_FMT, address);

        }
 
        return ERROR_OK;
        }
 
        return ERROR_OK;


@@ -1344,7 +1344,7 @@ int cortex_a_set_dscr_bits(struct target *target, unsigned long bit_mask, unsign
        return retval;
 }
 
        return retval;
 }
 

-static int cortex_a_step(struct target *target, int current, uint32_t address,
+static int cortex_a_step(struct target *target, int current, target_addr_t address,

        int handle_breakpoints)
 {
        struct cortex_a_common *cortex_a = target_to_cortex_a(target);
        int handle_breakpoints)
 {
        struct cortex_a_common *cortex_a = target_to_cortex_a(target);


@@ -2639,7 +2639,7 @@ out:
  */
 
 static int cortex_a_read_phys_memory(struct target *target,
  */
 
 static int cortex_a_read_phys_memory(struct target *target,

-       uint32_t address, uint32_t size,
+       target_addr_t address, uint32_t size,

        uint32_t count, uint8_t *buffer)
 {
        struct armv7a_common *armv7a = target_to_armv7a(target);
        uint32_t count, uint8_t *buffer)
 {
        struct armv7a_common *armv7a = target_to_armv7a(target);


@@ -2650,7 +2650,7 @@ static int cortex_a_read_phys_memory(struct target *target,
        if (!count || !buffer)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        if (!count || !buffer)
                return ERROR_COMMAND_SYNTAX_ERROR;
 

-       LOG_DEBUG("Reading memory at real address 0x%" PRIx32 "; size %" PRId32 "; count %" PRId32,
+       LOG_DEBUG("Reading memory at real address " TARGET_ADDR_FMT "; size %" PRId32 "; count %" PRId32,

                address, size, count);
 
        if (armv7a->memory_ap_available && (apsel == armv7a->memory_ap->ap_num))
                address, size, count);
 
        if (armv7a->memory_ap_available && (apsel == armv7a->memory_ap->ap_num))


@@ -2664,14 +2664,14 @@ static int cortex_a_read_phys_memory(struct target *target,
        return retval;
 }
 
        return retval;
 }
 

-static int cortex_a_read_memory(struct target *target, uint32_t address,
+static int cortex_a_read_memory(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        int retval;
 
        /* cortex_a handles unaligned memory access */
        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        int retval;
 
        /* cortex_a handles unaligned memory access */

-       LOG_DEBUG("Reading memory at address 0x%" PRIx32 "; size %" PRId32 "; count %" PRId32, address,
-               size, count);
+       LOG_DEBUG("Reading memory at address " TARGET_ADDR_FMT "; size %" PRId32 "; count %" PRId32,
+               address, size, count);

 
        cortex_a_prep_memaccess(target, 0);
        retval = cortex_a_read_cpu_memory(target, address, size, count, buffer);
 
        cortex_a_prep_memaccess(target, 0);
        retval = cortex_a_read_cpu_memory(target, address, size, count, buffer);


@@ -2680,11 +2680,11 @@ static int cortex_a_read_memory(struct target *target, uint32_t address,
        return retval;
 }
 
        return retval;
 }
 

-static int cortex_a_read_memory_ahb(struct target *target, uint32_t address,
+static int cortex_a_read_memory_ahb(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        int mmu_enabled = 0;
        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        int mmu_enabled = 0;

-       uint32_t virt, phys;
+       target_addr_t virt, phys;

        int retval;
        struct armv7a_common *armv7a = target_to_armv7a(target);
        struct adiv5_dap *swjdp = armv7a->arm.dap;
        int retval;
        struct armv7a_common *armv7a = target_to_armv7a(target);
        struct adiv5_dap *swjdp = armv7a->arm.dap;


@@ -2694,8 +2694,8 @@ static int cortex_a_read_memory_ahb(struct target *target, uint32_t address,
                return target_read_memory(target, address, size, count, buffer);
 
        /* cortex_a handles unaligned memory access */
                return target_read_memory(target, address, size, count, buffer);
 
        /* cortex_a handles unaligned memory access */

-       LOG_DEBUG("Reading memory at address 0x%" PRIx32 "; size %" PRId32 "; count %" PRId32, address,
-               size, count);
+       LOG_DEBUG("Reading memory at address " TARGET_ADDR_FMT "; size %" PRId32 "; count %" PRId32,
+               address, size, count);

 
        /* determine if MMU was enabled on target stop */
        if (!armv7a->is_armv7r) {
 
        /* determine if MMU was enabled on target stop */
        if (!armv7a->is_armv7r) {


@@ -2710,7 +2710,8 @@ static int cortex_a_read_memory_ahb(struct target *target, uint32_t address,
                if (retval != ERROR_OK)
                        return retval;
 
                if (retval != ERROR_OK)
                        return retval;
 

-               LOG_DEBUG("Reading at virtual address. Translating v:0x%" PRIx32 " to r:0x%" PRIx32,
+               LOG_DEBUG("Reading at virtual address. "
+                         "Translating v:" TARGET_ADDR_FMT " to r:" TARGET_ADDR_FMT,

                          virt, phys);
                address = phys;
        }
                          virt, phys);
                address = phys;
        }


@@ -2724,7 +2725,7 @@ static int cortex_a_read_memory_ahb(struct target *target, uint32_t address,
 }
 
 static int cortex_a_write_phys_memory(struct target *target,
 }
 
 static int cortex_a_write_phys_memory(struct target *target,

-       uint32_t address, uint32_t size,
+       target_addr_t address, uint32_t size,

        uint32_t count, const uint8_t *buffer)
 {
        struct armv7a_common *armv7a = target_to_armv7a(target);
        uint32_t count, const uint8_t *buffer)
 {
        struct armv7a_common *armv7a = target_to_armv7a(target);


@@ -2735,8 +2736,8 @@ static int cortex_a_write_phys_memory(struct target *target,
        if (!count || !buffer)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        if (!count || !buffer)
                return ERROR_COMMAND_SYNTAX_ERROR;
 

-       LOG_DEBUG("Writing memory to real address 0x%" PRIx32 "; size %" PRId32 "; count %" PRId32, address,
-               size, count);
+       LOG_DEBUG("Writing memory to real address " TARGET_ADDR_FMT "; size %" PRId32 "; count %" PRId32,
+               address, size, count);

 
        if (armv7a->memory_ap_available && (apsel == armv7a->memory_ap->ap_num))
                return mem_ap_write_buf(armv7a->memory_ap, buffer, size, count, address);
 
        if (armv7a->memory_ap_available && (apsel == armv7a->memory_ap->ap_num))
                return mem_ap_write_buf(armv7a->memory_ap, buffer, size, count, address);


@@ -2749,14 +2750,14 @@ static int cortex_a_write_phys_memory(struct target *target,
        return retval;
 }
 
        return retval;
 }
 

-static int cortex_a_write_memory(struct target *target, uint32_t address,
+static int cortex_a_write_memory(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        int retval;
 
        /* cortex_a handles unaligned memory access */
        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        int retval;
 
        /* cortex_a handles unaligned memory access */

-       LOG_DEBUG("Writing memory at address 0x%" PRIx32 "; size %" PRId32 "; count %" PRId32, address,
-               size, count);
+       LOG_DEBUG("Writing memory at address " TARGET_ADDR_FMT "; size %" PRId32 "; count %" PRId32,
+               address, size, count);

 
        /* memory writes bypass the caches, must flush before writing */
        armv7a_cache_auto_flush_on_write(target, address, size * count);
 
        /* memory writes bypass the caches, must flush before writing */
        armv7a_cache_auto_flush_on_write(target, address, size * count);


@@ -2767,11 +2768,11 @@ static int cortex_a_write_memory(struct target *target, uint32_t address,
        return retval;
 }
 
        return retval;
 }
 

-static int cortex_a_write_memory_ahb(struct target *target, uint32_t address,
+static int cortex_a_write_memory_ahb(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        int mmu_enabled = 0;
        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        int mmu_enabled = 0;

-       uint32_t virt, phys;
+       target_addr_t virt, phys;

        int retval;
        struct armv7a_common *armv7a = target_to_armv7a(target);
        struct adiv5_dap *swjdp = armv7a->arm.dap;
        int retval;
        struct armv7a_common *armv7a = target_to_armv7a(target);
        struct adiv5_dap *swjdp = armv7a->arm.dap;


@@ -2781,8 +2782,8 @@ static int cortex_a_write_memory_ahb(struct target *target, uint32_t address,
                return target_write_memory(target, address, size, count, buffer);
 
        /* cortex_a handles unaligned memory access */
                return target_write_memory(target, address, size, count, buffer);
 
        /* cortex_a handles unaligned memory access */

-       LOG_DEBUG("Writing memory at address 0x%" PRIx32 "; size %" PRId32 "; count %" PRId32, address,
-               size, count);
+       LOG_DEBUG("Writing memory at address " TARGET_ADDR_FMT "; size %" PRId32 "; count %" PRId32,
+               address, size, count);

 
        /* determine if MMU was enabled on target stop */
        if (!armv7a->is_armv7r) {
 
        /* determine if MMU was enabled on target stop */
        if (!armv7a->is_armv7r) {


@@ -2797,7 +2798,8 @@ static int cortex_a_write_memory_ahb(struct target *target, uint32_t address,
                if (retval != ERROR_OK)
                        return retval;
 
                if (retval != ERROR_OK)
                        return retval;
 

-               LOG_DEBUG("Writing to virtual address. Translating v:0x%" PRIx32 " to r:0x%" PRIx32,
+               LOG_DEBUG("Writing to virtual address. "
+                         "Translating v:" TARGET_ADDR_FMT " to r:" TARGET_ADDR_FMT,

                          virt,
                          phys);
                address = phys;
                          virt,
                          phys);
                address = phys;


@@ -2811,7 +2813,7 @@ static int cortex_a_write_memory_ahb(struct target *target, uint32_t address,
        return retval;
 }
 
        return retval;
 }
 

-static int cortex_a_read_buffer(struct target *target, uint32_t address,
+static int cortex_a_read_buffer(struct target *target, target_addr_t address,

                                uint32_t count, uint8_t *buffer)
 {
        uint32_t size;
                                uint32_t count, uint8_t *buffer)
 {
        uint32_t size;


@@ -2845,7 +2847,7 @@ static int cortex_a_read_buffer(struct target *target, uint32_t address,
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int cortex_a_write_buffer(struct target *target, uint32_t address,
+static int cortex_a_write_buffer(struct target *target, target_addr_t address,

                                 uint32_t count, const uint8_t *buffer)
 {
        uint32_t size;
                                 uint32_t count, const uint8_t *buffer)
 {
        uint32_t size;


@@ -3202,7 +3204,7 @@ static int cortex_a_mmu(struct target *target, int *enabled)
 }
 
 static int cortex_a_virt2phys(struct target *target,
 }
 
 static int cortex_a_virt2phys(struct target *target,

-       uint32_t virt, uint32_t *phys)
+       target_addr_t virt, target_addr_t *phys)

 {
        int retval = ERROR_FAIL;
        struct armv7a_common *armv7a = target_to_armv7a(target);
 {
        int retval = ERROR_FAIL;
        struct armv7a_common *armv7a = target_to_armv7a(target);


@@ -3220,7 +3222,8 @@ static int cortex_a_virt2phys(struct target *target,
                retval = cortex_a_mmu_modify(target, 1);
                if (retval != ERROR_OK)
                        goto done;
                retval = cortex_a_mmu_modify(target, 1);
                if (retval != ERROR_OK)
                        goto done;

-               retval = armv7a_mmu_translate_va_pa(target, virt,  phys, 1);
+               retval = armv7a_mmu_translate_va_pa(target, (uint32_t)virt,
+                                                   (uint32_t *)phys, 1);

        }
 done:
        return retval;
        }
 done:
        return retval;

diff --git a/src/target/cortex_m.c b/src/target/cortex_m.c
index 36a774671d77fdc4b85a3fa8a9520dc14a208d7c..e80cd2356b023bf730f275ae10b56353edaa9c3f 100644 (file)
--- a/src/target/cortex_m.c
+++ b/src/target/cortex_m.c
@@ -682,7 +682,7 @@ void cortex_m_enable_breakpoints(struct target *target)
 }
 
 static int cortex_m_resume(struct target *target, int current,
 }
 
 static int cortex_m_resume(struct target *target, int current,

-       uint32_t address, int handle_breakpoints, int debug_execution)
+       target_addr_t address, int handle_breakpoints, int debug_execution)

 {
        struct armv7m_common *armv7m = target_to_armv7m(target);
        struct breakpoint *breakpoint = NULL;
 {
        struct armv7m_common *armv7m = target_to_armv7m(target);
        struct breakpoint *breakpoint = NULL;


@@ -750,7 +750,7 @@ static int cortex_m_resume(struct target *target, int current,
                /* Single step past breakpoint at current address */
                breakpoint = breakpoint_find(target, resume_pc);
                if (breakpoint) {
                /* Single step past breakpoint at current address */
                breakpoint = breakpoint_find(target, resume_pc);
                if (breakpoint) {

-                       LOG_DEBUG("unset breakpoint at 0x%8.8" PRIx32 " (ID: %" PRIu32 ")",
+                       LOG_DEBUG("unset breakpoint at " TARGET_ADDR_FMT " (ID: %" PRIu32 ")",

                                breakpoint->address,
                                breakpoint->unique_id);
                        cortex_m_unset_breakpoint(target, breakpoint);
                                breakpoint->address,
                                breakpoint->unique_id);
                        cortex_m_unset_breakpoint(target, breakpoint);


@@ -782,7 +782,7 @@ static int cortex_m_resume(struct target *target, int current,
 
 /* int irqstepcount = 0; */
 static int cortex_m_step(struct target *target, int current,
 
 /* int irqstepcount = 0; */
 static int cortex_m_step(struct target *target, int current,

-       uint32_t address, int handle_breakpoints)
+       target_addr_t address, int handle_breakpoints)

 {
        struct cortex_m_common *cortex_m = target_to_cm(target);
        struct armv7m_common *armv7m = &cortex_m->armv7m;
 {
        struct cortex_m_common *cortex_m = target_to_cm(target);
        struct armv7m_common *armv7m = &cortex_m->armv7m;


@@ -1198,7 +1198,7 @@ int cortex_m_set_breakpoint(struct target *target, struct breakpoint *breakpoint
                breakpoint->set = true;
        }
 
                breakpoint->set = true;
        }
 

-       LOG_DEBUG("BPID: %" PRIu32 ", Type: %d, Address: 0x%08" PRIx32 " Length: %d (set=%d)",
+       LOG_DEBUG("BPID: %" PRIu32 ", Type: %d, Address: " TARGET_ADDR_FMT " Length: %d (set=%d)",

                breakpoint->unique_id,
                (int)(breakpoint->type),
                breakpoint->address,
                breakpoint->unique_id,
                (int)(breakpoint->type),
                breakpoint->address,


@@ -1219,7 +1219,7 @@ int cortex_m_unset_breakpoint(struct target *target, struct breakpoint *breakpoi
                return ERROR_OK;
        }
 
                return ERROR_OK;
        }
 

-       LOG_DEBUG("BPID: %" PRIu32 ", Type: %d, Address: 0x%08" PRIx32 " Length: %d (set=%d)",
+       LOG_DEBUG("BPID: %" PRIu32 ", Type: %d, Address: " TARGET_ADDR_FMT " Length: %d (set=%d)",

                breakpoint->unique_id,
                (int)(breakpoint->type),
                breakpoint->address,
                breakpoint->unique_id,
                (int)(breakpoint->type),
                breakpoint->address,


@@ -1664,7 +1664,7 @@ static int cortex_m_store_core_reg_u32(struct target *target,
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int cortex_m_read_memory(struct target *target, uint32_t address,
+static int cortex_m_read_memory(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct armv7m_common *armv7m = target_to_armv7m(target);
        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct armv7m_common *armv7m = target_to_armv7m(target);


@@ -1678,7 +1678,7 @@ static int cortex_m_read_memory(struct target *target, uint32_t address,
        return mem_ap_read_buf(armv7m->debug_ap, buffer, size, count, address);
 }
 
        return mem_ap_read_buf(armv7m->debug_ap, buffer, size, count, address);
 }
 

-static int cortex_m_write_memory(struct target *target, uint32_t address,
+static int cortex_m_write_memory(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct armv7m_common *armv7m = target_to_armv7m(target);
        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct armv7m_common *armv7m = target_to_armv7m(target);

diff --git a/src/target/dsp563xx.c b/src/target/dsp563xx.c
index 783a0198c6f39f4218c64413cf416d5f8cdc0e88..1d728dff863a2662af050d773caca41811a42721 100644 (file)
--- a/src/target/dsp563xx.c
+++ b/src/target/dsp563xx.c
@@ -1117,7 +1117,7 @@ static int dsp563xx_halt(struct target *target)
 
 static int dsp563xx_resume(struct target *target,
        int current,
 
 static int dsp563xx_resume(struct target *target,
        int current,

-       uint32_t address,
+       target_addr_t address,

        int handle_breakpoints,
        int debug_execution)
 {
        int handle_breakpoints,
        int debug_execution)
 {


@@ -1290,7 +1290,7 @@ static int dsp563xx_step_ex(struct target *target,
 
 static int dsp563xx_step(struct target *target,
        int current,
 
 static int dsp563xx_step(struct target *target,
        int current,

-       uint32_t address,
+       target_addr_t address,

        int handle_breakpoints)
 {
        int err;
        int handle_breakpoints)
 {
        int err;


@@ -1374,7 +1374,7 @@ static int dsp563xx_deassert_reset(struct target *target)
 static int dsp563xx_run_algorithm(struct target *target,
        int num_mem_params, struct mem_param *mem_params,
        int num_reg_params, struct reg_param *reg_params,
 static int dsp563xx_run_algorithm(struct target *target,
        int num_mem_params, struct mem_param *mem_params,
        int num_reg_params, struct reg_param *reg_params,

-       uint32_t entry_point, uint32_t exit_point,
+       target_addr_t entry_point, target_addr_t exit_point,

        int timeout_ms, void *arch_info)
 {
        int i;
        int timeout_ms, void *arch_info)
 {
        int i;


@@ -1592,7 +1592,7 @@ static int dsp563xx_read_memory_core(struct target *target,
 
 static int dsp563xx_read_memory(struct target *target,
        int mem_type,
 
 static int dsp563xx_read_memory(struct target *target,
        int mem_type,

-       uint32_t address,
+       target_addr_t address,

        uint32_t size,
        uint32_t count,
        uint8_t *buffer)
        uint32_t size,
        uint32_t count,
        uint8_t *buffer)


@@ -1660,7 +1660,7 @@ static int dsp563xx_read_memory(struct target *target,
 }
 
 static int dsp563xx_read_memory_default(struct target *target,
 }
 
 static int dsp563xx_read_memory_default(struct target *target,

-       uint32_t address,
+       target_addr_t address,

        uint32_t size,
        uint32_t count,
        uint8_t *buffer)
        uint32_t size,
        uint32_t count,
        uint8_t *buffer)


@@ -1671,7 +1671,7 @@ static int dsp563xx_read_memory_default(struct target *target,
 }
 
 static int dsp563xx_read_buffer_default(struct target *target,
 }
 
 static int dsp563xx_read_buffer_default(struct target *target,

-       uint32_t address,
+       target_addr_t address,

        uint32_t size,
        uint8_t *buffer)
 {
        uint32_t size,
        uint8_t *buffer)
 {


@@ -1682,7 +1682,7 @@ static int dsp563xx_read_buffer_default(struct target *target,
 
 static int dsp563xx_write_memory_core(struct target *target,
        int mem_type,
 
 static int dsp563xx_write_memory_core(struct target *target,
        int mem_type,

-       uint32_t address,
+       target_addr_t address,

        uint32_t size,
        uint32_t count,
        const uint8_t *buffer)
        uint32_t size,
        uint32_t count,
        const uint8_t *buffer)


@@ -1694,7 +1694,7 @@ static int dsp563xx_write_memory_core(struct target *target,
        const uint8_t *b;
 
        LOG_DEBUG(
        const uint8_t *b;
 
        LOG_DEBUG(

-               "memtype: %d address: 0x%8.8" PRIx32 ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32 "",
+               "memtype: %d address: 0x%8.8" TARGET_PRIxADDR ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32 "",

                mem_type,
                address,
                size,
                mem_type,
                address,
                size,


@@ -1766,7 +1766,7 @@ static int dsp563xx_write_memory_core(struct target *target,
 
 static int dsp563xx_write_memory(struct target *target,
        int mem_type,
 
 static int dsp563xx_write_memory(struct target *target,
        int mem_type,

-       uint32_t address,
+       target_addr_t address,

        uint32_t size,
        uint32_t count,
        const uint8_t *buffer)
        uint32_t size,
        uint32_t count,
        const uint8_t *buffer)


@@ -1834,7 +1834,7 @@ static int dsp563xx_write_memory(struct target *target,
 }
 
 static int dsp563xx_write_memory_default(struct target *target,
 }
 
 static int dsp563xx_write_memory_default(struct target *target,

-       uint32_t address,
+       target_addr_t address,

        uint32_t size,
        uint32_t count,
        const uint8_t *buffer)
        uint32_t size,
        uint32_t count,
        const uint8_t *buffer)


@@ -1844,7 +1844,7 @@ static int dsp563xx_write_memory_default(struct target *target,
 }
 
 static int dsp563xx_write_buffer_default(struct target *target,
 }
 
 static int dsp563xx_write_buffer_default(struct target *target,

-       uint32_t address,
+       target_addr_t address,

        uint32_t size,
        const uint8_t *buffer)
 {
        uint32_t size,
        const uint8_t *buffer)
 {

diff --git a/src/target/dsp5680xx.c b/src/target/dsp5680xx.c
index 205d8fe43f903b155807bb0a25aa65b8bb9b3a36..a50f2cd4746b7b95169a60e296ee1437f77ae01a 100644 (file)
--- a/src/target/dsp5680xx.c
+++ b/src/target/dsp5680xx.c
@@ -1011,7 +1011,7 @@ static int dsp5680xx_poll(struct target *target)
 }
 
 static int dsp5680xx_resume(struct target *target, int current,
 }
 
 static int dsp5680xx_resume(struct target *target, int current,

-                           uint32_t address, int hb, int d)
+                           target_addr_t address, int hb, int d)

 {
        if (target->state == TARGET_RUNNING) {
                LOG_USER("Target already running.");
 {
        if (target->state == TARGET_RUNNING) {
                LOG_USER("Target already running.");


@@ -1168,7 +1168,7 @@ static int dsp5680xx_read_32_single(struct target *t, uint32_t a,
        return retval;
 }
 
        return retval;
 }
 

-static int dsp5680xx_read(struct target *t, uint32_t a, uint32_t size,
+static int dsp5680xx_read(struct target *t, target_addr_t a, uint32_t size,

                          uint32_t count, uint8_t *buf)
 {
        struct target *target = t;
                          uint32_t count, uint8_t *buf)
 {
        struct target *target = t;


@@ -1423,7 +1423,7 @@ static int dsp5680xx_write_32(struct target *t, uint32_t a, uint32_t c,
  *
  * @return
  */
  *
  * @return
  */

-static int dsp5680xx_write(struct target *t, uint32_t a, uint32_t s, uint32_t c,
+static int dsp5680xx_write(struct target *t, target_addr_t a, uint32_t s, uint32_t c,

                           const uint8_t *b)
 {
        /* TODO Cannot write 32bit to odd address, will write 0x12345678  as 0x5678 0x0012 */
                           const uint8_t *b)
 {
        /* TODO Cannot write 32bit to odd address, will write 0x12345678  as 0x5678 0x0012 */


@@ -1468,7 +1468,7 @@ static int dsp5680xx_write(struct target *t, uint32_t a, uint32_t s, uint32_t c,
        return retval;
 }
 
        return retval;
 }
 

-static int dsp5680xx_write_buffer(struct target *t, uint32_t a, uint32_t size,
+static int dsp5680xx_write_buffer(struct target *t, target_addr_t a, uint32_t size,

                                  const uint8_t *b)
 {
        check_halt_and_debug(t);
                                  const uint8_t *b)
 {
        check_halt_and_debug(t);


@@ -1485,7 +1485,7 @@ static int dsp5680xx_write_buffer(struct target *t, uint32_t a, uint32_t size,
  *
  * @return
  */
  *
  * @return
  */

-static int dsp5680xx_read_buffer(struct target *t, uint32_t a, uint32_t size,
+static int dsp5680xx_read_buffer(struct target *t, target_addr_t a, uint32_t size,

                                 uint8_t *buf)
 {
        check_halt_and_debug(t);
                                 uint8_t *buf)
 {
        check_halt_and_debug(t);


@@ -1505,7 +1505,7 @@ static int dsp5680xx_read_buffer(struct target *t, uint32_t a, uint32_t size,
  *
  * @return
  */
  *
  * @return
  */

-static int dsp5680xx_checksum_memory(struct target *t, uint32_t a, uint32_t s,
+static int dsp5680xx_checksum_memory(struct target *t, target_addr_t a, uint32_t s,

                                     uint32_t *checksum)
 {
        return ERROR_FAIL;
                                     uint32_t *checksum)
 {
        return ERROR_FAIL;


@@ -2262,7 +2262,7 @@ int dsp5680xx_f_lock(struct target *target)
        return retval;
 }
 
        return retval;
 }
 

-static int dsp5680xx_step(struct target *target, int current, uint32_t address,
+static int dsp5680xx_step(struct target *target, int current, target_addr_t address,

                          int handle_breakpoints)
 {
        err_check(ERROR_FAIL, DSP5680XX_ERROR_NOT_IMPLEMENTED_STEP,
                          int handle_breakpoints)
 {
        err_check(ERROR_FAIL, DSP5680XX_ERROR_NOT_IMPLEMENTED_STEP,

diff --git a/src/target/feroceon.c b/src/target/feroceon.c
index f12e4e450628e1c8e62f73bc11158e333594da5e..6b14ab6a8679eadbb7e2fb24ba38588c7f5c19a7 100644 (file)
--- a/src/target/feroceon.c
+++ b/src/target/feroceon.c
@@ -460,7 +460,7 @@ static int feroceon_examine_debug_reason(struct target *target)
 }
 
 static int feroceon_bulk_write_memory(struct target *target,
 }
 
 static int feroceon_bulk_write_memory(struct target *target,

-               uint32_t address, uint32_t count, const uint8_t *buffer)
+               target_addr_t address, uint32_t count, const uint8_t *buffer)

 {
        int retval;
        struct arm *arm = target->arch_info;
 {
        int retval;
        struct arm *arm = target->arch_info;


@@ -565,7 +565,7 @@ static int feroceon_bulk_write_memory(struct target *target,
                        buf_get_u32(arm->core_cache->reg_list[0].value, 0, 32);
                if (endaddress != address + count*4) {
                        LOG_ERROR("DCC write failed,"
                        buf_get_u32(arm->core_cache->reg_list[0].value, 0, 32);
                if (endaddress != address + count*4) {
                        LOG_ERROR("DCC write failed,"

-                               " expected end address 0x%08" PRIx32
+                               " expected end address 0x%08" TARGET_PRIxADDR

                                " got 0x%0" PRIx32 "",
                                address + count*4, endaddress);
                        retval = ERROR_FAIL;
                                " got 0x%0" PRIx32 "",
                                address + count*4, endaddress);
                        retval = ERROR_FAIL;

diff --git a/src/target/hla_target.c b/src/target/hla_target.c
index feeb11f667c3b2d867967664aae8ba448ea949ed..78dc8c5128228ef12e22c5636eeb80ae28f3d62a 100644 (file)
--- a/src/target/hla_target.c
+++ b/src/target/hla_target.c
@@ -584,7 +584,7 @@ static int adapter_halt(struct target *target)
 }
 
 static int adapter_resume(struct target *target, int current,
 }
 
 static int adapter_resume(struct target *target, int current,

-               uint32_t address, int handle_breakpoints,
+               target_addr_t address, int handle_breakpoints,

                int debug_execution)
 {
        int res;
                int debug_execution)
 {
        int res;


@@ -594,8 +594,8 @@ static int adapter_resume(struct target *target, int current,
        struct breakpoint *breakpoint = NULL;
        struct reg *pc;
 
        struct breakpoint *breakpoint = NULL;
        struct reg *pc;
 

-       LOG_DEBUG("%s %d 0x%08" PRIx32 " %d %d", __func__, current, address,
-                       handle_breakpoints, debug_execution);
+       LOG_DEBUG("%s %d " TARGET_ADDR_FMT " %d %d", __func__, current,
+                       address, handle_breakpoints, debug_execution);

 
        if (target->state != TARGET_HALTED) {
                LOG_WARNING("target not halted");
 
        if (target->state != TARGET_HALTED) {
                LOG_WARNING("target not halted");


@@ -642,7 +642,7 @@ static int adapter_resume(struct target *target, int current,
                /* Single step past breakpoint at current address */
                breakpoint = breakpoint_find(target, resume_pc);
                if (breakpoint) {
                /* Single step past breakpoint at current address */
                breakpoint = breakpoint_find(target, resume_pc);
                if (breakpoint) {

-                       LOG_DEBUG("unset breakpoint at 0x%8.8" PRIx32 " (ID: %" PRIu32 ")",
+                       LOG_DEBUG("unset breakpoint at " TARGET_ADDR_FMT " (ID: %" PRIu32 ")",

                                        breakpoint->address,
                                        breakpoint->unique_id);
                        cortex_m_unset_breakpoint(target, breakpoint);
                                        breakpoint->address,
                                        breakpoint->unique_id);
                        cortex_m_unset_breakpoint(target, breakpoint);


@@ -675,7 +675,7 @@ static int adapter_resume(struct target *target, int current,
 }
 
 static int adapter_step(struct target *target, int current,
 }
 
 static int adapter_step(struct target *target, int current,

-               uint32_t address, int handle_breakpoints)
+               target_addr_t address, int handle_breakpoints)

 {
        int res;
        struct hl_interface_s *adapter = target_to_adapter(target);
 {
        int res;
        struct hl_interface_s *adapter = target_to_adapter(target);


@@ -738,7 +738,7 @@ static int adapter_step(struct target *target, int current,
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int adapter_read_memory(struct target *target, uint32_t address,
+static int adapter_read_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count,
                uint8_t *buffer)
 {
                uint32_t size, uint32_t count,
                uint8_t *buffer)
 {


@@ -747,12 +747,13 @@ static int adapter_read_memory(struct target *target, uint32_t address,
        if (!count || !buffer)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        if (!count || !buffer)
                return ERROR_COMMAND_SYNTAX_ERROR;
 

-       LOG_DEBUG("%s 0x%08" PRIx32 " %" PRIu32 " %" PRIu32, __func__, address, size, count);
+       LOG_DEBUG("%s " TARGET_ADDR_FMT " %" PRIu32 " %" PRIu32,
+                         __func__, address, size, count);

 
        return adapter->layout->api->read_mem(adapter->handle, address, size, count, buffer);
 }
 
 
        return adapter->layout->api->read_mem(adapter->handle, address, size, count, buffer);
 }
 

-static int adapter_write_memory(struct target *target, uint32_t address,
+static int adapter_write_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count,
                const uint8_t *buffer)
 {
                uint32_t size, uint32_t count,
                const uint8_t *buffer)
 {


@@ -761,7 +762,8 @@ static int adapter_write_memory(struct target *target, uint32_t address,
        if (!count || !buffer)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        if (!count || !buffer)
                return ERROR_COMMAND_SYNTAX_ERROR;
 

-       LOG_DEBUG("%s 0x%08" PRIx32 " %" PRIu32 " %" PRIu32, __func__, address, size, count);
+       LOG_DEBUG("%s " TARGET_ADDR_FMT " %" PRIu32 " %" PRIu32,
+                         __func__, address, size, count);

 
        return adapter->layout->api->write_mem(adapter->handle, address, size, count, buffer);
 }
 
        return adapter->layout->api->write_mem(adapter->handle, address, size, count, buffer);
 }

diff --git a/src/target/image.h b/src/target/image.h
index 9bf7af35d82b2947350eb2ce0bce138d67cb4353..9907a5f3fbca180b080d46eae257632b5d4f07a2 100644 (file)
--- a/src/target/image.h
+++ b/src/target/image.h
@@ -46,7 +46,7 @@ enum image_type {
 };
 
 struct imagesection {
 };
 
 struct imagesection {

-       uint32_t base_address;
+       target_addr_t base_address;

        uint32_t size;
        int flags;
        void *private;          /* private data */
        uint32_t size;
        int flags;
        void *private;          /* private data */

diff --git a/src/target/lakemont.c b/src/target/lakemont.c
index 27efc6946b4e20307da5d084fec0a724a93865ec..2bd12fd41ce14b3562dd2c12715ce39d8d4d3577 100644 (file)
--- a/src/target/lakemont.c
+++ b/src/target/lakemont.c
@@ -994,7 +994,7 @@ int lakemont_halt(struct target *t)
        }
 }
 
        }
 }
 

-int lakemont_resume(struct target *t, int current, uint32_t address,
+int lakemont_resume(struct target *t, int current, target_addr_t address,

                        int handle_breakpoints, int debug_execution)
 {
        struct breakpoint *bp = NULL;
                        int handle_breakpoints, int debug_execution)
 {
        struct breakpoint *bp = NULL;


@@ -1036,7 +1036,7 @@ int lakemont_resume(struct target *t, int current, uint32_t address,
 }
 
 int lakemont_step(struct target *t, int current,
 }
 
 int lakemont_step(struct target *t, int current,

-                       uint32_t address, int handle_breakpoints)
+                       target_addr_t address, int handle_breakpoints)

 {
        struct x86_32_common *x86_32 = target_to_x86_32(t);
        uint32_t eflags = buf_get_u32(x86_32->cache->reg_list[EFLAGS].value, 0, 32);
 {
        struct x86_32_common *x86_32 = target_to_x86_32(t);
        uint32_t eflags = buf_get_u32(x86_32->cache->reg_list[EFLAGS].value, 0, 32);

diff --git a/src/target/lakemont.h b/src/target/lakemont.h
index b07a05612f0fb55e28ceec3f17ccba25a105980c..98efd44a996e7cf1e49671a936c228bac4df61c4 100644 (file)
--- a/src/target/lakemont.h
+++ b/src/target/lakemont.h
@@ -95,10 +95,10 @@ int lakemont_init_arch_info(struct target *t, struct x86_32_common *x86_32);
 int lakemont_poll(struct target *t);
 int lakemont_arch_state(struct target *t);
 int lakemont_halt(struct target *t);
 int lakemont_poll(struct target *t);
 int lakemont_arch_state(struct target *t);
 int lakemont_halt(struct target *t);

-int lakemont_resume(struct target *t, int current, uint32_t address,
+int lakemont_resume(struct target *t, int current, target_addr_t address,

                        int handle_breakpoints, int debug_execution);
 int lakemont_step(struct target *t, int current,
                        int handle_breakpoints, int debug_execution);
 int lakemont_step(struct target *t, int current,

-                       uint32_t address, int handle_breakpoints);
+                       target_addr_t address, int handle_breakpoints);

 int lakemont_reset_assert(struct target *t);
 int lakemont_reset_deassert(struct target *t);
 int lakemont_update_after_probemode_entry(struct target *t);
 int lakemont_reset_assert(struct target *t);
 int lakemont_reset_deassert(struct target *t);
 int lakemont_update_after_probemode_entry(struct target *t);

diff --git a/src/target/ls1_sap.c b/src/target/ls1_sap.c
index b4d814bbf5b36ff6cf62bab318f745978c95111a..bc46ed4db814c1f5101d6f0dffa98827a5190378 100644 (file)
--- a/src/target/ls1_sap.c
+++ b/src/target/ls1_sap.c
@@ -64,14 +64,14 @@ static int ls1_sap_halt(struct target *target)
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int ls1_sap_resume(struct target *target, int current, uint32_t address,
+static int ls1_sap_resume(struct target *target, int current, target_addr_t address,

                int handle_breakpoints, int debug_execution)
 {
        LOG_DEBUG("%s", __func__);
        return ERROR_OK;
 }
 
                int handle_breakpoints, int debug_execution)
 {
        LOG_DEBUG("%s", __func__);
        return ERROR_OK;
 }
 

-static int ls1_sap_step(struct target *target, int current, uint32_t address,
+static int ls1_sap_step(struct target *target, int current, target_addr_t address,

                                int handle_breakpoints)
 {
        LOG_DEBUG("%s", __func__);
                                int handle_breakpoints)
 {
        LOG_DEBUG("%s", __func__);


@@ -178,10 +178,10 @@ static void ls1_sap_memory_write(struct jtag_tap *tap, uint32_t size,
        jtag_add_dr_scan(tap, 1, &field, TAP_IDLE);
 }
 
        jtag_add_dr_scan(tap, 1, &field, TAP_IDLE);
 }
 

-static int ls1_sap_read_memory(struct target *target, uint32_t address,
+static int ls1_sap_read_memory(struct target *target, target_addr_t address,

                               uint32_t size, uint32_t count, uint8_t *buffer)
 {
                               uint32_t size, uint32_t count, uint8_t *buffer)
 {

-       LOG_DEBUG("Reading memory at physical address 0x%" PRIx32
+       LOG_DEBUG("Reading memory at physical address 0x%" TARGET_PRIxADDR

                  "; size %" PRId32 "; count %" PRId32, address, size, count);
 
        if (count == 0 || buffer == NULL)
                  "; size %" PRId32 "; count %" PRId32, address, size, count);
 
        if (count == 0 || buffer == NULL)


@@ -199,11 +199,11 @@ static int ls1_sap_read_memory(struct target *target, uint32_t address,
        return jtag_execute_queue();
 }
 
        return jtag_execute_queue();
 }
 

-static int ls1_sap_write_memory(struct target *target, uint32_t address,
+static int ls1_sap_write_memory(struct target *target, target_addr_t address,

                                uint32_t size, uint32_t count,
                                const uint8_t *buffer)
 {
                                uint32_t size, uint32_t count,
                                const uint8_t *buffer)
 {

-       LOG_DEBUG("Writing memory at physical address 0x%" PRIx32
+       LOG_DEBUG("Writing memory at physical address 0x%" TARGET_PRIxADDR

                  "; size %" PRId32 "; count %" PRId32, address, size, count);
 
 
                  "; size %" PRId32 "; count %" PRId32, address, size, count);
 
 

diff --git a/src/target/mips32.c b/src/target/mips32.c
index 27caebee19d7c2b5c9514aa9b4aa0d11c04924c2..cec45499a8564468047a69cca849ce54fa0288c4 100644 (file)
--- a/src/target/mips32.c
+++ b/src/target/mips32.c
@@ -391,8 +391,8 @@ int mips32_init_arch_info(struct target *target, struct mips32_common *mips32, s
 }
 
 /* run to exit point. return error if exit point was not reached. */
 }
 
 /* run to exit point. return error if exit point was not reached. */

-static int mips32_run_and_wait(struct target *target, uint32_t entry_point,
-               int timeout_ms, uint32_t exit_point, struct mips32_common *mips32)
+static int mips32_run_and_wait(struct target *target, target_addr_t entry_point,
+               int timeout_ms, target_addr_t exit_point, struct mips32_common *mips32)

 {
        uint32_t pc;
        int retval;
 {
        uint32_t pc;
        int retval;


@@ -425,8 +425,8 @@ static int mips32_run_and_wait(struct target *target, uint32_t entry_point,
 
 int mips32_run_algorithm(struct target *target, int num_mem_params,
                struct mem_param *mem_params, int num_reg_params,
 
 int mips32_run_algorithm(struct target *target, int num_mem_params,
                struct mem_param *mem_params, int num_reg_params,

-               struct reg_param *reg_params, uint32_t entry_point,
-               uint32_t exit_point, int timeout_ms, void *arch_info)
+               struct reg_param *reg_params, target_addr_t entry_point,
+               target_addr_t exit_point, int timeout_ms, void *arch_info)

 {
        struct mips32_common *mips32 = target_to_mips32(target);
        struct mips32_algorithm *mips32_algorithm_info = arch_info;
 {
        struct mips32_common *mips32 = target_to_mips32(target);
        struct mips32_algorithm *mips32_algorithm_info = arch_info;


@@ -696,7 +696,7 @@ int mips32_enable_interrupts(struct target *target, int enable)
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-int mips32_checksum_memory(struct target *target, uint32_t address,
+int mips32_checksum_memory(struct target *target, target_addr_t address,

                uint32_t count, uint32_t *checksum)
 {
        struct working_area *crc_algorithm;
                uint32_t count, uint32_t *checksum)
 {
        struct working_area *crc_algorithm;


@@ -773,7 +773,7 @@ int mips32_checksum_memory(struct target *target, uint32_t address,
 
 /** Checks whether a memory region is erased. */
 int mips32_blank_check_memory(struct target *target,
 
 /** Checks whether a memory region is erased. */
 int mips32_blank_check_memory(struct target *target,

-               uint32_t address, uint32_t count, uint32_t *blank, uint8_t erased_value)
+               target_addr_t address, uint32_t count, uint32_t *blank, uint8_t erased_value)

 {
        struct working_area *erase_check_algorithm;
        struct reg_param reg_params[3];
 {
        struct working_area *erase_check_algorithm;
        struct reg_param reg_params[3];

diff --git a/src/target/mips32.h b/src/target/mips32.h
index d493b39ed23ec66e237b7d7fbc1352f43ea95824..2e7067fb0871bf31d74845414484558318c5b233 100644 (file)
--- a/src/target/mips32.h
+++ b/src/target/mips32.h
@@ -232,7 +232,7 @@ struct reg_cache *mips32_build_reg_cache(struct target *target);
 int mips32_run_algorithm(struct target *target,
                int num_mem_params, struct mem_param *mem_params,
                int num_reg_params, struct reg_param *reg_params,
 int mips32_run_algorithm(struct target *target,
                int num_mem_params, struct mem_param *mem_params,
                int num_reg_params, struct reg_param *reg_params,

-               uint32_t entry_point, uint32_t exit_point,
+               target_addr_t entry_point, target_addr_t exit_point,

                int timeout_ms, void *arch_info);
 
 int mips32_configure_break_unit(struct target *target);
                int timeout_ms, void *arch_info);
 
 int mips32_configure_break_unit(struct target *target);


@@ -246,9 +246,9 @@ int mips32_register_commands(struct command_context *cmd_ctx);
 int mips32_get_gdb_reg_list(struct target *target,
                struct reg **reg_list[], int *reg_list_size,
                enum target_register_class reg_class);
 int mips32_get_gdb_reg_list(struct target *target,
                struct reg **reg_list[], int *reg_list_size,
                enum target_register_class reg_class);

-int mips32_checksum_memory(struct target *target, uint32_t address,
+int mips32_checksum_memory(struct target *target, target_addr_t address,

                uint32_t count, uint32_t *checksum);
 int mips32_blank_check_memory(struct target *target,
                uint32_t count, uint32_t *checksum);
 int mips32_blank_check_memory(struct target *target,

-               uint32_t address, uint32_t count, uint32_t *blank, uint8_t erased_value);
+               target_addr_t address, uint32_t count, uint32_t *blank, uint8_t erased_value);

 
 #endif /* OPENOCD_TARGET_MIPS32_H */
 
 #endif /* OPENOCD_TARGET_MIPS32_H */

diff --git a/src/target/mips32_pracc.c b/src/target/mips32_pracc.c
index 7cc0424fbd4e74e93cdd51e357307ddf2d61bb1a..5456e8cca27df87495baeee88088c2bf964cf155 100644 (file)
--- a/src/target/mips32_pracc.c
+++ b/src/target/mips32_pracc.c
@@ -1035,7 +1035,7 @@ int mips32_pracc_fastdata_xfer(struct mips_ejtag *ejtag_info, struct working_are
                ejtag_info->fast_access_save = write_t;
        }
 
                ejtag_info->fast_access_save = write_t;
        }
 

-       LOG_DEBUG("%s using 0x%.8" PRIx32 " for write handler", __func__, source->address);
+       LOG_DEBUG("%s using 0x%.8" TARGET_PRIxADDR " for write handler", __func__, source->address);

 
        jmp_code[0] |= UPPER16(source->address);
        jmp_code[1] |= LOWER16(source->address);
 
        jmp_code[0] |= UPPER16(source->address);
        jmp_code[1] |= LOWER16(source->address);

diff --git a/src/target/mips_m4k.c b/src/target/mips_m4k.c
index db69b95b162b2dd261c2705609b85f599de9eb32..bd3c602288a7164f3feb95b2b5f7cab53861b137 100644 (file)
--- a/src/target/mips_m4k.c
+++ b/src/target/mips_m4k.c
@@ -44,7 +44,7 @@ static int mips_m4k_internal_restore(struct target *target, int current,
                uint32_t address, int handle_breakpoints,
                int debug_execution);
 static int mips_m4k_halt(struct target *target);
                uint32_t address, int handle_breakpoints,
                int debug_execution);
 static int mips_m4k_halt(struct target *target);

-static int mips_m4k_bulk_write_memory(struct target *target, uint32_t address,
+static int mips_m4k_bulk_write_memory(struct target *target, target_addr_t address,

                uint32_t count, const uint8_t *buffer);
 
 static int mips_m4k_examine_debug_reason(struct target *target)
                uint32_t count, const uint8_t *buffer);
 
 static int mips_m4k_examine_debug_reason(struct target *target)


@@ -469,7 +469,8 @@ static int mips_m4k_internal_restore(struct target *target, int current,
                /* Single step past breakpoint at current address */
                breakpoint = breakpoint_find(target, resume_pc);
                if (breakpoint) {
                /* Single step past breakpoint at current address */
                breakpoint = breakpoint_find(target, resume_pc);
                if (breakpoint) {

-                       LOG_DEBUG("unset breakpoint at 0x%8.8" PRIx32 "", breakpoint->address);
+                       LOG_DEBUG("unset breakpoint at " TARGET_ADDR_FMT "",
+                                         breakpoint->address);

                        mips_m4k_unset_breakpoint(target, breakpoint);
                        mips_m4k_single_step_core(target);
                        mips_m4k_set_breakpoint(target, breakpoint);
                        mips_m4k_unset_breakpoint(target, breakpoint);
                        mips_m4k_single_step_core(target);
                        mips_m4k_set_breakpoint(target, breakpoint);


@@ -500,7 +501,7 @@ static int mips_m4k_internal_restore(struct target *target, int current,
 }
 
 static int mips_m4k_resume(struct target *target, int current,
 }
 
 static int mips_m4k_resume(struct target *target, int current,

-               uint32_t address, int handle_breakpoints, int debug_execution)
+               target_addr_t address, int handle_breakpoints, int debug_execution)

 {
        int retval = ERROR_OK;
 
 {
        int retval = ERROR_OK;
 


@@ -527,7 +528,7 @@ static int mips_m4k_resume(struct target *target, int current,
 }
 
 static int mips_m4k_step(struct target *target, int current,
 }
 
 static int mips_m4k_step(struct target *target, int current,

-               uint32_t address, int handle_breakpoints)
+               target_addr_t address, int handle_breakpoints)

 {
        /* get pointers to arch-specific information */
        struct mips32_common *mips32 = target_to_mips32(target);
 {
        /* get pointers to arch-specific information */
        struct mips32_common *mips32 = target_to_mips32(target);


@@ -655,7 +656,7 @@ static int mips_m4k_set_breakpoint(struct target *target,
                        if (retval != ERROR_OK)
                                return retval;
                        if (verify != MIPS32_SDBBP) {
                        if (retval != ERROR_OK)
                                return retval;
                        if (verify != MIPS32_SDBBP) {

-                               LOG_ERROR("Unable to set 32bit breakpoint at address %08" PRIx32
+                               LOG_ERROR("Unable to set 32-bit breakpoint at address " TARGET_ADDR_FMT

                                                " - check that memory is read/writable", breakpoint->address);
                                return ERROR_OK;
                        }
                                                " - check that memory is read/writable", breakpoint->address);
                                return ERROR_OK;
                        }


@@ -674,7 +675,7 @@ static int mips_m4k_set_breakpoint(struct target *target,
                        if (retval != ERROR_OK)
                                return retval;
                        if (verify != MIPS16_SDBBP) {
                        if (retval != ERROR_OK)
                                return retval;
                        if (verify != MIPS16_SDBBP) {

-                               LOG_ERROR("Unable to set 16bit breakpoint at address %08" PRIx32
+                               LOG_ERROR("Unable to set 16-bit breakpoint at address " TARGET_ADDR_FMT

                                                " - check that memory is read/writable", breakpoint->address);
                                return ERROR_OK;
                        }
                                                " - check that memory is read/writable", breakpoint->address);
                                return ERROR_OK;
                        }


@@ -949,13 +950,13 @@ static void mips_m4k_enable_watchpoints(struct target *target)
        }
 }
 
        }
 }
 

-static int mips_m4k_read_memory(struct target *target, uint32_t address,
+static int mips_m4k_read_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct mips32_common *mips32 = target_to_mips32(target);
        struct mips_ejtag *ejtag_info = &mips32->ejtag_info;
 
                uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct mips32_common *mips32 = target_to_mips32(target);
        struct mips_ejtag *ejtag_info = &mips32->ejtag_info;
 

-       LOG_DEBUG("address: 0x%8.8" PRIx32 ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32 "",
+       LOG_DEBUG("address: " TARGET_ADDR_FMT ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32 "",

                        address, size, count);
 
        if (target->state != TARGET_HALTED) {
                        address, size, count);
 
        if (target->state != TARGET_HALTED) {


@@ -1008,13 +1009,13 @@ static int mips_m4k_read_memory(struct target *target, uint32_t address,
        return retval;
 }
 
        return retval;
 }
 

-static int mips_m4k_write_memory(struct target *target, uint32_t address,
+static int mips_m4k_write_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct mips32_common *mips32 = target_to_mips32(target);
        struct mips_ejtag *ejtag_info = &mips32->ejtag_info;
 
                uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct mips32_common *mips32 = target_to_mips32(target);
        struct mips_ejtag *ejtag_info = &mips32->ejtag_info;
 

-       LOG_DEBUG("address: 0x%8.8" PRIx32 ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32 "",
+       LOG_DEBUG("address: " TARGET_ADDR_FMT ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32 "",

                        address, size, count);
 
        if (target->state != TARGET_HALTED) {
                        address, size, count);
 
        if (target->state != TARGET_HALTED) {


@@ -1139,7 +1140,7 @@ static int mips_m4k_examine(struct target *target)
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int mips_m4k_bulk_write_memory(struct target *target, uint32_t address,
+static int mips_m4k_bulk_write_memory(struct target *target, target_addr_t address,

                uint32_t count, const uint8_t *buffer)
 {
        struct mips32_common *mips32 = target_to_mips32(target);
                uint32_t count, const uint8_t *buffer)
 {
        struct mips32_common *mips32 = target_to_mips32(target);


@@ -1148,7 +1149,8 @@ static int mips_m4k_bulk_write_memory(struct target *target, uint32_t address,
        int retval;
        int write_t = 1;
 
        int retval;
        int write_t = 1;
 

-       LOG_DEBUG("address: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32 "", address, count);
+       LOG_DEBUG("address: " TARGET_ADDR_FMT ", count: 0x%8.8" PRIx32 "",
+                         address, count);

 
        /* check alignment */
        if (address & 0x3u)
 
        /* check alignment */
        if (address & 0x3u)


@@ -1175,8 +1177,8 @@ static int mips_m4k_bulk_write_memory(struct target *target, uint32_t address,
 
        if (address <= fast_data_area->address + fast_data_area->size &&
                        fast_data_area->address <= address + count) {
 
        if (address <= fast_data_area->address + fast_data_area->size &&
                        fast_data_area->address <= address + count) {

-               LOG_ERROR("fast_data (0x%8.8" PRIx32 ") is within write area "
-                         "(0x%8.8" PRIx32 "-0x%8.8" PRIx32 ").",
+               LOG_ERROR("fast_data (" TARGET_ADDR_FMT ") is within write area "
+                         "(" TARGET_ADDR_FMT "-" TARGET_ADDR_FMT ").",

                          fast_data_area->address, address, address + count);
                LOG_ERROR("Change work-area-phys or load_image address!");
                return ERROR_FAIL;
                          fast_data_area->address, address, address + count);
                LOG_ERROR("Change work-area-phys or load_image address!");
                return ERROR_FAIL;

diff --git a/src/target/nds32.c b/src/target/nds32.c
index 2926b236778d20f3c1bb4a2858466d7a871081c1..e4bb17f9df278bd736ded0f78c1086476bc01d24 100644 (file)
--- a/src/target/nds32.c
+++ b/src/target/nds32.c
@@ -823,7 +823,7 @@ int nds32_read_memory(struct target *target, uint32_t address,
        return aice_read_mem_unit(aice, address, size, count, buffer);
 }
 
        return aice_read_mem_unit(aice, address, size, count, buffer);
 }
 

-int nds32_read_phys_memory(struct target *target, uint32_t address,
+int nds32_read_phys_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct aice_port_s *aice = target_to_aice(target);
                uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct aice_port_s *aice = target_to_aice(target);


@@ -932,7 +932,7 @@ int nds32_write_memory(struct target *target, uint32_t address,
        return aice_write_mem_unit(aice, address, size, count, buffer);
 }
 
        return aice_write_mem_unit(aice, address, size, count, buffer);
 }
 

-int nds32_write_phys_memory(struct target *target, uint32_t address,
+int nds32_write_phys_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct aice_port_s *aice = target_to_aice(target);
                uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct aice_port_s *aice = target_to_aice(target);


@@ -1674,7 +1674,7 @@ int nds32_init_arch_info(struct target *target, struct nds32 *nds32)
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-int nds32_virtual_to_physical(struct target *target, uint32_t address, uint32_t *physical)
+int nds32_virtual_to_physical(struct target *target, target_addr_t address, target_addr_t *physical)

 {
        struct nds32 *nds32 = target_to_nds32(target);
 
 {
        struct nds32 *nds32 = target_to_nds32(target);
 


@@ -1692,7 +1692,7 @@ int nds32_virtual_to_physical(struct target *target, uint32_t address, uint32_t
        return ERROR_FAIL;
 }
 
        return ERROR_FAIL;
 }
 

-int nds32_cache_sync(struct target *target, uint32_t address, uint32_t length)
+int nds32_cache_sync(struct target *target, target_addr_t address, uint32_t length)

 {
        struct aice_port_s *aice = target_to_aice(target);
        struct nds32 *nds32 = target_to_nds32(target);
 {
        struct aice_port_s *aice = target_to_aice(target);
        struct nds32 *nds32 = target_to_nds32(target);


@@ -1738,7 +1738,7 @@ int nds32_cache_sync(struct target *target, uint32_t address, uint32_t length)
                        /* Because PSW.IT is turned off under debug exception, address MUST
                         * be physical address.  L1I_VA_INVALIDATE uses PSW.IT to decide
                         * address translation or not. */
                        /* Because PSW.IT is turned off under debug exception, address MUST
                         * be physical address.  L1I_VA_INVALIDATE uses PSW.IT to decide
                         * address translation or not. */

-                       uint32_t physical_addr;
+                       target_addr_t physical_addr;

                        if (ERROR_FAIL == target->type->virt2phys(target, cur_address,
                                                &physical_addr))
                                return ERROR_FAIL;
                        if (ERROR_FAIL == target->type->virt2phys(target, cur_address,
                                                &physical_addr))
                                return ERROR_FAIL;


@@ -1764,7 +1764,7 @@ uint32_t nds32_nextpc(struct nds32 *nds32, int current, uint32_t address)
 }
 
 int nds32_step(struct target *target, int current,
 }
 
 int nds32_step(struct target *target, int current,

-               uint32_t address, int handle_breakpoints)
+               target_addr_t address, int handle_breakpoints)

 {
        LOG_DEBUG("target->state: %s",
                        target_state_name(target));
 {
        LOG_DEBUG("target->state: %s",
                        target_state_name(target));


@@ -1778,7 +1778,7 @@ int nds32_step(struct target *target, int current,
 
        address = nds32_nextpc(nds32, current, address);
 
 
        address = nds32_nextpc(nds32, current, address);
 

-       LOG_DEBUG("STEP PC %08" PRIx32 "%s", address, !current ? "!" : "");
+       LOG_DEBUG("STEP PC %08" TARGET_PRIxADDR "%s", address, !current ? "!" : "");

 
        /** set DSSIM */
        uint32_t ir14_value;
 
        /** set DSSIM */
        uint32_t ir14_value;


@@ -2120,9 +2120,9 @@ int nds32_poll(struct target *target)
 }
 
 int nds32_resume(struct target *target, int current,
 }
 
 int nds32_resume(struct target *target, int current,

-               uint32_t address, int handle_breakpoints, int debug_execution)
+               target_addr_t address, int handle_breakpoints, int debug_execution)

 {
 {

-       LOG_DEBUG("current %d address %08" PRIx32
+       LOG_DEBUG("current %d address %08" TARGET_PRIxADDR

                        " handle_breakpoints %d"
                        " debug_execution %d",
                        current, address, handle_breakpoints, debug_execution);
                        " handle_breakpoints %d"
                        " debug_execution %d",
                        current, address, handle_breakpoints, debug_execution);


@@ -2136,7 +2136,7 @@ int nds32_resume(struct target *target, int current,
 
        address = nds32_nextpc(nds32, current, address);
 
 
        address = nds32_nextpc(nds32, current, address);
 

-       LOG_DEBUG("RESUME PC %08" PRIx32 "%s", address, !current ? "!" : "");
+       LOG_DEBUG("RESUME PC %08" TARGET_PRIxADDR "%s", address, !current ? "!" : "");

 
        if (!debug_execution)
                target_free_all_working_areas(target);
 
        if (!debug_execution)
                target_free_all_working_areas(target);

diff --git a/src/target/nds32.h b/src/target/nds32.h
index 88af4f3aa8b1687a2fbbe1dd3be42e45273530d7..141dbf4cb9bd10c2497a58173df8ff0bddbef1b9 100644 (file)
--- a/src/target/nds32.h
+++ b/src/target/nds32.h
@@ -400,23 +400,23 @@ extern int nds32_get_mapped_reg(struct nds32 *nds32, unsigned regnum, uint32_t *
 extern int nds32_set_mapped_reg(struct nds32 *nds32, unsigned regnum, uint32_t value);
 
 extern int nds32_edm_config(struct nds32 *nds32);
 extern int nds32_set_mapped_reg(struct nds32 *nds32, unsigned regnum, uint32_t value);
 
 extern int nds32_edm_config(struct nds32 *nds32);

-extern int nds32_cache_sync(struct target *target, uint32_t address, uint32_t length);
+extern int nds32_cache_sync(struct target *target, target_addr_t address, uint32_t length);

 extern int nds32_mmu(struct target *target, int *enabled);
 extern int nds32_mmu(struct target *target, int *enabled);

-extern int nds32_virtual_to_physical(struct target *target, uint32_t address,
-               uint32_t *physical);
-extern int nds32_read_phys_memory(struct target *target, uint32_t address,
+extern int nds32_virtual_to_physical(struct target *target, target_addr_t address,
+               target_addr_t *physical);
+extern int nds32_read_phys_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, uint8_t *buffer);
                uint32_t size, uint32_t count, uint8_t *buffer);

-extern int nds32_write_phys_memory(struct target *target, uint32_t address,
+extern int nds32_write_phys_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, const uint8_t *buffer);
 extern uint32_t nds32_nextpc(struct nds32 *nds32, int current, uint32_t address);
 extern int nds32_examine_debug_reason(struct nds32 *nds32);
 extern int nds32_step(struct target *target, int current,
                uint32_t size, uint32_t count, const uint8_t *buffer);
 extern uint32_t nds32_nextpc(struct nds32 *nds32, int current, uint32_t address);
 extern int nds32_examine_debug_reason(struct nds32 *nds32);
 extern int nds32_step(struct target *target, int current,

-               uint32_t address, int handle_breakpoints);
+               target_addr_t address, int handle_breakpoints);

 extern int nds32_target_state(struct nds32 *nds32, enum target_state *state);
 extern int nds32_halt(struct target *target);
 extern int nds32_poll(struct target *target);
 extern int nds32_resume(struct target *target, int current,
 extern int nds32_target_state(struct nds32 *nds32, enum target_state *state);
 extern int nds32_halt(struct target *target);
 extern int nds32_poll(struct target *target);
 extern int nds32_resume(struct target *target, int current,

-               uint32_t address, int handle_breakpoints, int debug_execution);
+               target_addr_t address, int handle_breakpoints, int debug_execution);

 extern int nds32_assert_reset(struct target *target);
 extern int nds32_init(struct nds32 *nds32);
 extern int nds32_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fileio_info);
 extern int nds32_assert_reset(struct target *target);
 extern int nds32_init(struct nds32 *nds32);
 extern int nds32_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fileio_info);

diff --git a/src/target/nds32_aice.c b/src/target/nds32_aice.c
index bdfafb53a0ebdec9e776696d02cd34bd8d8b77a5..e494a3e1cd42cc055eed10ea6abeb917d83b4163 100644 (file)
--- a/src/target/nds32_aice.c
+++ b/src/target/nds32_aice.c
@@ -42,8 +42,8 @@ int aice_write_reg_64(struct aice_port_s *aice, uint32_t num, uint64_t val)
        return aice->port->api->write_reg_64(aice->coreid, num, val);
 }
 
        return aice->port->api->write_reg_64(aice->coreid, num, val);
 }
 

-int aice_read_tlb(struct aice_port_s *aice, uint32_t virtual_address,
-               uint32_t *physical_address)
+int aice_read_tlb(struct aice_port_s *aice, target_addr_t virtual_address,
+               target_addr_t *physical_address)

 {
        if (aice->port->api->read_tlb == NULL) {
                LOG_WARNING("Not implemented: %s", __func__);
 {
        if (aice->port->api->read_tlb == NULL) {
                LOG_WARNING("Not implemented: %s", __func__);

diff --git a/src/target/nds32_aice.h b/src/target/nds32_aice.h
index ae801ed31d5daf3700223c83e6a2dbb1bb6869b9..5ea3b1611b6534ca24095c6ae3ac4c415be12535 100644 (file)
--- a/src/target/nds32_aice.h
+++ b/src/target/nds32_aice.h
@@ -23,8 +23,8 @@
 
 int aice_read_reg_64(struct aice_port_s *aice, uint32_t num, uint64_t *val);
 int aice_write_reg_64(struct aice_port_s *aice, uint32_t num, uint64_t val);
 
 int aice_read_reg_64(struct aice_port_s *aice, uint32_t num, uint64_t *val);
 int aice_write_reg_64(struct aice_port_s *aice, uint32_t num, uint64_t val);

-int aice_read_tlb(struct aice_port_s *aice, uint32_t virtual_address,
-               uint32_t *physical_address);
+int aice_read_tlb(struct aice_port_s *aice, target_addr_t virtual_address,
+               target_addr_t *physical_address);

 int aice_cache_ctl(struct aice_port_s *aice, uint32_t subtype, uint32_t address);
 int aice_set_retry_times(struct aice_port_s *aice, uint32_t a_retry_times);
 int aice_program_edm(struct aice_port_s *aice, char *command_sequence);
 int aice_cache_ctl(struct aice_port_s *aice, uint32_t subtype, uint32_t address);
 int aice_set_retry_times(struct aice_port_s *aice, uint32_t a_retry_times);
 int aice_program_edm(struct aice_port_s *aice, char *command_sequence);

diff --git a/src/target/nds32_tlb.c b/src/target/nds32_tlb.c
index 6a91a0f88567f56c19ac382f4617f584ec39da62..c4bce1a6a2a619468fd3522b3cf65329c72d728a 100644 (file)
--- a/src/target/nds32_tlb.c
+++ b/src/target/nds32_tlb.c
@@ -22,8 +22,8 @@
 #include "nds32_aice.h"
 #include "nds32_tlb.h"
 
 #include "nds32_aice.h"
 #include "nds32_tlb.h"
 

-int nds32_probe_tlb(struct nds32 *nds32, const uint32_t virtual_address,
-               uint32_t *physical_address)
+int nds32_probe_tlb(struct nds32 *nds32, const target_addr_t virtual_address,
+               target_addr_t *physical_address)

 {
        struct target *target = nds32->target;
        struct aice_port_s *aice = target_to_aice(target);
 {
        struct target *target = nds32->target;
        struct aice_port_s *aice = target_to_aice(target);


@@ -38,8 +38,8 @@ struct page_table_walker_info_s page_table_info[PAGE_SIZE_NUM] = {
        {0xFF000000, 22, 0x00FFE000, 11, 0x00001FFF, 0xFFFFF000, 0xFFFFE000, 0xFFFFE000},
 };
 
        {0xFF000000, 22, 0x00FFE000, 11, 0x00001FFF, 0xFFFFF000, 0xFFFFE000, 0xFFFFE000},
 };
 

-int nds32_walk_page_table(struct nds32 *nds32, const uint32_t virtual_address,
-               uint32_t *physical_address)
+int nds32_walk_page_table(struct nds32 *nds32, const target_addr_t virtual_address,
+               target_addr_t *physical_address)

 {
        struct target *target = nds32->target;
        uint32_t value_mr1;
 {
        struct target *target = nds32->target;
        uint32_t value_mr1;

diff --git a/src/target/nds32_tlb.h b/src/target/nds32_tlb.h
index ada2c198bd05f4dce22861f53cc2b6e4f67e6259..62512c11140dd92d6b9fe38d3d00aa22a02fa798 100644 (file)
--- a/src/target/nds32_tlb.h
+++ b/src/target/nds32_tlb.h
@@ -39,9 +39,9 @@ struct page_table_walker_info_s {
        uint32_t ppn_mask;
 };
 
        uint32_t ppn_mask;
 };
 

-extern int nds32_probe_tlb(struct nds32 *nds32, const uint32_t virtual_address,
-               uint32_t *physical_address);
-extern int nds32_walk_page_table(struct nds32 *nds32, const uint32_t virtual_address,
-               uint32_t *physical_address);
+extern int nds32_probe_tlb(struct nds32 *nds32, const target_addr_t virtual_address,
+               target_addr_t *physical_address);
+extern int nds32_walk_page_table(struct nds32 *nds32, const target_addr_t virtual_address,
+               target_addr_t *physical_address);

 
 #endif /* OPENOCD_TARGET_NDS32_TLB_H */
 
 #endif /* OPENOCD_TARGET_NDS32_TLB_H */

diff --git a/src/target/nds32_v2.c b/src/target/nds32_v2.c
index 4497551afa4baa3e5271c4f17dda1e89f6124641..29489a0341c6ff707eb1e2420c46868eaf495acb 100644 (file)
--- a/src/target/nds32_v2.c
+++ b/src/target/nds32_v2.c
@@ -112,7 +112,7 @@ static int nds32_v2_activate_hardware_breakpoint(struct target *target)
                                /* enable breakpoint (physical address) */
                                aice_write_debug_reg(aice, NDS_EDM_SR_BPC0 + hbr_index, 0xA);
 
                                /* enable breakpoint (physical address) */
                                aice_write_debug_reg(aice, NDS_EDM_SR_BPC0 + hbr_index, 0xA);
 

-                       LOG_DEBUG("Add hardware BP %" PRId32 " at %08" PRIx32, hbr_index,
+                       LOG_DEBUG("Add hardware BP %" PRId32 " at %08" TARGET_PRIxADDR, hbr_index,

                                        bp->address);
 
                        hbr_index++;
                                        bp->address);
 
                        hbr_index++;


@@ -139,7 +139,7 @@ static int nds32_v2_deactivate_hardware_breakpoint(struct target *target)
                else
                        return ERROR_FAIL;
 
                else
                        return ERROR_FAIL;
 

-               LOG_DEBUG("Remove hardware BP %" PRId32 " at %08" PRIx32, hbr_index,
+               LOG_DEBUG("Remove hardware BP %" PRId32 " at %08" TARGET_PRIxADDR, hbr_index,

                                bp->address);
 
                hbr_index++;
                                bp->address);
 
                hbr_index++;


@@ -184,7 +184,7 @@ static int nds32_v2_activate_hardware_watchpoint(struct target *target)
                /* set value */
                aice_write_debug_reg(aice, NDS_EDM_SR_BPV0 + wp_num, 0);
 
                /* set value */
                aice_write_debug_reg(aice, NDS_EDM_SR_BPV0 + wp_num, 0);
 

-               LOG_DEBUG("Add hardware watchpoint %" PRId32 " at %08" PRIx32 " mask %08" PRIx32, wp_num,
+               LOG_DEBUG("Add hardware watchpoint %" PRId32 " at %08" TARGET_PRIxADDR " mask %08" PRIx32, wp_num,

                                wp->address, wp->mask);
 
        }
                                wp->address, wp->mask);
 
        }


@@ -204,7 +204,7 @@ static int nds32_v2_deactivate_hardware_watchpoint(struct target *target)
                /* disable watchpoint */
                aice_write_debug_reg(aice, NDS_EDM_SR_BPC0 + wp_num, 0x0);
 
                /* disable watchpoint */
                aice_write_debug_reg(aice, NDS_EDM_SR_BPC0 + wp_num, 0x0);
 

-               LOG_DEBUG("Remove hardware watchpoint %" PRId32 " at %08" PRIx32 " mask %08" PRIx32,
+               LOG_DEBUG("Remove hardware watchpoint %" PRId32 " at %08" TARGET_PRIxADDR " mask %08" PRIx32,

                                wp_num, wp->address, wp->mask);
        }
 
                                wp_num, wp->address, wp->mask);
        }
 


@@ -405,7 +405,7 @@ static int nds32_v2_deassert_reset(struct target *target)
 }
 
 static int nds32_v2_checksum_memory(struct target *target,
 }
 
 static int nds32_v2_checksum_memory(struct target *target,

-               uint32_t address, uint32_t count, uint32_t *checksum)
+               target_addr_t address, uint32_t count, uint32_t *checksum)

 {
        LOG_WARNING("Not implemented: %s", __func__);
 
 {
        LOG_WARNING("Not implemented: %s", __func__);
 


@@ -561,8 +561,8 @@ static int nds32_v2_run_algorithm(struct target *target,
                struct mem_param *mem_params,
                int num_reg_params,
                struct reg_param *reg_params,
                struct mem_param *mem_params,
                int num_reg_params,
                struct reg_param *reg_params,

-               uint32_t entry_point,
-               uint32_t exit_point,
+               target_addr_t entry_point,
+               target_addr_t exit_point,

                int timeout_ms,
                void *arch_info)
 {
                int timeout_ms,
                void *arch_info)
 {


@@ -635,11 +635,11 @@ static int nds32_v2_examine(struct target *target)
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int nds32_v2_translate_address(struct target *target, uint32_t *address)
+static int nds32_v2_translate_address(struct target *target, target_addr_t *address)

 {
        struct nds32 *nds32 = target_to_nds32(target);
        struct nds32_memory *memory = &(nds32->memory);
 {
        struct nds32 *nds32 = target_to_nds32(target);
        struct nds32_memory *memory = &(nds32->memory);

-       uint32_t physical_address;
+       target_addr_t physical_address;

 
        /* Following conditions need to do address translation
         * 1. BUS mode
 
        /* Following conditions need to do address translation
         * 1. BUS mode


@@ -656,7 +656,7 @@ static int nds32_v2_translate_address(struct target *target, uint32_t *address)
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int nds32_v2_read_buffer(struct target *target, uint32_t address,
+static int nds32_v2_read_buffer(struct target *target, target_addr_t address,

                uint32_t size, uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);
                uint32_t size, uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);


@@ -676,7 +676,7 @@ static int nds32_v2_read_buffer(struct target *target, uint32_t address,
        return nds32_read_buffer(target, address, size, buffer);
 }
 
        return nds32_read_buffer(target, address, size, buffer);
 }
 

-static int nds32_v2_write_buffer(struct target *target, uint32_t address,
+static int nds32_v2_write_buffer(struct target *target, target_addr_t address,

                uint32_t size, const uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);
                uint32_t size, const uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);


@@ -696,7 +696,7 @@ static int nds32_v2_write_buffer(struct target *target, uint32_t address,
        return nds32_write_buffer(target, address, size, buffer);
 }
 
        return nds32_write_buffer(target, address, size, buffer);
 }
 

-static int nds32_v2_read_memory(struct target *target, uint32_t address,
+static int nds32_v2_read_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);
                uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);


@@ -716,7 +716,7 @@ static int nds32_v2_read_memory(struct target *target, uint32_t address,
        return nds32_read_memory(target, address, size, count, buffer);
 }
 
        return nds32_read_memory(target, address, size, count, buffer);
 }
 

-static int nds32_v2_write_memory(struct target *target, uint32_t address,
+static int nds32_v2_write_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);
                uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);

diff --git a/src/target/nds32_v3.c b/src/target/nds32_v3.c
index 35b72e3d593475ada37f95cf5ee6363113e55841..e5d146bb6a639ba07778ba60aa6512de8028ad34 100644 (file)
--- a/src/target/nds32_v3.c
+++ b/src/target/nds32_v3.c
@@ -53,7 +53,7 @@ static int nds32_v3_activate_hardware_breakpoint(struct target *target)
                                /* enable breakpoint (physical address) */
                                aice_write_debug_reg(aice, NDS_EDM_SR_BPC0 + hbr_index, 0xA);
 
                                /* enable breakpoint (physical address) */
                                aice_write_debug_reg(aice, NDS_EDM_SR_BPC0 + hbr_index, 0xA);
 

-                       LOG_DEBUG("Add hardware BP %" PRId32 " at %08" PRIx32, hbr_index,
+                       LOG_DEBUG("Add hardware BP %" PRId32 " at %08" TARGET_PRIxADDR, hbr_index,

                                        bp->address);
                } else {
                        return ERROR_FAIL;
                                        bp->address);
                } else {
                        return ERROR_FAIL;


@@ -81,7 +81,7 @@ static int nds32_v3_deactivate_hardware_breakpoint(struct target *target)
                        return ERROR_FAIL;
                }
 
                        return ERROR_FAIL;
                }
 

-               LOG_DEBUG("Remove hardware BP %" PRId32 " at %08" PRIx32, hbr_index,
+               LOG_DEBUG("Remove hardware BP %" PRId32 " at %08" TARGET_PRIxADDR, hbr_index,

                                bp->address);
        }
 
                                bp->address);
        }
 


@@ -128,7 +128,7 @@ static int nds32_v3_activate_hardware_watchpoint(struct target *target)
                        /* set value */
                        aice_write_debug_reg(aice, NDS_EDM_SR_BPV0 + wp_num, 0);
 
                        /* set value */
                        aice_write_debug_reg(aice, NDS_EDM_SR_BPV0 + wp_num, 0);
 

-                       LOG_DEBUG("Add hardware watchpoint %" PRId32 " at %08" PRIx32 " mask %08" PRIx32,
+                       LOG_DEBUG("Add hardware watchpoint %" PRId32 " at %08" TARGET_PRIxADDR " mask %08" PRIx32,

                                        wp_num, wp->address, wp->mask);
 
                        wp_num++;
                                        wp_num, wp->address, wp->mask);
 
                        wp_num++;


@@ -169,7 +169,7 @@ static int nds32_v3_deactivate_hardware_watchpoint(struct target *target)
                        /* disable watchpoint */
                        aice_write_debug_reg(aice, NDS_EDM_SR_BPC0 + wp_num, 0x0);
 
                        /* disable watchpoint */
                        aice_write_debug_reg(aice, NDS_EDM_SR_BPC0 + wp_num, 0x0);
 

-                       LOG_DEBUG("Remove hardware watchpoint %" PRId32 " at %08" PRIx32
+                       LOG_DEBUG("Remove hardware watchpoint %" PRId32 " at %08" TARGET_PRIxADDR

                                        " mask %08" PRIx32, wp_num,
                                        wp->address, wp->mask);
                        wp_num++;
                                        " mask %08" PRIx32, wp_num,
                                        wp->address, wp->mask);
                        wp_num++;

diff --git a/src/target/nds32_v3_common.c b/src/target/nds32_v3_common.c
index 191f4b5cc1b63c9d8b1fb8e664028af412357c13..271ffdd1cebdcc33dfa9bb700f337a420ac4d687 100644 (file)
--- a/src/target/nds32_v3_common.c
+++ b/src/target/nds32_v3_common.c
@@ -368,7 +368,7 @@ int nds32_v3_target_request_data(struct target *target,
 }
 
 int nds32_v3_checksum_memory(struct target *target,
 }
 
 int nds32_v3_checksum_memory(struct target *target,

-               uint32_t address, uint32_t count, uint32_t *checksum)
+               target_addr_t address, uint32_t count, uint32_t *checksum)

 {
        LOG_WARNING("Not implemented: %s", __func__);
 
 {
        LOG_WARNING("Not implemented: %s", __func__);
 


@@ -434,8 +434,8 @@ int nds32_v3_run_algorithm(struct target *target,
                struct mem_param *mem_params,
                int num_reg_params,
                struct reg_param *reg_params,
                struct mem_param *mem_params,
                int num_reg_params,
                struct reg_param *reg_params,

-               uint32_t entry_point,
-               uint32_t exit_point,
+               target_addr_t entry_point,
+               target_addr_t exit_point,

                int timeout_ms,
                void *arch_info)
 {
                int timeout_ms,
                void *arch_info)
 {


@@ -444,7 +444,7 @@ int nds32_v3_run_algorithm(struct target *target,
        return ERROR_FAIL;
 }
 
        return ERROR_FAIL;
 }
 

-int nds32_v3_read_buffer(struct target *target, uint32_t address,
+int nds32_v3_read_buffer(struct target *target, target_addr_t address,

                uint32_t size, uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);
                uint32_t size, uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);


@@ -456,7 +456,7 @@ int nds32_v3_read_buffer(struct target *target, uint32_t address,
                return ERROR_TARGET_NOT_HALTED;
        }
 
                return ERROR_TARGET_NOT_HALTED;
        }
 

-       uint32_t physical_address;
+       target_addr_t physical_address;

        /* BUG: If access range crosses multiple pages, the translation will not correct
         * for second page or so. */
 
        /* BUG: If access range crosses multiple pages, the translation will not correct
         * for second page or so. */
 


@@ -502,7 +502,7 @@ int nds32_v3_read_buffer(struct target *target, uint32_t address,
        return result;
 }
 
        return result;
 }
 

-int nds32_v3_write_buffer(struct target *target, uint32_t address,
+int nds32_v3_write_buffer(struct target *target, target_addr_t address,

                uint32_t size, const uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);
                uint32_t size, const uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);


@@ -514,7 +514,7 @@ int nds32_v3_write_buffer(struct target *target, uint32_t address,
                return ERROR_TARGET_NOT_HALTED;
        }
 
                return ERROR_TARGET_NOT_HALTED;
        }
 

-       uint32_t physical_address;
+       target_addr_t physical_address;

        /* BUG: If access range crosses multiple pages, the translation will not correct
         * for second page or so. */
 
        /* BUG: If access range crosses multiple pages, the translation will not correct
         * for second page or so. */
 


@@ -564,7 +564,7 @@ int nds32_v3_write_buffer(struct target *target, uint32_t address,
        return nds32_write_buffer(target, address, size, buffer);
 }
 
        return nds32_write_buffer(target, address, size, buffer);
 }
 

-int nds32_v3_read_memory(struct target *target, uint32_t address,
+int nds32_v3_read_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);
                uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);


@@ -576,7 +576,7 @@ int nds32_v3_read_memory(struct target *target, uint32_t address,
                return ERROR_TARGET_NOT_HALTED;
        }
 
                return ERROR_TARGET_NOT_HALTED;
        }
 

-       uint32_t physical_address;
+       target_addr_t physical_address;

        /* BUG: If access range crosses multiple pages, the translation will not correct
         * for second page or so. */
 
        /* BUG: If access range crosses multiple pages, the translation will not correct
         * for second page or so. */
 


@@ -622,7 +622,7 @@ int nds32_v3_read_memory(struct target *target, uint32_t address,
        return result;
 }
 
        return result;
 }
 

-int nds32_v3_write_memory(struct target *target, uint32_t address,
+int nds32_v3_write_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);
                uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct nds32 *nds32 = target_to_nds32(target);


@@ -634,7 +634,7 @@ int nds32_v3_write_memory(struct target *target, uint32_t address,
                return ERROR_TARGET_NOT_HALTED;
        }
 
                return ERROR_TARGET_NOT_HALTED;
        }
 

-       uint32_t physical_address;
+       target_addr_t physical_address;

        /* BUG: If access range crosses multiple pages, the translation will not correct
         * for second page or so. */
 
        /* BUG: If access range crosses multiple pages, the translation will not correct
         * for second page or so. */
 

diff --git a/src/target/nds32_v3_common.h b/src/target/nds32_v3_common.h
index 1f5df19957bdb47f594a716356bdf79e0d931804..23393e55d25b0679aa558f0046c4e8a7333dd816 100644 (file)
--- a/src/target/nds32_v3_common.h
+++ b/src/target/nds32_v3_common.h
@@ -34,7 +34,7 @@ void nds32_v3_common_register_callback(struct nds32_v3_common_callback *callback
 int nds32_v3_target_request_data(struct target *target,
                uint32_t size, uint8_t *buffer);
 int nds32_v3_checksum_memory(struct target *target,
 int nds32_v3_target_request_data(struct target *target,
                uint32_t size, uint8_t *buffer);
 int nds32_v3_checksum_memory(struct target *target,

-               uint32_t address, uint32_t count, uint32_t *checksum);
+               target_addr_t address, uint32_t count, uint32_t *checksum);

 int nds32_v3_hit_watchpoint(struct target *target,
                struct watchpoint **hit_watchpoint);
 int nds32_v3_target_create_common(struct target *target, struct nds32 *nds32);
 int nds32_v3_hit_watchpoint(struct target *target,
                struct watchpoint **hit_watchpoint);
 int nds32_v3_target_create_common(struct target *target, struct nds32 *nds32);


@@ -43,17 +43,17 @@ int nds32_v3_run_algorithm(struct target *target,
                struct mem_param *mem_params,
                int num_reg_params,
                struct reg_param *reg_params,
                struct mem_param *mem_params,
                int num_reg_params,
                struct reg_param *reg_params,

-               uint32_t entry_point,
-               uint32_t exit_point,
+               target_addr_t entry_point,
+               target_addr_t exit_point,

                int timeout_ms,
                void *arch_info);
                int timeout_ms,
                void *arch_info);

-int nds32_v3_read_buffer(struct target *target, uint32_t address,
+int nds32_v3_read_buffer(struct target *target, target_addr_t address,

                uint32_t size, uint8_t *buffer);
                uint32_t size, uint8_t *buffer);

-int nds32_v3_write_buffer(struct target *target, uint32_t address,
+int nds32_v3_write_buffer(struct target *target, target_addr_t address,

                uint32_t size, const uint8_t *buffer);
                uint32_t size, const uint8_t *buffer);

-int nds32_v3_read_memory(struct target *target, uint32_t address,
+int nds32_v3_read_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, uint8_t *buffer);
                uint32_t size, uint32_t count, uint8_t *buffer);

-int nds32_v3_write_memory(struct target *target, uint32_t address,
+int nds32_v3_write_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, const uint8_t *buffer);
 int nds32_v3_init_target(struct command_context *cmd_ctx,
                struct target *target);
                uint32_t size, uint32_t count, const uint8_t *buffer);
 int nds32_v3_init_target(struct command_context *cmd_ctx,
                struct target *target);

diff --git a/src/target/nds32_v3m.c b/src/target/nds32_v3m.c
index 2d52bc3822b01caa4722dea092f936e2bac3a6e2..86903a51ba6ee75e61ef6884ed03b79aaea6da06 100644 (file)
--- a/src/target/nds32_v3m.c
+++ b/src/target/nds32_v3m.c
@@ -50,7 +50,7 @@ static int nds32_v3m_activate_hardware_breakpoint(struct target *target)
                                /* enable breakpoint (physical address) */
                                aice_write_debug_reg(aice, NDS_EDM_SR_BPC0 + brp_num, 0xA);
 
                                /* enable breakpoint (physical address) */
                                aice_write_debug_reg(aice, NDS_EDM_SR_BPC0 + brp_num, 0xA);
 

-                       LOG_DEBUG("Add hardware BP %u at %08" PRIx32, brp_num,
+                       LOG_DEBUG("Add hardware BP %u at %08" TARGET_PRIxADDR, brp_num,

                                        bp->address);
 
                        brp_num--;
                                        bp->address);
 
                        brp_num--;


@@ -78,7 +78,7 @@ static int nds32_v3m_deactivate_hardware_breakpoint(struct target *target)
                else
                        return ERROR_FAIL;
 
                else
                        return ERROR_FAIL;
 

-               LOG_DEBUG("Remove hardware BP %u at %08" PRIx32, brp_num,
+               LOG_DEBUG("Remove hardware BP %u at %08" TARGET_PRIxADDR, brp_num,

                                bp->address);
 
                brp_num--;
                                bp->address);
 
                brp_num--;


@@ -125,7 +125,7 @@ static int nds32_v3m_activate_hardware_watchpoint(struct target *target)
                        /* enable watchpoint */
                        aice_write_debug_reg(aice, NDS_EDM_SR_BPC0 + wp_num, wp_config);
 
                        /* enable watchpoint */
                        aice_write_debug_reg(aice, NDS_EDM_SR_BPC0 + wp_num, wp_config);
 

-                       LOG_DEBUG("Add hardware watchpoint %" PRId32 " at %08" PRIx32
+                       LOG_DEBUG("Add hardware watchpoint %" PRId32 " at %08" TARGET_PRIxADDR

                                        " mask %08" PRIx32, wp_num, wp->address, wp->mask);
 
                        wp_num++;
                                        " mask %08" PRIx32, wp_num, wp->address, wp->mask);
 
                        wp_num++;


@@ -166,7 +166,7 @@ static int nds32_v3m_deactivate_hardware_watchpoint(struct target *target)
                        /* disable watchpoint */
                        aice_write_debug_reg(aice, NDS_EDM_SR_BPC0 + wp_num, 0x0);
 
                        /* disable watchpoint */
                        aice_write_debug_reg(aice, NDS_EDM_SR_BPC0 + wp_num, 0x0);
 

-                       LOG_DEBUG("Remove hardware watchpoint %" PRId32 " at %08" PRIx32
+                       LOG_DEBUG("Remove hardware watchpoint %" PRId32 " at %08" TARGET_PRIxADDR

                                        " mask %08" PRIx32, wp_num, wp->address, wp->mask);
                        wp_num++;
                } else if (nds32_v3m->nds32.global_stop) {
                                        " mask %08" PRIx32, wp_num, wp->address, wp->mask);
                        wp_num++;
                } else if (nds32_v3m->nds32.global_stop) {

diff --git a/src/target/openrisc/or1k.c b/src/target/openrisc/or1k.c
index 2cc869f9a627e149fb7ed3d1ecd11b070a4a262f..3895ddfaf518100ef48ea5e8cfd302574a947305 100644 (file)
--- a/src/target/openrisc/or1k.c
+++ b/src/target/openrisc/or1k.c
@@ -861,7 +861,7 @@ static int or1k_resume_or_step(struct target *target, int current,
                /* Single step past breakpoint at current address */
                breakpoint = breakpoint_find(target, resume_pc);
                if (breakpoint) {
                /* Single step past breakpoint at current address */
                breakpoint = breakpoint_find(target, resume_pc);
                if (breakpoint) {

-                       LOG_DEBUG("Unset breakpoint at 0x%08" PRIx32, breakpoint->address);
+                       LOG_DEBUG("Unset breakpoint at 0x%08" TARGET_PRIxADDR, breakpoint->address);

                        retval = or1k_remove_breakpoint(target, breakpoint);
                        if (retval != ERROR_OK)
                                return retval;
                        retval = or1k_remove_breakpoint(target, breakpoint);
                        if (retval != ERROR_OK)
                                return retval;


@@ -897,7 +897,8 @@ static int or1k_resume_or_step(struct target *target, int current,
 }
 
 static int or1k_resume(struct target *target, int current,
 }
 
 static int or1k_resume(struct target *target, int current,

-               uint32_t address, int handle_breakpoints, int debug_execution)
+                      target_addr_t address, int handle_breakpoints,
+                      int debug_execution)

 {
        return or1k_resume_or_step(target, current, address,
                                   handle_breakpoints,
 {
        return or1k_resume_or_step(target, current, address,
                                   handle_breakpoints,


@@ -906,7 +907,7 @@ static int or1k_resume(struct target *target, int current,
 }
 
 static int or1k_step(struct target *target, int current,
 }
 
 static int or1k_step(struct target *target, int current,

-                    uint32_t address, int handle_breakpoints)
+                    target_addr_t address, int handle_breakpoints)

 {
        return or1k_resume_or_step(target, current, address,
                                   handle_breakpoints,
 {
        return or1k_resume_or_step(target, current, address,
                                   handle_breakpoints,


@@ -922,7 +923,7 @@ static int or1k_add_breakpoint(struct target *target,
        struct or1k_du *du_core = or1k_to_du(or1k);
        uint8_t data;
 
        struct or1k_du *du_core = or1k_to_du(or1k);
        uint8_t data;
 

-       LOG_DEBUG("Adding breakpoint: addr 0x%08" PRIx32 ", len %d, type %d, set: %d, id: %" PRId32,
+       LOG_DEBUG("Adding breakpoint: addr 0x%08" TARGET_PRIxADDR ", len %d, type %d, set: %d, id: %" PRId32,

                  breakpoint->address, breakpoint->length, breakpoint->type,
                  breakpoint->set, breakpoint->unique_id);
 
                  breakpoint->address, breakpoint->length, breakpoint->type,
                  breakpoint->set, breakpoint->unique_id);
 


@@ -937,7 +938,7 @@ static int or1k_add_breakpoint(struct target *target,
                                         1,
                                         &data);
        if (retval != ERROR_OK) {
                                         1,
                                         &data);
        if (retval != ERROR_OK) {

-               LOG_ERROR("Error while reading the instruction at 0x%08" PRIx32,
+               LOG_ERROR("Error while reading the instruction at 0x%08" TARGET_PRIxADDR,

                           breakpoint->address);
                return retval;
        }
                           breakpoint->address);
                return retval;
        }


@@ -958,14 +959,15 @@ static int or1k_add_breakpoint(struct target *target,
                                          or1k_trap_insn);
 
        if (retval != ERROR_OK) {
                                          or1k_trap_insn);
 
        if (retval != ERROR_OK) {

-               LOG_ERROR("Error while writing OR1K_TRAP_INSTR at 0x%08" PRIx32,
+               LOG_ERROR("Error while writing OR1K_TRAP_INSTR at 0x%08" TARGET_PRIxADDR,

                           breakpoint->address);
                return retval;
        }
 
        /* invalidate instruction cache */
                           breakpoint->address);
                return retval;
        }
 
        /* invalidate instruction cache */

+       uint32_t addr = breakpoint->address;

        retval = du_core->or1k_jtag_write_cpu(&or1k->jtag,
        retval = du_core->or1k_jtag_write_cpu(&or1k->jtag,

-                       OR1K_ICBIR_CPU_REG_ADD, 1, &breakpoint->address);
+                       OR1K_ICBIR_CPU_REG_ADD, 1, &addr);

        if (retval != ERROR_OK) {
                LOG_ERROR("Error while invalidating the ICACHE");
                return retval;
        if (retval != ERROR_OK) {
                LOG_ERROR("Error while invalidating the ICACHE");
                return retval;


@@ -980,7 +982,7 @@ static int or1k_remove_breakpoint(struct target *target,
        struct or1k_common *or1k = target_to_or1k(target);
        struct or1k_du *du_core = or1k_to_du(or1k);
 
        struct or1k_common *or1k = target_to_or1k(target);
        struct or1k_du *du_core = or1k_to_du(or1k);
 

-       LOG_DEBUG("Removing breakpoint: addr 0x%08" PRIx32 ", len %d, type %d, set: %d, id: %" PRId32,
+       LOG_DEBUG("Removing breakpoint: addr 0x%08" TARGET_PRIxADDR ", len %d, type %d, set: %d, id: %" PRId32,

                  breakpoint->address, breakpoint->length, breakpoint->type,
                  breakpoint->set, breakpoint->unique_id);
 
                  breakpoint->address, breakpoint->length, breakpoint->type,
                  breakpoint->set, breakpoint->unique_id);
 


@@ -996,14 +998,15 @@ static int or1k_remove_breakpoint(struct target *target,
                                          breakpoint->orig_instr);
 
        if (retval != ERROR_OK) {
                                          breakpoint->orig_instr);
 
        if (retval != ERROR_OK) {

-               LOG_ERROR("Error while writing back the instruction at 0x%08" PRIx32,
+               LOG_ERROR("Error while writing back the instruction at 0x%08" TARGET_PRIxADDR,

                           breakpoint->address);
                return retval;
        }
 
        /* invalidate instruction cache */
                           breakpoint->address);
                return retval;
        }
 
        /* invalidate instruction cache */

+       uint32_t addr = breakpoint->address;

        retval = du_core->or1k_jtag_write_cpu(&or1k->jtag,
        retval = du_core->or1k_jtag_write_cpu(&or1k->jtag,

-                       OR1K_ICBIR_CPU_REG_ADD, 1, &breakpoint->address);
+                       OR1K_ICBIR_CPU_REG_ADD, 1, &addr);

        if (retval != ERROR_OK) {
                LOG_ERROR("Error while invalidating the ICACHE");
                return retval;
        if (retval != ERROR_OK) {
                LOG_ERROR("Error while invalidating the ICACHE");
                return retval;


@@ -1026,13 +1029,13 @@ static int or1k_remove_watchpoint(struct target *target,
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int or1k_read_memory(struct target *target, uint32_t address,
+static int or1k_read_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct or1k_common *or1k = target_to_or1k(target);
        struct or1k_du *du_core = or1k_to_du(or1k);
 
                uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct or1k_common *or1k = target_to_or1k(target);
        struct or1k_du *du_core = or1k_to_du(or1k);
 

-       LOG_DEBUG("Read memory at 0x%08" PRIx32 ", size: %" PRIu32 ", count: 0x%08" PRIx32, address, size, count);
+       LOG_DEBUG("Read memory at 0x%08" TARGET_PRIxADDR ", size: %" PRIu32 ", count: 0x%08" PRIx32, address, size, count);

 
        if (target->state != TARGET_HALTED) {
                LOG_ERROR("Target not halted");
 
        if (target->state != TARGET_HALTED) {
                LOG_ERROR("Target not halted");


@@ -1053,13 +1056,13 @@ static int or1k_read_memory(struct target *target, uint32_t address,
        return du_core->or1k_jtag_read_memory(&or1k->jtag, address, size, count, buffer);
 }
 
        return du_core->or1k_jtag_read_memory(&or1k->jtag, address, size, count, buffer);
 }
 

-static int or1k_write_memory(struct target *target, uint32_t address,
+static int or1k_write_memory(struct target *target, target_addr_t address,

                uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct or1k_common *or1k = target_to_or1k(target);
        struct or1k_du *du_core = or1k_to_du(or1k);
 
                uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct or1k_common *or1k = target_to_or1k(target);
        struct or1k_du *du_core = or1k_to_du(or1k);
 

-       LOG_DEBUG("Write memory at 0x%08" PRIx32 ", size: %" PRIu32 ", count: 0x%08" PRIx32, address, size, count);
+       LOG_DEBUG("Write memory at 0x%08" TARGET_PRIxADDR ", size: %" PRIu32 ", count: 0x%08" PRIx32, address, size, count);

 
        if (target->state != TARGET_HALTED) {
                LOG_WARNING("Target not halted");
 
        if (target->state != TARGET_HALTED) {
                LOG_WARNING("Target not halted");


@@ -1203,7 +1206,7 @@ int or1k_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *file
        return ERROR_FAIL;
 }
 
        return ERROR_FAIL;
 }
 

-static int or1k_checksum_memory(struct target *target, uint32_t address,
+static int or1k_checksum_memory(struct target *target, target_addr_t address,

                uint32_t count, uint32_t *checksum) {
 
        return ERROR_FAIL;
                uint32_t count, uint32_t *checksum) {
 
        return ERROR_FAIL;

diff --git a/src/target/target.c b/src/target/target.c
index c8a3ce4d8e8288d3c1168889249d2c0903b8a25a..40baf8ed840391f33caeeb711df4256fe4130218 100644 (file)
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -58,9 +58,9 @@
 /* default halt wait timeout (ms) */
 #define DEFAULT_HALT_TIMEOUT 5000
 
 /* default halt wait timeout (ms) */
 #define DEFAULT_HALT_TIMEOUT 5000
 

-static int target_read_buffer_default(struct target *target, uint32_t address,
+static int target_read_buffer_default(struct target *target, target_addr_t address,

                uint32_t count, uint8_t *buffer);
                uint32_t count, uint8_t *buffer);

-static int target_write_buffer_default(struct target *target, uint32_t address,
+static int target_write_buffer_default(struct target *target, target_addr_t address,

                uint32_t count, const uint8_t *buffer);
 static int target_array2mem(Jim_Interp *interp, struct target *target,
                int argc, Jim_Obj * const *argv);
                uint32_t count, const uint8_t *buffer);
 static int target_array2mem(Jim_Interp *interp, struct target *target,
                int argc, Jim_Obj * const *argv);


@@ -597,7 +597,8 @@ int target_halt(struct target *target)
  * hand the infrastructure for running such helpers might use this
  * procedure but rely on hardware breakpoint to detect termination.)
  */
  * hand the infrastructure for running such helpers might use this
  * procedure but rely on hardware breakpoint to detect termination.)
  */

-int target_resume(struct target *target, int current, uint32_t address, int handle_breakpoints, int debug_execution)
+int target_resume(struct target *target, int current, target_addr_t address,
+               int handle_breakpoints, int debug_execution)

 {
        int retval;
 
 {
        int retval;
 


@@ -668,7 +669,7 @@ static int target_process_reset(struct command_context *cmd_ctx, enum target_res
 }
 
 static int identity_virt2phys(struct target *target,
 }
 
 static int identity_virt2phys(struct target *target,

-               uint32_t virtual, uint32_t *physical)
+               target_addr_t virtual, target_addr_t *physical)

 {
        *physical = virtual;
        return ERROR_OK;
 {
        *physical = virtual;
        return ERROR_OK;


@@ -1034,7 +1035,7 @@ int target_run_flash_async_algorithm(struct target *target,
 }
 
 int target_read_memory(struct target *target,
 }
 
 int target_read_memory(struct target *target,

-               uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer)
+               target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)

 {
        if (!target_was_examined(target)) {
                LOG_ERROR("Target not examined yet");
 {
        if (!target_was_examined(target)) {
                LOG_ERROR("Target not examined yet");


@@ -1048,7 +1049,7 @@ int target_read_memory(struct target *target,
 }
 
 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)
+               target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)

 {
        if (!target_was_examined(target)) {
                LOG_ERROR("Target not examined yet");
 {
        if (!target_was_examined(target)) {
                LOG_ERROR("Target not examined yet");


@@ -1062,7 +1063,7 @@ int target_read_phys_memory(struct target *target,
 }
 
 int target_write_memory(struct target *target,
 }
 
 int target_write_memory(struct target *target,

-               uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
+               target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)

 {
        if (!target_was_examined(target)) {
                LOG_ERROR("Target not examined yet");
 {
        if (!target_was_examined(target)) {
                LOG_ERROR("Target not examined yet");


@@ -1076,7 +1077,7 @@ int target_write_memory(struct target *target,
 }
 
 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)
+               target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)

 {
        if (!target_was_examined(target)) {
                LOG_ERROR("Target not examined yet");
 {
        if (!target_was_examined(target)) {
                LOG_ERROR("Target not examined yet");


@@ -1164,7 +1165,7 @@ int target_get_gdb_reg_list(struct target *target,
        return target->type->get_gdb_reg_list(target, reg_list, reg_list_size, reg_class);
 }
 int target_step(struct target *target,
        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)
+               int current, target_addr_t address, int handle_breakpoints)

 {
        return target->type->step(target, current, address, handle_breakpoints);
 }
 {
        return target->type->step(target, current, address, handle_breakpoints);
 }


@@ -1635,7 +1636,7 @@ static void print_wa_layout(struct target *target)
        struct working_area *c = target->working_areas;
 
        while (c) {
        struct working_area *c = target->working_areas;
 
        while (c) {

-               LOG_DEBUG("%c%c 0x%08"PRIx32"-0x%08"PRIx32" (%"PRIu32" bytes)",
+               LOG_DEBUG("%c%c " TARGET_ADDR_FMT "-" TARGET_ADDR_FMT " (%" PRIu32 " bytes)",

                        c->backup ? 'b' : ' ', c->free ? ' ' : '*',
                        c->address, c->address + c->size - 1, c->size);
                c = c->next;
                        c->backup ? 'b' : ' ', c->free ? ' ' : '*',
                        c->address, c->address + c->size - 1, c->size);
                c = c->next;


@@ -1720,7 +1721,7 @@ int target_alloc_working_area_try(struct target *target, uint32_t size, struct w
                if (!enabled) {
                        if (target->working_area_phys_spec) {
                                LOG_DEBUG("MMU disabled, using physical "
                if (!enabled) {
                        if (target->working_area_phys_spec) {
                                LOG_DEBUG("MMU disabled, using physical "

-                                       "address for working memory 0x%08"PRIx32,
+                                       "address for working memory " TARGET_ADDR_FMT,

                                        target->working_area_phys);
                                target->working_area = target->working_area_phys;
                        } else {
                                        target->working_area_phys);
                                target->working_area = target->working_area_phys;
                        } else {


@@ -1731,7 +1732,7 @@ int target_alloc_working_area_try(struct target *target, uint32_t size, struct w
                } else {
                        if (target->working_area_virt_spec) {
                                LOG_DEBUG("MMU enabled, using virtual "
                } else {
                        if (target->working_area_virt_spec) {
                                LOG_DEBUG("MMU enabled, using virtual "

-                                       "address for working memory 0x%08"PRIx32,
+                                       "address for working memory " TARGET_ADDR_FMT,

                                        target->working_area_virt);
                                target->working_area = target->working_area_virt;
                        } else {
                                        target->working_area_virt);
                                target->working_area = target->working_area_virt;
                        } else {


@@ -1774,7 +1775,8 @@ int target_alloc_working_area_try(struct target *target, uint32_t size, struct w
        /* Split the working area into the requested size */
        target_split_working_area(c, size);
 
        /* Split the working area into the requested size */
        target_split_working_area(c, size);
 

-       LOG_DEBUG("allocated new working area of %"PRIu32" bytes at address 0x%08"PRIx32, size, c->address);
+       LOG_DEBUG("allocated new working area of %" PRIu32 " bytes at address " TARGET_ADDR_FMT,
+                         size, c->address);

 
        if (target->backup_working_area) {
                if (c->backup == NULL) {
 
        if (target->backup_working_area) {
                if (c->backup == NULL) {


@@ -1818,7 +1820,7 @@ static int target_restore_working_area(struct target *target, struct working_are
        if (target->backup_working_area && area->backup != NULL) {
                retval = target_write_memory(target, area->address, 4, area->size / 4, area->backup);
                if (retval != ERROR_OK)
        if (target->backup_working_area && area->backup != NULL) {
                retval = target_write_memory(target, area->address, 4, area->size / 4, area->backup);
                if (retval != ERROR_OK)

-                       LOG_ERROR("failed to restore %"PRIu32" bytes of working area at address 0x%08"PRIx32,
+                       LOG_ERROR("failed to restore %" PRIu32 " bytes of working area at address " TARGET_ADDR_FMT,

                                        area->size, area->address);
        }
 
                                        area->size, area->address);
        }
 


@@ -1842,7 +1844,7 @@ static int target_free_working_area_restore(struct target *target, struct workin
 
        area->free = true;
 
 
        area->free = true;
 

-       LOG_DEBUG("freed %"PRIu32" bytes of working area at address 0x%08"PRIx32,
+       LOG_DEBUG("freed %" PRIu32 " bytes of working area at address " TARGET_ADDR_FMT,

                        area->size, area->address);
 
        /* mark user pointer invalid */
                        area->size, area->address);
 
        /* mark user pointer invalid */


@@ -2024,9 +2026,9 @@ static int target_profiling_default(struct target *target, uint32_t *samples,
  * mode respectively, otherwise data is handled as quickly as
  * possible
  */
  * mode respectively, otherwise data is handled as quickly as
  * possible
  */

-int target_write_buffer(struct target *target, uint32_t address, uint32_t size, const uint8_t *buffer)
+int target_write_buffer(struct target *target, target_addr_t address, uint32_t size, const uint8_t *buffer)

 {
 {

-       LOG_DEBUG("writing buffer of %" PRIi32 " byte at 0x%8.8" PRIx32,
+       LOG_DEBUG("writing buffer of %" PRIi32 " byte at " TARGET_ADDR_FMT,

                          size, address);
 
        if (!target_was_examined(target)) {
                          size, address);
 
        if (!target_was_examined(target)) {


@@ -2039,7 +2041,7 @@ int target_write_buffer(struct target *target, uint32_t address, uint32_t size,
 
        if ((address + size - 1) < address) {
                /* GDB can request this when e.g. PC is 0xfffffffc */
 
        if ((address + size - 1) < address) {
                /* GDB can request this when e.g. PC is 0xfffffffc */

-               LOG_ERROR("address + size wrapped (0x%08" PRIx32 ", 0x%08" PRIx32 ")",
+               LOG_ERROR("address + size wrapped (" TARGET_ADDR_FMT ", 0x%08" PRIx32 ")",

                                  address,
                                  size);
                return ERROR_FAIL;
                                  address,
                                  size);
                return ERROR_FAIL;


@@ -2048,7 +2050,8 @@ int target_write_buffer(struct target *target, uint32_t address, uint32_t size,
        return target->type->write_buffer(target, address, size, buffer);
 }
 
        return target->type->write_buffer(target, address, size, buffer);
 }
 

-static int target_write_buffer_default(struct target *target, uint32_t address, uint32_t count, const uint8_t *buffer)
+static int target_write_buffer_default(struct target *target,
+       target_addr_t address, uint32_t count, const uint8_t *buffer)

 {
        uint32_t size;
 
 {
        uint32_t size;
 


@@ -2085,9 +2088,9 @@ static int target_write_buffer_default(struct target *target, uint32_t address,
  * mode respectively, otherwise data is handled as quickly as
  * possible
  */
  * mode respectively, otherwise data is handled as quickly as
  * possible
  */

-int target_read_buffer(struct target *target, uint32_t address, uint32_t size, uint8_t *buffer)
+int target_read_buffer(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)

 {
 {

-       LOG_DEBUG("reading buffer of %" PRIi32 " byte at 0x%8.8" PRIx32,
+       LOG_DEBUG("reading buffer of %" PRIi32 " byte at " TARGET_ADDR_FMT,

                          size, address);
 
        if (!target_was_examined(target)) {
                          size, address);
 
        if (!target_was_examined(target)) {


@@ -2100,7 +2103,7 @@ int target_read_buffer(struct target *target, uint32_t address, uint32_t size, u
 
        if ((address + size - 1) < address) {
                /* GDB can request this when e.g. PC is 0xfffffffc */
 
        if ((address + size - 1) < address) {
                /* GDB can request this when e.g. PC is 0xfffffffc */

-               LOG_ERROR("address + size wrapped (0x%08" PRIx32 ", 0x%08" PRIx32 ")",
+               LOG_ERROR("address + size wrapped (" TARGET_ADDR_FMT ", 0x%08" PRIx32 ")",

                                  address,
                                  size);
                return ERROR_FAIL;
                                  address,
                                  size);
                return ERROR_FAIL;


@@ -2109,7 +2112,7 @@ int target_read_buffer(struct target *target, uint32_t address, uint32_t size, u
        return target->type->read_buffer(target, address, size, buffer);
 }
 
        return target->type->read_buffer(target, address, size, buffer);
 }
 

-static int target_read_buffer_default(struct target *target, uint32_t address, uint32_t count, uint8_t *buffer)
+static int target_read_buffer_default(struct target *target, target_addr_t address, uint32_t count, uint8_t *buffer)

 {
        uint32_t size;
 
 {
        uint32_t size;
 


@@ -2142,7 +2145,7 @@ static int target_read_buffer_default(struct target *target, uint32_t address, u
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-int target_checksum_memory(struct target *target, uint32_t address, uint32_t size, uint32_t* crc)
+int target_checksum_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t* crc)

 {
        uint8_t *buffer;
        int retval;
 {
        uint8_t *buffer;
        int retval;


@@ -2182,7 +2185,7 @@ int target_checksum_memory(struct target *target, uint32_t address, uint32_t siz
        return retval;
 }
 
        return retval;
 }
 

-int target_blank_check_memory(struct target *target, uint32_t address, uint32_t size, uint32_t* blank,
+int target_blank_check_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t* blank,

        uint8_t erased_value)
 {
        int retval;
        uint8_t erased_value)
 {
        int retval;


@@ -2199,7 +2202,7 @@ int target_blank_check_memory(struct target *target, uint32_t address, uint32_t
        return retval;
 }
 
        return retval;
 }
 

-int target_read_u64(struct target *target, uint64_t address, uint64_t *value)
+int target_read_u64(struct target *target, target_addr_t address, uint64_t *value)

 {
        uint8_t value_buf[8];
        if (!target_was_examined(target)) {
 {
        uint8_t value_buf[8];
        if (!target_was_examined(target)) {


@@ -2211,19 +2214,19 @@ int target_read_u64(struct target *target, uint64_t address, uint64_t *value)
 
        if (retval == ERROR_OK) {
                *value = target_buffer_get_u64(target, value_buf);
 
        if (retval == ERROR_OK) {
                *value = target_buffer_get_u64(target, value_buf);

-               LOG_DEBUG("address: 0x%" PRIx64 ", value: 0x%16.16" PRIx64 "",
+               LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%16.16" PRIx64 "",

                                  address,
                                  *value);
        } else {
                *value = 0x0;
                                  address,
                                  *value);
        } else {
                *value = 0x0;

-               LOG_DEBUG("address: 0x%" PRIx64 " failed",
+               LOG_DEBUG("address: " TARGET_ADDR_FMT " failed",

                                  address);
        }
 
        return retval;
 }
 
                                  address);
        }
 
        return retval;
 }
 

-int target_read_u32(struct target *target, uint32_t address, uint32_t *value)
+int target_read_u32(struct target *target, target_addr_t address, uint32_t *value)

 {
        uint8_t value_buf[4];
        if (!target_was_examined(target)) {
 {
        uint8_t value_buf[4];
        if (!target_was_examined(target)) {


@@ -2235,19 +2238,19 @@ int target_read_u32(struct target *target, uint32_t address, uint32_t *value)
 
        if (retval == ERROR_OK) {
                *value = target_buffer_get_u32(target, value_buf);
 
        if (retval == ERROR_OK) {
                *value = target_buffer_get_u32(target, value_buf);

-               LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8" PRIx32 "",
+               LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%8.8" PRIx32 "",

                                  address,
                                  *value);
        } else {
                *value = 0x0;
                                  address,
                                  *value);
        } else {
                *value = 0x0;

-               LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
+               LOG_DEBUG("address: " TARGET_ADDR_FMT " failed",

                                  address);
        }
 
        return retval;
 }
 
                                  address);
        }
 
        return retval;
 }
 

-int target_read_u16(struct target *target, uint32_t address, uint16_t *value)
+int target_read_u16(struct target *target, target_addr_t address, uint16_t *value)

 {
        uint8_t value_buf[2];
        if (!target_was_examined(target)) {
 {
        uint8_t value_buf[2];
        if (!target_was_examined(target)) {


@@ -2259,19 +2262,19 @@ int target_read_u16(struct target *target, uint32_t address, uint16_t *value)
 
        if (retval == ERROR_OK) {
                *value = target_buffer_get_u16(target, value_buf);
 
        if (retval == ERROR_OK) {
                *value = target_buffer_get_u16(target, value_buf);

-               LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%4.4" PRIx16,
+               LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%4.4" PRIx16,

                                  address,
                                  *value);
        } else {
                *value = 0x0;
                                  address,
                                  *value);
        } else {
                *value = 0x0;

-               LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
+               LOG_DEBUG("address: " TARGET_ADDR_FMT " failed",

                                  address);
        }
 
        return retval;
 }
 
                                  address);
        }
 
        return retval;
 }
 

-int target_read_u8(struct target *target, uint32_t address, uint8_t *value)
+int target_read_u8(struct target *target, target_addr_t address, uint8_t *value)

 {
        if (!target_was_examined(target)) {
                LOG_ERROR("Target not examined yet");
 {
        if (!target_was_examined(target)) {
                LOG_ERROR("Target not examined yet");


@@ -2281,19 +2284,19 @@ int target_read_u8(struct target *target, uint32_t address, uint8_t *value)
        int retval = target_read_memory(target, address, 1, 1, value);
 
        if (retval == ERROR_OK) {
        int retval = target_read_memory(target, address, 1, 1, value);
 
        if (retval == ERROR_OK) {

-               LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%2.2" PRIx8,
+               LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%2.2" PRIx8,

                                  address,
                                  *value);
        } else {
                *value = 0x0;
                                  address,
                                  *value);
        } else {
                *value = 0x0;

-               LOG_DEBUG("address: 0x%8.8" PRIx32 " failed",
+               LOG_DEBUG("address: " TARGET_ADDR_FMT " failed",

                                  address);
        }
 
        return retval;
 }
 
                                  address);
        }
 
        return retval;
 }
 

-int target_write_u64(struct target *target, uint64_t address, uint64_t value)
+int target_write_u64(struct target *target, target_addr_t address, uint64_t value)

 {
        int retval;
        uint8_t value_buf[8];
 {
        int retval;
        uint8_t value_buf[8];


@@ -2302,7 +2305,7 @@ int target_write_u64(struct target *target, uint64_t address, uint64_t value)
                return ERROR_FAIL;
        }
 
                return ERROR_FAIL;
        }
 

-       LOG_DEBUG("address: 0x%" PRIx64 ", value: 0x%16.16" PRIx64 "",
+       LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%16.16" PRIx64 "",

                          address,
                          value);
 
                          address,
                          value);
 


@@ -2314,7 +2317,7 @@ int target_write_u64(struct target *target, uint64_t address, uint64_t value)
        return retval;
 }
 
        return retval;
 }
 

-int target_write_u32(struct target *target, uint32_t address, uint32_t value)
+int target_write_u32(struct target *target, target_addr_t address, uint32_t value)

 {
        int retval;
        uint8_t value_buf[4];
 {
        int retval;
        uint8_t value_buf[4];


@@ -2323,7 +2326,7 @@ int target_write_u32(struct target *target, uint32_t address, uint32_t value)
                return ERROR_FAIL;
        }
 
                return ERROR_FAIL;
        }
 

-       LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8" PRIx32 "",
+       LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%8.8" PRIx32 "",

                          address,
                          value);
 
                          address,
                          value);
 


@@ -2335,7 +2338,7 @@ int target_write_u32(struct target *target, uint32_t address, uint32_t value)
        return retval;
 }
 
        return retval;
 }
 

-int target_write_u16(struct target *target, uint32_t address, uint16_t value)
+int target_write_u16(struct target *target, target_addr_t address, uint16_t value)

 {
        int retval;
        uint8_t value_buf[2];
 {
        int retval;
        uint8_t value_buf[2];


@@ -2344,7 +2347,7 @@ int target_write_u16(struct target *target, uint32_t address, uint16_t value)
                return ERROR_FAIL;
        }
 
                return ERROR_FAIL;
        }
 

-       LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%8.8" PRIx16,
+       LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%8.8" PRIx16,

                          address,
                          value);
 
                          address,
                          value);
 


@@ -2356,7 +2359,7 @@ int target_write_u16(struct target *target, uint32_t address, uint16_t value)
        return retval;
 }
 
        return retval;
 }
 

-int target_write_u8(struct target *target, uint32_t address, uint8_t value)
+int target_write_u8(struct target *target, target_addr_t address, uint8_t value)

 {
        int retval;
        if (!target_was_examined(target)) {
 {
        int retval;
        if (!target_was_examined(target)) {


@@ -2364,7 +2367,7 @@ int target_write_u8(struct target *target, uint32_t address, uint8_t value)
                return ERROR_FAIL;
        }
 
                return ERROR_FAIL;
        }
 

-       LOG_DEBUG("address: 0x%8.8" PRIx32 ", value: 0x%2.2" PRIx8,
+       LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%2.2" PRIx8,

                          address, value);
 
        retval = target_write_memory(target, address, 1, 1, &value);
                          address, value);
 
        retval = target_write_memory(target, address, 1, 1, &value);


@@ -2374,6 +2377,87 @@ int target_write_u8(struct target *target, uint32_t address, uint8_t value)
        return retval;
 }
 
        return retval;
 }
 

+int target_write_phys_u64(struct target *target, target_addr_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: " TARGET_ADDR_FMT ", value: 0x%16.16" PRIx64 "",
+                         address,
+                         value);
+
+       target_buffer_set_u64(target, value_buf, value);
+       retval = target_write_phys_memory(target, address, 8, 1, value_buf);
+       if (retval != ERROR_OK)
+               LOG_DEBUG("failed: %i", retval);
+
+       return retval;
+}
+
+int target_write_phys_u32(struct target *target, target_addr_t address, uint32_t value)
+{
+       int retval;
+       uint8_t value_buf[4];
+       if (!target_was_examined(target)) {
+               LOG_ERROR("Target not examined yet");
+               return ERROR_FAIL;
+       }
+
+       LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%8.8" PRIx32 "",
+                         address,
+                         value);
+
+       target_buffer_set_u32(target, value_buf, value);
+       retval = target_write_phys_memory(target, address, 4, 1, value_buf);
+       if (retval != ERROR_OK)
+               LOG_DEBUG("failed: %i", retval);
+
+       return retval;
+}
+
+int target_write_phys_u16(struct target *target, target_addr_t address, uint16_t value)
+{
+       int retval;
+       uint8_t value_buf[2];
+       if (!target_was_examined(target)) {
+               LOG_ERROR("Target not examined yet");
+               return ERROR_FAIL;
+       }
+
+       LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%8.8" PRIx16,
+                         address,
+                         value);
+
+       target_buffer_set_u16(target, value_buf, value);
+       retval = target_write_phys_memory(target, address, 2, 1, value_buf);
+       if (retval != ERROR_OK)
+               LOG_DEBUG("failed: %i", retval);
+
+       return retval;
+}
+
+int target_write_phys_u8(struct target *target, target_addr_t address, uint8_t value)
+{
+       int retval;
+       if (!target_was_examined(target)) {
+               LOG_ERROR("Target not examined yet");
+               return ERROR_FAIL;
+       }
+
+       LOG_DEBUG("address: " TARGET_ADDR_FMT ", value: 0x%2.2" PRIx8,
+                         address, value);
+
+       retval = target_write_phys_memory(target, address, 1, 1, &value);
+       if (retval != ERROR_OK)
+               LOG_DEBUG("failed: %i", retval);
+
+       return retval;
+}
+

 static int find_target(struct command_context *cmd_ctx, const char *name)
 {
        struct target *target = get_target(name);
 static int find_target(struct command_context *cmd_ctx, const char *name)
 {
        struct target *target = get_target(name);


@@ -2877,9 +2961,9 @@ COMMAND_HANDLER(handle_resume_command)
        /* with no CMD_ARGV, resume from current pc, addr = 0,
         * with one arguments, addr = CMD_ARGV[0],
         * handle breakpoints, not debugging */
        /* with no CMD_ARGV, resume from current pc, addr = 0,
         * with one arguments, addr = CMD_ARGV[0],
         * handle breakpoints, not debugging */

-       uint32_t addr = 0;
+       target_addr_t addr = 0;

        if (CMD_ARGC == 1) {
        if (CMD_ARGC == 1) {

-               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
+               COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr);

                current = 0;
        }
 
                current = 0;
        }
 


@@ -2896,10 +2980,10 @@ COMMAND_HANDLER(handle_step_command)
        /* with no CMD_ARGV, step from current pc, addr = 0,
         * with one argument addr = CMD_ARGV[0],
         * handle breakpoints, debugging */
        /* with no CMD_ARGV, step from current pc, addr = 0,
         * with one argument addr = CMD_ARGV[0],
         * handle breakpoints, debugging */

-       uint32_t addr = 0;
+       target_addr_t addr = 0;

        int current_pc = 1;
        if (CMD_ARGC == 1) {
        int current_pc = 1;
        if (CMD_ARGC == 1) {

-               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
+               COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr);

                current_pc = 0;
        }
 
                current_pc = 0;
        }
 


@@ -2909,7 +2993,7 @@ COMMAND_HANDLER(handle_step_command)
 }
 
 static void handle_md_output(struct command_context *cmd_ctx,
 }
 
 static void handle_md_output(struct command_context *cmd_ctx,

-               struct target *target, uint32_t address, unsigned size,
+               struct target *target, target_addr_t address, unsigned size,

                unsigned count, const uint8_t *buffer)
 {
        const unsigned line_bytecnt = 32;
                unsigned count, const uint8_t *buffer)
 {
        const unsigned line_bytecnt = 32;


@@ -2920,6 +3004,9 @@ static void handle_md_output(struct command_context *cmd_ctx,
 
        const char *value_fmt;
        switch (size) {
 
        const char *value_fmt;
        switch (size) {

+       case 8:
+               value_fmt = "%16.16llx ";
+               break;

        case 4:
                value_fmt = "%8.8x ";
                break;
        case 4:
                value_fmt = "%8.8x ";
                break;


@@ -2939,13 +3026,16 @@ static void handle_md_output(struct command_context *cmd_ctx,
                if (i % line_modulo == 0) {
                        output_len += snprintf(output + output_len,
                                        sizeof(output) - output_len,
                if (i % line_modulo == 0) {
                        output_len += snprintf(output + output_len,
                                        sizeof(output) - output_len,

-                                       "0x%8.8x: ",
-                                       (unsigned)(address + (i*size)));
+                                       TARGET_ADDR_FMT ": ",
+                                       (address + (i * size)));

                }
 
                }
 

-               uint32_t value = 0;
+               uint64_t value = 0;

                const uint8_t *value_ptr = buffer + i * size;
                switch (size) {
                const uint8_t *value_ptr = buffer + i * size;
                switch (size) {

+               case 8:
+                       value = target_buffer_get_u64(target, value_ptr);
+                       break;

                case 4:
                        value = target_buffer_get_u32(target, value_ptr);
                        break;
                case 4:
                        value = target_buffer_get_u32(target, value_ptr);
                        break;


@@ -2973,6 +3063,9 @@ COMMAND_HANDLER(handle_md_command)
 
        unsigned size = 0;
        switch (CMD_NAME[2]) {
 
        unsigned size = 0;
        switch (CMD_NAME[2]) {

+       case 'd':
+               size = 8;
+               break;

        case 'w':
                size = 4;
                break;
        case 'w':
                size = 4;
                break;


@@ -2988,7 +3081,7 @@ COMMAND_HANDLER(handle_md_command)
 
        bool physical = strcmp(CMD_ARGV[0], "phys") == 0;
        int (*fn)(struct target *target,
 
        bool physical = strcmp(CMD_ARGV[0], "phys") == 0;
        int (*fn)(struct target *target,

-                       uint32_t address, uint32_t size_value, uint32_t count, uint8_t *buffer);
+                       target_addr_t address, uint32_t size_value, uint32_t count, uint8_t *buffer);

        if (physical) {
                CMD_ARGC--;
                CMD_ARGV++;
        if (physical) {
                CMD_ARGC--;
                CMD_ARGV++;


@@ -2998,8 +3091,8 @@ COMMAND_HANDLER(handle_md_command)
        if ((CMD_ARGC < 1) || (CMD_ARGC > 2))
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        if ((CMD_ARGC < 1) || (CMD_ARGC > 2))
                return ERROR_COMMAND_SYNTAX_ERROR;
 

-       uint32_t address;
-       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
+       target_addr_t address;
+       COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address);

 
        unsigned count = 1;
        if (CMD_ARGC == 2)
 
        unsigned count = 1;
        if (CMD_ARGC == 2)


@@ -3018,14 +3111,14 @@ COMMAND_HANDLER(handle_md_command)
 }
 
 typedef int (*target_write_fn)(struct target *target,
 }
 
 typedef int (*target_write_fn)(struct target *target,

-               uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
+               target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer);

 
 static int target_fill_mem(struct target *target,
 
 static int target_fill_mem(struct target *target,

-               uint32_t address,
+               target_addr_t address,

                target_write_fn fn,
                unsigned data_size,
                /* value */
                target_write_fn fn,
                unsigned data_size,
                /* value */

-               uint32_t b,
+               uint64_t b,

                /* count */
                unsigned c)
 {
                /* count */
                unsigned c)
 {


@@ -3040,6 +3133,9 @@ static int target_fill_mem(struct target *target,
 
        for (unsigned i = 0; i < chunk_size; i++) {
                switch (data_size) {
 
        for (unsigned i = 0; i < chunk_size; i++) {
                switch (data_size) {

+               case 8:
+                       target_buffer_set_u64(target, target_buf + i * data_size, b);
+                       break;

                case 4:
                        target_buffer_set_u32(target, target_buf + i * data_size, b);
                        break;
                case 4:
                        target_buffer_set_u32(target, target_buf + i * data_size, b);
                        break;


@@ -3088,11 +3184,11 @@ COMMAND_HANDLER(handle_mw_command)
        if ((CMD_ARGC < 2) || (CMD_ARGC > 3))
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        if ((CMD_ARGC < 2) || (CMD_ARGC > 3))
                return ERROR_COMMAND_SYNTAX_ERROR;
 

-       uint32_t address;
-       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
+       target_addr_t address;
+       COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address);

 
 

-       uint32_t value;
-       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value);
+       target_addr_t value;
+       COMMAND_PARSE_ADDRESS(CMD_ARGV[1], value);

 
        unsigned count = 1;
        if (CMD_ARGC == 3)
 
        unsigned count = 1;
        if (CMD_ARGC == 3)


@@ -3101,6 +3197,9 @@ COMMAND_HANDLER(handle_mw_command)
        struct target *target = get_current_target(CMD_CTX);
        unsigned wordsize;
        switch (CMD_NAME[2]) {
        struct target *target = get_current_target(CMD_CTX);
        unsigned wordsize;
        switch (CMD_NAME[2]) {

+               case 'd':
+                       wordsize = 8;
+                       break;

                case 'w':
                        wordsize = 4;
                        break;
                case 'w':
                        wordsize = 4;
                        break;


@@ -3118,7 +3217,7 @@ COMMAND_HANDLER(handle_mw_command)
 }
 
 static COMMAND_HELPER(parse_load_image_command_CMD_ARGV, struct image *image,
 }
 
 static COMMAND_HELPER(parse_load_image_command_CMD_ARGV, struct image *image,

-               uint32_t *min_address, uint32_t *max_address)
+               target_addr_t *min_address, target_addr_t *max_address)

 {
        if (CMD_ARGC < 1 || CMD_ARGC > 5)
                return ERROR_COMMAND_SYNTAX_ERROR;
 {
        if (CMD_ARGC < 1 || CMD_ARGC > 5)
                return ERROR_COMMAND_SYNTAX_ERROR;


@@ -3126,8 +3225,8 @@ static COMMAND_HELPER(parse_load_image_command_CMD_ARGV, struct image *image,
        /* a base address isn't always necessary,
         * default to 0x0 (i.e. don't relocate) */
        if (CMD_ARGC >= 2) {
        /* a base address isn't always necessary,
         * default to 0x0 (i.e. don't relocate) */
        if (CMD_ARGC >= 2) {

-               uint32_t addr;
-               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr);
+               target_addr_t addr;
+               COMMAND_PARSE_ADDRESS(CMD_ARGV[1], addr);

                image->base_address = addr;
                image->base_address_set = 1;
        } else
                image->base_address = addr;
                image->base_address_set = 1;
        } else


@@ -3136,9 +3235,9 @@ static COMMAND_HELPER(parse_load_image_command_CMD_ARGV, struct image *image,
        image->start_address_set = 0;
 
        if (CMD_ARGC >= 4)
        image->start_address_set = 0;
 
        if (CMD_ARGC >= 4)

-               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], *min_address);
+               COMMAND_PARSE_ADDRESS(CMD_ARGV[3], *min_address);

        if (CMD_ARGC == 5) {
        if (CMD_ARGC == 5) {

-               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[4], *max_address);
+               COMMAND_PARSE_ADDRESS(CMD_ARGV[4], *max_address);

                /* use size (given) to find max (required) */
                *max_address += *min_address;
        }
                /* use size (given) to find max (required) */
                *max_address += *min_address;
        }


@@ -3154,8 +3253,8 @@ COMMAND_HANDLER(handle_load_image_command)
        uint8_t *buffer;
        size_t buf_cnt;
        uint32_t image_size;
        uint8_t *buffer;
        size_t buf_cnt;
        uint32_t image_size;

-       uint32_t min_address = 0;
-       uint32_t max_address = 0xffffffff;
+       target_addr_t min_address = 0;
+       target_addr_t max_address = -1;

        int i;
        struct image image;
 
        int i;
        struct image image;
 


@@ -3214,7 +3313,7 @@ COMMAND_HANDLER(handle_load_image_command)
                                break;
                        }
                        image_size += length;
                                break;
                        }
                        image_size += length;

-                       command_print(CMD_CTX, "%u bytes written at address 0x%8.8" PRIx32 "",
+                       command_print(CMD_CTX, "%u bytes written at address " TARGET_ADDR_FMT "",

                                        (unsigned int)length,
                                        image.sections[i].base_address + offset);
                }
                                        (unsigned int)length,
                                        image.sections[i].base_address + offset);
                }


@@ -3239,15 +3338,15 @@ COMMAND_HANDLER(handle_dump_image_command)
        struct fileio *fileio;
        uint8_t *buffer;
        int retval, retvaltemp;
        struct fileio *fileio;
        uint8_t *buffer;
        int retval, retvaltemp;

-       uint32_t address, size;
+       target_addr_t address, size;

        struct duration bench;
        struct target *target = get_current_target(CMD_CTX);
 
        if (CMD_ARGC != 3)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        struct duration bench;
        struct target *target = get_current_target(CMD_CTX);
 
        if (CMD_ARGC != 3)
                return ERROR_COMMAND_SYNTAX_ERROR;
 

-       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], address);
-       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], size);
+       COMMAND_PARSE_ADDRESS(CMD_ARGV[1], address);
+       COMMAND_PARSE_ADDRESS(CMD_ARGV[2], size);

 
        uint32_t buf_size = (size > 4096) ? 4096 : size;
        buffer = malloc(buf_size);
 
        uint32_t buf_size = (size > 4096) ? 4096 : size;
        buffer = malloc(buf_size);


@@ -3328,8 +3427,8 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver
        duration_start(&bench);
 
        if (CMD_ARGC >= 2) {
        duration_start(&bench);
 
        if (CMD_ARGC >= 2) {

-               uint32_t addr;
-               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], addr);
+               target_addr_t addr;
+               COMMAND_PARSE_ADDRESS(CMD_ARGV[1], addr);

                image.base_address = addr;
                image.base_address_set = 1;
        } else {
                image.base_address = addr;
                image.base_address_set = 1;
        } else {


@@ -3419,7 +3518,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver
                                free(data);
                        }
                } else {
                                free(data);
                        }
                } else {

-                       command_print(CMD_CTX, "address 0x%08" PRIx32 " length 0x%08zx",
+                       command_print(CMD_CTX, "address " TARGET_ADDR_FMT " length 0x%08zx",

                                                  image.sections[i].base_address,
                                                  buf_cnt);
                }
                                                  image.sections[i].base_address,
                                                  buf_cnt);
                }


@@ -3466,7 +3565,7 @@ static int handle_bp_command_list(struct command_context *cmd_ctx)
                if (breakpoint->type == BKPT_SOFT) {
                        char *buf = buf_to_str(breakpoint->orig_instr,
                                        breakpoint->length, 16);
                if (breakpoint->type == BKPT_SOFT) {
                        char *buf = buf_to_str(breakpoint->orig_instr,
                                        breakpoint->length, 16);

-                       command_print(cmd_ctx, "IVA breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i, 0x%s",
+                       command_print(cmd_ctx, "IVA breakpoint: " TARGET_ADDR_FMT ", 0x%x, %i, 0x%s",

                                        breakpoint->address,
                                        breakpoint->length,
                                        breakpoint->set, buf);
                                        breakpoint->address,
                                        breakpoint->length,
                                        breakpoint->set, buf);


@@ -3477,13 +3576,13 @@ static int handle_bp_command_list(struct command_context *cmd_ctx)
                                                        breakpoint->asid,
                                                        breakpoint->length, breakpoint->set);
                        else if ((breakpoint->address != 0) && (breakpoint->asid != 0)) {
                                                        breakpoint->asid,
                                                        breakpoint->length, breakpoint->set);
                        else if ((breakpoint->address != 0) && (breakpoint->asid != 0)) {

-                               command_print(cmd_ctx, "Hybrid breakpoint(IVA): 0x%8.8" PRIx32 ", 0x%x, %i",
+                               command_print(cmd_ctx, "Hybrid breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",

                                                        breakpoint->address,
                                                        breakpoint->length, breakpoint->set);
                                command_print(cmd_ctx, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
                                                        breakpoint->asid);
                        } else
                                                        breakpoint->address,
                                                        breakpoint->length, breakpoint->set);
                                command_print(cmd_ctx, "\t|--->linked with ContextID: 0x%8.8" PRIx32,
                                                        breakpoint->asid);
                        } else

-                               command_print(cmd_ctx, "Breakpoint(IVA): 0x%8.8" PRIx32 ", 0x%x, %i",
+                               command_print(cmd_ctx, "Breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i",

                                                        breakpoint->address,
                                                        breakpoint->length, breakpoint->set);
                }
                                                        breakpoint->address,
                                                        breakpoint->length, breakpoint->set);
                }


@@ -3494,7 +3593,7 @@ static int handle_bp_command_list(struct command_context *cmd_ctx)
 }
 
 static int handle_bp_command_set(struct command_context *cmd_ctx,
 }
 
 static int handle_bp_command_set(struct command_context *cmd_ctx,

-               uint32_t addr, uint32_t asid, uint32_t length, int hw)
+               target_addr_t addr, uint32_t asid, uint32_t length, int hw)

 {
        struct target *target = get_current_target(cmd_ctx);
        int retval;
 {
        struct target *target = get_current_target(cmd_ctx);
        int retval;


@@ -3502,7 +3601,7 @@ static int handle_bp_command_set(struct command_context *cmd_ctx,
        if (asid == 0) {
                retval = breakpoint_add(target, addr, length, hw);
                if (ERROR_OK == retval)
        if (asid == 0) {
                retval = breakpoint_add(target, addr, length, hw);
                if (ERROR_OK == retval)

-                       command_print(cmd_ctx, "breakpoint set at 0x%8.8" PRIx32 "", addr);
+                       command_print(cmd_ctx, "breakpoint set at " TARGET_ADDR_FMT "", addr);

                else {
                        LOG_ERROR("Failure setting breakpoint, the same address(IVA) is already used");
                        return retval;
                else {
                        LOG_ERROR("Failure setting breakpoint, the same address(IVA) is already used");
                        return retval;


@@ -3537,7 +3636,7 @@ static int handle_bp_command_set(struct command_context *cmd_ctx,
 
 COMMAND_HANDLER(handle_bp_command)
 {
 
 COMMAND_HANDLER(handle_bp_command)
 {

-       uint32_t addr;
+       target_addr_t addr;

        uint32_t asid;
        uint32_t length;
        int hw = BKPT_SOFT;
        uint32_t asid;
        uint32_t length;
        int hw = BKPT_SOFT;


@@ -3548,17 +3647,15 @@ COMMAND_HANDLER(handle_bp_command)
 
                case 2:
                        asid = 0;
 
                case 2:
                        asid = 0;

-                       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
+                       COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr);

                        COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
                        return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
 
                case 3:
                        if (strcmp(CMD_ARGV[2], "hw") == 0) {
                                hw = BKPT_HARD;
                        COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
                        return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
 
                case 3:
                        if (strcmp(CMD_ARGV[2], "hw") == 0) {
                                hw = BKPT_HARD;

-                               COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
-
+                               COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr);

                                COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
                                COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);

-

                                asid = 0;
                                return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
                        } else if (strcmp(CMD_ARGV[2], "hw_ctx") == 0) {
                                asid = 0;
                                return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
                        } else if (strcmp(CMD_ARGV[2], "hw_ctx") == 0) {


@@ -3571,7 +3668,7 @@ COMMAND_HANDLER(handle_bp_command)
 
                case 4:
                        hw = BKPT_HARD;
 
                case 4:
                        hw = BKPT_HARD;

-                       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
+                       COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr);

                        COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], asid);
                        COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], length);
                        return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);
                        COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], asid);
                        COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], length);
                        return handle_bp_command_set(CMD_CTX, addr, asid, length, hw);


@@ -3586,8 +3683,8 @@ COMMAND_HANDLER(handle_rbp_command)
        if (CMD_ARGC != 1)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        if (CMD_ARGC != 1)
                return ERROR_COMMAND_SYNTAX_ERROR;
 

-       uint32_t addr;
-       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], addr);
+       target_addr_t addr;
+       COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr);

 
        struct target *target = get_current_target(CMD_CTX);
        breakpoint_remove(target, addr);
 
        struct target *target = get_current_target(CMD_CTX);
        breakpoint_remove(target, addr);


@@ -3603,7 +3700,7 @@ COMMAND_HANDLER(handle_wp_command)
                struct watchpoint *watchpoint = target->watchpoints;
 
                while (watchpoint) {
                struct watchpoint *watchpoint = target->watchpoints;
 
                while (watchpoint) {

-                       command_print(CMD_CTX, "address: 0x%8.8" PRIx32
+                       command_print(CMD_CTX, "address: " TARGET_ADDR_FMT

                                        ", len: 0x%8.8" PRIx32
                                        ", r/w/a: %i, value: 0x%8.8" PRIx32
                                        ", mask: 0x%8.8" PRIx32,
                                        ", len: 0x%8.8" PRIx32
                                        ", r/w/a: %i, value: 0x%8.8" PRIx32
                                        ", mask: 0x%8.8" PRIx32,


@@ -3688,14 +3785,14 @@ COMMAND_HANDLER(handle_virt2phys_command)
        if (CMD_ARGC != 1)
                return ERROR_COMMAND_SYNTAX_ERROR;
 
        if (CMD_ARGC != 1)
                return ERROR_COMMAND_SYNTAX_ERROR;
 

-       uint32_t va;
-       COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], va);
-       uint32_t pa;
+       target_addr_t va;
+       COMMAND_PARSE_ADDRESS(CMD_ARGV[0], va);
+       target_addr_t pa;

 
        struct target *target = get_current_target(CMD_CTX);
        int retval = target->type->virt2phys(target, va, &pa);
        if (retval == ERROR_OK)
 
        struct target *target = get_current_target(CMD_CTX);
        int retval = target->type->virt2phys(target, va, &pa);
        if (retval == ERROR_OK)

-               command_print(CMD_CTX, "Physical address 0x%08" PRIx32 "", pa);
+               command_print(CMD_CTX, "Physical address " TARGET_ADDR_FMT "", pa);

 
        return retval;
 }
 
        return retval;
 }


@@ -4771,7 +4868,7 @@ static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
        }
 
        int (*fn)(struct target *target,
        }
 
        int (*fn)(struct target *target,

-                       uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
+                       target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer);

        fn = target_read_memory;
 
        int e;
        fn = target_read_memory;
 
        int e;


@@ -5643,7 +5740,7 @@ static const struct command_registration target_subcommand_handlers[] = {
 };
 
 struct FastLoad {
 };
 
 struct FastLoad {

-       uint32_t address;
+       target_addr_t address;

        uint8_t *data;
        int length;
 
        uint8_t *data;
        int length;
 


@@ -5670,8 +5767,8 @@ COMMAND_HANDLER(handle_fast_load_image_command)
        uint8_t *buffer;
        size_t buf_cnt;
        uint32_t image_size;
        uint8_t *buffer;
        size_t buf_cnt;
        uint32_t image_size;

-       uint32_t min_address = 0;
-       uint32_t max_address = 0xffffffff;
+       target_addr_t min_address = 0;
+       target_addr_t max_address = -1;

        int i;
 
        struct image image;
        int i;
 
        struct image image;


@@ -6141,6 +6238,13 @@ static const struct command_registration target_exec_command_handlers[] = {
                .help = "step one instruction from current PC or address",
                .usage = "[address]",
        },
                .help = "step one instruction from current PC or address",
                .usage = "[address]",
        },

+       {
+               .name = "mdd",
+               .handler = handle_md_command,
+               .mode = COMMAND_EXEC,
+               .help = "display memory words",
+               .usage = "['phys'] address [count]",
+       },

        {
                .name = "mdw",
                .handler = handle_md_command,
        {
                .name = "mdw",
                .handler = handle_md_command,


@@ -6162,6 +6266,13 @@ static const struct command_registration target_exec_command_handlers[] = {
                .help = "display memory bytes",
                .usage = "['phys'] address [count]",
        },
                .help = "display memory bytes",
                .usage = "['phys'] address [count]",
        },

+       {
+               .name = "mwd",
+               .handler = handle_mw_command,
+               .mode = COMMAND_EXEC,
+               .help = "write memory word",
+               .usage = "['phys'] address value [count]",
+       },

        {
                .name = "mww",
                .handler = handle_mw_command,
        {
                .name = "mww",
                .handler = handle_mw_command,

diff --git a/src/target/target.h b/src/target/target.h
index e86b700a3fb69863c8300b673a69626e109df3cf..41c9333ec72f3f57a7534e0f317e5c82f7f76489 100644 (file)
--- a/src/target/target.h
+++ b/src/target/target.h
@@ -93,7 +93,7 @@ enum target_endianness {
 };
 
 struct working_area {
 };
 
 struct working_area {

-       uint32_t address;
+       target_addr_t address;

        uint32_t size;
        bool free;
        uint8_t *backup;
        uint32_t size;
        bool free;
        uint8_t *backup;


@@ -156,9 +156,9 @@ struct target {
        uint32_t working_area;                          /* working area (initialised RAM). Evaluated
                                                                                 * upon first allocation from virtual/physical address. */
        bool working_area_virt_spec;            /* virtual address specified? */
        uint32_t working_area;                          /* working area (initialised RAM). Evaluated
                                                                                 * upon first allocation from virtual/physical address. */
        bool working_area_virt_spec;            /* virtual address specified? */

-       uint32_t working_area_virt;                     /* virtual address */
+       target_addr_t working_area_virt;                        /* virtual address */

        bool working_area_phys_spec;            /* physical address specified? */
        bool working_area_phys_spec;            /* physical address specified? */

-       uint32_t working_area_phys;                     /* physical address */
+       target_addr_t working_area_phys;                        /* physical address */

        uint32_t working_area_size;                     /* size in bytes */
        uint32_t backup_working_area;           /* whether the content of the working area has to be preserved */
        struct working_area *working_areas;/* list of allocated working areas */
        uint32_t working_area_size;                     /* size in bytes */
        uint32_t backup_working_area;           /* whether the content of the working area has to be preserved */
        struct working_area *working_areas;/* list of allocated working areas */


@@ -353,7 +353,7 @@ int target_unregister_trace_callback(
  * yet it is possible to detect error conditions.
  */
 int target_poll(struct target *target);
  * yet it is possible to detect error conditions.
  */
 int target_poll(struct target *target);

-int target_resume(struct target *target, int current, uint32_t address,
+int target_resume(struct target *target, int current, target_addr_t address,

                int handle_breakpoints, int debug_execution);
 int target_halt(struct target *target);
 int target_call_event_callbacks(struct target *target, enum target_event event);
                int handle_breakpoints, int debug_execution);
 int target_halt(struct target *target);
 int target_call_event_callbacks(struct target *target, enum target_event event);


@@ -474,7 +474,7 @@ int target_get_gdb_reg_list(struct target *target,
  * This routine is a wrapper for target->type->step.
  */
 int target_step(struct target *target,
  * This routine is a wrapper for target->type->step.
  */
 int target_step(struct target *target,

-               int current, uint32_t address, int handle_breakpoints);
+               int current, target_addr_t address, int handle_breakpoints);

 /**
  * Run an algorithm on the @a target given.
  *
 /**
  * Run an algorithm on the @a target given.
  *


@@ -527,9 +527,9 @@ int target_run_flash_async_algorithm(struct target *target,
  * This routine is a wrapper for target->type->read_memory.
  */
 int target_read_memory(struct target *target,
  * This routine is a wrapper for target->type->read_memory.
  */
 int target_read_memory(struct target *target,

-               uint32_t address, uint32_t size, uint32_t count, uint8_t *buffer);
+               target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer);

 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);
+               target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer);

 /**
  * Write @a count items of @a size bytes to the memory of @a target at
  * the @a address given. @a address must be aligned to @a size
 /**
  * Write @a count items of @a size bytes to the memory of @a target at
  * the @a address given. @a address must be aligned to @a size


@@ -548,9 +548,9 @@ int target_read_phys_memory(struct target *target,
  * This routine is wrapper for target->type->write_memory.
  */
 int target_write_memory(struct target *target,
  * This routine is wrapper for target->type->write_memory.
  */
 int target_write_memory(struct target *target,

-               uint32_t address, uint32_t size, uint32_t count, const uint8_t *buffer);
+               target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer);

 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);
+               target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer);

 
 /*
  * Write to target memory using the virtual address.
 
 /*
  * Write to target memory using the virtual address.


@@ -577,13 +577,13 @@ int target_write_phys_memory(struct target *target,
  * peripheral registers which do not support byte operations.
  */
 int target_write_buffer(struct target *target,
  * peripheral registers which do not support byte operations.
  */
 int target_write_buffer(struct target *target,

-               uint32_t address, uint32_t size, const uint8_t *buffer);
+               target_addr_t address, uint32_t size, const uint8_t *buffer);

 int target_read_buffer(struct target *target,
 int target_read_buffer(struct target *target,

-               uint32_t address, uint32_t size, uint8_t *buffer);
+               target_addr_t address, uint32_t size, uint8_t *buffer);

 int target_checksum_memory(struct target *target,
 int target_checksum_memory(struct target *target,

-               uint32_t address, uint32_t size, uint32_t *crc);
+               target_addr_t address, uint32_t size, uint32_t *crc);

 int target_blank_check_memory(struct target *target,
 int target_blank_check_memory(struct target *target,

-               uint32_t address, uint32_t size, uint32_t *blank, uint8_t erased_value);
+               target_addr_t address, uint32_t size, uint32_t *blank, uint8_t erased_value);

 int target_wait_state(struct target *target, enum target_state state, int ms);
 
 /**
 int target_wait_state(struct target *target, enum target_state state, int ms);
 
 /**


@@ -659,14 +659,19 @@ void target_buffer_set_u64_array(struct target *target, uint8_t *buffer, uint32_
 void target_buffer_set_u32_array(struct target *target, uint8_t *buffer, uint32_t count, const uint32_t *srcbuf);
 void target_buffer_set_u16_array(struct target *target, uint8_t *buffer, uint32_t count, const uint16_t *srcbuf);
 
 void target_buffer_set_u32_array(struct target *target, uint8_t *buffer, uint32_t count, const uint32_t *srcbuf);
 void target_buffer_set_u16_array(struct target *target, uint8_t *buffer, uint32_t count, const uint16_t *srcbuf);
 

-int target_read_u64(struct target *target, uint64_t address, uint64_t *value);
-int target_read_u32(struct target *target, uint32_t address, uint32_t *value);
-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 target_write_u64(struct target *target, uint64_t address, uint64_t value);
-int target_write_u32(struct target *target, uint32_t address, uint32_t value);
-int target_write_u16(struct target *target, uint32_t address, uint16_t value);
-int target_write_u8(struct target *target, uint32_t address, uint8_t value);
+int target_read_u64(struct target *target, target_addr_t address, uint64_t *value);
+int target_read_u32(struct target *target, target_addr_t address, uint32_t *value);
+int target_read_u16(struct target *target, target_addr_t address, uint16_t *value);
+int target_read_u8(struct target *target, target_addr_t address, uint8_t *value);
+int target_write_u64(struct target *target, target_addr_t address, uint64_t value);
+int target_write_u32(struct target *target, target_addr_t address, uint32_t value);
+int target_write_u16(struct target *target, target_addr_t address, uint16_t value);
+int target_write_u8(struct target *target, target_addr_t address, uint8_t value);
+
+int target_write_phys_u64(struct target *target, target_addr_t address, uint64_t value);
+int target_write_phys_u32(struct target *target, target_addr_t address, uint32_t value);
+int target_write_phys_u16(struct target *target, target_addr_t address, uint16_t value);
+int target_write_phys_u8(struct target *target, target_addr_t address, uint8_t value);

 
 /* Issues USER() statements with target state information */
 int target_arch_state(struct target *target);
 
 /* Issues USER() statements with target state information */
 int target_arch_state(struct target *target);

diff --git a/src/target/target_type.h b/src/target/target_type.h
index 2473c62cbeee8e88479576ba14e037edeaba389c..34e2778ad0c53d9e06c3937066add6b30a0e37f2 100644 (file)
--- a/src/target/target_type.h
+++ b/src/target/target_type.h
@@ -53,11 +53,10 @@ struct target_type {
 
        /* halt will log a warning, but return ERROR_OK if the target is already halted. */
        int (*halt)(struct target *target);
 
        /* halt will log a warning, but return ERROR_OK if the target is already halted. */
        int (*halt)(struct target *target);

-       int (*resume)(struct target *target, int current, uint32_t address,
+       int (*resume)(struct target *target, int current, target_addr_t address,

                        int handle_breakpoints, int debug_execution);
                        int handle_breakpoints, int debug_execution);

-       int (*step)(struct target *target, int current, uint32_t address,
+       int (*step)(struct target *target, int current, target_addr_t address,

                        int handle_breakpoints);
                        int handle_breakpoints);

-

        /* target reset control. assert reset can be invoked when OpenOCD and
         * the target is out of sync.
         *
        /* target reset control. assert reset can be invoked when OpenOCD and
         * the target is out of sync.
         *


@@ -111,26 +110,26 @@ struct target_type {
         * Target memory read callback.  Do @b not call this function
         * directly, use target_read_memory() instead.
         */
         * Target memory read callback.  Do @b not call this function
         * directly, use target_read_memory() instead.
         */

-       int (*read_memory)(struct target *target, uint32_t address,
+       int (*read_memory)(struct target *target, target_addr_t address,

                        uint32_t size, uint32_t count, uint8_t *buffer);
        /**
         * Target memory write callback.  Do @b not call this function
         * directly, use target_write_memory() instead.
         */
                        uint32_t size, uint32_t count, uint8_t *buffer);
        /**
         * Target memory write callback.  Do @b not call this function
         * directly, use target_write_memory() instead.
         */

-       int (*write_memory)(struct target *target, uint32_t address,
+       int (*write_memory)(struct target *target, target_addr_t address,

                        uint32_t size, uint32_t count, const uint8_t *buffer);
 
        /* Default implementation will do some fancy alignment to improve performance, target can override */
                        uint32_t size, uint32_t count, const uint8_t *buffer);
 
        /* Default implementation will do some fancy alignment to improve performance, target can override */

-       int (*read_buffer)(struct target *target, uint32_t address,
+       int (*read_buffer)(struct target *target, target_addr_t address,

                        uint32_t size, uint8_t *buffer);
 
        /* Default implementation will do some fancy alignment to improve performance, target can override */
                        uint32_t size, uint8_t *buffer);
 
        /* Default implementation will do some fancy alignment to improve performance, target can override */

-       int (*write_buffer)(struct target *target, uint32_t address,
+       int (*write_buffer)(struct target *target, target_addr_t address,

                        uint32_t size, const uint8_t *buffer);
 
                        uint32_t size, const uint8_t *buffer);
 

-       int (*checksum_memory)(struct target *target, uint32_t address,
+       int (*checksum_memory)(struct target *target, target_addr_t address,

                        uint32_t count, uint32_t *checksum);
                        uint32_t count, uint32_t *checksum);

-       int (*blank_check_memory)(struct target *target, uint32_t address,
+       int (*blank_check_memory)(struct target *target, target_addr_t address,

                        uint32_t count, uint32_t *blank, uint8_t erased_value);
 
        /*
                        uint32_t count, uint32_t *blank, uint8_t erased_value);
 
        /*


@@ -175,15 +174,15 @@ struct target_type {
         */
        int (*run_algorithm)(struct target *target, int num_mem_params,
                        struct mem_param *mem_params, int num_reg_params,
         */
        int (*run_algorithm)(struct target *target, int num_mem_params,
                        struct mem_param *mem_params, int num_reg_params,

-                       struct reg_param *reg_param, uint32_t entry_point,
-                       uint32_t exit_point, int timeout_ms, void *arch_info);
+                       struct reg_param *reg_param, target_addr_t entry_point,
+                       target_addr_t exit_point, int timeout_ms, void *arch_info);

        int (*start_algorithm)(struct target *target, int num_mem_params,
                        struct mem_param *mem_params, int num_reg_params,
        int (*start_algorithm)(struct target *target, int num_mem_params,
                        struct mem_param *mem_params, int num_reg_params,

-                       struct reg_param *reg_param, uint32_t entry_point,
-                       uint32_t exit_point, void *arch_info);
+                       struct reg_param *reg_param, target_addr_t entry_point,
+                       target_addr_t exit_point, void *arch_info);

        int (*wait_algorithm)(struct target *target, int num_mem_params,
                        struct mem_param *mem_params, int num_reg_params,
        int (*wait_algorithm)(struct target *target, int num_mem_params,
                        struct mem_param *mem_params, int num_reg_params,

-                       struct reg_param *reg_param, uint32_t exit_point,
+                       struct reg_param *reg_param, target_addr_t exit_point,

                        int timeout_ms, void *arch_info);
 
        const struct command_registration *commands;
                        int timeout_ms, void *arch_info);
 
        const struct command_registration *commands;


@@ -233,7 +232,7 @@ struct target_type {
        /* translate from virtual to physical address. Default implementation is successful
         * no-op(i.e. virtual==physical).
         */
        /* translate from virtual to physical address. Default implementation is successful
         * no-op(i.e. virtual==physical).
         */

-       int (*virt2phys)(struct target *target, uint32_t address, uint32_t *physical);
+       int (*virt2phys)(struct target *target, target_addr_t address, target_addr_t *physical);

 
        /* read directly from physical memory. caches are bypassed and untouched.
         *
 
        /* read directly from physical memory. caches are bypassed and untouched.
         *


@@ -243,13 +242,13 @@ struct target_type {
         *
         * Default implementation is to call read_memory.
         */
         *
         * Default implementation is to call read_memory.
         */

-       int (*read_phys_memory)(struct target *target, uint32_t phys_address,
+       int (*read_phys_memory)(struct target *target, target_addr_t phys_address,

                        uint32_t size, uint32_t count, uint8_t *buffer);
 
        /*
         * same as read_phys_memory, except that it writes...
         */
                        uint32_t size, uint32_t count, uint8_t *buffer);
 
        /*
         * same as read_phys_memory, except that it writes...
         */

-       int (*write_phys_memory)(struct target *target, uint32_t phys_address,
+       int (*write_phys_memory)(struct target *target, target_addr_t phys_address,

                        uint32_t size, uint32_t count, const uint8_t *buffer);
 
        int (*mmu)(struct target *target, int *enabled);
                        uint32_t size, uint32_t count, const uint8_t *buffer);
 
        int (*mmu)(struct target *target, int *enabled);

diff --git a/src/target/x86_32_common.c b/src/target/x86_32_common.c
index c21167e1e1af35625546c3407b1074548405a96b..34f92eaca81d2deff7f1ef833854757f6c47aa9a 100644 (file)
--- a/src/target/x86_32_common.c
+++ b/src/target/x86_32_common.c
@@ -48,8 +48,8 @@ static int read_mem(struct target *t, uint32_t size,
                        uint32_t addr, uint8_t *buf);
 static int write_mem(struct target *t, uint32_t size,
                        uint32_t addr, const uint8_t *buf);
                        uint32_t addr, uint8_t *buf);
 static int write_mem(struct target *t, uint32_t size,
                        uint32_t addr, const uint8_t *buf);

-static int calcaddr_physfromlin(struct target *t, uint32_t addr,
-                       uint32_t *physaddr);
+static int calcaddr_physfromlin(struct target *t, target_addr_t addr,
+                       target_addr_t *physaddr);

 static int read_phys_mem(struct target *t, uint32_t phys_address,
                        uint32_t size, uint32_t count, uint8_t *buffer);
 static int write_phys_mem(struct target *t, uint32_t phys_address,
 static int read_phys_mem(struct target *t, uint32_t phys_address,
                        uint32_t size, uint32_t count, uint8_t *buffer);
 static int write_phys_mem(struct target *t, uint32_t phys_address,


@@ -113,7 +113,7 @@ int x86_32_common_mmu(struct target *t, int *enabled)
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-int x86_32_common_virt2phys(struct target *t, uint32_t address, uint32_t *physical)
+int x86_32_common_virt2phys(struct target *t, target_addr_t address, target_addr_t *physical)

 {
        struct x86_32_common *x86_32 = target_to_x86_32(t);
 
 {
        struct x86_32_common *x86_32 = target_to_x86_32(t);
 


@@ -135,7 +135,7 @@ int x86_32_common_virt2phys(struct target *t, uint32_t address, uint32_t *physic
        } else {
                /* target halted in protected mode */
                if (calcaddr_physfromlin(t, address, physical) != ERROR_OK) {
        } else {
                /* target halted in protected mode */
                if (calcaddr_physfromlin(t, address, physical) != ERROR_OK) {

-                       LOG_ERROR("%s failed to calculate physical address from 0x%08" PRIx32,
+                       LOG_ERROR("%s failed to calculate physical address from " TARGET_ADDR_FMT,

                                        __func__, address);
                        return ERROR_FAIL;
                }
                                        __func__, address);
                        return ERROR_FAIL;
                }


@@ -143,7 +143,7 @@ int x86_32_common_virt2phys(struct target *t, uint32_t address, uint32_t *physic
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-int x86_32_common_read_phys_mem(struct target *t, uint32_t phys_address,
+int x86_32_common_read_phys_mem(struct target *t, target_addr_t phys_address,

                        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct x86_32_common *x86_32 = target_to_x86_32(t);
                        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct x86_32_common *x86_32 = target_to_x86_32(t);


@@ -226,7 +226,7 @@ static int read_phys_mem(struct target *t, uint32_t phys_address,
        return retval;
 }
 
        return retval;
 }
 

-int x86_32_common_write_phys_mem(struct target *t, uint32_t phys_address,
+int x86_32_common_write_phys_mem(struct target *t, target_addr_t phys_address,

                        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct x86_32_common *x86_32 = target_to_x86_32(t);
                        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct x86_32_common *x86_32 = target_to_x86_32(t);


@@ -235,7 +235,7 @@ int x86_32_common_write_phys_mem(struct target *t, uint32_t phys_address,
 
        check_not_halted(t);
        if (!count || !buffer || !phys_address) {
 
        check_not_halted(t);
        if (!count || !buffer || !phys_address) {

-               LOG_ERROR("%s invalid params count=0x%" PRIx32 ", buf=%p, addr=0x%08" PRIx32,
+               LOG_ERROR("%s invalid params count=0x%" PRIx32 ", buf=%p, addr=" TARGET_ADDR_FMT,

                                __func__, count, buffer, phys_address);
                return ERROR_COMMAND_ARGUMENT_INVALID;
        }
                                __func__, count, buffer, phys_address);
                return ERROR_COMMAND_ARGUMENT_INVALID;
        }


@@ -444,7 +444,7 @@ static int write_mem(struct target *t, uint32_t size,
        return retval;
 }
 
        return retval;
 }
 

-int calcaddr_physfromlin(struct target *t, uint32_t addr, uint32_t *physaddr)
+int calcaddr_physfromlin(struct target *t, target_addr_t addr, target_addr_t *physaddr)

 {
        uint8_t entry_buffer[8];
 
 {
        uint8_t entry_buffer[8];
 


@@ -568,16 +568,16 @@ int calcaddr_physfromlin(struct target *t, uint32_t addr, uint32_t *physaddr)
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-int x86_32_common_read_memory(struct target *t, uint32_t addr,
+int x86_32_common_read_memory(struct target *t, target_addr_t addr,

                        uint32_t size, uint32_t count, uint8_t *buf)
 {
        int retval = ERROR_OK;
        struct x86_32_common *x86_32 = target_to_x86_32(t);
                        uint32_t size, uint32_t count, uint8_t *buf)
 {
        int retval = ERROR_OK;
        struct x86_32_common *x86_32 = target_to_x86_32(t);

-       LOG_DEBUG("addr=0x%08" PRIx32 ", size=%" PRIu32 ", count=0x%" PRIx32 ", buf=%p",
+       LOG_DEBUG("addr=" TARGET_ADDR_FMT ", size=%" PRIu32 ", count=0x%" PRIx32 ", buf=%p",

                        addr, size, count, buf);
        check_not_halted(t);
        if (!count || !buf || !addr) {
                        addr, size, count, buf);
        check_not_halted(t);
        if (!count || !buf || !addr) {

-               LOG_ERROR("%s invalid params count=0x%" PRIx32 ", buf=%p, addr=0x%08" PRIx32,
+               LOG_ERROR("%s invalid params count=0x%" PRIx32 ", buf=%p, addr=" TARGET_ADDR_FMT,

                                __func__, count, buf, addr);
                return ERROR_COMMAND_ARGUMENT_INVALID;
        }
                                __func__, count, buf, addr);
                return ERROR_COMMAND_ARGUMENT_INVALID;
        }


@@ -591,9 +591,10 @@ int x86_32_common_read_memory(struct target *t, uint32_t addr,
                        LOG_ERROR("%s could not disable paging", __func__);
                        return retval;
                }
                        LOG_ERROR("%s could not disable paging", __func__);
                        return retval;
                }

-               uint32_t physaddr = 0;
+               target_addr_t physaddr = 0;

                if (calcaddr_physfromlin(t, addr, &physaddr) != ERROR_OK) {
                if (calcaddr_physfromlin(t, addr, &physaddr) != ERROR_OK) {

-                       LOG_ERROR("%s failed to calculate physical address from 0x%08" PRIx32, __func__, addr);
+                       LOG_ERROR("%s failed to calculate physical address from " TARGET_ADDR_FMT,
+                                         __func__, addr);

                        retval = ERROR_FAIL;
                }
                /* TODO: !!! Watch out for page boundaries
                        retval = ERROR_FAIL;
                }
                /* TODO: !!! Watch out for page boundaries


@@ -603,7 +604,8 @@ int x86_32_common_read_memory(struct target *t, uint32_t addr,
 
                if (retval == ERROR_OK
                        && x86_32_common_read_phys_mem(t, physaddr, size, count, buf) != ERROR_OK) {
 
                if (retval == ERROR_OK
                        && x86_32_common_read_phys_mem(t, physaddr, size, count, buf) != ERROR_OK) {

-                       LOG_ERROR("%s failed to read memory from physical address 0x%08" PRIx32, __func__, physaddr);
+                       LOG_ERROR("%s failed to read memory from physical address " TARGET_ADDR_FMT,
+                                         __func__, physaddr);

                        retval = ERROR_FAIL;
                }
                /* restore PG bit if it was cleared prior (regardless of retval) */
                        retval = ERROR_FAIL;
                }
                /* restore PG bit if it was cleared prior (regardless of retval) */


@@ -615,7 +617,8 @@ int x86_32_common_read_memory(struct target *t, uint32_t addr,
        } else {
                /* paging is off - linear address is physical address */
                if (x86_32_common_read_phys_mem(t, addr, size, count, buf) != ERROR_OK) {
        } else {
                /* paging is off - linear address is physical address */
                if (x86_32_common_read_phys_mem(t, addr, size, count, buf) != ERROR_OK) {

-                       LOG_ERROR("%s failed to read memory from address 0%08" PRIx32, __func__, addr);
+                       LOG_ERROR("%s failed to read memory from address " TARGET_ADDR_FMT,
+                                         __func__, addr);

                        retval = ERROR_FAIL;
                }
        }
                        retval = ERROR_FAIL;
                }
        }


@@ -623,16 +626,16 @@ int x86_32_common_read_memory(struct target *t, uint32_t addr,
        return retval;
 }
 
        return retval;
 }
 

-int x86_32_common_write_memory(struct target *t, uint32_t addr,
+int x86_32_common_write_memory(struct target *t, target_addr_t addr,

                        uint32_t size, uint32_t count, const uint8_t *buf)
 {
        int retval = ERROR_OK;
        struct x86_32_common *x86_32 = target_to_x86_32(t);
                        uint32_t size, uint32_t count, const uint8_t *buf)
 {
        int retval = ERROR_OK;
        struct x86_32_common *x86_32 = target_to_x86_32(t);

-       LOG_DEBUG("addr=0x%08" PRIx32 ", size=%" PRIu32 ", count=0x%" PRIx32 ", buf=%p",
+       LOG_DEBUG("addr=" TARGET_ADDR_FMT ", size=%" PRIu32 ", count=0x%" PRIx32 ", buf=%p",

                        addr, size, count, buf);
        check_not_halted(t);
        if (!count || !buf || !addr) {
                        addr, size, count, buf);
        check_not_halted(t);
        if (!count || !buf || !addr) {

-               LOG_ERROR("%s invalid params count=0x%" PRIx32 ", buf=%p, addr=0x%08" PRIx32,
+               LOG_ERROR("%s invalid params count=0x%" PRIx32 ", buf=%p, addr=" TARGET_ADDR_FMT,

                                        __func__, count, buf, addr);
                return ERROR_COMMAND_ARGUMENT_INVALID;
        }
                                        __func__, count, buf, addr);
                return ERROR_COMMAND_ARGUMENT_INVALID;
        }


@@ -645,9 +648,9 @@ int x86_32_common_write_memory(struct target *t, uint32_t addr,
                        LOG_ERROR("%s could not disable paging", __func__);
                        return retval;
                }
                        LOG_ERROR("%s could not disable paging", __func__);
                        return retval;
                }

-               uint32_t physaddr = 0;
+               target_addr_t physaddr = 0;

                if (calcaddr_physfromlin(t, addr, &physaddr) != ERROR_OK) {
                if (calcaddr_physfromlin(t, addr, &physaddr) != ERROR_OK) {

-                       LOG_ERROR("%s failed to calculate physical address from 0x%08" PRIx32,
+                       LOG_ERROR("%s failed to calculate physical address from " TARGET_ADDR_FMT,

                                        __func__, addr);
                        retval = ERROR_FAIL;
                }
                                        __func__, addr);
                        retval = ERROR_FAIL;
                }


@@ -657,7 +660,7 @@ int x86_32_common_write_memory(struct target *t, uint32_t addr,
                 */
                if (retval == ERROR_OK
                        && x86_32_common_write_phys_mem(t, physaddr, size, count, buf) != ERROR_OK) {
                 */
                if (retval == ERROR_OK
                        && x86_32_common_write_phys_mem(t, physaddr, size, count, buf) != ERROR_OK) {

-                       LOG_ERROR("%s failed to write memory to physical address 0x%08" PRIx32,
+                       LOG_ERROR("%s failed to write memory to physical address " TARGET_ADDR_FMT,

                                        __func__, physaddr);
                        retval = ERROR_FAIL;
                }
                                        __func__, physaddr);
                        retval = ERROR_FAIL;
                }


@@ -671,7 +674,7 @@ int x86_32_common_write_memory(struct target *t, uint32_t addr,
 
                /* paging is off - linear address is physical address */
                if (x86_32_common_write_phys_mem(t, addr, size, count, buf) != ERROR_OK) {
 
                /* paging is off - linear address is physical address */
                if (x86_32_common_write_phys_mem(t, addr, size, count, buf) != ERROR_OK) {

-                       LOG_ERROR("%s failed to write memory to address 0x%08" PRIx32,
+                       LOG_ERROR("%s failed to write memory to address " TARGET_ADDR_FMT,

                                        __func__, addr);
                        retval = ERROR_FAIL;
                }
                                        __func__, addr);
                        retval = ERROR_FAIL;
                }


@@ -852,7 +855,7 @@ int x86_32_common_remove_watchpoint(struct target *t, struct watchpoint *wp)
 
 int x86_32_common_add_breakpoint(struct target *t, struct breakpoint *bp)
 {
 
 int x86_32_common_add_breakpoint(struct target *t, struct breakpoint *bp)
 {

-       LOG_DEBUG("type=%d, addr=0x%08" PRIx32, bp->type, bp->address);
+       LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, bp->type, bp->address);

        if (check_not_halted(t))
                return ERROR_TARGET_NOT_HALTED;
        /* set_breakpoint() will return ERROR_TARGET_RESOURCE_NOT_AVAILABLE if all
        if (check_not_halted(t))
                return ERROR_TARGET_NOT_HALTED;
        /* set_breakpoint() will return ERROR_TARGET_RESOURCE_NOT_AVAILABLE if all


@@ -863,7 +866,7 @@ int x86_32_common_add_breakpoint(struct target *t, struct breakpoint *bp)
 
 int x86_32_common_remove_breakpoint(struct target *t, struct breakpoint *bp)
 {
 
 int x86_32_common_remove_breakpoint(struct target *t, struct breakpoint *bp)
 {

-       LOG_DEBUG("type=%d, addr=0x%08" PRIx32, bp->type, bp->address);
+       LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, bp->type, bp->address);

        if (check_not_halted(t))
                return ERROR_TARGET_NOT_HALTED;
        if (bp->set)
        if (check_not_halted(t))
                return ERROR_TARGET_NOT_HALTED;
        if (bp->set)


@@ -1003,7 +1006,7 @@ static int unset_hwbp(struct target *t, struct breakpoint *bp)
        debug_reg_list[hwbp_num].used = 0;
        debug_reg_list[hwbp_num].bp_value = 0;
 
        debug_reg_list[hwbp_num].used = 0;
        debug_reg_list[hwbp_num].bp_value = 0;
 

-       LOG_USER("%s hardware breakpoint %" PRIu32 " removed from 0x%08" PRIx32 " (hwreg=%d)",
+       LOG_USER("%s hardware breakpoint %" PRIu32 " removed from " TARGET_ADDR_FMT " (hwreg=%d)",

                        __func__, bp->unique_id, bp->address, hwbp_num);
        return ERROR_OK;
 }
                        __func__, bp->unique_id, bp->address, hwbp_num);
        return ERROR_OK;
 }


@@ -1012,7 +1015,7 @@ static int set_swbp(struct target *t, struct breakpoint *bp)
 {
        struct x86_32_common *x86_32 = target_to_x86_32(t);
        LOG_DEBUG("id %" PRIx32, bp->unique_id);
 {
        struct x86_32_common *x86_32 = target_to_x86_32(t);
        LOG_DEBUG("id %" PRIx32, bp->unique_id);

-       uint32_t physaddr;
+       target_addr_t physaddr;

        uint8_t opcode = SW_BP_OPCODE;
        uint8_t readback;
 
        uint8_t opcode = SW_BP_OPCODE;
        uint8_t readback;
 


@@ -1032,7 +1035,7 @@ static int set_swbp(struct target *t, struct breakpoint *bp)
                return ERROR_FAIL;
 
        if (readback != SW_BP_OPCODE) {
                return ERROR_FAIL;
 
        if (readback != SW_BP_OPCODE) {

-               LOG_ERROR("%s software breakpoint error at 0x%08" PRIx32 ", check memory",
+               LOG_ERROR("%s software breakpoint error at " TARGET_ADDR_FMT ", check memory",

                                __func__, bp->address);
                LOG_ERROR("%s readback=0x%02" PRIx8 " orig=0x%02" PRIx8 "",
                                __func__, readback, *bp->orig_instr);
                                __func__, bp->address);
                LOG_ERROR("%s readback=0x%02" PRIx8 " orig=0x%02" PRIx8 "",
                                __func__, readback, *bp->orig_instr);


@@ -1059,7 +1062,7 @@ static int set_swbp(struct target *t, struct breakpoint *bp)
                        addto = addto->next;
                addto->next = new_patch;
        }
                        addto = addto->next;
                addto->next = new_patch;
        }

-       LOG_USER("%s software breakpoint %" PRIu32 " set at 0x%08" PRIx32,
+       LOG_USER("%s software breakpoint %" PRIu32 " set at " TARGET_ADDR_FMT,

                        __func__, bp->unique_id, bp->address);
        return ERROR_OK;
 }
                        __func__, bp->unique_id, bp->address);
        return ERROR_OK;
 }


@@ -1068,7 +1071,7 @@ static int unset_swbp(struct target *t, struct breakpoint *bp)
 {
        struct x86_32_common *x86_32 = target_to_x86_32(t);
        LOG_DEBUG("id %" PRIx32, bp->unique_id);
 {
        struct x86_32_common *x86_32 = target_to_x86_32(t);
        LOG_DEBUG("id %" PRIx32, bp->unique_id);

-       uint32_t physaddr;
+       target_addr_t physaddr;

        uint8_t current_instr;
 
        /* check that user program has not modified breakpoint instruction */
        uint8_t current_instr;
 
        /* check that user program has not modified breakpoint instruction */


@@ -1081,7 +1084,7 @@ static int unset_swbp(struct target *t, struct breakpoint *bp)
                if (write_phys_mem(t, physaddr, 1, 1, bp->orig_instr))
                        return ERROR_FAIL;
        } else {
                if (write_phys_mem(t, physaddr, 1, 1, bp->orig_instr))
                        return ERROR_FAIL;
        } else {

-               LOG_ERROR("%s software breakpoint remove error at 0x%08" PRIx32 ", check memory",
+               LOG_ERROR("%s software breakpoint remove error at " TARGET_ADDR_FMT ", check memory",

                                __func__, bp->address);
                LOG_ERROR("%s current=0x%02" PRIx8 " orig=0x%02" PRIx8 "",
                                __func__, current_instr, *bp->orig_instr);
                                __func__, bp->address);
                LOG_ERROR("%s current=0x%02" PRIx8 " orig=0x%02" PRIx8 "",
                                __func__, current_instr, *bp->orig_instr);


@@ -1107,7 +1110,7 @@ static int unset_swbp(struct target *t, struct breakpoint *bp)
                }
        }
 
                }
        }
 

-       LOG_USER("%s software breakpoint %" PRIu32 " removed from 0x%08" PRIx32,
+       LOG_USER("%s software breakpoint %" PRIu32 " removed from " TARGET_ADDR_FMT,

                        __func__, bp->unique_id, bp->address);
        return ERROR_OK;
 }
                        __func__, bp->unique_id, bp->address);
        return ERROR_OK;
 }


@@ -1116,7 +1119,7 @@ static int set_breakpoint(struct target *t, struct breakpoint *bp)
 {
        int error = ERROR_OK;
        struct x86_32_common *x86_32 = target_to_x86_32(t);
 {
        int error = ERROR_OK;
        struct x86_32_common *x86_32 = target_to_x86_32(t);

-       LOG_DEBUG("type=%d, addr=0x%08" PRIx32, bp->type, bp->address);
+       LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, bp->type, bp->address);

        if (bp->set) {
                LOG_ERROR("breakpoint already set");
                return error;
        if (bp->set) {
                LOG_ERROR("breakpoint already set");
                return error;


@@ -1124,7 +1127,7 @@ static int set_breakpoint(struct target *t, struct breakpoint *bp)
        if (bp->type == BKPT_HARD) {
                error = set_hwbp(t, bp);
                if (error != ERROR_OK) {
        if (bp->type == BKPT_HARD) {
                error = set_hwbp(t, bp);
                if (error != ERROR_OK) {

-                       LOG_ERROR("%s error setting hardware breakpoint at 0x%08" PRIx32,
+                       LOG_ERROR("%s error setting hardware breakpoint at " TARGET_ADDR_FMT,

                                        __func__, bp->address);
                        return error;
                }
                                        __func__, bp->address);
                        return error;
                }


@@ -1132,7 +1135,7 @@ static int set_breakpoint(struct target *t, struct breakpoint *bp)
                if (x86_32->sw_bpts_supported(t)) {
                        error = set_swbp(t, bp);
                        if (error != ERROR_OK) {
                if (x86_32->sw_bpts_supported(t)) {
                        error = set_swbp(t, bp);
                        if (error != ERROR_OK) {

-                               LOG_ERROR("%s error setting software breakpoint at 0x%08" PRIx32,
+                               LOG_ERROR("%s error setting software breakpoint at " TARGET_ADDR_FMT,

                                                __func__, bp->address);
                                return error;
                        }
                                                __func__, bp->address);
                                return error;
                        }


@@ -1147,7 +1150,7 @@ static int set_breakpoint(struct target *t, struct breakpoint *bp)
 
 static int unset_breakpoint(struct target *t, struct breakpoint *bp)
 {
 
 static int unset_breakpoint(struct target *t, struct breakpoint *bp)
 {

-       LOG_DEBUG("type=%d, addr=0x%08" PRIx32, bp->type, bp->address);
+       LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, bp->type, bp->address);

        if (!bp->set) {
                LOG_WARNING("breakpoint not set");
                return ERROR_OK;
        if (!bp->set) {
                LOG_WARNING("breakpoint not set");
                return ERROR_OK;


@@ -1155,13 +1158,13 @@ static int unset_breakpoint(struct target *t, struct breakpoint *bp)
 
        if (bp->type == BKPT_HARD) {
                if (unset_hwbp(t, bp) != ERROR_OK) {
 
        if (bp->type == BKPT_HARD) {
                if (unset_hwbp(t, bp) != ERROR_OK) {

-                       LOG_ERROR("%s error removing hardware breakpoint at 0x%08" PRIx32,
+                       LOG_ERROR("%s error removing hardware breakpoint at " TARGET_ADDR_FMT,

                                        __func__, bp->address);
                        return ERROR_FAIL;
                }
        } else {
                if (unset_swbp(t, bp) != ERROR_OK) {
                                        __func__, bp->address);
                        return ERROR_FAIL;
                }
        } else {
                if (unset_swbp(t, bp) != ERROR_OK) {

-                       LOG_ERROR("%s error removing software breakpoint at 0x%08" PRIx32,
+                       LOG_ERROR("%s error removing software breakpoint at " TARGET_ADDR_FMT,

                                        __func__, bp->address);
                        return ERROR_FAIL;
                }
                                        __func__, bp->address);
                        return ERROR_FAIL;
                }


@@ -1175,7 +1178,7 @@ static int set_watchpoint(struct target *t, struct watchpoint *wp)
        struct x86_32_common *x86_32 = target_to_x86_32(t);
        struct x86_32_dbg_reg *debug_reg_list = x86_32->hw_break_list;
        int wp_num = 0;
        struct x86_32_common *x86_32 = target_to_x86_32(t);
        struct x86_32_dbg_reg *debug_reg_list = x86_32->hw_break_list;
        int wp_num = 0;

-       LOG_DEBUG("type=%d, addr=0x%08" PRIx32, wp->rw, wp->address);
+       LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, wp->rw, wp->address);

 
        if (wp->set) {
                LOG_ERROR("%s watchpoint already set", __func__);
 
        if (wp->set) {
                LOG_ERROR("%s watchpoint already set", __func__);


@@ -1220,7 +1223,7 @@ static int set_watchpoint(struct target *t, struct watchpoint *wp)
        wp->set = wp_num + 1;
        debug_reg_list[wp_num].used = 1;
        debug_reg_list[wp_num].bp_value = wp->address;
        wp->set = wp_num + 1;
        debug_reg_list[wp_num].used = 1;
        debug_reg_list[wp_num].bp_value = wp->address;

-       LOG_USER("'%s' watchpoint %d set at 0x%08" PRIx32 " with length %" PRIu32 " (hwreg=%d)",
+       LOG_USER("'%s' watchpoint %d set at " TARGET_ADDR_FMT " with length %" PRIu32 " (hwreg=%d)",

                        wp->rw == WPT_READ ? "read" : wp->rw == WPT_WRITE ?
                        "write" : wp->rw == WPT_ACCESS ? "access" : "?",
                        wp->unique_id, wp->address, wp->length, wp_num);
                        wp->rw == WPT_READ ? "read" : wp->rw == WPT_WRITE ?
                        "write" : wp->rw == WPT_ACCESS ? "access" : "?",
                        wp->unique_id, wp->address, wp->length, wp_num);


@@ -1231,7 +1234,7 @@ static int unset_watchpoint(struct target *t, struct watchpoint *wp)
 {
        struct x86_32_common *x86_32 = target_to_x86_32(t);
        struct x86_32_dbg_reg *debug_reg_list = x86_32->hw_break_list;
 {
        struct x86_32_common *x86_32 = target_to_x86_32(t);
        struct x86_32_dbg_reg *debug_reg_list = x86_32->hw_break_list;

-       LOG_DEBUG("type=%d, addr=0x%08" PRIx32, wp->rw, wp->address);
+       LOG_DEBUG("type=%d, addr=" TARGET_ADDR_FMT, wp->rw, wp->address);

        if (!wp->set) {
                LOG_WARNING("watchpoint not set");
                return ERROR_OK;
        if (!wp->set) {
                LOG_WARNING("watchpoint not set");
                return ERROR_OK;


@@ -1249,7 +1252,7 @@ static int unset_watchpoint(struct target *t, struct watchpoint *wp)
        debug_reg_list[wp_num].bp_value = 0;
        wp->set = 0;
 
        debug_reg_list[wp_num].bp_value = 0;
        wp->set = 0;
 

-       LOG_USER("'%s' watchpoint %d removed from 0x%08" PRIx32 " with length %" PRIu32 " (hwreg=%d)",
+       LOG_USER("'%s' watchpoint %d removed from " TARGET_ADDR_FMT " with length %" PRIu32 " (hwreg=%d)",

                        wp->rw == WPT_READ ? "read" : wp->rw == WPT_WRITE ?
                        "write" : wp->rw == WPT_ACCESS ? "access" : "?",
                        wp->unique_id, wp->address, wp->length, wp_num);
                        wp->rw == WPT_READ ? "read" : wp->rw == WPT_WRITE ?
                        "write" : wp->rw == WPT_ACCESS ? "access" : "?",
                        wp->unique_id, wp->address, wp->length, wp_num);

diff --git a/src/target/x86_32_common.h b/src/target/x86_32_common.h
index b5877da4a10c400d4d752ff5737ff9807f1bdc2e..0aaa963d7e0c0bb179c63f205afd1186fa037e2a 100644 (file)
--- a/src/target/x86_32_common.h
+++ b/src/target/x86_32_common.h
@@ -309,14 +309,14 @@ int x86_32_get_gdb_reg_list(struct target *t,
 int x86_32_common_init_arch_info(struct target *target,
                        struct x86_32_common *x86_32);
 int x86_32_common_mmu(struct target *t, int *enabled);
 int x86_32_common_init_arch_info(struct target *target,
                        struct x86_32_common *x86_32);
 int x86_32_common_mmu(struct target *t, int *enabled);

-int x86_32_common_virt2phys(struct target *t, uint32_t address, uint32_t *physical);
-int x86_32_common_read_phys_mem(struct target *t, uint32_t phys_address,
+int x86_32_common_virt2phys(struct target *t, target_addr_t address, target_addr_t *physical);
+int x86_32_common_read_phys_mem(struct target *t, target_addr_t phys_address,

                        uint32_t size, uint32_t count, uint8_t *buffer);
                        uint32_t size, uint32_t count, uint8_t *buffer);

-int x86_32_common_write_phys_mem(struct target *t, uint32_t phys_address,
+int x86_32_common_write_phys_mem(struct target *t, target_addr_t phys_address,

                        uint32_t size, uint32_t count, const uint8_t *buffer);
                        uint32_t size, uint32_t count, const uint8_t *buffer);

-int x86_32_common_read_memory(struct target *t, uint32_t addr,
+int x86_32_common_read_memory(struct target *t, target_addr_t addr,

                        uint32_t size, uint32_t count, uint8_t *buf);
                        uint32_t size, uint32_t count, uint8_t *buf);

-int x86_32_common_write_memory(struct target *t, uint32_t addr,
+int x86_32_common_write_memory(struct target *t, target_addr_t addr,

                        uint32_t size, uint32_t count, const uint8_t *buf);
 int x86_32_common_read_io(struct target *t, uint32_t addr,
                        uint32_t size, uint8_t *buf);
                        uint32_t size, uint32_t count, const uint8_t *buf);
 int x86_32_common_read_io(struct target *t, uint32_t addr,
                        uint32_t size, uint8_t *buf);

diff --git a/src/target/xscale.c b/src/target/xscale.c
index e54033fe9f7d10331f09243d50f69c53fefff01d..8fe8a2cb9939f1052fe63d5bdcc1c5d61042cb9f 100644 (file)
--- a/src/target/xscale.c
+++ b/src/target/xscale.c
@@ -59,7 +59,7 @@
 
 /* forward declarations */
 static int xscale_resume(struct target *, int current,
 
 /* forward declarations */
 static int xscale_resume(struct target *, int current,

-       uint32_t address, int handle_breakpoints, int debug_execution);
+       target_addr_t address, int handle_breakpoints, int debug_execution);

 static int xscale_debug_entry(struct target *);
 static int xscale_restore_banked(struct target *);
 static int xscale_get_reg(struct reg *reg);
 static int xscale_debug_entry(struct target *);
 static int xscale_restore_banked(struct target *);
 static int xscale_get_reg(struct reg *reg);


@@ -1120,7 +1120,7 @@ static void xscale_free_trace_data(struct xscale_common *xscale)
 }
 
 static int xscale_resume(struct target *target, int current,
 }
 
 static int xscale_resume(struct target *target, int current,

-       uint32_t address, int handle_breakpoints, int debug_execution)
+       target_addr_t address, int handle_breakpoints, int debug_execution)

 {
        struct xscale_common *xscale = target_to_xscale(target);
        struct arm *arm = &xscale->arm;
 {
        struct xscale_common *xscale = target_to_xscale(target);
        struct arm *arm = &xscale->arm;


@@ -1165,7 +1165,8 @@ static int xscale_resume(struct target *target, int current,
                        enum trace_mode saved_trace_mode;
 
                        /* there's a breakpoint at the current PC, we have to step over it */
                        enum trace_mode saved_trace_mode;
 
                        /* there's a breakpoint at the current PC, we have to step over it */

-                       LOG_DEBUG("unset breakpoint at 0x%8.8" PRIx32 "", breakpoint->address);
+                       LOG_DEBUG("unset breakpoint at " TARGET_ADDR_FMT "",
+                               breakpoint->address);

                        xscale_unset_breakpoint(target, breakpoint);
 
                        /* calculate PC of next instruction */
                        xscale_unset_breakpoint(target, breakpoint);
 
                        /* calculate PC of next instruction */


@@ -1222,7 +1223,8 @@ static int xscale_resume(struct target *target, int current,
                        LOG_DEBUG("disable single-step");
                        xscale_disable_single_step(target);
 
                        LOG_DEBUG("disable single-step");
                        xscale_disable_single_step(target);
 

-                       LOG_DEBUG("set breakpoint at 0x%8.8" PRIx32 "", breakpoint->address);
+                       LOG_DEBUG("set breakpoint at " TARGET_ADDR_FMT "",
+                               breakpoint->address);

                        xscale_set_breakpoint(target, breakpoint);
                }
        }
                        xscale_set_breakpoint(target, breakpoint);
                }
        }


@@ -1384,7 +1386,7 @@ static int xscale_step_inner(struct target *target, int current,
 }
 
 static int xscale_step(struct target *target, int current,
 }
 
 static int xscale_step(struct target *target, int current,

-       uint32_t address, int handle_breakpoints)
+       target_addr_t address, int handle_breakpoints)

 {
        struct arm *arm = target_to_arm(target);
        struct breakpoint *breakpoint = NULL;
 {
        struct arm *arm = target_to_arm(target);
        struct breakpoint *breakpoint = NULL;


@@ -1778,7 +1780,7 @@ dirty:
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int xscale_read_memory(struct target *target, uint32_t address,
+static int xscale_read_memory(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct xscale_common *xscale = target_to_xscale(target);
        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct xscale_common *xscale = target_to_xscale(target);


@@ -1786,7 +1788,7 @@ static int xscale_read_memory(struct target *target, uint32_t address,
        uint32_t i;
        int retval;
 
        uint32_t i;
        int retval;
 

-       LOG_DEBUG("address: 0x%8.8" PRIx32 ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32,
+       LOG_DEBUG("address: " TARGET_ADDR_FMT ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32,

                address,
                size,
                count);
                address,
                size,
                count);


@@ -1864,7 +1866,7 @@ static int xscale_read_memory(struct target *target, uint32_t address,
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int xscale_read_phys_memory(struct target *target, uint32_t address,
+static int xscale_read_phys_memory(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct xscale_common *xscale = target_to_xscale(target);
        uint32_t size, uint32_t count, uint8_t *buffer)
 {
        struct xscale_common *xscale = target_to_xscale(target);


@@ -1879,13 +1881,13 @@ static int xscale_read_phys_memory(struct target *target, uint32_t address,
        return ERROR_FAIL;
 }
 
        return ERROR_FAIL;
 }
 

-static int xscale_write_memory(struct target *target, uint32_t address,
+static int xscale_write_memory(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct xscale_common *xscale = target_to_xscale(target);
        int retval;
 
        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct xscale_common *xscale = target_to_xscale(target);
        int retval;
 

-       LOG_DEBUG("address: 0x%8.8" PRIx32 ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32,
+       LOG_DEBUG("address: " TARGET_ADDR_FMT ", size: 0x%8.8" PRIx32 ", count: 0x%8.8" PRIx32,

                address,
                size,
                count);
                address,
                size,
                count);


@@ -1963,7 +1965,7 @@ static int xscale_write_memory(struct target *target, uint32_t address,
        return ERROR_OK;
 }
 
        return ERROR_OK;
 }
 

-static int xscale_write_phys_memory(struct target *target, uint32_t address,
+static int xscale_write_phys_memory(struct target *target, target_addr_t address,

        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct xscale_common *xscale = target_to_xscale(target);
        uint32_t size, uint32_t count, const uint8_t *buffer)
 {
        struct xscale_common *xscale = target_to_xscale(target);


@@ -3093,7 +3095,7 @@ COMMAND_HANDLER(xscale_handle_cache_info_command)
 }
 
 static int xscale_virt2phys(struct target *target,
 }
 
 static int xscale_virt2phys(struct target *target,

-       uint32_t virtual, uint32_t *physical)
+       target_addr_t virtual, target_addr_t *physical)

 {
        struct xscale_common *xscale = target_to_xscale(target);
        uint32_t cb;
 {
        struct xscale_common *xscale = target_to_xscale(target);
        uint32_t cb;