gdb/user-regs.c

   1 /* User visible, per-frame registers, for GDB, the GNU debugger.
   2
   3    Copyright (C) 2002-2014 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 "user-regs.h"
  24 #include "gdbtypes.h"
  25 #include "frame.h"
  26
  27 /* A table of user registers.
  28
  29    User registers have regnum's that live above of the range [0
  30    .. gdbarch_num_regs + gdbarch_num_pseudo_regs)
  31    (which is controlled by the target).
  32    The target should never see a user register's regnum value.
  33
  34    Always append, never delete.  By doing this, the relative regnum
  35    (offset from gdbarch_num_regs + gdbarch_num_pseudo_regs)
  36     assigned to each user  register never changes.  */
  37
  38 struct user_reg
  39 {
  40   const char *name;
  41   struct value *(*read) (struct frame_info * frame, const void *baton);
  42   const void *baton;
  43   struct user_reg *next;
  44 };
  45
  46 /* This structure is named gdb_user_regs instead of user_regs to avoid
  47    conflicts with any "struct user_regs" in system headers.  For instance,
  48    on ARM GNU/Linux native builds, nm-linux.h includes <signal.h> includes
  49    <sys/ucontext.h> includes <sys/procfs.h> includes <sys/user.h>, which
  50    declares "struct user_regs".  */
  51
  52 struct gdb_user_regs
  53 {
  54   struct user_reg *first;
  55   struct user_reg **last;
  56 };
  57
  58 static void
  59 append_user_reg (struct gdb_user_regs *regs, const char *name,
  60                  user_reg_read_ftype *read, const void *baton,
  61                  struct user_reg *reg)
  62 {
  63   /* The caller is responsible for allocating memory needed to store
  64      the register.  By doing this, the function can operate on a
  65      register list stored in the common heap or a specific obstack.  */
  66   gdb_assert (reg != NULL);
  67   reg->name = name;
  68   reg->read = read;
  69   reg->baton = baton;
  70   reg->next = NULL;
  71   (*regs->last) = reg;
  72   regs->last = &(*regs->last)->next;
  73 }
  74
  75 /* An array of the builtin user registers.  */
  76
  77 static struct gdb_user_regs builtin_user_regs = {
  78   NULL, &builtin_user_regs.first
  79 };
  80
  81 void
  82 user_reg_add_builtin (const char *name, user_reg_read_ftype *read,
  83                       const void *baton)
  84 {
  85   append_user_reg (&builtin_user_regs, name, read, baton,
  86                    XNEW (struct user_reg));
  87 }
  88
  89 /* Per-architecture user registers.  Start with the builtin user
  90    registers and then, again, append.  */
  91
  92 static struct gdbarch_data *user_regs_data;
  93
  94 static void *
  95 user_regs_init (struct gdbarch *gdbarch)
  96 {
  97   struct user_reg *reg;
  98   struct gdb_user_regs *regs
  99     = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct gdb_user_regs);
 100
 101   regs->last = &regs->first;
 102   for (reg = builtin_user_regs.first; reg != NULL; reg = reg->next)
 103     append_user_reg (regs, reg->name, reg->read, reg->baton,
 104                      GDBARCH_OBSTACK_ZALLOC (gdbarch, struct user_reg));
 105   return regs;
 106 }
 107
 108 void
 109 user_reg_add (struct gdbarch *gdbarch, const char *name,
 110               user_reg_read_ftype *read, const void *baton)
 111 {
 112   struct gdb_user_regs *regs = gdbarch_data (gdbarch, user_regs_data);
 113
 114   if (regs == NULL)
 115     {
 116       /* ULGH, called during architecture initialization.  Patch
 117          things up.  */
 118       regs = user_regs_init (gdbarch);
 119       deprecated_set_gdbarch_data (gdbarch, user_regs_data, regs);
 120     }
 121   append_user_reg (regs, name, read, baton,
 122                    GDBARCH_OBSTACK_ZALLOC (gdbarch, struct user_reg));
 123 }
 124
 125 int
 126 user_reg_map_name_to_regnum (struct gdbarch *gdbarch, const char *name,
 127                              int len)
 128 {
 129   /* Make life easy, set the len to something reasonable.  */
 130   if (len < 0)
 131     len = strlen (name);
 132
 133   /* Search register name space first - always let an architecture
 134      specific register override the user registers.  */
 135   {
 136     int i;
 137     int maxregs = (gdbarch_num_regs (gdbarch)
 138                    + gdbarch_num_pseudo_regs (gdbarch));
 139
 140     for (i = 0; i < maxregs; i++)
 141       {
 142         const char *regname = gdbarch_register_name (gdbarch, i);
 143
 144         if (regname != NULL && len == strlen (regname)
 145             && strncmp (regname, name, len) == 0)
 146           {
 147             return i;
 148           }
 149       }
 150   }
 151
 152   /* Search the user name space.  */
 153   {
 154     struct gdb_user_regs *regs = gdbarch_data (gdbarch, user_regs_data);
 155     struct user_reg *reg;
 156     int nr;
 157
 158     for (nr = 0, reg = regs->first; reg != NULL; reg = reg->next, nr++)
 159       {
 160         if ((len < 0 && strcmp (reg->name, name))
 161             || (len == strlen (reg->name)
 162                 && strncmp (reg->name, name, len) == 0))
 163           return gdbarch_num_regs (gdbarch)
 164                  + gdbarch_num_pseudo_regs (gdbarch) + nr;
 165       }
 166   }
 167
 168   return -1;
 169 }
 170
 171 static struct user_reg *
 172 usernum_to_user_reg (struct gdbarch *gdbarch, int usernum)
 173 {
 174   struct gdb_user_regs *regs = gdbarch_data (gdbarch, user_regs_data);
 175   struct user_reg *reg;
 176
 177   for (reg = regs->first; reg != NULL; reg = reg->next)
 178     {
 179       if (usernum == 0)
 180         return reg;
 181       usernum--;
 182     }
 183   return NULL;
 184 }
 185
 186 const char *
 187 user_reg_map_regnum_to_name (struct gdbarch *gdbarch, int regnum)
 188 {
 189   int maxregs = (gdbarch_num_regs (gdbarch)
 190                  + gdbarch_num_pseudo_regs (gdbarch));
 191
 192   if (regnum < 0)
 193     return NULL;
 194   else if (regnum < maxregs)
 195     return gdbarch_register_name (gdbarch, regnum);
 196   else
 197     {
 198       struct user_reg *reg = usernum_to_user_reg (gdbarch, regnum - maxregs);
 199       if (reg == NULL)
 200         return NULL;
 201       else
 202         return reg->name;
 203     }
 204 }
 205
 206 struct value *
 207 value_of_user_reg (int regnum, struct frame_info *frame)
 208 {
 209   struct gdbarch *gdbarch = get_frame_arch (frame);
 210   int maxregs = (gdbarch_num_regs (gdbarch)
 211                  + gdbarch_num_pseudo_regs (gdbarch));
 212   struct user_reg *reg = usernum_to_user_reg (gdbarch, regnum - maxregs);
 213
 214   gdb_assert (reg != NULL);
 215   return reg->read (frame, reg->baton);
 216 }
 217
 218 extern initialize_file_ftype _initialize_user_regs; /* -Wmissing-prototypes */
 219
 220 void
 221 _initialize_user_regs (void)
 222 {
 223   user_regs_data = gdbarch_data_register_post_init (user_regs_init);
 224 }