1 /* Register support routines for the remote server for GDB.
2 Copyright (C) 2001, 2002, 2004, 2005, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 static int register_bytes;
28 static struct reg *reg_defs;
29 static int num_registers;
31 const char **gdbserver_expedite_regs;
34 get_thread_regcache (struct thread_info *thread, int fetch)
36 struct regcache *regcache;
38 regcache = (struct regcache *) inferior_regcache_data (thread);
41 fatal ("no register cache");
43 if (fetch && regcache->registers_valid == 0)
45 struct thread_info *saved_inferior = current_inferior;
47 current_inferior = thread;
48 fetch_inferior_registers (regcache, -1);
49 current_inferior = saved_inferior;
50 regcache->registers_valid = 1;
57 regcache_invalidate_one (struct inferior_list_entry *entry)
59 struct thread_info *thread = (struct thread_info *) entry;
60 struct regcache *regcache;
62 regcache = (struct regcache *) inferior_regcache_data (thread);
64 if (regcache->registers_valid)
66 struct thread_info *saved_inferior = current_inferior;
68 current_inferior = thread;
69 store_inferior_registers (regcache, -1);
70 current_inferior = saved_inferior;
73 regcache->registers_valid = 0;
77 regcache_invalidate (void)
79 for_each_inferior (&all_threads, regcache_invalidate_one);
83 init_register_cache (struct regcache *regcache, unsigned char *regbuf)
87 /* Make sure to zero-initialize the register cache when it is
88 created, in case there are registers the target never
89 fetches. This way they'll read as zero instead of
91 regcache->registers = xcalloc (1, register_bytes);
92 regcache->registers_owned = 1;
96 regcache->registers = regbuf;
97 regcache->registers_owned = 0;
100 regcache->registers_valid = 0;
106 new_register_cache (void)
108 struct regcache *regcache;
110 if (register_bytes == 0)
111 return NULL; /* The architecture hasn't been initialized yet. */
113 regcache = xmalloc (sizeof (*regcache));
114 return init_register_cache (regcache, NULL);
118 free_register_cache (struct regcache *regcache)
122 free (regcache->registers);
128 regcache_cpy (struct regcache *dst, struct regcache *src)
130 memcpy (dst->registers, src->registers, register_bytes);
131 dst->registers_valid = src->registers_valid;
135 realloc_register_cache (struct inferior_list_entry *thread_p)
137 struct thread_info *thread = (struct thread_info *) thread_p;
138 struct regcache *regcache
139 = (struct regcache *) inferior_regcache_data (thread);
141 free_register_cache (regcache);
142 set_inferior_regcache_data (thread, new_register_cache ());
146 set_register_cache (struct reg *regs, int n)
154 for (i = 0; i < n; i++)
156 regs[i].offset = offset;
157 offset += regs[i].size;
160 register_bytes = offset / 8;
162 /* Make sure PBUFSIZ is large enough to hold a full register packet. */
163 if (2 * register_bytes + 32 > PBUFSIZ)
164 fatal ("Register packet size exceeds PBUFSIZ.");
166 /* Re-allocate all pre-existing register caches. */
167 for_each_inferior (&all_threads, realloc_register_cache);
171 register_cache_size (void)
173 return register_bytes;
177 registers_to_string (struct regcache *regcache, char *buf)
179 unsigned char *registers = regcache->registers;
181 convert_int_to_ascii (registers, buf, register_bytes);
185 registers_from_string (struct regcache *regcache, char *buf)
187 int len = strlen (buf);
188 unsigned char *registers = regcache->registers;
190 if (len != register_bytes * 2)
192 warning ("Wrong sized register packet (expected %d bytes, got %d)",
193 2*register_bytes, len);
194 if (len > register_bytes * 2)
195 len = register_bytes * 2;
197 convert_ascii_to_int (buf, registers, len / 2);
201 find_register_by_name (const char *name)
205 for (i = 0; i < num_registers; i++)
206 if (!strcmp (name, reg_defs[i].name))
208 fatal ("Unknown register %s requested", name);
213 find_regno (const char *name)
217 for (i = 0; i < num_registers; i++)
218 if (!strcmp (name, reg_defs[i].name))
220 fatal ("Unknown register %s requested", name);
225 find_register_by_number (int n)
231 register_size (int n)
233 return reg_defs[n].size / 8;
236 static unsigned char *
237 register_data (struct regcache *regcache, int n, int fetch)
239 return regcache->registers + (reg_defs[n].offset / 8);
243 supply_register (struct regcache *regcache, int n, const void *buf)
246 memcpy (register_data (regcache, n, 0), buf, register_size (n));
248 memset (register_data (regcache, n, 0), 0, register_size (n));
252 supply_regblock (struct regcache *regcache, const void *buf)
255 memcpy (regcache->registers, buf, register_bytes);
257 memset (regcache->registers, 0, register_bytes);
261 supply_register_by_name (struct regcache *regcache,
262 const char *name, const void *buf)
264 supply_register (regcache, find_regno (name), buf);
268 collect_register (struct regcache *regcache, int n, void *buf)
270 memcpy (buf, register_data (regcache, n, 1), register_size (n));
274 collect_register_as_string (struct regcache *regcache, int n, char *buf)
276 convert_int_to_ascii (register_data (regcache, n, 1),
277 buf, register_size (n));
281 collect_register_by_name (struct regcache *regcache,
282 const char *name, void *buf)
284 collect_register (regcache, find_regno (name), buf);
287 /* Special handling for register PC. */
290 regcache_read_pc (struct regcache *regcache)
294 if (the_target->read_pc)
295 pc_val = the_target->read_pc (regcache);
297 internal_error (__FILE__, __LINE__,
298 "regcache_read_pc: Unable to find PC");
304 regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
306 if (the_target->write_pc)
307 the_target->write_pc (regcache, pc);
309 internal_error (__FILE__, __LINE__,
310 "regcache_write_pc: Unable to update PC");