Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
command_handler: change 'args' to CMD_ARGV
[openocd.git] / src / server / gdb_server.c
diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c
index 0bdb3a0c2154b0fde9da720f0e815b7d4f9b7a23..716e1cfe6673cc658bb2c1c7a0f42c77b91f4401 100644 (file)
--- a/src/server/gdb_server.c
+++ b/src/server/gdb_server.c
@@ -27,11 +27,12 @@
 #include "config.h"
 #endif
 
-#include "gdb_server.h"
+#include "breakpoints.h"
 #include "target_request.h"
 #include "register.h"
 #include "server.h"
 #include "flash.h"
+#include "gdb_server.h"
 #include "image.h"
 #include "jtag.h"
 
@@ -67,7 +68,7 @@ int gdb_flash_program = 1;
  * see the code in gdb_read_memory_packet() for further explanations */
 int gdb_report_data_abort = 0;
 
-int gdb_last_signal(target_t *target)
+int gdb_last_signal(struct target *target)
 {
        switch (target->debug_reason)
        {
@@ -650,7 +651,7 @@ int gdb_output_con(struct connection *connection, const char* line)
        return retval;
 }
 
-int gdb_output(struct command_context_s *context, const char* line)
+int gdb_output(struct command_context *context, const char* line)
 {
        /* this will be dumped to the log and also sent as an O packet if possible */
        LOG_USER_N("%s", line);
@@ -658,7 +659,7 @@ int gdb_output(struct command_context_s *context, const char* line)
 }
 
 
-static void gdb_frontend_halted(struct target_s *target, struct connection *connection)
+static void gdb_frontend_halted(struct target *target, struct connection *connection)
 {
        struct gdb_connection *gdb_connection = connection->priv;
 
@@ -695,7 +696,7 @@ static void gdb_frontend_halted(struct target_s *target, struct connection *conn
        }
 }
 
-int gdb_target_callback_event_handler(struct target_s *target, enum target_event event, void *priv)
+int gdb_target_callback_event_handler(struct target *target, enum target_event event, void *priv)
 {
        int retval;
        struct connection *connection = priv;
@@ -833,7 +834,7 @@ void gdb_send_error(struct connection *connection, uint8_t the_error)
        gdb_put_packet(connection, err, 3);
 }
 
-int gdb_last_signal_packet(struct connection *connection, target_t *target, char* packet, int packet_size)
+int gdb_last_signal_packet(struct connection *connection, struct target *target, char* packet, int packet_size)
 {
        char sig_reply[4];
        int signal;
@@ -846,7 +847,7 @@ int gdb_last_signal_packet(struct connection *connection, target_t *target, char
        return ERROR_OK;
 }
 
-static int gdb_reg_pos(target_t *target, int pos, int len)
+static int gdb_reg_pos(struct target *target, int pos, int len)
 {
        if (target->endianness == TARGET_LITTLE_ENDIAN)
                return pos;
@@ -863,14 +864,14 @@ static int gdb_reg_pos(target_t *target, int pos, int len)
  * The format of reg->value is little endian
  *
  */
-void gdb_str_to_target(target_t *target, char *tstr, reg_t *reg)
+void gdb_str_to_target(struct target *target, char *tstr, struct reg *reg)
 {
        int i;
 
        uint8_t *buf;
        int buf_len;
        buf = reg->value;
-       buf_len = CEIL(reg->size, 8);
+       buf_len = DIV_ROUND_UP(reg->size, 8);
 
        for (i = 0; i < buf_len; i++)
        {
@@ -896,7 +897,7 @@ static int hextoint(char c)
 }
 
 /* copy over in register buffer */
-void gdb_target_to_reg(target_t *target, char *tstr, int str_len, uint8_t *bin)
+void gdb_target_to_reg(struct target *target, char *tstr, int str_len, uint8_t *bin)
 {
        if (str_len % 2)
        {
@@ -915,9 +916,9 @@ void gdb_target_to_reg(target_t *target, char *tstr, int str_len, uint8_t *bin)
        }
 }
 
-int gdb_get_registers_packet(struct connection *connection, target_t *target, char* packet, int packet_size)
+int gdb_get_registers_packet(struct connection *connection, struct target *target, char* packet, int packet_size)
 {
-       reg_t **reg_list;
+       struct reg **reg_list;
        int reg_list_size;
        int retval;
        int reg_packet_size = 0;
@@ -939,25 +940,25 @@ int gdb_get_registers_packet(struct connection *connection, target_t *target, ch
                reg_packet_size += reg_list[i]->size;
        }
 
-       reg_packet = malloc(CEIL(reg_packet_size, 8) * 2);
+       reg_packet = malloc(DIV_ROUND_UP(reg_packet_size, 8) * 2);
        reg_packet_p = reg_packet;
 
        for (i = 0; i < reg_list_size; i++)
        {
                gdb_str_to_target(target, reg_packet_p, reg_list[i]);
-               reg_packet_p += CEIL(reg_list[i]->size, 8) * 2;
+               reg_packet_p += DIV_ROUND_UP(reg_list[i]->size, 8) * 2;
        }
 
 #ifdef _DEBUG_GDB_IO_
        {
                char *reg_packet_p;
-               reg_packet_p = strndup(reg_packet, CEIL(reg_packet_size, 8) * 2);
+               reg_packet_p = strndup(reg_packet, DIV_ROUND_UP(reg_packet_size, 8) * 2);
                LOG_DEBUG("reg_packet: %s", reg_packet_p);
                free(reg_packet_p);
        }
 #endif
 
-       gdb_put_packet(connection, reg_packet, CEIL(reg_packet_size, 8) * 2);
+       gdb_put_packet(connection, reg_packet, DIV_ROUND_UP(reg_packet_size, 8) * 2);
        free(reg_packet);
 
        free(reg_list);
@@ -965,10 +966,10 @@ int gdb_get_registers_packet(struct connection *connection, target_t *target, ch
        return ERROR_OK;
 }
 
-int gdb_set_registers_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
+int gdb_set_registers_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
        int i;
-       reg_t **reg_list;
+       struct reg **reg_list;
        int reg_list_size;
        int retval;
        char *packet_p;
@@ -996,21 +997,17 @@ int gdb_set_registers_packet(struct connection *connection, target_t *target, ch
        for (i = 0; i < reg_list_size; i++)
        {
                uint8_t *bin_buf;
-               int chars = (CEIL(reg_list[i]->size, 8) * 2);
+               int chars = (DIV_ROUND_UP(reg_list[i]->size, 8) * 2);
 
                if (packet_p + chars > packet + packet_size)
                {
                        LOG_ERROR("BUG: register packet is too small for registers");
                }
 
-               struct reg_arch_type *arch_type;
-               bin_buf = malloc(CEIL(reg_list[i]->size, 8));
+               bin_buf = malloc(DIV_ROUND_UP(reg_list[i]->size, 8));
                gdb_target_to_reg(target, packet_p, chars, bin_buf);
 
-               /* get register arch_type, and call set method */
-               arch_type = register_get_arch_type(reg_list[i]->arch_type);
-
-               arch_type->set(reg_list[i], bin_buf);
+               reg_list[i]->type->set(reg_list[i], bin_buf);
 
                /* advance packet pointer */
                packet_p += chars;
@@ -1019,7 +1016,7 @@ int gdb_set_registers_packet(struct connection *connection, target_t *target, ch
                free(bin_buf);
        }
 
-       /* free reg_t *reg_list[] array allocated by get_gdb_reg_list */
+       /* free struct reg *reg_list[] array allocated by get_gdb_reg_list */
        free(reg_list);
 
        gdb_put_packet(connection, "OK", 2);
@@ -1027,11 +1024,11 @@ int gdb_set_registers_packet(struct connection *connection, target_t *target, ch
        return ERROR_OK;
 }
 
-int gdb_get_register_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
+int gdb_get_register_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
        char *reg_packet;
        int reg_num = strtoul(packet + 1, NULL, 16);
-       reg_t **reg_list;
+       struct reg **reg_list;
        int reg_list_size;
        int retval;
 
@@ -1050,11 +1047,11 @@ int gdb_get_register_packet(struct connection *connection, target_t *target, cha
                exit(-1);
        }
 
-       reg_packet = malloc(CEIL(reg_list[reg_num]->size, 8) * 2);
+       reg_packet = malloc(DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
 
        gdb_str_to_target(target, reg_packet, reg_list[reg_num]);
 
-       gdb_put_packet(connection, reg_packet, CEIL(reg_list[reg_num]->size, 8) * 2);
+       gdb_put_packet(connection, reg_packet, DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
 
        free(reg_list);
        free(reg_packet);
@@ -1062,15 +1059,14 @@ int gdb_get_register_packet(struct connection *connection, target_t *target, cha
        return ERROR_OK;
 }
 
-int gdb_set_register_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
+int gdb_set_register_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
        char *separator;
        uint8_t *bin_buf;
        int reg_num = strtoul(packet + 1, &separator, 16);
-       reg_t **reg_list;
+       struct reg **reg_list;
        int reg_list_size;
        int retval;
-       struct reg_arch_type *arch_type;
 
        LOG_DEBUG("-");
 
@@ -1092,16 +1088,14 @@ int gdb_set_register_packet(struct connection *connection, target_t *target, cha
        }
 
        /* convert from GDB-string (target-endian) to hex-string (big-endian) */
-       bin_buf = malloc(CEIL(reg_list[reg_num]->size, 8));
-       int chars = (CEIL(reg_list[reg_num]->size, 8) * 2);
+       bin_buf = malloc(DIV_ROUND_UP(reg_list[reg_num]->size, 8));
+       int chars = (DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
 
        /* fix!!! add some sanity checks on packet size here */
 
        gdb_target_to_reg(target, separator + 1, chars, bin_buf);
 
-               /* get register arch_type, and call set method */
-       arch_type = register_get_arch_type(reg_list[reg_num]->arch_type);
-       arch_type->set(reg_list[reg_num], bin_buf);
+       reg_list[reg_num]->type->set(reg_list[reg_num], bin_buf);
 
        gdb_put_packet(connection, "OK", 2);
 
@@ -1142,7 +1136,7 @@ int gdb_error(struct connection *connection, int retval)
  *
  * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
  */
-int gdb_read_memory_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
+int gdb_read_memory_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
        char *separator;
        uint32_t addr = 0;
@@ -1216,7 +1210,7 @@ int gdb_read_memory_packet(struct connection *connection, target_t *target, char
        return retval;
 }
 
-int gdb_write_memory_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
+int gdb_write_memory_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
        char *separator;
        uint32_t addr = 0;
@@ -1273,7 +1267,7 @@ int gdb_write_memory_packet(struct connection *connection, target_t *target, cha
        return retval;
 }
 
-int gdb_write_memory_binary_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
+int gdb_write_memory_binary_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
        char *separator;
        uint32_t addr = 0;
@@ -1321,7 +1315,7 @@ int gdb_write_memory_binary_packet(struct connection *connection, target_t *targ
        return ERROR_OK;
 }
 
-int gdb_step_continue_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
+int gdb_step_continue_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
        int current = 0;
        uint32_t address = 0x0;
@@ -1354,7 +1348,7 @@ int gdb_step_continue_packet(struct connection *connection, target_t *target, ch
        return retval;
 }
 
-int gdb_breakpoint_watchpoint_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
+int gdb_breakpoint_watchpoint_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
        int type;
        enum breakpoint_type bp_type = BKPT_SOFT /* dummy init to avoid warning */;
@@ -1520,7 +1514,7 @@ static int decode_xfer_read(char *buf, char **annex, int *ofs, unsigned int *len
        return 0;
 }
 
-int gdb_calc_blocksize(flash_bank_t *bank)
+int gdb_calc_blocksize(struct flash_bank *bank)
 {
        uint32_t i;
        uint32_t block_size = 0xffffffff;
@@ -1538,9 +1532,9 @@ int gdb_calc_blocksize(flash_bank_t *bank)
 
 static int compare_bank (const void * a, const void * b)
 {
-       flash_bank_t *b1, *b2;
-       b1=*((flash_bank_t **)a);
-       b2=*((flash_bank_t **)b);
+       struct flash_bank *b1, *b2;
+       b1=*((struct flash_bank **)a);
+       b2=*((struct flash_bank **)b);
 
        if (b1->base == b2->base)
        {
@@ -1554,9 +1548,9 @@ static int compare_bank (const void * a, const void * b)
        }
 }
 
-int gdb_query_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
+int gdb_query_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
-       command_context_t *cmd_ctx = connection->cmd_ctx;
+       struct command_context *cmd_ctx = connection->cmd_ctx;
        struct gdb_connection *gdb_connection = connection->priv;
 
        if (strstr(packet, "qRcmd,"))
@@ -1661,7 +1655,7 @@ int gdb_query_packet(struct connection *connection, target_t *target, char *pack
                 * Normally we only execute this code once, but no big deal if we
                 * have to regenerate it a couple of times. */
 
-               flash_bank_t *p;
+               struct flash_bank *p;
                char *xml = NULL;
                int size = 0;
                int pos = 0;
@@ -1685,7 +1679,7 @@ int gdb_query_packet(struct connection *connection, target_t *target, char *pack
                read/write) by default for GDB.
                GDB does not have a concept of non-cacheable read/write memory.
                 */
-               flash_bank_t **banks = malloc(sizeof(flash_bank_t *)*flash_get_bank_count());
+               struct flash_bank **banks = malloc(sizeof(struct flash_bank *)*flash_get_bank_count());
                int i;
 
                for (i = 0; i < flash_get_bank_count(); i++)
@@ -1701,7 +1695,7 @@ int gdb_query_packet(struct connection *connection, target_t *target, char *pack
                        banks[i]=p;
                }
 
-               qsort(banks, flash_get_bank_count(), sizeof(flash_bank_t *), compare_bank);
+               qsort(banks, flash_get_bank_count(), sizeof(struct flash_bank *), compare_bank);
 
                uint32_t ram_start = 0;
                for (i = 0; i < flash_get_bank_count(); i++)
@@ -1810,7 +1804,7 @@ int gdb_query_packet(struct connection *connection, target_t *target, char *pack
        return ERROR_OK;
 }
 
-int gdb_v_packet(struct connection *connection, target_t *target, char *packet, int packet_size)
+int gdb_v_packet(struct connection *connection, struct target *target, char *packet, int packet_size)
 {
        struct gdb_connection *gdb_connection = connection->priv;
        struct gdb_service *gdb_service = connection->service->priv;
@@ -1899,7 +1893,7 @@ int gdb_v_packet(struct connection *connection, target_t *target, char *packet,
                /* create a new image if there isn't already one */
                if (gdb_connection->vflash_image == NULL)
                {
-                       gdb_connection->vflash_image = malloc(sizeof(image_t));
+                       gdb_connection->vflash_image = malloc(sizeof(struct image));
                        image_open(gdb_connection->vflash_image, "", "build");
                }
 
@@ -1947,7 +1941,7 @@ int gdb_v_packet(struct connection *connection, target_t *target, char *packet,
        return ERROR_OK;
 }
 
-int gdb_detach(struct connection *connection, target_t *target)
+int gdb_detach(struct connection *connection, struct target *target)
 {
        struct gdb_service *gdb_service = connection->service->priv;
 
@@ -1985,7 +1979,7 @@ static void gdb_sig_halted(struct connection *connection)
 int gdb_input_inner(struct connection *connection)
 {
        struct gdb_service *gdb_service = connection->service->priv;
-       target_t *target = gdb_service->target;
+       struct target *target = gdb_service->target;
        char *packet = gdb_packet_buffer;
        int packet_size;
        int retval;
@@ -2198,7 +2192,7 @@ int gdb_input(struct connection *connection)
 int gdb_init(void)
 {
        struct gdb_service *gdb_service;
-       target_t *target = all_targets;
+       struct target *target = all_targets;
 
        if (!target)
        {
@@ -2251,7 +2245,7 @@ int gdb_init(void)
 
 COMMAND_HANDLER(handle_gdb_sync_command)
 {
-       if (argc != 0)
+       if (CMD_ARGC != 0)
        {
                return ERROR_COMMAND_SYNTAX_ERROR;
        }
@@ -2276,20 +2270,20 @@ COMMAND_HANDLER(handle_gdb_port_command)
 
 COMMAND_HANDLER(handle_gdb_memory_map_command)
 {
-       if (argc == 1)
+       if (CMD_ARGC == 1)
        {
-               if (strcmp(args[0], "enable") == 0)
+               if (strcmp(CMD_ARGV[0], "enable") == 0)
                {
                        gdb_use_memory_map = 1;
                        return ERROR_OK;
                }
-               else if (strcmp(args[0], "disable") == 0)
+               else if (strcmp(CMD_ARGV[0], "disable") == 0)
                {
                        gdb_use_memory_map = 0;
                        return ERROR_OK;
                }
                else
-                       LOG_WARNING("invalid gdb_memory_map configuration directive %s", args[0]);
+                       LOG_WARNING("invalid gdb_memory_map configuration directive %s", CMD_ARGV[0]);
        }
 
        return ERROR_COMMAND_SYNTAX_ERROR;
@@ -2297,20 +2291,20 @@ COMMAND_HANDLER(handle_gdb_memory_map_command)
 
 COMMAND_HANDLER(handle_gdb_flash_program_command)
 {
-       if (argc == 1)
+       if (CMD_ARGC == 1)
        {
-               if (strcmp(args[0], "enable") == 0)
+               if (strcmp(CMD_ARGV[0], "enable") == 0)
                {
                        gdb_flash_program = 1;
                        return ERROR_OK;
                }
-               else if (strcmp(args[0], "disable") == 0)
+               else if (strcmp(CMD_ARGV[0], "disable") == 0)
                {
                        gdb_flash_program = 0;
                        return ERROR_OK;
                }
                else
-                       LOG_WARNING("invalid gdb_flash_program configuration directive: %s", args[0]);
+                       LOG_WARNING("invalid gdb_flash_program configuration directive: %s", CMD_ARGV[0]);
        }
 
        return ERROR_COMMAND_SYNTAX_ERROR;
@@ -2318,20 +2312,20 @@ COMMAND_HANDLER(handle_gdb_flash_program_command)
 
 COMMAND_HANDLER(handle_gdb_report_data_abort_command)
 {
-       if (argc == 1)
+       if (CMD_ARGC == 1)
        {
-               if (strcmp(args[0], "enable") == 0)
+               if (strcmp(CMD_ARGV[0], "enable") == 0)
                {
                        gdb_report_data_abort = 1;
                        return ERROR_OK;
                }
-               else if (strcmp(args[0], "disable") == 0)
+               else if (strcmp(CMD_ARGV[0], "disable") == 0)
                {
                        gdb_report_data_abort = 0;
                        return ERROR_OK;
                }
                else
-                       LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", args[0]);
+                       LOG_WARNING("invalid gdb_report_data_abort configuration directive: %s", CMD_ARGV[0]);
        }
 
        return ERROR_COMMAND_SYNTAX_ERROR;
@@ -2340,19 +2334,19 @@ COMMAND_HANDLER(handle_gdb_report_data_abort_command)
 /* gdb_breakpoint_override */
 COMMAND_HANDLER(handle_gdb_breakpoint_override_command)
 {
-       if (argc == 0)
+       if (CMD_ARGC == 0)
        {
 
-       } else if (argc == 1)
+       } else if (CMD_ARGC == 1)
        {
                gdb_breakpoint_override = 1;
-               if (strcmp(args[0], "hard") == 0)
+               if (strcmp(CMD_ARGV[0], "hard") == 0)
                {
                        gdb_breakpoint_override_type = BKPT_HARD;
-               } else if (strcmp(args[0], "soft") == 0)
+               } else if (strcmp(CMD_ARGV[0], "soft") == 0)
                {
                        gdb_breakpoint_override_type = BKPT_SOFT;
-               } else if (strcmp(args[0], "disable") == 0)
+               } else if (strcmp(CMD_ARGV[0], "disable") == 0)
                {
                        gdb_breakpoint_override = 0;
                }
@@ -2371,7 +2365,7 @@ COMMAND_HANDLER(handle_gdb_breakpoint_override_command)
        return ERROR_OK;
 }
 
-int gdb_register_commands(command_context_t *command_context)
+int gdb_register_commands(struct command_context *command_context)
 {
        register_command(command_context, NULL, "gdb_sync",
                        handle_gdb_sync_command, COMMAND_ANY,
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)