1 /* Register groupings for GDB, the GNU debugger. 2 3 Copyright (C) 2002-2016 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 106 = (struct reggroups *) gdbarch_data (gdbarch, reggroups_data); 107 108 if (groups == NULL) 109 { 110 /* ULGH, called during architecture initialization. Patch 111 things up. */ 112 groups = (struct reggroups *) reggroups_init (gdbarch); 113 deprecated_set_gdbarch_data (gdbarch, reggroups_data, groups); 114 } 115 add_group (groups, group, 116 GDBARCH_OBSTACK_ZALLOC (gdbarch, struct reggroup_el)); 117 } 118 119 /* The default register groups for an architecture. */ 120 121 static struct reggroups default_groups = { NULL, &default_groups.first }; 122 123 /* A register group iterator. */ 124 125 struct reggroup * 126 reggroup_next (struct gdbarch *gdbarch, struct reggroup *last) 127 { 128 struct reggroups *groups; 129 struct reggroup_el *el; 130 131 /* Don't allow this function to be called during architecture 132 creation. If there are no groups, use the default groups list. */ 133 groups = (struct reggroups *) gdbarch_data (gdbarch, reggroups_data); 134 gdb_assert (groups != NULL); 135 if (groups->first == NULL) 136 groups = &default_groups; 137 138 /* Return the first/next reggroup. */ 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) 144 { 145 if (el->next != NULL) 146 return el->next->group; 147 else 148 return NULL; 149 } 150 } 151 return NULL; 152 } 153 154 /* See reggroups.h. */ 155 156 struct reggroup * 157 reggroup_prev (struct gdbarch *gdbarch, struct reggroup *curr) 158 { 159 struct reggroups *groups; 160 struct reggroup_el *el; 161 struct reggroup *prev; 162 163 /* Don't allow this function to be called during architecture 164 creation. If there are no groups, use the default groups list. */ 165 groups = (struct reggroups *) gdbarch_data (gdbarch, reggroups_data); 166 gdb_assert (groups != NULL); 167 if (groups->first == NULL) 168 groups = &default_groups; 169 170 prev = NULL; 171 for (el = groups->first; el != NULL; el = el->next) 172 { 173 gdb_assert (el->group != NULL); 174 if (el->group == curr) 175 return prev; 176 prev = el->group; 177 } 178 if (curr == NULL) 179 return prev; 180 return NULL; 181 } 182 183 /* Is REGNUM a member of REGGROUP? */ 184 int 185 default_register_reggroup_p (struct gdbarch *gdbarch, int regnum, 186 struct reggroup *group) 187 { 188 int vector_p; 189 int float_p; 190 int raw_p; 191 192 if (gdbarch_register_name (gdbarch, regnum) == NULL 193 || *gdbarch_register_name (gdbarch, regnum) == '\0') 194 return 0; 195 if (group == all_reggroup) 196 return 1; 197 vector_p = TYPE_VECTOR (register_type (gdbarch, regnum)); 198 float_p = TYPE_CODE (register_type (gdbarch, regnum)) == TYPE_CODE_FLT; 199 raw_p = regnum < gdbarch_num_regs (gdbarch); 200 if (group == float_reggroup) 201 return float_p; 202 if (group == vector_reggroup) 203 return vector_p; 204 if (group == general_reggroup) 205 return (!vector_p && !float_p); 206 if (group == save_reggroup || group == restore_reggroup) 207 return raw_p; 208 return 0; 209 } 210 211 /* Dump out a table of register groups for the current architecture. */ 212 213 static void 214 reggroups_dump (struct gdbarch *gdbarch, struct ui_file *file) 215 { 216 struct reggroup *group = NULL; 217 218 do 219 { 220 /* Group name. */ 221 { 222 const char *name; 223 224 if (group == NULL) 225 name = "Group"; 226 else 227 name = reggroup_name (group); 228 fprintf_unfiltered (file, " %-10s", name); 229 } 230 231 /* Group type. */ 232 { 233 const char *type; 234 235 if (group == NULL) 236 type = "Type"; 237 else 238 { 239 switch (reggroup_type (group)) 240 { 241 case USER_REGGROUP: 242 type = "user"; 243 break; 244 case INTERNAL_REGGROUP: 245 type = "internal"; 246 break; 247 default: 248 internal_error (__FILE__, __LINE__, _("bad switch")); 249 } 250 } 251 fprintf_unfiltered (file, " %-10s", type); 252 } 253 254 /* Note: If you change this, be sure to also update the 255 documentation. */ 256 257 fprintf_unfiltered (file, "\n"); 258 259 group = reggroup_next (gdbarch, group); 260 } 261 while (group != NULL); 262 } 263 264 static void 265 maintenance_print_reggroups (char *args, int from_tty) 266 { 267 struct gdbarch *gdbarch = get_current_arch (); 268 269 if (args == NULL) 270 reggroups_dump (gdbarch, gdb_stdout); 271 else 272 { 273 struct cleanup *cleanups; 274 struct ui_file *file = gdb_fopen (args, "w"); 275 276 if (file == NULL) 277 perror_with_name (_("maintenance print reggroups")); 278 cleanups = make_cleanup_ui_file_delete (file); 279 reggroups_dump (gdbarch, file); 280 do_cleanups (cleanups); 281 } 282 } 283 284 /* Pre-defined register groups. */ 285 static struct reggroup general_group = { "general", USER_REGGROUP }; 286 static struct reggroup float_group = { "float", USER_REGGROUP }; 287 static struct reggroup system_group = { "system", USER_REGGROUP }; 288 static struct reggroup vector_group = { "vector", USER_REGGROUP }; 289 static struct reggroup all_group = { "all", USER_REGGROUP }; 290 static struct reggroup save_group = { "save", INTERNAL_REGGROUP }; 291 static struct reggroup restore_group = { "restore", INTERNAL_REGGROUP }; 292 293 struct reggroup *const general_reggroup = &general_group; 294 struct reggroup *const float_reggroup = &float_group; 295 struct reggroup *const system_reggroup = &system_group; 296 struct reggroup *const vector_reggroup = &vector_group; 297 struct reggroup *const all_reggroup = &all_group; 298 struct reggroup *const save_reggroup = &save_group; 299 struct reggroup *const restore_reggroup = &restore_group; 300 301 extern initialize_file_ftype _initialize_reggroup; /* -Wmissing-prototypes */ 302 303 void 304 _initialize_reggroup (void) 305 { 306 reggroups_data = gdbarch_data_register_post_init (reggroups_init); 307 308 /* The pre-defined list of groups. */ 309 add_group (&default_groups, general_reggroup, XNEW (struct reggroup_el)); 310 add_group (&default_groups, float_reggroup, XNEW (struct reggroup_el)); 311 add_group (&default_groups, system_reggroup, XNEW (struct reggroup_el)); 312 add_group (&default_groups, vector_reggroup, XNEW (struct reggroup_el)); 313 add_group (&default_groups, all_reggroup, XNEW (struct reggroup_el)); 314 add_group (&default_groups, save_reggroup, XNEW (struct reggroup_el)); 315 add_group (&default_groups, restore_reggroup, XNEW (struct reggroup_el)); 316 317 add_cmd ("reggroups", class_maintenance, 318 maintenance_print_reggroups, _("\ 319 Print the internal register group names.\n\ 320 Takes an optional file parameter."), 321 &maintenanceprintlist); 322 323 } 324