gdb/reggroups.c

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