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