1 /* Register support routines for the remote server for GDB.
2 Copyright (C) 2001, 2002, 2004, 2005, 2007, 2008, 2009, 2010, 2011
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;
33 #ifndef IN_PROCESS_AGENT
36 get_thread_regcache (struct thread_info *thread, int fetch)
38 struct regcache *regcache;
40 regcache = (struct regcache *) inferior_regcache_data (thread);
43 fatal ("no register cache");
45 if (fetch && regcache->registers_valid == 0)
47 struct thread_info *saved_inferior = current_inferior;
49 current_inferior = thread;
50 fetch_inferior_registers (regcache, -1);
51 current_inferior = saved_inferior;
52 regcache->registers_valid = 1;
59 regcache_invalidate_one (struct inferior_list_entry *entry)
61 struct thread_info *thread = (struct thread_info *) entry;
62 struct regcache *regcache;
64 regcache = (struct regcache *) inferior_regcache_data (thread);
69 if (regcache->registers_valid)
71 struct thread_info *saved_inferior = current_inferior;
73 current_inferior = thread;
74 store_inferior_registers (regcache, -1);
75 current_inferior = saved_inferior;
78 regcache->registers_valid = 0;
82 regcache_invalidate (void)
84 for_each_inferior (&all_threads, regcache_invalidate_one);
90 init_register_cache (struct regcache *regcache, unsigned char *regbuf)
92 #ifndef IN_PROCESS_AGENT
95 /* Make sure to zero-initialize the register cache when it is
96 created, in case there are registers the target never
97 fetches. This way they'll read as zero instead of
99 regcache->registers = xcalloc (1, register_bytes);
100 regcache->registers_owned = 1;
101 regcache->register_status = xcalloc (1, num_registers);
102 gdb_assert (REG_UNAVAILABLE == 0);
107 fatal ("init_register_cache: can't allocate memory from the heap");
111 regcache->registers = regbuf;
112 regcache->registers_owned = 0;
113 #ifndef IN_PROCESS_AGENT
114 regcache->register_status = NULL;
118 regcache->registers_valid = 0;
123 #ifndef IN_PROCESS_AGENT
126 new_register_cache (void)
128 struct regcache *regcache;
130 if (register_bytes == 0)
131 return NULL; /* The architecture hasn't been initialized yet. */
133 regcache = xmalloc (sizeof (*regcache));
134 return init_register_cache (regcache, NULL);
138 free_register_cache (struct regcache *regcache)
142 if (regcache->registers_owned)
143 free (regcache->registers);
144 free (regcache->register_status);
152 regcache_cpy (struct regcache *dst, struct regcache *src)
154 memcpy (dst->registers, src->registers, register_bytes);
155 #ifndef IN_PROCESS_AGENT
156 if (dst->register_status != NULL && src->register_status != NULL)
157 memcpy (dst->register_status, src->register_status, num_registers);
159 dst->registers_valid = src->registers_valid;
162 #ifndef IN_PROCESS_AGENT
164 realloc_register_cache (struct inferior_list_entry *thread_p)
166 struct thread_info *thread = (struct thread_info *) thread_p;
167 struct regcache *regcache
168 = (struct regcache *) inferior_regcache_data (thread);
170 if (regcache != NULL)
171 regcache_invalidate_one (thread_p);
172 free_register_cache (regcache);
173 set_inferior_regcache_data (thread, new_register_cache ());
178 set_register_cache (struct reg *regs, int n)
182 #ifndef IN_PROCESS_AGENT
183 /* Before changing the register cache internal layout, flush the
184 contents of valid caches back to the threads. */
185 regcache_invalidate ();
192 for (i = 0; i < n; i++)
194 regs[i].offset = offset;
195 offset += regs[i].size;
198 register_bytes = offset / 8;
200 /* Make sure PBUFSIZ is large enough to hold a full register packet. */
201 if (2 * register_bytes + 32 > PBUFSIZ)
202 fatal ("Register packet size exceeds PBUFSIZ.");
204 #ifndef IN_PROCESS_AGENT
205 /* Re-allocate all pre-existing register caches. */
206 for_each_inferior (&all_threads, realloc_register_cache);
211 register_cache_size (void)
213 return register_bytes;
216 #ifndef IN_PROCESS_AGENT
219 registers_to_string (struct regcache *regcache, char *buf)
221 unsigned char *registers = regcache->registers;
224 for (i = 0; i < num_registers; i++)
226 if (regcache->register_status[i] == REG_VALID)
228 convert_int_to_ascii (registers, buf, register_size (i));
229 buf += register_size (i) * 2;
233 memset (buf, 'x', register_size (i) * 2);
234 buf += register_size (i) * 2;
236 registers += register_size (i);
242 registers_from_string (struct regcache *regcache, char *buf)
244 int len = strlen (buf);
245 unsigned char *registers = regcache->registers;
247 if (len != register_bytes * 2)
249 warning ("Wrong sized register packet (expected %d bytes, got %d)",
250 2*register_bytes, len);
251 if (len > register_bytes * 2)
252 len = register_bytes * 2;
254 convert_ascii_to_int (buf, registers, len / 2);
258 find_register_by_name (const char *name)
262 for (i = 0; i < num_registers; i++)
263 if (!strcmp (name, reg_defs[i].name))
265 fatal ("Unknown register %s requested", name);
270 find_regno (const char *name)
274 for (i = 0; i < num_registers; i++)
275 if (!strcmp (name, reg_defs[i].name))
277 fatal ("Unknown register %s requested", name);
282 find_register_by_number (int n)
290 register_size (int n)
292 return reg_defs[n].size / 8;
295 static unsigned char *
296 register_data (struct regcache *regcache, int n, int fetch)
298 return regcache->registers + (reg_defs[n].offset / 8);
301 /* Supply register N, whose contents are stored in BUF, to REGCACHE.
302 If BUF is NULL, the register's value is recorded as
306 supply_register (struct regcache *regcache, int n, const void *buf)
310 memcpy (register_data (regcache, n, 0), buf, register_size (n));
311 #ifndef IN_PROCESS_AGENT
312 if (regcache->register_status != NULL)
313 regcache->register_status[n] = REG_VALID;
318 memset (register_data (regcache, n, 0), 0, register_size (n));
319 #ifndef IN_PROCESS_AGENT
320 if (regcache->register_status != NULL)
321 regcache->register_status[n] = REG_UNAVAILABLE;
326 /* Supply register N with value zero to REGCACHE. */
329 supply_register_zeroed (struct regcache *regcache, int n)
331 memset (register_data (regcache, n, 0), 0, register_size (n));
332 #ifndef IN_PROCESS_AGENT
333 if (regcache->register_status != NULL)
334 regcache->register_status[n] = REG_VALID;
338 /* Supply the whole register set whose contents are stored in BUF, to
339 REGCACHE. If BUF is NULL, all the registers' values are recorded
343 supply_regblock (struct regcache *regcache, const void *buf)
347 memcpy (regcache->registers, buf, register_bytes);
348 #ifndef IN_PROCESS_AGENT
352 for (i = 0; i < num_registers; i++)
353 regcache->register_status[i] = REG_VALID;
359 memset (regcache->registers, 0, register_bytes);
360 #ifndef IN_PROCESS_AGENT
364 for (i = 0; i < num_registers; i++)
365 regcache->register_status[i] = REG_UNAVAILABLE;
371 #ifndef IN_PROCESS_AGENT
374 supply_register_by_name (struct regcache *regcache,
375 const char *name, const void *buf)
377 supply_register (regcache, find_regno (name), buf);
383 collect_register (struct regcache *regcache, int n, void *buf)
385 memcpy (buf, register_data (regcache, n, 1), register_size (n));
388 #ifndef IN_PROCESS_AGENT
391 collect_register_as_string (struct regcache *regcache, int n, char *buf)
393 convert_int_to_ascii (register_data (regcache, n, 1),
394 buf, register_size (n));
398 collect_register_by_name (struct regcache *regcache,
399 const char *name, void *buf)
401 collect_register (regcache, find_regno (name), buf);
404 /* Special handling for register PC. */
407 regcache_read_pc (struct regcache *regcache)
411 if (the_target->read_pc)
412 pc_val = the_target->read_pc (regcache);
414 internal_error (__FILE__, __LINE__,
415 "regcache_read_pc: Unable to find PC");
421 regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
423 if (the_target->write_pc)
424 the_target->write_pc (regcache, pc);
426 internal_error (__FILE__, __LINE__,
427 "regcache_write_pc: Unable to update PC");