This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
[patch, rfc] Switch reggroups to the architecture's obstack
- From: Andrew Cagney <ac131313 at redhat dot com>
- To: gdb-patches at sources dot redhat dot com
- Date: Fri, 01 Aug 2003 13:50:07 -0400
- Subject: [patch, rfc] Switch reggroups to the architecture's obstack
Hello,
This patch updates the reggroups code so that it uses the architecture's
obstack. Only one thing of note, it replaces reggroups (returned an
array of groups) with reggroup_next (an iterator).
I'll look to commit this in a few days,
Andrew
2003-08-01 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.
Index: infcmd.c
===================================================================
RCS file: /cvs/src/src/gdb/infcmd.c,v
retrieving revision 1.85
diff -u -r1.85 infcmd.c
--- infcmd.c 31 Jul 2003 23:41:25 -0000 1.85
+++ infcmd.c 1 Aug 2003 17:36:06 -0000
@@ -1677,24 +1677,24 @@
/* 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);
Index: regcache.c
===================================================================
RCS file: /cvs/src/src/gdb/regcache.c,v
retrieving revision 1.91
diff -u -r1.91 regcache.c
--- regcache.c 28 Jul 2003 15:41:19 -0000 1.91
+++ regcache.c 1 Aug 2003 17:36:07 -0000
@@ -1426,7 +1426,6 @@
{
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 @@
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 = ",";
}
}
Index: reggroups.c
===================================================================
RCS file: /cvs/src/src/gdb/reggroups.c,v
retrieving revision 1.4
diff -u -r1.4 reggroups.c
--- reggroups.c 8 Jun 2003 18:27:14 -0000 1.4
+++ reggroups.c 1 Aug 2003 17:36:07 -0000
@@ -60,12 +60,18 @@
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 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 @@
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 @@
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 @@
documentation. */
fprintf_unfiltered (file, "\n");
- i++;
+
+ group = reggroup_next (gdbarch, group);
}
- while (groups[i] != NULL);
+ while (group != NULL);
}
static void
@@ -250,18 +259,16 @@
void
_initialize_reggroup (void)
{
- reggroups_data = register_gdbarch_data (reggroups_init, reggroups_free);
-
/* 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));
+ reggroups_data = register_gdbarch_data (reggroups_init, NULL);
add_cmd ("reggroups", class_maintenance,
maintenance_print_reggroups, "\
Index: reggroups.h
===================================================================
RCS file: /cvs/src/src/gdb/reggroups.h,v
retrieving revision 1.2
diff -u -r1.2 reggroups.h
--- reggroups.h 2 Nov 2002 15:13:34 -0000 1.2
+++ reggroups.h 1 Aug 2003 17:36:07 -0000
@@ -51,8 +51,11 @@
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,