2003-08-04 Andrew Cagney <cagney@redhat.com>

	* reggroups.c (struct reggroup_el): Define.
	(struct reggroups): Delete field "nr_group".  Replace array
	"group" with a "first" to "last" linked list.
	(reggroups_init): Update.  Allocate using gdbarch's obstack.
	(reggroups_free): Delete function.
	(add_group): Update.  Add "el" parameter.
	(reggroup_add): Pass gdbarch obstack allocated space to add_group.
	(default_groups): Update.
	(reggroup_next): Replace reggroups.
	(reggroups_dump): Update.
	(_initialize_reggroup): Pass XMALLOC allocated space to add_group.
	* regcache.c (regcache_dump): Use reggroup_next instead of reggroups.
	* infcmd.c (registers_info): Use reggroup_next instead of reggroups.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 407553d49388855f241e8cb4feebe941bfdb6f08..32fe0d9129e81945d2ed61678227d1f8d119a653 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,19 @@
+2003-08-04  Andrew Cagney  <cagney@redhat.com>
+
+       * reggroups.c (struct reggroup_el): Define.
+       (struct reggroups): Delete field "nr_group".  Replace array
+       "group" with a "first" to "last" linked list.
+       (reggroups_init): Update.  Allocate using gdbarch's obstack.
+       (reggroups_free): Delete function.
+       (add_group): Update.  Add "el" parameter.
+       (reggroup_add): Pass gdbarch obstack allocated space to add_group.
+       (default_groups): Update.
+       (reggroup_next): Replace reggroups.
+       (reggroups_dump): Update.
+       (_initialize_reggroup): Pass XMALLOC allocated space to add_group.
+       * regcache.c (regcache_dump): Use reggroup_next instead of reggroups.
+       * infcmd.c (registers_info): Use reggroup_next instead of reggroups.
+
 2003-08-04  Daniel Jacobowitz  <drow@mvista.com>
 
        * Makefile.in (tui-interp.o): Update dependencies.

diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index df7d9508ccac0754e0acba5bc4e600b5808639c5..6831d6be8f93504118d9c9d9a8b1bd4a444fe550 100644 (file)
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -1677,24 +1677,24 @@ registers_info (char *addr_exp, int fpregs)
 
       /* A register group?  */
       {
-       struct reggroup *const *group;
-       for (group = reggroups (current_gdbarch);
-            (*group) != NULL;
-            group++)
+       struct reggroup *group;
+       for (group = reggroup_next (current_gdbarch, NULL);
+            group != NULL;
+            group = reggroup_next (current_gdbarch, group))
          {
            /* Don't bother with a length check.  Should the user
               enter a short register group name, go with the first
               group that matches.  */
-           if (strncmp (start, reggroup_name ((*group)), end - start) == 0)
+           if (strncmp (start, reggroup_name (group), end - start) == 0)
              break;
          }
-       if ((*group) != NULL)
+       if (group != NULL)
          {
            int regnum;
            for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
              {
                if (gdbarch_register_reggroup_p (current_gdbarch, regnum,
-                                                (*group)))
+                                                group))
                  gdbarch_print_registers_info (current_gdbarch,
                                                gdb_stdout, deprecated_selected_frame,
                                                regnum, fpregs);

diff --git a/gdb/regcache.c b/gdb/regcache.c
index b66e06d51be3023dde26b7b4d7d7de7ef735b9a4..2b8c33f5b46f9daff2b8a67cae9c9ae308bbcc22 100644 (file)
--- a/gdb/regcache.c
+++ b/gdb/regcache.c
@@ -1426,7 +1426,6 @@ regcache_dump (struct regcache *regcache, struct ui_file *file,
 {
   struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
   struct gdbarch *gdbarch = regcache->descr->gdbarch;
-  struct reggroup *const *groups = reggroups (gdbarch);
   int regnum;
   int footnote_nr = 0;
   int footnote_register_size = 0;
@@ -1597,13 +1596,15 @@ regcache_dump (struct regcache *regcache, struct ui_file *file,
            fprintf_unfiltered (file, "Groups");
          else
            {
-             int i;
              const char *sep = "";
-             for (i = 0; groups[i] != NULL; i++)
+             struct reggroup *group;
+             for (group = reggroup_next (gdbarch, NULL);
+                  group != NULL;
+                  group = reggroup_next (gdbarch, group))
                {
-                 if (gdbarch_register_reggroup_p (gdbarch, regnum, groups[i]))
+                 if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
                    {
-                     fprintf_unfiltered (file, "%s%s", sep, reggroup_name (groups[i]));
+                     fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
                      sep = ",";
                    }
                }

diff --git a/gdb/reggroups.c b/gdb/reggroups.c
index ea9a9ec921e2fc839b5ea4f8907765c373362cba..a4e940ef2cceef46a59383e9601c7d5fcb090685 100644 (file)
--- a/gdb/reggroups.c
+++ b/gdb/reggroups.c
@@ -60,12 +60,18 @@ reggroup_type (struct reggroup *group)
   return group->type;
 }
 
-/* All the groups for a given architecture.  */
+/* A linked list of groups for the given architecture.  */
+
+struct reggroup_el
+{
+  struct reggroup *group;
+  struct reggroup_el *next;
+};
 
 struct reggroups
 {
-  int nr_group;
-  struct reggroup **group;
+  struct reggroup_el *first;
+  struct reggroup_el **last;
 };
 
 static struct gdbarch_data *reggroups_data;
@@ -73,33 +79,24 @@ static struct gdbarch_data *reggroups_data;
 static void *
 reggroups_init (struct gdbarch *gdbarch)
 {
-  struct reggroups *groups = XMALLOC (struct reggroups);
-  groups->nr_group = 0;
-  groups->group = NULL;
+  struct reggroups *groups = GDBARCH_OBSTACK_ZALLOC (gdbarch,
+                                                    struct reggroups);
+  groups->last = &groups->first;
   return groups;
 }
 
-static void
-reggroups_free (struct gdbarch *gdbarch, void *data)
-{
-  struct reggroups *groups = data;
-  xfree (groups->group);
-  xfree (groups);
-}
-
 /* Add a register group (with attribute values) to the pre-defined
-   list.  This function can be called during architecture
-   initialization and hence needs to handle NULL architecture groups.  */
+   list.  */
 
 static void
-add_group (struct reggroups *groups, struct reggroup *group)
+add_group (struct reggroups *groups, struct reggroup *group,
+          struct reggroup_el *el)
 {
   gdb_assert (group != NULL);
-  groups->nr_group++;
-  groups->group = xrealloc (groups->group, (sizeof (struct reggroup *)
-                                           * (groups->nr_group + 1)));
-  groups->group[groups->nr_group - 1] = group;
-  groups->group[groups->nr_group] = NULL;
+  el->group = group;
+  el->next = NULL;
+  (*groups->last) = el;
+  groups->last = &el->next;
 }
 
 void
@@ -113,25 +110,37 @@ reggroup_add (struct gdbarch *gdbarch, struct reggroup *group)
       groups = reggroups_init (gdbarch);
       set_gdbarch_data (gdbarch, reggroups_data, groups);
     }
-  add_group (groups, group);
+  add_group (groups, group,
+            GDBARCH_OBSTACK_ZALLOC (gdbarch, struct reggroup_el));
 }
 
-/* The register groups for the current architecture.  Mumble something
-   about the lifetime of the buffer....  */
+/* The default register groups for an architecture.  */
+
+static struct reggroups default_groups = { NULL, &default_groups.first };
 
-static struct reggroups *default_groups;
+/* A register group iterator.  */
 
-struct reggroup * const*
-reggroups (struct gdbarch *gdbarch)
+struct reggroup *
+reggroup_next (struct gdbarch *gdbarch, struct reggroup *last)
 {
-  struct reggroups *groups = gdbarch_data (gdbarch, reggroups_data);
+  struct reggroups *groups;
+  struct reggroup_el *el;
   /* Don't allow this function to be called during architecture
-     creation.  */
+     creation.  If there are no groups, use the default groups list.  */
+  groups = gdbarch_data (gdbarch, reggroups_data);
   gdb_assert (groups != NULL);
-  if (groups->group == NULL)
-    return default_groups->group;
-  else
-    return groups->group;
+  if (groups->first == NULL)
+    groups = &default_groups;
+
+  /* Retun the first/next reggroup.  */
+  if (last == NULL)
+    return groups->first->group;
+  for (el = groups->first; el != NULL; el = el->next)
+    {
+      if (el->group == last)
+       return el->next->group;
+    }
+  return NULL;
 }
 
 /* Is REGNUM a member of REGGROUP?  */
@@ -168,28 +177,27 @@ default_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
 static void
 reggroups_dump (struct gdbarch *gdbarch, struct ui_file *file)
 {
-  struct reggroup *const *groups = reggroups (gdbarch);
-  int i = -1;
+  struct reggroup *group = NULL;
   do
     {
       /* Group name.  */
       {
        const char *name;
-       if (i < 0)
+       if (group == NULL)
          name = "Group";
        else
-         name = reggroup_name (groups[i]);
+         name = reggroup_name (group);
        fprintf_unfiltered (file, " %-10s", name);
       }
       
       /* Group type.  */
       {
        const char *type;
-       if (i < 0)
+       if (group == NULL)
          type = "Type";
        else
          {
-           switch (reggroup_type (groups[i]))
+           switch (reggroup_type (group))
              {
              case USER_REGGROUP:
                type = "user";
@@ -208,9 +216,10 @@ reggroups_dump (struct gdbarch *gdbarch, struct ui_file *file)
          documentation.  */
       
       fprintf_unfiltered (file, "\n");
-      i++;
+
+      group = reggroup_next (gdbarch, group);
     }
-  while (groups[i] != NULL);
+  while (group != NULL);
 }
 
 static void
@@ -250,18 +259,16 @@ extern initialize_file_ftype _initialize_reggroup; /* -Wmissing-prototypes */
 void
 _initialize_reggroup (void)
 {
-  reggroups_data = register_gdbarch_data (reggroups_init, reggroups_free);
+  reggroups_data = register_gdbarch_data (reggroups_init, NULL);
 
   /* The pre-defined list of groups.  */
-  default_groups = reggroups_init (NULL);
-  add_group (default_groups, general_reggroup);
-  add_group (default_groups, float_reggroup);
-  add_group (default_groups, system_reggroup);
-  add_group (default_groups, vector_reggroup);
-  add_group (default_groups, all_reggroup);
-  add_group (default_groups, save_reggroup);
-  add_group (default_groups, restore_reggroup);
-
+  add_group (&default_groups, general_reggroup, XMALLOC (struct reggroup_el));
+  add_group (&default_groups, float_reggroup, XMALLOC (struct reggroup_el));
+  add_group (&default_groups, system_reggroup, XMALLOC (struct reggroup_el));
+  add_group (&default_groups, vector_reggroup, XMALLOC (struct reggroup_el));
+  add_group (&default_groups, all_reggroup, XMALLOC (struct reggroup_el));
+  add_group (&default_groups, save_reggroup, XMALLOC (struct reggroup_el));
+  add_group (&default_groups, restore_reggroup, XMALLOC (struct reggroup_el));
 
   add_cmd ("reggroups", class_maintenance,
           maintenance_print_reggroups, "\

diff --git a/gdb/reggroups.h b/gdb/reggroups.h
index 0088a8520e3266f9effcb06147289e90d43e5d14..22c0a6fcca9d8fb412c617a6c4b2a0153c696267 100644 (file)
--- a/gdb/reggroups.h
+++ b/gdb/reggroups.h
@@ -51,8 +51,11 @@ extern void reggroup_add (struct gdbarch *gdbarch, struct reggroup *group);
 extern const char *reggroup_name (struct reggroup *reggroup);
 extern enum reggroup_type reggroup_type (struct reggroup *reggroup);
 
-/* The register groups for the current architecture.  */
-extern struct reggroup *const *reggroups (struct gdbarch *gdbarch);
+/* Interator for the architecture's register groups.  Pass in NULL,
+   returns the first group.  Pass in a group, returns the next group,
+   or NULL when the last group is reached.  */
+extern struct reggroup *reggroup_next (struct gdbarch *gdbarch,
+                                      struct reggroup *last);
 
 /* Is REGNUM a member of REGGROUP?  */
 extern int default_register_reggroup_p (struct gdbarch *gdbarch, int regnum,