1 /* User visible, per-frame registers, for GDB, the GNU debugger. 2 3 Copyright (C) 2002, 2003, 2004, 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 "user-regs.h" 25 #include "gdbtypes.h" 26 #include "gdb_string.h" 27 #include "gdb_assert.h" 28 #include "frame.h" 29 30 /* A table of user registers. 31 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. 36 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. */ 40 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 }; 48 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". */ 54 55 struct gdb_user_regs 56 { 57 struct user_reg *first; 58 struct user_reg **last; 59 }; 60 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 } 77 78 /* An array of the builtin user registers. */ 79 80 static struct gdb_user_regs builtin_user_regs = { NULL, &builtin_user_regs.first }; 81 82 void 83 user_reg_add_builtin (const char *name, user_reg_read_ftype *read, 84 const void *baton) 85 { 86 append_user_reg (&builtin_user_regs, name, read, baton, 87 XMALLOC (struct user_reg)); 88 } 89 90 /* Per-architecture user registers. Start with the builtin user 91 registers and then, again, append. */ 92 93 static struct gdbarch_data *user_regs_data; 94 95 static void * 96 user_regs_init (struct gdbarch *gdbarch) 97 { 98 struct user_reg *reg; 99 struct gdb_user_regs *regs 100 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct gdb_user_regs); 101 102 regs->last = ®s->first; 103 for (reg = builtin_user_regs.first; reg != NULL; reg = reg->next) 104 append_user_reg (regs, reg->name, reg->read, reg->baton, 105 GDBARCH_OBSTACK_ZALLOC (gdbarch, struct user_reg)); 106 return regs; 107 } 108 109 void 110 user_reg_add (struct gdbarch *gdbarch, const char *name, 111 user_reg_read_ftype *read, const void *baton) 112 { 113 struct gdb_user_regs *regs = gdbarch_data (gdbarch, user_regs_data); 114 115 if (regs == NULL) 116 { 117 /* ULGH, called during architecture initialization. Patch 118 things up. */ 119 regs = user_regs_init (gdbarch); 120 deprecated_set_gdbarch_data (gdbarch, user_regs_data, regs); 121 } 122 append_user_reg (regs, name, read, baton, 123 GDBARCH_OBSTACK_ZALLOC (gdbarch, struct user_reg)); 124 } 125 126 int 127 user_reg_map_name_to_regnum (struct gdbarch *gdbarch, const char *name, 128 int len) 129 { 130 /* Make life easy, set the len to something reasonable. */ 131 if (len < 0) 132 len = strlen (name); 133 134 /* Search register name space first - always let an architecture 135 specific register override the user registers. */ 136 { 137 int i; 138 int maxregs = (gdbarch_num_regs (gdbarch) 139 + gdbarch_num_pseudo_regs (gdbarch)); 140 141 for (i = 0; i < maxregs; i++) 142 { 143 const char *regname = gdbarch_register_name (gdbarch, i); 144 145 if (regname != NULL && len == strlen (regname) 146 && strncmp (regname, name, len) == 0) 147 { 148 return i; 149 } 150 } 151 } 152 153 /* Search the user name space. */ 154 { 155 struct gdb_user_regs *regs = gdbarch_data (gdbarch, user_regs_data); 156 struct user_reg *reg; 157 int nr; 158 159 for (nr = 0, reg = regs->first; reg != NULL; reg = reg->next, nr++) 160 { 161 if ((len < 0 && strcmp (reg->name, name)) 162 || (len == strlen (reg->name) 163 && strncmp (reg->name, name, len) == 0)) 164 return gdbarch_num_regs (gdbarch) 165 + gdbarch_num_pseudo_regs (gdbarch) + nr; 166 } 167 } 168 169 return -1; 170 } 171 172 static struct user_reg * 173 usernum_to_user_reg (struct gdbarch *gdbarch, int usernum) 174 { 175 struct gdb_user_regs *regs = gdbarch_data (gdbarch, user_regs_data); 176 struct user_reg *reg; 177 178 for (reg = regs->first; reg != NULL; reg = reg->next) 179 { 180 if (usernum == 0) 181 return reg; 182 usernum--; 183 } 184 return NULL; 185 } 186 187 const char * 188 user_reg_map_regnum_to_name (struct gdbarch *gdbarch, int regnum) 189 { 190 int maxregs = (gdbarch_num_regs (gdbarch) 191 + gdbarch_num_pseudo_regs (gdbarch)); 192 193 if (regnum < 0) 194 return NULL; 195 else if (regnum < maxregs) 196 return gdbarch_register_name (gdbarch, regnum); 197 else 198 { 199 struct user_reg *reg = usernum_to_user_reg (gdbarch, regnum - maxregs); 200 if (reg == NULL) 201 return NULL; 202 else 203 return reg->name; 204 } 205 } 206 207 struct value * 208 value_of_user_reg (int regnum, struct frame_info *frame) 209 { 210 struct gdbarch *gdbarch = get_frame_arch (frame); 211 int maxregs = (gdbarch_num_regs (gdbarch) 212 + gdbarch_num_pseudo_regs (gdbarch)); 213 struct user_reg *reg = usernum_to_user_reg (gdbarch, regnum - maxregs); 214 215 gdb_assert (reg != NULL); 216 return reg->read (frame, reg->baton); 217 } 218 219 extern initialize_file_ftype _initialize_user_regs; /* -Wmissing-prototypes */ 220 221 void 222 _initialize_user_regs (void) 223 { 224 user_regs_data = gdbarch_data_register_post_init (user_regs_init); 225 } 226