Combine register lists of smp targets.

[openocd.git] / src / server / gdb_server.c

diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c
index 0d2d1ae2c307eb18ec3321e59c18b31b65d70e75..b6f4a82647a60cc07c8b81be525f1d04931a1cd9 100644 (file)
--- a/src/server/gdb_server.c
+++ b/src/server/gdb_server.c
@@ -1006,16 +1006,19 @@ static int gdb_new_connection(struct connection *connection)
        breakpoint_clear_target(target);
        watchpoint_clear_target(target);
 
-       /* remove the initial ACK from the incoming buffer */
+       /* Since version 3.95 (gdb-19990504), with the exclusion of 6.5~6.8, GDB
+        * sends an ACK at connection with the following comment in its source code:
+        * "Ack any packet which the remote side has already sent."
+        * LLDB does the same since the first gdb-remote implementation.
+        * Remove the initial ACK from the incoming buffer.
+        */
        retval = gdb_get_char(connection, &initial_ack);
        if (retval != ERROR_OK)
                return retval;
 
-       /* FIX!!!??? would we actually ever receive a + here???
-        * Not observed.
-        */
        if (initial_ack != '+')
                gdb_putback_char(connection, initial_ack);
+
        target_call_event_callbacks(target, TARGET_EVENT_GDB_ATTACH);
 
        if (target->rtos) {
@@ -2256,6 +2259,108 @@ static int get_reg_features_list(struct target *target, char const **feature_lis
        return ERROR_OK;
 }
 
+/* Create a register list that's the union of all the registers of the SMP
+ * group this target is in. If the target is not part of an SMP group, this
+ * returns the same as target_get_gdb_reg_list_noread().
+ */
+static int smp_reg_list_noread(struct target *target,
+               struct reg **combined_list[], int *combined_list_size,
+               enum target_register_class reg_class)
+{
+       if (!target->smp)
+               return target_get_gdb_reg_list_noread(target, combined_list,
+                               combined_list_size, REG_CLASS_ALL);
+
+       unsigned int combined_allocated = 256;
+       *combined_list = malloc(combined_allocated * sizeof(struct reg *));
+       if (*combined_list == NULL) {
+               LOG_ERROR("malloc(%zu) failed", combined_allocated * sizeof(struct reg *));
+               return ERROR_FAIL;
+       }
+       *combined_list_size = 0;
+
+       struct target_list *head;
+       foreach_smp_target(head, target->head) {
+               struct reg **reg_list = NULL;
+               int reg_list_size;
+               int result = target_get_gdb_reg_list_noread(head->target, &reg_list,
+                               &reg_list_size, reg_class);
+               if (result != ERROR_OK) {
+                       free(*combined_list);
+                       return result;
+               }
+               for (int i = 0; i < reg_list_size; i++) {
+                       bool found = false;
+                       struct reg *a = reg_list[i];
+                       if (a->exist) {
+                               /* Nested loop makes this O(n^2), but this entire function with
+                                * 5 RISC-V targets takes just 2ms on my computer. Fast enough
+                                * for me. */
+                               for (int j = 0; j < *combined_list_size; j++) {
+                                       struct reg *b = (*combined_list)[j];
+                                       if (!strcmp(a->name, b->name)) {
+                                               found = true;
+                                               if (a->size != b->size) {
+                                                       LOG_ERROR("SMP register %s is %d bits on one "
+                                                                       "target, but %d bits on another target.",
+                                                                       a->name, a->size, b->size);
+                                                       free(reg_list);
+                                                       free(*combined_list);
+                                                       return ERROR_FAIL;
+                                               }
+                                               break;
+                                       }
+                               }
+                               if (!found) {
+                                       LOG_DEBUG("[%s] %s not found in combined list", target_name(target), a->name);
+                                       if (*combined_list_size >= (int) combined_allocated) {
+                                               combined_allocated *= 2;
+                                               *combined_list = realloc(*combined_list, combined_allocated * sizeof(struct reg *));
+                                               if (*combined_list == NULL) {
+                                                       LOG_ERROR("realloc(%zu) failed", combined_allocated * sizeof(struct reg *));
+                                                       return ERROR_FAIL;
+                                               }
+                                       }
+                                       (*combined_list)[*combined_list_size] = a;
+                                       (*combined_list_size)++;
+                               }
+                       }
+               }
+               free(reg_list);
+       }
+
+       /* Now warn the user about any registers that weren't found in every target. */
+       foreach_smp_target(head, target->head) {
+               struct reg **reg_list = NULL;
+               int reg_list_size;
+               int result = target_get_gdb_reg_list_noread(head->target, &reg_list,
+                               &reg_list_size, reg_class);
+               if (result != ERROR_OK) {
+                       free(*combined_list);
+                       return result;
+               }
+               for (int i = 0; i < *combined_list_size; i++) {
+                       bool found = false;
+                       struct reg *a = (*combined_list)[i];
+                       for (int j = 0; j < reg_list_size; j++) {
+                               struct reg *b = reg_list[j];
+                               if (b->exist && !strcmp(a->name, b->name)) {
+                                       found = true;
+                                       break;
+                               }
+                       }
+                       if (!found) {
+                               LOG_WARNING("Register %s does not exist in %s, which is part of an SMP group where "
+                                           "this register does exist.",
+                                           a->name, target_name(head->target));
+                       }
+               }
+               free(reg_list);
+       }
+
+       return ERROR_OK;
+}
+
 static int gdb_generate_target_description(struct target *target, char **tdesc_out)
 {
        int retval = ERROR_OK;
@@ -2269,8 +2374,8 @@ static int gdb_generate_target_description(struct target *target, char **tdesc_o
        int size = 0;
 
 
-       retval = target_get_gdb_reg_list_noread(target, &reg_list,
-                       &reg_list_size, REG_CLASS_ALL);
+       retval = smp_reg_list_noread(target, &reg_list, &reg_list_size,
+                       REG_CLASS_ALL);
 
        if (retval != ERROR_OK) {
                LOG_ERROR("get register list failed");