projects / fw / openocd / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
remove target argument from gdb packet handling functions
[fw/openocd] / src / server / gdb_server.c
diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c
index aeb4e2e883b6a061b773e7608caf0ef8a04a7448..5eb6cac4da70ab5fb37b7f331d5bca80aaa91291 100644 (file)
--- a/src/server/gdb_server.c
+++ b/src/server/gdb_server.c
@@ -944,8 +944,9 @@ static void gdb_send_error(struct connection *connection, uint8_t the_error)
 }
 
 static int gdb_last_signal_packet(struct connection *connection,
-               struct target *target, char* packet, int packet_size)
+               char* packet, int packet_size)
 {
+       struct target *target = get_target_from_connection(connection);
        char sig_reply[4];
        int signal_var;
 
@@ -1029,8 +1030,9 @@ static void gdb_target_to_reg(struct target *target,
 }
 
 static int gdb_get_registers_packet(struct connection *connection,
-               struct target *target, char* packet, int packet_size)
+               char* packet, int packet_size)
 {
+       struct target *target = get_target_from_connection(connection);
        struct reg **reg_list;
        int reg_list_size;
        int retval;
@@ -1044,7 +1046,7 @@ static int gdb_get_registers_packet(struct connection *connection,
 #endif
 
        if ( ( target->rtos != NULL ) &&
-                ( ERROR_FAIL != rtos_get_gdb_reg_list( connection, target, &reg_list, &reg_list_size) ) )
+                ( ERROR_FAIL != rtos_get_gdb_reg_list( connection, &reg_list, &reg_list_size) ) )
        {
                return ERROR_OK;
        }
@@ -1064,6 +1066,8 @@ static int gdb_get_registers_packet(struct connection *connection,
 
        for (i = 0; i < reg_list_size; i++)
        {
+               if (!reg_list[i]->valid)
+                       reg_list[i]->type->get(reg_list[i]);
                gdb_str_to_target(target, reg_packet_p, reg_list[i]);
                reg_packet_p += DIV_ROUND_UP(reg_list[i]->size, 8) * 2;
        }
@@ -1086,8 +1090,9 @@ static int gdb_get_registers_packet(struct connection *connection,
 }
 
 static int gdb_set_registers_packet(struct connection *connection,
-               struct target *target, char *packet, int packet_size)
+               char *packet, int packet_size)
 {
+       struct target *target = get_target_from_connection(connection);
        int i;
        struct reg **reg_list;
        int reg_list_size;
@@ -1145,8 +1150,9 @@ static int gdb_set_registers_packet(struct connection *connection,
 }
 
 static int gdb_get_register_packet(struct connection *connection,
-               struct target *target, char *packet, int packet_size)
+               char *packet, int packet_size)
 {
+       struct target *target = get_target_from_connection(connection);
        char *reg_packet;
        int reg_num = strtoul(packet + 1, NULL, 16);
        struct reg **reg_list;
@@ -1168,6 +1174,9 @@ static int gdb_get_register_packet(struct connection *connection,
                exit(-1);
        }
 
+       if (!reg_list[reg_num]->valid)
+               reg_list[reg_num]->type->get(reg_list[reg_num]);
+
        reg_packet = malloc(DIV_ROUND_UP(reg_list[reg_num]->size, 8) * 2);
 
        gdb_str_to_target(target, reg_packet, reg_list[reg_num]);
@@ -1181,8 +1190,9 @@ static int gdb_get_register_packet(struct connection *connection,
 }
 
 static int gdb_set_register_packet(struct connection *connection,
-               struct target *target, char *packet, int packet_size)
+               char *packet, int packet_size)
 {
+       struct target *target = get_target_from_connection(connection);
        char *separator;
        uint8_t *bin_buf;
        int reg_num = strtoul(packet + 1, &separator, 16);
@@ -1244,8 +1254,9 @@ static int gdb_error(struct connection *connection, int retval)
  * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192?????
  */
 static int gdb_read_memory_packet(struct connection *connection,
-               struct target *target, char *packet, int packet_size)
+               char *packet, int packet_size)
 {
+       struct target *target = get_target_from_connection(connection);
        char *separator;
        uint32_t addr = 0;
        uint32_t len = 0;
@@ -1319,8 +1330,9 @@ static int gdb_read_memory_packet(struct connection *connection,
 }
 
 static int gdb_write_memory_packet(struct connection *connection,
-               struct target *target, char *packet, int packet_size)
+               char *packet, int packet_size)
 {
+       struct target *target = get_target_from_connection(connection);
        char *separator;
        uint32_t addr = 0;
        uint32_t len = 0;
@@ -1377,8 +1389,9 @@ static int gdb_write_memory_packet(struct connection *connection,
 }
 
 static int gdb_write_memory_binary_packet(struct connection *connection,
-               struct target *target, char *packet, int packet_size)
+               char *packet, int packet_size)
 {
+       struct target *target = get_target_from_connection(connection);
        char *separator;
        uint32_t addr = 0;
        uint32_t len = 0;
@@ -1441,8 +1454,9 @@ static int gdb_write_memory_binary_packet(struct connection *connection,
 }
 
 static int gdb_step_continue_packet(struct connection *connection,
-               struct target *target, char *packet, int packet_size)
+               char *packet, int packet_size)
 {
+       struct target *target = get_target_from_connection(connection);
        int current = 0;
        uint32_t address = 0x0;
        int retval = ERROR_OK;
@@ -1475,8 +1489,9 @@ static int gdb_step_continue_packet(struct connection *connection,
 }
 
 static int gdb_breakpoint_watchpoint_packet(struct connection *connection,
-               struct target *target, char *packet, int packet_size)
+               char *packet, int packet_size)
 {
+       struct target *target = get_target_from_connection(connection);
        int type;
        enum breakpoint_type bp_type = BKPT_SOFT /* dummy init to avoid warning */;
        enum watchpoint_rw wp_type = WPT_READ /* dummy init to avoid warning */;
@@ -1669,7 +1684,7 @@ static int compare_bank (const void * a, const void * b)
 }
 
 static int gdb_memory_map(struct connection *connection,
-               struct target *target, char *packet, int packet_size)
+               char *packet, int packet_size)
 {
        /* We get away with only specifying flash here. Regions that are not
         * specified are treated as if we provided no memory map(if not we
@@ -1678,6 +1693,7 @@ static int gdb_memory_map(struct connection *connection,
         * have to regenerate it a couple of times.
         */
 
+       struct target *target = get_target_from_connection(connection);
        struct flash_bank *p;
        char *xml = NULL;
        int size = 0;
@@ -1726,11 +1742,10 @@ static int gdb_memory_map(struct connection *connection,
        for (i = 0; i < flash_get_bank_count(); i++) {
                int j;
                unsigned sector_size = 0;
-               uint32_t start, end;
+               uint32_t start;
 
                p = banks[i];
                start = p->base;
-               end = p->base + p->size;
 
                if (ram_start < p->base)
                        xml_printf(&retval, &xml, &pos, &size,
@@ -1814,10 +1829,11 @@ static int gdb_memory_map(struct connection *connection,
 }
 
 static int gdb_query_packet(struct connection *connection,
-       struct target *target, char *packet, int packet_size)
+               char *packet, int packet_size)
 {
        struct command_context *cmd_ctx = connection->cmd_ctx;
        struct gdb_connection *gdb_connection = connection->priv;
+       struct target *target = get_target_from_connection(connection);
 
        if (strstr(packet, "qRcmd,"))
        {
@@ -1915,7 +1931,7 @@ static int gdb_query_packet(struct connection *connection,
        }
        else if (strstr(packet, "qXfer:memory-map:read::")
                        && (flash_get_bank_count() > 0))
-               return gdb_memory_map(connection, target, packet, packet_size);
+               return gdb_memory_map(connection, packet, packet_size);
        else if (strstr(packet, "qXfer:features:read:"))
        {
                char *xml = NULL;
@@ -1968,7 +1984,7 @@ static int gdb_query_packet(struct connection *connection,
 }
 
 static int gdb_v_packet(struct connection *connection,
-               struct target *target, char *packet, int packet_size)
+               char *packet, int packet_size)
 {
        struct gdb_connection *gdb_connection = connection->priv;
        struct gdb_service *gdb_service = connection->service->priv;
@@ -2115,7 +2131,7 @@ static int gdb_v_packet(struct connection *connection,
        return ERROR_OK;
 }
 
-static int gdb_detach(struct connection *connection, struct target *target)
+static int gdb_detach(struct connection *connection)
 {
        struct gdb_service *gdb_service = connection->service->priv;
 
@@ -2203,61 +2219,43 @@ static int gdb_input_inner(struct connection *connection)
                        switch (packet[0])
                        {
                            case 'T': // Is thread alive?
-                               gdb_thread_packet(connection, target, packet, packet_size);
+                               gdb_thread_packet(connection, packet, packet_size);
                                break;
                            case 'H': // Set current thread ( 'c' for step and continue, 'g' for all other operations )
-                               gdb_thread_packet(connection, target, packet, packet_size);
+                               gdb_thread_packet(connection, packet, packet_size);
                                break;
                                case 'q':
                                case 'Q':
-                                       retval = gdb_thread_packet(connection,
-                                                                                               target, packet,
-                                                                                               packet_size);
+                                       retval = gdb_thread_packet(connection, packet, packet_size);
                                        if ( retval == GDB_THREAD_PACKET_NOT_CONSUMED )
                                        {
-                                               retval = gdb_query_packet(connection,
-                                                               target, packet,
-                                                               packet_size);
+                                               retval = gdb_query_packet(connection, packet, packet_size);
                                        }
                                        break;
                                case 'g':
-                                       retval = gdb_get_registers_packet(
-                                                       connection, target,
-                                                       packet, packet_size);
+                                       retval = gdb_get_registers_packet(connection, packet, packet_size);
                                        break;
                                case 'G':
-                                       retval = gdb_set_registers_packet(
-                                                       connection, target,
-                                                       packet, packet_size);
+                                       retval = gdb_set_registers_packet(connection, packet, packet_size);
                                        break;
                                case 'p':
-                                       retval = gdb_get_register_packet(
-                                                       connection, target,
-                                                       packet, packet_size);
+                                       retval = gdb_get_register_packet(connection, packet, packet_size);
                                        break;
                                case 'P':
-                                       retval = gdb_set_register_packet(
-                                                       connection, target,
-                                                       packet, packet_size);
+                                       retval = gdb_set_register_packet(connection, packet, packet_size);
                                        break;
                                case 'm':
-                                       retval = gdb_read_memory_packet(
-                                                       connection, target,
-                                                       packet, packet_size);
+                                       retval = gdb_read_memory_packet(connection, packet, packet_size);
                                        break;
                                case 'M':
-                                       retval = gdb_write_memory_packet(
-                                                       connection, target,
-                                                       packet, packet_size);
+                                       retval = gdb_write_memory_packet(connection, packet, packet_size);
                                        break;
                                case 'z':
                                case 'Z':
-                                       retval = gdb_breakpoint_watchpoint_packet(connection, target, packet, packet_size);
+                                       retval = gdb_breakpoint_watchpoint_packet(connection, packet, packet_size);
                                        break;
                                case '?':
-                                       gdb_last_signal_packet(
-                                                       connection, target,
-                                                       packet, packet_size);
+                                       gdb_last_signal_packet(connection, packet, packet_size);
                                        break;
                                case 'c':
                                case 's':
@@ -2320,7 +2318,7 @@ static int gdb_input_inner(struct connection *connection)
                                                        {
                                                                /* Here we don't want packet processing to stop even if this fails,
                                                                 * so we use a local variable instead of retval. */
-                                                               retval = gdb_step_continue_packet(connection, target, packet, packet_size);
+                                                               retval = gdb_step_continue_packet(connection, packet, packet_size);
                                                                if (retval != ERROR_OK)
                                                                {
                                                                        /* we'll never receive a halted condition... issue a false one.. */
@@ -2331,18 +2329,14 @@ static int gdb_input_inner(struct connection *connection)
                                        }
                                        break;
                                case 'v':
-                                       retval = gdb_v_packet(
-                                                       connection, target,
-                                                       packet, packet_size);
+                                       retval = gdb_v_packet(connection, packet, packet_size);
                                        break;
                                case 'D':
-                                       retval = gdb_detach(connection, target);
+                                       retval = gdb_detach(connection);
                                        extended_protocol = 0;
                                        break;
                                case 'X':
-                                       retval = gdb_write_memory_binary_packet(
-                                                       connection, target,
-                                                       packet, packet_size);
+                                       retval = gdb_write_memory_binary_packet(connection, packet, packet_size);
                                        if (retval != ERROR_OK)
                                                return retval;
                                        break;
@@ -2363,23 +2357,20 @@ static int gdb_input_inner(struct connection *connection)
                                        command_run_linef(connection->cmd_ctx,
                                                        "ocd_gdb_restart %s",
                                                        target_name(target));
+                                       gdb_put_packet(connection, "OK", 2);
                                        break;
 
                                case 'j':
                                    /*  packet supported only by smp target i.e cortex_a.c*/
                                        /* handle smp packet replying coreid played to gbd */
-                                       gdb_read_smp_packet(
-                                                       connection, target,
-                                                       packet, packet_size);
+                                       gdb_read_smp_packet(connection, packet, packet_size);
                                        break;
 
                                case 'J':
                                        /*  packet supported only by smp target i.e cortex_a.c */
                                        /*  handle smp packet setting coreid to be played at next
                                         *  resume to gdb */
-                                       gdb_write_smp_packet(
-                                                       connection, target,
-                                                       packet, packet_size);
+                                       gdb_write_smp_packet(connection, packet, packet_size);
                                        break;
 
                                default:
openocd with support for Altus Metrum targets