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.

5 files changed, 93 insertions, 66 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 407553d4938..32fe0d9129e 100644
--- 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 df7d9508cca..6831d6be8f9 100644
--- 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 b66e06d51be..2b8c33f5b46 100644
--- 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 ea9a9ec921e..a4e940ef2cc 100644
--- 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 0088a8520e3..22c0a6fcca9 100644
--- 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,