gold/
[deliverable/binutils-gdb.git] / gdb / reggroups.c
CommitLineData
b59ff9d5
AC
1/* Register groupings for GDB, the GNU debugger.
2
28e7fd62 3 Copyright (C) 2002-2013 Free Software Foundation, Inc.
b59ff9d5
AC
4
5 Contributed by Red Hat.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
a9762ec7 11 the Free Software Foundation; either version 3 of the License, or
b59ff9d5
AC
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
a9762ec7 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
b59ff9d5
AC
21
22#include "defs.h"
e17c207e 23#include "arch-utils.h"
b59ff9d5
AC
24#include "reggroups.h"
25#include "gdbtypes.h"
26#include "gdb_assert.h"
27#include "regcache.h"
28#include "command.h"
29#include "gdbcmd.h" /* For maintenanceprintlist. */
30
31/* Individual register groups. */
32
33struct reggroup
34{
35 const char *name;
36 enum reggroup_type type;
37};
38
39struct reggroup *
40reggroup_new (const char *name, enum reggroup_type type)
41{
42 struct reggroup *group = XMALLOC (struct reggroup);
123f5f96 43
b59ff9d5
AC
44 group->name = name;
45 group->type = type;
46 return group;
47}
48
49/* Register group attributes. */
50
51const char *
52reggroup_name (struct reggroup *group)
53{
54 return group->name;
55}
56
57enum reggroup_type
58reggroup_type (struct reggroup *group)
59{
60 return group->type;
61}
62
6c7d17ba
AC
63/* A linked list of groups for the given architecture. */
64
65struct reggroup_el
66{
67 struct reggroup *group;
68 struct reggroup_el *next;
69};
b59ff9d5
AC
70
71struct reggroups
72{
6c7d17ba
AC
73 struct reggroup_el *first;
74 struct reggroup_el **last;
b59ff9d5
AC
75};
76
77static struct gdbarch_data *reggroups_data;
78
79static void *
80reggroups_init (struct gdbarch *gdbarch)
81{
6c7d17ba
AC
82 struct reggroups *groups = GDBARCH_OBSTACK_ZALLOC (gdbarch,
83 struct reggroups);
123f5f96 84
6c7d17ba 85 groups->last = &groups->first;
b59ff9d5
AC
86 return groups;
87}
88
b59ff9d5 89/* Add a register group (with attribute values) to the pre-defined
6c7d17ba 90 list. */
b59ff9d5
AC
91
92static void
6c7d17ba
AC
93add_group (struct reggroups *groups, struct reggroup *group,
94 struct reggroup_el *el)
b59ff9d5
AC
95{
96 gdb_assert (group != NULL);
6c7d17ba
AC
97 el->group = group;
98 el->next = NULL;
99 (*groups->last) = el;
100 groups->last = &el->next;
b59ff9d5
AC
101}
102
103void
104reggroup_add (struct gdbarch *gdbarch, struct reggroup *group)
105{
106 struct reggroups *groups = gdbarch_data (gdbarch, reggroups_data);
7e6d0ac8 107
b59ff9d5
AC
108 if (groups == NULL)
109 {
110 /* ULGH, called during architecture initialization. Patch
111 things up. */
112 groups = reggroups_init (gdbarch);
030f20e1 113 deprecated_set_gdbarch_data (gdbarch, reggroups_data, groups);
b59ff9d5 114 }
6c7d17ba
AC
115 add_group (groups, group,
116 GDBARCH_OBSTACK_ZALLOC (gdbarch, struct reggroup_el));
b59ff9d5
AC
117}
118
6c7d17ba
AC
119/* The default register groups for an architecture. */
120
121static struct reggroups default_groups = { NULL, &default_groups.first };
b59ff9d5 122
6c7d17ba 123/* A register group iterator. */
b59ff9d5 124
6c7d17ba
AC
125struct reggroup *
126reggroup_next (struct gdbarch *gdbarch, struct reggroup *last)
b59ff9d5 127{
6c7d17ba
AC
128 struct reggroups *groups;
129 struct reggroup_el *el;
7e6d0ac8 130
b59ff9d5 131 /* Don't allow this function to be called during architecture
6c7d17ba
AC
132 creation. If there are no groups, use the default groups list. */
133 groups = gdbarch_data (gdbarch, reggroups_data);
b59ff9d5 134 gdb_assert (groups != NULL);
6c7d17ba
AC
135 if (groups->first == NULL)
136 groups = &default_groups;
137
9dd5f34f 138 /* Return the first/next reggroup. */
6c7d17ba
AC
139 if (last == NULL)
140 return groups->first->group;
141 for (el = groups->first; el != NULL; el = el->next)
142 {
143 if (el->group == last)
9dd5f34f
AC
144 {
145 if (el->next != NULL)
146 return el->next->group;
147 else
148 return NULL;
149 }
6c7d17ba
AC
150 }
151 return NULL;
b59ff9d5
AC
152}
153
154/* Is REGNUM a member of REGGROUP? */
155int
156default_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
157 struct reggroup *group)
158{
159 int vector_p;
160 int float_p;
161 int raw_p;
7e6d0ac8 162
6bcde365
UW
163 if (gdbarch_register_name (gdbarch, regnum) == NULL
164 || *gdbarch_register_name (gdbarch, regnum) == '\0')
b59ff9d5
AC
165 return 0;
166 if (group == all_reggroup)
167 return 1;
168 vector_p = TYPE_VECTOR (register_type (gdbarch, regnum));
169 float_p = TYPE_CODE (register_type (gdbarch, regnum)) == TYPE_CODE_FLT;
6bcde365 170 raw_p = regnum < gdbarch_num_regs (gdbarch);
b59ff9d5
AC
171 if (group == float_reggroup)
172 return float_p;
173 if (group == vector_reggroup)
174 return vector_p;
175 if (group == general_reggroup)
176 return (!vector_p && !float_p);
177 if (group == save_reggroup || group == restore_reggroup)
178 return raw_p;
179 return 0;
180}
181
182/* Dump out a table of register groups for the current architecture. */
183
184static void
185reggroups_dump (struct gdbarch *gdbarch, struct ui_file *file)
186{
6c7d17ba 187 struct reggroup *group = NULL;
7e6d0ac8 188
b59ff9d5
AC
189 do
190 {
191 /* Group name. */
192 {
193 const char *name;
123f5f96 194
6c7d17ba 195 if (group == NULL)
b59ff9d5
AC
196 name = "Group";
197 else
6c7d17ba 198 name = reggroup_name (group);
b59ff9d5
AC
199 fprintf_unfiltered (file, " %-10s", name);
200 }
201
202 /* Group type. */
203 {
204 const char *type;
123f5f96 205
6c7d17ba 206 if (group == NULL)
b59ff9d5
AC
207 type = "Type";
208 else
209 {
6c7d17ba 210 switch (reggroup_type (group))
b59ff9d5
AC
211 {
212 case USER_REGGROUP:
213 type = "user";
214 break;
215 case INTERNAL_REGGROUP:
216 type = "internal";
217 break;
218 default:
e2e0b3e5 219 internal_error (__FILE__, __LINE__, _("bad switch"));
b59ff9d5
AC
220 }
221 }
222 fprintf_unfiltered (file, " %-10s", type);
223 }
224
225 /* Note: If you change this, be sure to also update the
226 documentation. */
227
228 fprintf_unfiltered (file, "\n");
6c7d17ba
AC
229
230 group = reggroup_next (gdbarch, group);
b59ff9d5 231 }
6c7d17ba 232 while (group != NULL);
b59ff9d5
AC
233}
234
235static void
236maintenance_print_reggroups (char *args, int from_tty)
237{
e17c207e
UW
238 struct gdbarch *gdbarch = get_current_arch ();
239
b59ff9d5 240 if (args == NULL)
e17c207e 241 reggroups_dump (gdbarch, gdb_stdout);
b59ff9d5
AC
242 else
243 {
724b958c 244 struct cleanup *cleanups;
b59ff9d5 245 struct ui_file *file = gdb_fopen (args, "w");
123f5f96 246
b59ff9d5 247 if (file == NULL)
e2e0b3e5 248 perror_with_name (_("maintenance print reggroups"));
724b958c 249 cleanups = make_cleanup_ui_file_delete (file);
e17c207e 250 reggroups_dump (gdbarch, file);
724b958c 251 do_cleanups (cleanups);
b59ff9d5
AC
252 }
253}
254
255/* Pre-defined register groups. */
256static struct reggroup general_group = { "general", USER_REGGROUP };
257static struct reggroup float_group = { "float", USER_REGGROUP };
258static struct reggroup system_group = { "system", USER_REGGROUP };
259static struct reggroup vector_group = { "vector", USER_REGGROUP };
260static struct reggroup all_group = { "all", USER_REGGROUP };
261static struct reggroup save_group = { "save", INTERNAL_REGGROUP };
262static struct reggroup restore_group = { "restore", INTERNAL_REGGROUP };
263
264struct reggroup *const general_reggroup = &general_group;
265struct reggroup *const float_reggroup = &float_group;
266struct reggroup *const system_reggroup = &system_group;
267struct reggroup *const vector_reggroup = &vector_group;
268struct reggroup *const all_reggroup = &all_group;
269struct reggroup *const save_reggroup = &save_group;
270struct reggroup *const restore_reggroup = &restore_group;
271
b9362cc7
AC
272extern initialize_file_ftype _initialize_reggroup; /* -Wmissing-prototypes */
273
b59ff9d5
AC
274void
275_initialize_reggroup (void)
276{
030f20e1 277 reggroups_data = gdbarch_data_register_post_init (reggroups_init);
b59ff9d5
AC
278
279 /* The pre-defined list of groups. */
6c7d17ba
AC
280 add_group (&default_groups, general_reggroup, XMALLOC (struct reggroup_el));
281 add_group (&default_groups, float_reggroup, XMALLOC (struct reggroup_el));
282 add_group (&default_groups, system_reggroup, XMALLOC (struct reggroup_el));
283 add_group (&default_groups, vector_reggroup, XMALLOC (struct reggroup_el));
284 add_group (&default_groups, all_reggroup, XMALLOC (struct reggroup_el));
285 add_group (&default_groups, save_reggroup, XMALLOC (struct reggroup_el));
286 add_group (&default_groups, restore_reggroup, XMALLOC (struct reggroup_el));
b59ff9d5
AC
287
288 add_cmd ("reggroups", class_maintenance,
1a966eab 289 maintenance_print_reggroups, _("\
b59ff9d5 290Print the internal register group names.\n\
1a966eab 291Takes an optional file parameter."),
b59ff9d5
AC
292 &maintenanceprintlist);
293
294}
This page took 1.713162 seconds and 4 git commands to generate.