gdb/reggroups.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* Register groupings for GDB, the GNU debugger.

  3.    Copyright (C) 2002-2015 Free Software Foundation, Inc.

  5.    Contributed by Red Hat.

  7.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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.  */

  30. /* Individual register groups.  */

  32. ‌struct reggroup
  33. {
  34.   const char *name;
  35.   enum reggroup_type type;
  36. };

  38. struct reggroup *
  39. ‌reggroup_new (const char *name, enum reggroup_type type)
  40. {
  41.   struct reggroup *group = XNEW (struct reggroup);

  43.   group->name = name;
  44.   group->type = type;
  45.   return group;
  46. }

  48. /* Register group attributes.  */

  50. const char *
  51. ‌reggroup_name (struct reggroup *group)
  52. {
  53.   return group->name;
  54. }

  56. enum reggroup_type
  57. ‌reggroup_type (struct reggroup *group)
  58. {
  59.   return group->type;
  60. }

  62. /* A linked list of groups for the given architecture.  */

  64. ‌struct reggroup_el
  65. {
  66.   struct reggroup *group;
  67.   struct reggroup_el *next;
  68. };

  70. ‌struct reggroups
  71. {
  72.   struct reggroup_el *first;
  73.   struct reggroup_el **last;
  74. };

  76. ‌static struct gdbarch_data *reggroups_data;

  78. static void *
  79. ‌reggroups_init (struct gdbarch *gdbarch)
  80. {
  81.   struct reggroups *groups = GDBARCH_OBSTACK_ZALLOC (gdbarch,
  82.                                                      struct reggroups);

  84.   groups->last = &groups->first;
  85.   return groups;
  86. }

  88. /* Add a register group (with attribute values) to the pre-defined
  89.    list.  */

  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. }

  102. void
  103. ‌reggroup_add (struct gdbarch *gdbarch, struct reggroup *group)
  104. {
  105.   struct reggroups *groups = gdbarch_data (gdbarch, reggroups_data);

  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. }

  118. /* The default register groups for an architecture.  */

  120. ‌static struct reggroups default_groups = { NULL, &default_groups.first };

  122. /* A register group iterator.  */

  124. struct reggroup *
  125. ‌reggroup_next (struct gdbarch *gdbarch, struct reggroup *last)
  126. {
  127.   struct reggroups *groups;
  128.   struct reggroup_el *el;

  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;

  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. }

  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;

  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. }

  181. /* Dump out a table of register groups for the current architecture.  */

  183. static void
  184. ‌reggroups_dump (struct gdbarch *gdbarch, struct ui_file *file)
  185. {
  186.   struct reggroup *group = NULL;

  188.   do
  189.     {
  190.       /* Group name.  */
  191.       {
  192.         const char *name;

  194.         if (group == NULL)
  195.           name = "Group";
  196.         else
  197.           name = reggroup_name (group);
  198.         fprintf_unfiltered (file, " %-10s", name);
  199.       }

  201.       /* Group type.  */
  202.       {
  203.         const char *type;

  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.       }

  224.       /* Note: If you change this, be sure to also update the
  225.          documentation.  */

  227.       fprintf_unfiltered (file, "\n");

  229.       group = reggroup_next (gdbarch, group);
  230.     }
  231.   while (group != NULL);
  232. }

  234. static void
  235. ‌maintenance_print_reggroups (char *args, int from_tty)
  236. {
  237.   struct gdbarch *gdbarch = get_current_arch ();

  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");

  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. }

  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 };

  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;

  271. extern initialize_file_ftype _initialize_reggroup; /* -Wmissing-prototypes */

  273. void
  274. ‌_initialize_reggroup (void)
  275. {
  276.   reggroups_data = gdbarch_data_register_post_init (reggroups_init);

  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));

  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);

  293. }