gdb/user-regs.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* User visible, per-frame registers, 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 "user-regs.h"
  24. #include "gdbtypes.h"
  25. #include "frame.h"
  26. #include "arch-utils.h"
  27. #include "command.h"
  28. #include "cli/cli-cmds.h"

  30. /* A table of user registers.

  32.    User registers have regnum's that live above of the range [0
  33.    .. gdbarch_num_regs + gdbarch_num_pseudo_regs)
  34.    (which is controlled by the target).
  35.    The target should never see a user register's regnum value.

  37.    Always append, never delete.  By doing this, the relative regnum
  38.    (offset from gdbarch_num_regs + gdbarch_num_pseudo_regs)
  39.     assigned to each user  register never changes.  */

  41. ‌struct user_reg
  42. {
  43.   const char *name;
  44.   struct value *(*read) (struct frame_info * frame, const void *baton);
  45.   const void *baton;
  46.   struct user_reg *next;
  47. };

  49. /* This structure is named gdb_user_regs instead of user_regs to avoid
  50.    conflicts with any "struct user_regs" in system headers.  For instance,
  51.    on ARM GNU/Linux native builds, nm-linux.h includes <signal.h> includes
  52.    <sys/ucontext.h> includes <sys/procfs.h> includes <sys/user.h>, which
  53.    declares "struct user_regs".  */

  55. ‌struct gdb_user_regs
  56. {
  57.   struct user_reg *first;
  58.   struct user_reg **last;
  59. };

  61. static void
  62. ‌append_user_reg (struct gdb_user_regs *regs, const char *name,
  63.                  user_reg_read_ftype *read, const void *baton,
  64.                  struct user_reg *reg)
  65. {
  66.   /* The caller is responsible for allocating memory needed to store
  67.      the register.  By doing this, the function can operate on a
  68.      register list stored in the common heap or a specific obstack.  */
  69.   gdb_assert (reg != NULL);
  70.   reg->name = name;
  71.   reg->read = read;
  72.   reg->baton = baton;
  73.   reg->next = NULL;
  74.   (*regs->last) = reg;
  75.   regs->last = &(*regs->last)->next;
  76. }

  78. /* An array of the builtin user registers.  */

  80. ‌static struct gdb_user_regs builtin_user_regs = {
  81.   NULL, &builtin_user_regs.first
  82. };

  84. void
  85. ‌user_reg_add_builtin (const char *name, user_reg_read_ftype *read,
  86.                       const void *baton)
  87. {
  88.   append_user_reg (&builtin_user_regs, name, read, baton,
  89.                    XNEW (struct user_reg));
  90. }

  92. /* Per-architecture user registers.  Start with the builtin user
  93.    registers and then, again, append.  */

  95. ‌static struct gdbarch_data *user_regs_data;

  97. static void *
  98. ‌user_regs_init (struct gdbarch *gdbarch)
  99. {
  100.   struct user_reg *reg;
  101.   struct gdb_user_regs *regs
  102.     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct gdb_user_regs);

  104.   regs->last = &regs->first;
  105.   for (reg = builtin_user_regs.first; reg != NULL; reg = reg->next)
  106.     append_user_reg (regs, reg->name, reg->read, reg->baton,
  107.                      GDBARCH_OBSTACK_ZALLOC (gdbarch, struct user_reg));
  108.   return regs;
  109. }

  111. void
  112. ‌user_reg_add (struct gdbarch *gdbarch, const char *name,
  113.               user_reg_read_ftype *read, const void *baton)
  114. {
  115.   struct gdb_user_regs *regs = gdbarch_data (gdbarch, user_regs_data);

  117.   if (regs == NULL)
  118.     {
  119.       /* ULGH, called during architecture initialization.  Patch
  120.          things up.  */
  121.       regs = user_regs_init (gdbarch);
  122.       deprecated_set_gdbarch_data (gdbarch, user_regs_data, regs);
  123.     }
  124.   append_user_reg (regs, name, read, baton,
  125.                    GDBARCH_OBSTACK_ZALLOC (gdbarch, struct user_reg));
  126. }

  128. int
  129. ‌user_reg_map_name_to_regnum (struct gdbarch *gdbarch, const char *name,
  130.                              int len)
  131. {
  132.   /* Make life easy, set the len to something reasonable.  */
  133.   if (len < 0)
  134.     len = strlen (name);

  136.   /* Search register name space first - always let an architecture
  137.      specific register override the user registers.  */
  138.   {
  139.     int i;
  140.     int maxregs = (gdbarch_num_regs (gdbarch)
  141.                    + gdbarch_num_pseudo_regs (gdbarch));

  143.     for (i = 0; i < maxregs; i++)
  144.       {
  145.         const char *regname = gdbarch_register_name (gdbarch, i);

  147.         if (regname != NULL && len == strlen (regname)
  148.             && strncmp (regname, name, len) == 0)
  149.           {
  150.             return i;
  151.           }
  152.       }
  153.   }

  155.   /* Search the user name space.  */
  156.   {
  157.     struct gdb_user_regs *regs = gdbarch_data (gdbarch, user_regs_data);
  158.     struct user_reg *reg;
  159.     int nr;

  161.     for (nr = 0, reg = regs->first; reg != NULL; reg = reg->next, nr++)
  162.       {
  163.         if ((len < 0 && strcmp (reg->name, name))
  164.             || (len == strlen (reg->name)
  165.                 && strncmp (reg->name, name, len) == 0))
  166.           return gdbarch_num_regs (gdbarch)
  167.                  + gdbarch_num_pseudo_regs (gdbarch) + nr;
  168.       }
  169.   }

  171.   return -1;
  172. }

  174. static struct user_reg *
  175. ‌usernum_to_user_reg (struct gdbarch *gdbarch, int usernum)
  176. {
  177.   struct gdb_user_regs *regs = gdbarch_data (gdbarch, user_regs_data);
  178.   struct user_reg *reg;

  180.   for (reg = regs->first; reg != NULL; reg = reg->next)
  181.     {
  182.       if (usernum == 0)
  183.         return reg;
  184.       usernum--;
  185.     }
  186.   return NULL;
  187. }

  189. const char *
  190. ‌user_reg_map_regnum_to_name (struct gdbarch *gdbarch, int regnum)
  191. {
  192.   int maxregs = (gdbarch_num_regs (gdbarch)
  193.                  + gdbarch_num_pseudo_regs (gdbarch));

  195.   if (regnum < 0)
  196.     return NULL;
  197.   else if (regnum < maxregs)
  198.     return gdbarch_register_name (gdbarch, regnum);
  199.   else
  200.     {
  201.       struct user_reg *reg = usernum_to_user_reg (gdbarch, regnum - maxregs);
  202.       if (reg == NULL)
  203.         return NULL;
  204.       else
  205.         return reg->name;
  206.     }
  207. }

  209. struct value *
  210. ‌value_of_user_reg (int regnum, struct frame_info *frame)
  211. {
  212.   struct gdbarch *gdbarch = get_frame_arch (frame);
  213.   int maxregs = (gdbarch_num_regs (gdbarch)
  214.                  + gdbarch_num_pseudo_regs (gdbarch));
  215.   struct user_reg *reg = usernum_to_user_reg (gdbarch, regnum - maxregs);

  217.   gdb_assert (reg != NULL);
  218.   return reg->read (frame, reg->baton);
  219. }

  221. static void
  222. ‌maintenance_print_user_registers (char *args, int from_tty)
  223. {
  224.   struct gdbarch *gdbarch = get_current_arch ();
  225.   struct gdb_user_regs *regs;
  226.   struct user_reg *reg;
  227.   int regnum;

  229.   regs = gdbarch_data (gdbarch, user_regs_data);
  230.   regnum = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);

  232.   fprintf_unfiltered (gdb_stdout, " %-11s %3s\n", "Name", "Nr");
  233.   for (reg = regs->first; reg != NULL; reg = reg->next, ++regnum)
  234.     fprintf_unfiltered (gdb_stdout, " %-11s %3d\n", reg->name, regnum);
  235. }

  237. extern initialize_file_ftype _initialize_user_regs; /* -Wmissing-prototypes */

  239. void
  240. ‌_initialize_user_regs (void)
  241. {
  242.   user_regs_data = gdbarch_data_register_post_init (user_regs_init);

  244.   add_cmd ("user-registers", class_maintenance,
  245.            maintenance_print_user_registers,
  246.            _("List the names of the current user registers.\n"),
  247.            &maintenanceprintlist);
  248. }