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 /* The private data for the register cache. Note that we have one
27 per inferior; this is primarily for simplicity, as the performance
28 benefit is minimal. */
30 struct inferior_regcache_data
33 unsigned char *registers
;
36 static int register_bytes
;
38 static struct reg
*reg_defs
;
39 static int num_registers
;
41 const char **gdbserver_expedite_regs
;
43 static struct inferior_regcache_data
*
44 get_regcache (struct thread_info
*inf
, int fetch
)
46 struct inferior_regcache_data
*regcache
;
48 regcache
= (struct inferior_regcache_data
*) inferior_regcache_data (inf
);
51 fatal ("no register cache");
53 /* FIXME - fetch registers for INF */
54 if (fetch
&& regcache
->registers_valid
== 0)
56 fetch_inferior_registers (-1);
57 regcache
->registers_valid
= 1;
64 regcache_invalidate_one (struct inferior_list_entry
*entry
)
66 struct thread_info
*thread
= (struct thread_info
*) entry
;
67 struct inferior_regcache_data
*regcache
;
69 regcache
= (struct inferior_regcache_data
*) inferior_regcache_data (thread
);
71 if (regcache
->registers_valid
)
73 struct thread_info
*saved_inferior
= current_inferior
;
75 current_inferior
= thread
;
76 store_inferior_registers (-1);
77 current_inferior
= saved_inferior
;
80 regcache
->registers_valid
= 0;
84 regcache_invalidate ()
86 for_each_inferior (&all_threads
, regcache_invalidate_one
);
90 new_register_cache (void)
92 struct inferior_regcache_data
*regcache
;
94 if (register_bytes
== 0)
95 return NULL
; /* The architecture hasn't been initialized yet. */
97 regcache
= xmalloc (sizeof (*regcache
));
99 /* Make sure to zero-initialize the register cache when it is created,
100 in case there are registers the target never fetches. This way they'll
101 read as zero instead of garbage. */
102 regcache
->registers
= xcalloc (1, register_bytes
);
104 regcache
->registers_valid
= 0;
110 free_register_cache (void *regcache_p
)
112 struct inferior_regcache_data
*regcache
113 = (struct inferior_regcache_data
*) regcache_p
;
117 free (regcache
->registers
);
123 realloc_register_cache (struct inferior_list_entry
*thread_p
)
125 struct thread_info
*thread
= (struct thread_info
*) thread_p
;
127 free_register_cache (inferior_regcache_data (thread
));
128 set_inferior_regcache_data (thread
, new_register_cache ());
132 set_register_cache (struct reg
*regs
, int n
)
140 for (i
= 0; i
< n
; i
++)
142 regs
[i
].offset
= offset
;
143 offset
+= regs
[i
].size
;
146 register_bytes
= offset
/ 8;
148 /* Make sure PBUFSIZ is large enough to hold a full register packet. */
149 if (2 * register_bytes
+ 32 > PBUFSIZ
)
150 fatal ("Register packet size exceeds PBUFSIZ.");
152 /* Re-allocate all pre-existing register caches. */
153 for_each_inferior (&all_threads
, realloc_register_cache
);
157 registers_to_string (char *buf
)
159 unsigned char *registers
= get_regcache (current_inferior
, 1)->registers
;
161 convert_int_to_ascii (registers
, buf
, register_bytes
);
165 registers_from_string (char *buf
)
167 int len
= strlen (buf
);
168 unsigned char *registers
= get_regcache (current_inferior
, 1)->registers
;
170 if (len
!= register_bytes
* 2)
172 warning ("Wrong sized register packet (expected %d bytes, got %d)",
173 2*register_bytes
, len
);
174 if (len
> register_bytes
* 2)
175 len
= register_bytes
* 2;
177 convert_ascii_to_int (buf
, registers
, len
/ 2);
181 find_register_by_name (const char *name
)
185 for (i
= 0; i
< num_registers
; i
++)
186 if (!strcmp (name
, reg_defs
[i
].name
))
188 fatal ("Unknown register %s requested", name
);
193 find_regno (const char *name
)
197 for (i
= 0; i
< num_registers
; i
++)
198 if (!strcmp (name
, reg_defs
[i
].name
))
200 fatal ("Unknown register %s requested", name
);
205 find_register_by_number (int n
)
211 register_size (int n
)
213 return reg_defs
[n
].size
/ 8;
216 static unsigned char *
217 register_data (int n
, int fetch
)
219 unsigned char *registers
220 = get_regcache (current_inferior
, fetch
)->registers
;
222 return registers
+ (reg_defs
[n
].offset
/ 8);
226 supply_register (int n
, const void *buf
)
228 memcpy (register_data (n
, 0), buf
, register_size (n
));
232 supply_register_by_name (const char *name
, const void *buf
)
234 supply_register (find_regno (name
), buf
);
238 collect_register (int n
, void *buf
)
240 memcpy (buf
, register_data (n
, 1), register_size (n
));
244 collect_register_as_string (int n
, char *buf
)
246 convert_int_to_ascii (register_data (n
, 1), buf
, register_size (n
));
250 collect_register_by_name (const char *name
, void *buf
)
252 collect_register (find_regno (name
), buf
);