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