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");
This page took 0.039732 seconds and 4 git commands to generate.