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

[deliverable/binutils-gdb.git] / gdb / reggroups.c

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, "\