gdb_server, target: Add target_address_bits()

Targets can use this to expose how many address bits there are.
gdb_server uses this to send gdb the appropriate upper limit in the
memory-map. (Before this change the upper limit would only be correct
for 32-bit targets.)

Change-Id: Idb0933255ed53951fcfb05e040674bcdf19441e1
Signed-off-by: Tim Newsome <tim@sifive.com>
Reviewed-on: http://openocd.zylin.com/4947
Tested-by: jenkins
Reviewed-by: Peter Mamonov <pmamonov@gmail.com>
Reviewed-by: Tomas Vanek <vanekt@fbl.cz>

diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c
index 54cf9aff8e06f9637bbdfac61bae4177a8d67e3d..3ade195cbffb8afb0833d1aeccdb51f70baeb04e 100644 (file)
--- a/src/server/gdb_server.c
+++ b/src/server/gdb_server.c
@@ -1921,11 +1921,10 @@ static int gdb_memory_map(struct connection *connection,
        if (ram_start != 0)
                xml_printf(&retval, &xml, &pos, &size,
                        "<memory type=\"ram\" start=\"" TARGET_ADDR_FMT "\" "
-                       "length=\"0x%x\"/>\n",
-                       ram_start, 0-ram_start);
-       /* ELSE a flash chip could be at the very end of the 32 bit address
-        * space, in which case ram_start will be precisely 0
-        */
+                       "length=\"" TARGET_ADDR_FMT "\"/>\n",
+                       ram_start, target_address_max(target) - ram_start + 1);
+       /* ELSE a flash chip could be at the very end of the address space, in
+        * which case ram_start will be precisely 0 */
 
        free(banks);
 

diff --git a/src/target/riscv/riscv.c b/src/target/riscv/riscv.c
index 02ba380553fb7057508a5c36da04126b07305d53..9a6b9389af62ee99966375c0cb9b5cb047a87c20 100644 (file)
--- a/src/target/riscv/riscv.c
+++ b/src/target/riscv/riscv.c
@@ -1560,6 +1560,11 @@ const struct command_registration riscv_command_handlers[] = {
        COMMAND_REGISTRATION_DONE
 };
 
+unsigned riscv_address_bits(struct target *target)
+{
+       return riscv_xlen(target);
+}
+
 struct target_type riscv_target = {
        .name = "riscv",
 
@@ -1594,7 +1599,9 @@ struct target_type riscv_target = {
 
        .run_algorithm = riscv_run_algorithm,
 
-       .commands = riscv_command_handlers
+       .commands = riscv_command_handlers,
+
+       .address_bits = riscv_address_bits
 };
 
 /*** RISC-V Interface ***/

diff --git a/src/target/target.c b/src/target/target.c
index 1f8e0bfc3c8c4cd67ddb0eac6ef791e4e4b64eda..5295dd626815ee86dacb4698218014c0b8303168 100644 (file)
--- a/src/target/target.c
+++ b/src/target/target.c
@@ -1257,6 +1257,22 @@ int target_gdb_fileio_end(struct target *target, int retcode, int fileio_errno,
        return target->type->gdb_fileio_end(target, retcode, fileio_errno, ctrl_c);
 }
 
+target_addr_t target_address_max(struct target *target)
+{
+       unsigned bits = target_address_bits(target);
+       if (sizeof(target_addr_t) * 8 == bits)
+               return (target_addr_t) -1;
+       else
+               return (((target_addr_t) 1) << bits) - 1;
+}
+
+unsigned target_address_bits(struct target *target)
+{
+       if (target->type->address_bits)
+               return target->type->address_bits(target);
+       return 32;
+}
+
 int target_profiling(struct target *target, uint32_t *samples,
                        uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds)
 {

diff --git a/src/target/target.h b/src/target/target.h
index 48793da6eb980b4f3b4a3e456112bfdec77bbaa1..65494afd0bab9e1520d079b0a62b95ef1b4ad18e 100644 (file)
--- a/src/target/target.h
+++ b/src/target/target.h
@@ -641,7 +641,17 @@ int target_get_gdb_fileio_info(struct target *target, struct gdb_fileio_info *fi
  */
 int target_gdb_fileio_end(struct target *target, int retcode, int fileio_errno, bool ctrl_c);
 
+/**
+ * Return the highest accessible address for this target.
+ */
+target_addr_t target_address_max(struct target *target);
 
+/**
+ * Return the number of address bits this target supports.
+ *
+ * This routine is a wrapper for target->type->address_bits.
+ */
+unsigned target_address_bits(struct target *target);
 
 /** Return the *name* of this targets current state */
 const char *target_state_name(struct target *target);

diff --git a/src/target/target_type.h b/src/target/target_type.h
index a8928911f65661453b0550416a25c222aa072f64..95745c9ebd3cacfe660662504220f3c55a606e24 100644 (file)
--- a/src/target/target_type.h
+++ b/src/target/target_type.h
@@ -284,6 +284,11 @@ struct target_type {
         */
        int (*profiling)(struct target *target, uint32_t *samples,
                        uint32_t max_num_samples, uint32_t *num_samples, uint32_t seconds);
+
+       /* Return the number of address bits this target supports. This will
+        * typically be 32 for 32-bit targets, and 64 for 64-bit targets. If not
+        * implemented, it's assumed to be 32. */
+       unsigned (*address_bits)(struct target *target);
 };
 
 #endif /* OPENOCD_TARGET_TARGET_TYPE_H */