1 /* User visible, per-frame registers, for GDB, the GNU debugger. 2 3 Copyright (C) 2002, 2003, 2004, 2007, 2008, 2009, 2010, 2011 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 = { 81 NULL, &builtin_user_regs.first 82 }; 83 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 XMALLOC (struct user_reg)); 90 } 91 92 /* Per-architecture user registers. Start with the builtin user 93 registers and then, again, append. */ 94 95 static struct gdbarch_data *user_regs_data; 96 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); 103 104 regs->last = ®s->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 } 110 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); 116 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 } 127 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); 135 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)); 142 143 for (i = 0; i < maxregs; i++) 144 { 145 const char *regname = gdbarch_register_name (gdbarch, i); 146 147 if (regname != NULL && len == strlen (regname) 148 && strncmp (regname, name, len) == 0) 149 { 150 return i; 151 } 152 } 153 } 154 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; 160 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 } 170 171 return -1; 172 } 173 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; 179 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 } 188 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)); 194 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 } 208 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); 216 217 gdb_assert (reg != NULL); 218 return reg->read (frame, reg->baton); 219 } 220 221 extern initialize_file_ftype _initialize_user_regs; /* -Wmissing-prototypes */ 222 223 void 224 _initialize_user_regs (void) 225 { 226 user_regs_data = gdbarch_data_register_post_init (user_regs_init); 227 } 228