1 /* User visible, per-frame registers, for GDB, the GNU debugger. 2 3 Copyright (C) 2002, 2003, 2004, 2007, 2008, 2009 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 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct gdb_user_regs); 100 regs->last = ®s->first; 101 for (reg = builtin_user_regs.first; reg != NULL; reg = reg->next) 102 append_user_reg (regs, reg->name, reg->read, reg->baton, 103 GDBARCH_OBSTACK_ZALLOC (gdbarch, struct user_reg)); 104 return regs; 105 } 106 107 void 108 user_reg_add (struct gdbarch *gdbarch, const char *name, 109 user_reg_read_ftype *read, const void *baton) 110 { 111 struct gdb_user_regs *regs = gdbarch_data (gdbarch, user_regs_data); 112 if (regs == NULL) 113 { 114 /* ULGH, called during architecture initialization. Patch 115 things up. */ 116 regs = user_regs_init (gdbarch); 117 deprecated_set_gdbarch_data (gdbarch, user_regs_data, regs); 118 } 119 append_user_reg (regs, name, read, baton, 120 GDBARCH_OBSTACK_ZALLOC (gdbarch, struct user_reg)); 121 } 122 123 int 124 user_reg_map_name_to_regnum (struct gdbarch *gdbarch, const char *name, 125 int len) 126 { 127 /* Make life easy, set the len to something reasonable. */ 128 if (len < 0) 129 len = strlen (name); 130 131 /* Search register name space first - always let an architecture 132 specific register override the user registers. */ 133 { 134 int i; 135 int maxregs = (gdbarch_num_regs (gdbarch) 136 + gdbarch_num_pseudo_regs (gdbarch)); 137 for (i = 0; i < maxregs; i++) 138 { 139 const char *regname = gdbarch_register_name (gdbarch, i); 140 if (regname != NULL && len == strlen (regname) 141 && strncmp (regname, name, len) == 0) 142 { 143 return i; 144 } 145 } 146 } 147 148 /* Search the user name space. */ 149 { 150 struct gdb_user_regs *regs = gdbarch_data (gdbarch, user_regs_data); 151 struct user_reg *reg; 152 int nr; 153 for (nr = 0, reg = regs->first; reg != NULL; reg = reg->next, nr++) 154 { 155 if ((len < 0 && strcmp (reg->name, name)) 156 || (len == strlen (reg->name) 157 && strncmp (reg->name, name, len) == 0)) 158 return gdbarch_num_regs (gdbarch) 159 + gdbarch_num_pseudo_regs (gdbarch) + nr; 160 } 161 } 162 163 return -1; 164 } 165 166 static struct user_reg * 167 usernum_to_user_reg (struct gdbarch *gdbarch, int usernum) 168 { 169 struct gdb_user_regs *regs = gdbarch_data (gdbarch, user_regs_data); 170 struct user_reg *reg; 171 for (reg = regs->first; reg != NULL; reg = reg->next) 172 { 173 if (usernum == 0) 174 return reg; 175 usernum--; 176 } 177 return NULL; 178 } 179 180 const char * 181 user_reg_map_regnum_to_name (struct gdbarch *gdbarch, int regnum) 182 { 183 int maxregs = (gdbarch_num_regs (gdbarch) 184 + gdbarch_num_pseudo_regs (gdbarch)); 185 if (regnum < 0) 186 return NULL; 187 else if (regnum < maxregs) 188 return gdbarch_register_name (gdbarch, regnum); 189 else 190 { 191 struct user_reg *reg = usernum_to_user_reg (gdbarch, regnum - maxregs); 192 if (reg == NULL) 193 return NULL; 194 else 195 return reg->name; 196 } 197 } 198 199 struct value * 200 value_of_user_reg (int regnum, struct frame_info *frame) 201 { 202 struct gdbarch *gdbarch = get_frame_arch (frame); 203 int maxregs = (gdbarch_num_regs (gdbarch) 204 + gdbarch_num_pseudo_regs (gdbarch)); 205 struct user_reg *reg = usernum_to_user_reg (gdbarch, regnum - maxregs); 206 gdb_assert (reg != NULL); 207 return reg->read (frame, reg->baton); 208 } 209 210 extern initialize_file_ftype _initialize_user_regs; /* -Wmissing-prototypes */ 211 212 void 213 _initialize_user_regs (void) 214 { 215 user_regs_data = gdbarch_data_register_post_init (user_regs_init); 216 } 217