* defs.h (extract_signed_integer, extract_unsigned_integer,
[deliverable/binutils-gdb.git] / gdb / regcache.c
CommitLineData
32178cab 1/* Cache and manage the values of registers for GDB, the GNU debugger.
3fadccb3 2
6aba47ca 3 Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
0fb0cc75 4 2002, 2004, 2007, 2008, 2009 Free Software Foundation, Inc.
32178cab
MS
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
a9762ec7 10 the Free Software Foundation; either version 3 of the License, or
32178cab
MS
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
a9762ec7 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
32178cab
MS
20
21#include "defs.h"
32178cab
MS
22#include "inferior.h"
23#include "target.h"
24#include "gdbarch.h"
705152c5 25#include "gdbcmd.h"
4e052eda 26#include "regcache.h"
b59ff9d5 27#include "reggroups.h"
61a0eb5b 28#include "gdb_assert.h"
b66d6d2e 29#include "gdb_string.h"
af030b9a 30#include "gdbcmd.h" /* For maintenanceprintlist. */
f4c5303c 31#include "observer.h"
32178cab
MS
32
33/*
34 * DATA STRUCTURE
35 *
36 * Here is the actual register cache.
37 */
38
3fadccb3
AC
39/* Per-architecture object describing the layout of a register cache.
40 Computed once when the architecture is created */
41
42struct gdbarch_data *regcache_descr_handle;
43
44struct regcache_descr
45{
46 /* The architecture this descriptor belongs to. */
47 struct gdbarch *gdbarch;
48
bb1db049
AC
49 /* The raw register cache. Each raw (or hard) register is supplied
50 by the target interface. The raw cache should not contain
51 redundant information - if the PC is constructed from two
d2f0b918 52 registers then those registers and not the PC lives in the raw
bb1db049 53 cache. */
3fadccb3
AC
54 int nr_raw_registers;
55 long sizeof_raw_registers;
56 long sizeof_raw_register_valid_p;
57
d138e37a
AC
58 /* The cooked register space. Each cooked register in the range
59 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
60 register. The remaining [NR_RAW_REGISTERS
02f60eae 61 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
d138e37a 62 both raw registers and memory by the architecture methods
02f60eae 63 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
d138e37a 64 int nr_cooked_registers;
067df2e5
AC
65 long sizeof_cooked_registers;
66 long sizeof_cooked_register_valid_p;
d138e37a
AC
67
68 /* Offset and size (in 8 bit bytes), of reach register in the
69 register cache. All registers (including those in the range
70 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an offset.
71 Assigning all registers an offset makes it possible to keep
72 legacy code, such as that found in read_register_bytes() and
73 write_register_bytes() working. */
3fadccb3 74 long *register_offset;
3fadccb3 75 long *sizeof_register;
3fadccb3 76
bb425013
AC
77 /* Cached table containing the type of each register. */
78 struct type **register_type;
3fadccb3
AC
79};
80
3fadccb3
AC
81static void *
82init_regcache_descr (struct gdbarch *gdbarch)
83{
84 int i;
85 struct regcache_descr *descr;
86 gdb_assert (gdbarch != NULL);
87
bb425013 88 /* Create an initial, zero filled, table. */
116f06ea 89 descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr);
3fadccb3 90 descr->gdbarch = gdbarch;
3fadccb3 91
d138e37a
AC
92 /* Total size of the register space. The raw registers are mapped
93 directly onto the raw register cache while the pseudo's are
3fadccb3 94 either mapped onto raw-registers or memory. */
214e098a
UW
95 descr->nr_cooked_registers = gdbarch_num_regs (gdbarch)
96 + gdbarch_num_pseudo_regs (gdbarch);
97 descr->sizeof_cooked_register_valid_p = gdbarch_num_regs (gdbarch)
f57d151a 98 + gdbarch_num_pseudo_regs
214e098a 99 (gdbarch);
3fadccb3 100
bb425013 101 /* Fill in a table of register types. */
116f06ea
AC
102 descr->register_type
103 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, struct type *);
bb425013 104 for (i = 0; i < descr->nr_cooked_registers; i++)
336a3131 105 descr->register_type[i] = gdbarch_register_type (gdbarch, i);
bb425013 106
bb1db049
AC
107 /* Construct a strictly RAW register cache. Don't allow pseudo's
108 into the register cache. */
214e098a 109 descr->nr_raw_registers = gdbarch_num_regs (gdbarch);
bb1db049
AC
110
111 /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
112 array. This pretects GDB from erant code that accesses elements
f57d151a
UW
113 of the global register_valid_p[] array in the range
114 [gdbarch_num_regs .. gdbarch_num_regs + gdbarch_num_pseudo_regs). */
bb1db049
AC
115 descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p;
116
067df2e5 117 /* Lay out the register cache.
3fadccb3 118
bb425013
AC
119 NOTE: cagney/2002-05-22: Only register_type() is used when
120 constructing the register cache. It is assumed that the
121 register's raw size, virtual size and type length are all the
122 same. */
3fadccb3
AC
123
124 {
125 long offset = 0;
116f06ea
AC
126 descr->sizeof_register
127 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
128 descr->register_offset
129 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
d138e37a 130 for (i = 0; i < descr->nr_cooked_registers; i++)
3fadccb3 131 {
bb425013 132 descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
3fadccb3
AC
133 descr->register_offset[i] = offset;
134 offset += descr->sizeof_register[i];
123a958e 135 gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
3fadccb3
AC
136 }
137 /* Set the real size of the register cache buffer. */
067df2e5 138 descr->sizeof_cooked_registers = offset;
3fadccb3
AC
139 }
140
067df2e5 141 /* FIXME: cagney/2002-05-22: Should only need to allocate space for
ce2826aa 142 the raw registers. Unfortunately some code still accesses the
067df2e5
AC
143 register array directly using the global registers[]. Until that
144 code has been purged, play safe and over allocating the register
145 buffer. Ulgh! */
146 descr->sizeof_raw_registers = descr->sizeof_cooked_registers;
147
3fadccb3
AC
148 return descr;
149}
150
151static struct regcache_descr *
152regcache_descr (struct gdbarch *gdbarch)
153{
154 return gdbarch_data (gdbarch, regcache_descr_handle);
155}
156
bb425013
AC
157/* Utility functions returning useful register attributes stored in
158 the regcache descr. */
159
160struct type *
161register_type (struct gdbarch *gdbarch, int regnum)
162{
163 struct regcache_descr *descr = regcache_descr (gdbarch);
164 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
165 return descr->register_type[regnum];
166}
167
0ed04cce
AC
168/* Utility functions returning useful register attributes stored in
169 the regcache descr. */
170
08a617da
AC
171int
172register_size (struct gdbarch *gdbarch, int regnum)
173{
174 struct regcache_descr *descr = regcache_descr (gdbarch);
175 int size;
f57d151a 176 gdb_assert (regnum >= 0
214e098a
UW
177 && regnum < (gdbarch_num_regs (gdbarch)
178 + gdbarch_num_pseudo_regs (gdbarch)));
08a617da 179 size = descr->sizeof_register[regnum];
08a617da
AC
180 return size;
181}
182
3fadccb3
AC
183/* The register cache for storing raw register values. */
184
185struct regcache
186{
187 struct regcache_descr *descr;
51b1fe4e 188 /* The register buffers. A read-only register cache can hold the
f57d151a
UW
189 full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
190 register cache can only hold [0 .. gdbarch_num_regs). */
2d522557 191 gdb_byte *registers;
b05e64e5
FR
192 /* Register cache status:
193 register_valid_p[REG] == 0 if REG value is not in the cache
194 > 0 if REG value is in the cache
195 < 0 if REG value is permanently unavailable */
196 signed char *register_valid_p;
2d28509a
AC
197 /* Is this a read-only cache? A read-only cache is used for saving
198 the target's register state (e.g, across an inferior function
199 call or just before forcing a function return). A read-only
200 cache can only be updated via the methods regcache_dup() and
201 regcache_cpy(). The actual contents are determined by the
202 reggroup_save and reggroup_restore methods. */
203 int readonly_p;
594f7785
UW
204 /* If this is a read-write cache, which thread's registers is
205 it connected to? */
206 ptid_t ptid;
3fadccb3
AC
207};
208
209struct regcache *
210regcache_xmalloc (struct gdbarch *gdbarch)
211{
212 struct regcache_descr *descr;
213 struct regcache *regcache;
214 gdb_assert (gdbarch != NULL);
215 descr = regcache_descr (gdbarch);
216 regcache = XMALLOC (struct regcache);
217 regcache->descr = descr;
51b1fe4e 218 regcache->registers
2d522557 219 = XCALLOC (descr->sizeof_raw_registers, gdb_byte);
51b1fe4e 220 regcache->register_valid_p
2d522557 221 = XCALLOC (descr->sizeof_raw_register_valid_p, gdb_byte);
2d28509a 222 regcache->readonly_p = 1;
594f7785 223 regcache->ptid = minus_one_ptid;
3fadccb3
AC
224 return regcache;
225}
226
227void
228regcache_xfree (struct regcache *regcache)
229{
230 if (regcache == NULL)
231 return;
51b1fe4e
AC
232 xfree (regcache->registers);
233 xfree (regcache->register_valid_p);
3fadccb3
AC
234 xfree (regcache);
235}
236
b9362cc7 237static void
36160dc4
AC
238do_regcache_xfree (void *data)
239{
240 regcache_xfree (data);
241}
242
243struct cleanup *
244make_cleanup_regcache_xfree (struct regcache *regcache)
245{
246 return make_cleanup (do_regcache_xfree, regcache);
247}
248
41d35cb0
MK
249/* Return REGCACHE's architecture. */
250
251struct gdbarch *
252get_regcache_arch (const struct regcache *regcache)
253{
254 return regcache->descr->gdbarch;
255}
256
51b1fe4e
AC
257/* Return a pointer to register REGNUM's buffer cache. */
258
2d522557 259static gdb_byte *
9a661b68 260register_buffer (const struct regcache *regcache, int regnum)
51b1fe4e
AC
261{
262 return regcache->registers + regcache->descr->register_offset[regnum];
263}
264
2d28509a 265void
5602984a
AC
266regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
267 void *src)
2d28509a
AC
268{
269 struct gdbarch *gdbarch = dst->descr->gdbarch;
2d522557 270 gdb_byte buf[MAX_REGISTER_SIZE];
2d28509a 271 int regnum;
2d28509a 272 /* The DST should be `read-only', if it wasn't then the save would
5602984a 273 end up trying to write the register values back out to the
2d28509a 274 target. */
2d28509a
AC
275 gdb_assert (dst->readonly_p);
276 /* Clear the dest. */
277 memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
278 memset (dst->register_valid_p, 0, dst->descr->sizeof_cooked_register_valid_p);
279 /* Copy over any registers (identified by their membership in the
f57d151a
UW
280 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
281 gdbarch_num_pseudo_regs) range is checked since some architectures need
5602984a 282 to save/restore `cooked' registers that live in memory. */
2d28509a
AC
283 for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
284 {
285 if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
286 {
5602984a
AC
287 int valid = cooked_read (src, regnum, buf);
288 if (valid)
289 {
290 memcpy (register_buffer (dst, regnum), buf,
291 register_size (gdbarch, regnum));
292 dst->register_valid_p[regnum] = 1;
293 }
2d28509a
AC
294 }
295 }
296}
297
298void
5602984a
AC
299regcache_restore (struct regcache *dst,
300 regcache_cooked_read_ftype *cooked_read,
2d522557 301 void *cooked_read_context)
2d28509a
AC
302{
303 struct gdbarch *gdbarch = dst->descr->gdbarch;
2d522557 304 gdb_byte buf[MAX_REGISTER_SIZE];
2d28509a 305 int regnum;
5602984a
AC
306 /* The dst had better not be read-only. If it is, the `restore'
307 doesn't make much sense. */
2d28509a 308 gdb_assert (!dst->readonly_p);
2d28509a 309 /* Copy over any registers, being careful to only restore those that
f57d151a
UW
310 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
311 + gdbarch_num_pseudo_regs) range is checked since some architectures need
5602984a
AC
312 to save/restore `cooked' registers that live in memory. */
313 for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
2d28509a 314 {
5602984a 315 if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
2d28509a 316 {
2d522557 317 int valid = cooked_read (cooked_read_context, regnum, buf);
5602984a
AC
318 if (valid)
319 regcache_cooked_write (dst, regnum, buf);
2d28509a
AC
320 }
321 }
322}
323
5602984a 324static int
2d522557 325do_cooked_read (void *src, int regnum, gdb_byte *buf)
5602984a
AC
326{
327 struct regcache *regcache = src;
6f4e5a41 328 if (!regcache->register_valid_p[regnum] && regcache->readonly_p)
5602984a
AC
329 /* Don't even think about fetching a register from a read-only
330 cache when the register isn't yet valid. There isn't a target
331 from which the register value can be fetched. */
332 return 0;
333 regcache_cooked_read (regcache, regnum, buf);
334 return 1;
335}
336
337
3fadccb3
AC
338void
339regcache_cpy (struct regcache *dst, struct regcache *src)
340{
341 int i;
2d522557 342 gdb_byte *buf;
3fadccb3
AC
343 gdb_assert (src != NULL && dst != NULL);
344 gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
345 gdb_assert (src != dst);
2d28509a
AC
346 gdb_assert (src->readonly_p || dst->readonly_p);
347 if (!src->readonly_p)
5602984a 348 regcache_save (dst, do_cooked_read, src);
2d28509a 349 else if (!dst->readonly_p)
5602984a 350 regcache_restore (dst, do_cooked_read, src);
2d28509a
AC
351 else
352 regcache_cpy_no_passthrough (dst, src);
3fadccb3
AC
353}
354
355void
356regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
357{
358 int i;
359 gdb_assert (src != NULL && dst != NULL);
360 gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
361 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
594f7785 362 move of data into the current regcache. Doing this would be
9564ee9f 363 silly - it would mean that valid_p would be completely invalid. */
594f7785 364 gdb_assert (dst->readonly_p);
51b1fe4e
AC
365 memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
366 memcpy (dst->register_valid_p, src->register_valid_p,
3fadccb3
AC
367 dst->descr->sizeof_raw_register_valid_p);
368}
369
370struct regcache *
371regcache_dup (struct regcache *src)
372{
373 struct regcache *newbuf;
3fadccb3
AC
374 newbuf = regcache_xmalloc (src->descr->gdbarch);
375 regcache_cpy (newbuf, src);
376 return newbuf;
377}
378
379struct regcache *
380regcache_dup_no_passthrough (struct regcache *src)
381{
382 struct regcache *newbuf;
3fadccb3
AC
383 newbuf = regcache_xmalloc (src->descr->gdbarch);
384 regcache_cpy_no_passthrough (newbuf, src);
385 return newbuf;
386}
387
388int
6ed7ea50 389regcache_valid_p (const struct regcache *regcache, int regnum)
3fadccb3
AC
390{
391 gdb_assert (regcache != NULL);
6ed7ea50
UW
392 gdb_assert (regnum >= 0);
393 if (regcache->readonly_p)
394 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
395 else
396 gdb_assert (regnum < regcache->descr->nr_raw_registers);
397
51b1fe4e 398 return regcache->register_valid_p[regnum];
3fadccb3
AC
399}
400
9c5ea4d9
UW
401void
402regcache_invalidate (struct regcache *regcache, int regnum)
403{
404 gdb_assert (regcache != NULL);
405 gdb_assert (regnum >= 0);
406 gdb_assert (!regcache->readonly_p);
407 gdb_assert (regnum < regcache->descr->nr_raw_registers);
408 regcache->register_valid_p[regnum] = 0;
409}
410
411
3fadccb3 412/* Global structure containing the current regcache. */
3fadccb3 413
5ebd2499 414/* NOTE: this is a write-through cache. There is no "dirty" bit for
32178cab
MS
415 recording if the register values have been changed (eg. by the
416 user). Therefore all registers must be written back to the
417 target when appropriate. */
418
c2250ad1 419struct regcache_list
594f7785 420{
c2250ad1
UW
421 struct regcache *regcache;
422 struct regcache_list *next;
423};
424
425static struct regcache_list *current_regcache;
426
427struct regcache *
428get_thread_arch_regcache (ptid_t ptid, struct gdbarch *gdbarch)
429{
430 struct regcache_list *list;
431 struct regcache *new_regcache;
594f7785 432
c2250ad1
UW
433 for (list = current_regcache; list; list = list->next)
434 if (ptid_equal (list->regcache->ptid, ptid)
435 && get_regcache_arch (list->regcache) == gdbarch)
436 return list->regcache;
594f7785 437
c2250ad1
UW
438 new_regcache = regcache_xmalloc (gdbarch);
439 new_regcache->readonly_p = 0;
440 new_regcache->ptid = ptid;
594f7785 441
c2250ad1
UW
442 list = xmalloc (sizeof (struct regcache_list));
443 list->regcache = new_regcache;
444 list->next = current_regcache;
445 current_regcache = list;
594f7785 446
c2250ad1 447 return new_regcache;
594f7785
UW
448}
449
c2250ad1
UW
450static ptid_t current_thread_ptid;
451static struct gdbarch *current_thread_arch;
452
453struct regcache *
454get_thread_regcache (ptid_t ptid)
455{
456 if (!current_thread_arch || !ptid_equal (current_thread_ptid, ptid))
457 {
458 current_thread_ptid = ptid;
459 current_thread_arch = target_thread_architecture (ptid);
460 }
461
462 return get_thread_arch_regcache (ptid, current_thread_arch);
463}
464
465struct regcache *
466get_current_regcache (void)
594f7785
UW
467{
468 return get_thread_regcache (inferior_ptid);
469}
32178cab 470
32178cab 471
f4c5303c
OF
472/* Observer for the target_changed event. */
473
2c0b251b 474static void
f4c5303c
OF
475regcache_observer_target_changed (struct target_ops *target)
476{
477 registers_changed ();
478}
479
5231c1fd
PA
480/* Update global variables old ptids to hold NEW_PTID if they were
481 holding OLD_PTID. */
482static void
483regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
484{
c2250ad1
UW
485 struct regcache_list *list;
486
487 for (list = current_regcache; list; list = list->next)
488 if (ptid_equal (list->regcache->ptid, old_ptid))
489 list->regcache->ptid = new_ptid;
5231c1fd
PA
490}
491
32178cab
MS
492/* Low level examining and depositing of registers.
493
494 The caller is responsible for making sure that the inferior is
495 stopped before calling the fetching routines, or it will get
496 garbage. (a change from GDB version 3, in which the caller got the
497 value from the last stop). */
498
499/* REGISTERS_CHANGED ()
500
501 Indicate that registers may have changed, so invalidate the cache. */
502
503void
504registers_changed (void)
505{
c2250ad1
UW
506 struct regcache_list *list, *next;
507
508 for (list = current_regcache; list; list = next)
509 {
510 next = list->next;
511 regcache_xfree (list->regcache);
512 xfree (list);
513 }
32178cab 514
594f7785 515 current_regcache = NULL;
32178cab 516
c2250ad1
UW
517 current_thread_ptid = null_ptid;
518 current_thread_arch = NULL;
519
a5d9d57d
DJ
520 /* Need to forget about any frames we have cached, too. */
521 reinit_frame_cache ();
522
32178cab
MS
523 /* Force cleanup of any alloca areas if using C alloca instead of
524 a builtin alloca. This particular call is used to clean up
525 areas allocated by low level target code which may build up
526 during lengthy interactions between gdb and the target before
527 gdb gives control to the user (ie watchpoints). */
528 alloca (0);
32178cab
MS
529}
530
32178cab 531
61a0eb5b 532void
2d522557 533regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
61a0eb5b 534{
3fadccb3
AC
535 gdb_assert (regcache != NULL && buf != NULL);
536 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
3fadccb3
AC
537 /* Make certain that the register cache is up-to-date with respect
538 to the current thread. This switching shouldn't be necessary
539 only there is still only one target side register cache. Sigh!
540 On the bright side, at least there is a regcache object. */
2d28509a 541 if (!regcache->readonly_p)
3fadccb3 542 {
594f7785 543 if (!regcache_valid_p (regcache, regnum))
3fadccb3 544 {
594f7785
UW
545 struct cleanup *old_chain = save_inferior_ptid ();
546 inferior_ptid = regcache->ptid;
547 target_fetch_registers (regcache, regnum);
548 do_cleanups (old_chain);
3fadccb3 549 }
0a8146bf
AC
550#if 0
551 /* FIXME: cagney/2004-08-07: At present a number of targets
04c663e3
DA
552 forget (or didn't know that they needed) to set this leading to
553 panics. Also is the problem that targets need to indicate
0a8146bf
AC
554 that a register is in one of the possible states: valid,
555 undefined, unknown. The last of which isn't yet
556 possible. */
9c5ea4d9 557 gdb_assert (regcache_valid_p (regcache, regnum));
0a8146bf 558#endif
3fadccb3
AC
559 }
560 /* Copy the value directly into the register cache. */
51b1fe4e 561 memcpy (buf, register_buffer (regcache, regnum),
3fadccb3 562 regcache->descr->sizeof_register[regnum]);
61a0eb5b
AC
563}
564
28fc6740
AC
565void
566regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
567{
2d522557 568 gdb_byte *buf;
28fc6740
AC
569 gdb_assert (regcache != NULL);
570 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
571 buf = alloca (regcache->descr->sizeof_register[regnum]);
572 regcache_raw_read (regcache, regnum, buf);
e17a4113
UW
573 (*val) = extract_signed_integer
574 (buf, regcache->descr->sizeof_register[regnum],
575 gdbarch_byte_order (regcache->descr->gdbarch));
28fc6740
AC
576}
577
578void
579regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
580 ULONGEST *val)
581{
2d522557 582 gdb_byte *buf;
28fc6740
AC
583 gdb_assert (regcache != NULL);
584 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
585 buf = alloca (regcache->descr->sizeof_register[regnum]);
586 regcache_raw_read (regcache, regnum, buf);
e17a4113
UW
587 (*val) = extract_unsigned_integer
588 (buf, regcache->descr->sizeof_register[regnum],
589 gdbarch_byte_order (regcache->descr->gdbarch));
28fc6740
AC
590}
591
c00dcbe9
MK
592void
593regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
594{
595 void *buf;
596 gdb_assert (regcache != NULL);
597 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
598 buf = alloca (regcache->descr->sizeof_register[regnum]);
e17a4113
UW
599 store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
600 gdbarch_byte_order (regcache->descr->gdbarch), val);
c00dcbe9
MK
601 regcache_raw_write (regcache, regnum, buf);
602}
603
604void
605regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
606 ULONGEST val)
607{
608 void *buf;
609 gdb_assert (regcache != NULL);
610 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
611 buf = alloca (regcache->descr->sizeof_register[regnum]);
e17a4113
UW
612 store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
613 gdbarch_byte_order (regcache->descr->gdbarch), val);
c00dcbe9
MK
614 regcache_raw_write (regcache, regnum, buf);
615}
616
68365089 617void
2d522557 618regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
68365089 619{
d138e37a 620 gdb_assert (regnum >= 0);
68365089
AC
621 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
622 if (regnum < regcache->descr->nr_raw_registers)
623 regcache_raw_read (regcache, regnum, buf);
2d28509a
AC
624 else if (regcache->readonly_p
625 && regnum < regcache->descr->nr_cooked_registers
626 && regcache->register_valid_p[regnum])
b2fa5097 627 /* Read-only register cache, perhaps the cooked value was cached? */
2d28509a
AC
628 memcpy (buf, register_buffer (regcache, regnum),
629 regcache->descr->sizeof_register[regnum]);
d138e37a 630 else
68365089
AC
631 gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
632 regnum, buf);
61a0eb5b
AC
633}
634
a378f419
AC
635void
636regcache_cooked_read_signed (struct regcache *regcache, int regnum,
637 LONGEST *val)
638{
2d522557 639 gdb_byte *buf;
a378f419 640 gdb_assert (regcache != NULL);
a66a9c23 641 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
a378f419
AC
642 buf = alloca (regcache->descr->sizeof_register[regnum]);
643 regcache_cooked_read (regcache, regnum, buf);
e17a4113
UW
644 (*val) = extract_signed_integer
645 (buf, regcache->descr->sizeof_register[regnum],
646 gdbarch_byte_order (regcache->descr->gdbarch));
a378f419
AC
647}
648
649void
650regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
651 ULONGEST *val)
652{
2d522557 653 gdb_byte *buf;
a378f419 654 gdb_assert (regcache != NULL);
a66a9c23 655 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
a378f419
AC
656 buf = alloca (regcache->descr->sizeof_register[regnum]);
657 regcache_cooked_read (regcache, regnum, buf);
e17a4113
UW
658 (*val) = extract_unsigned_integer
659 (buf, regcache->descr->sizeof_register[regnum],
660 gdbarch_byte_order (regcache->descr->gdbarch));
a378f419
AC
661}
662
a66a9c23
AC
663void
664regcache_cooked_write_signed (struct regcache *regcache, int regnum,
665 LONGEST val)
666{
667 void *buf;
668 gdb_assert (regcache != NULL);
669 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
670 buf = alloca (regcache->descr->sizeof_register[regnum]);
e17a4113
UW
671 store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
672 gdbarch_byte_order (regcache->descr->gdbarch), val);
a66a9c23
AC
673 regcache_cooked_write (regcache, regnum, buf);
674}
675
676void
677regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
678 ULONGEST val)
679{
680 void *buf;
681 gdb_assert (regcache != NULL);
682 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
683 buf = alloca (regcache->descr->sizeof_register[regnum]);
e17a4113
UW
684 store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
685 gdbarch_byte_order (regcache->descr->gdbarch), val);
a66a9c23
AC
686 regcache_cooked_write (regcache, regnum, buf);
687}
688
61a0eb5b 689void
2d522557
AC
690regcache_raw_write (struct regcache *regcache, int regnum,
691 const gdb_byte *buf)
61a0eb5b 692{
594f7785
UW
693 struct cleanup *old_chain;
694
3fadccb3
AC
695 gdb_assert (regcache != NULL && buf != NULL);
696 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
2d28509a 697 gdb_assert (!regcache->readonly_p);
3fadccb3 698
3fadccb3
AC
699 /* On the sparc, writing %g0 is a no-op, so we don't even want to
700 change the registers array if something writes to this register. */
214e098a 701 if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
3fadccb3
AC
702 return;
703
3fadccb3
AC
704 /* If we have a valid copy of the register, and new value == old
705 value, then don't bother doing the actual store. */
706 if (regcache_valid_p (regcache, regnum)
707 && (memcmp (register_buffer (regcache, regnum), buf,
708 regcache->descr->sizeof_register[regnum]) == 0))
709 return;
710
594f7785
UW
711 old_chain = save_inferior_ptid ();
712 inferior_ptid = regcache->ptid;
713
316f2060 714 target_prepare_to_store (regcache);
3fadccb3
AC
715 memcpy (register_buffer (regcache, regnum), buf,
716 regcache->descr->sizeof_register[regnum]);
51b1fe4e 717 regcache->register_valid_p[regnum] = 1;
56be3814 718 target_store_registers (regcache, regnum);
594f7785
UW
719
720 do_cleanups (old_chain);
61a0eb5b
AC
721}
722
68365089 723void
2d522557
AC
724regcache_cooked_write (struct regcache *regcache, int regnum,
725 const gdb_byte *buf)
68365089 726{
d138e37a 727 gdb_assert (regnum >= 0);
68365089
AC
728 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
729 if (regnum < regcache->descr->nr_raw_registers)
730 regcache_raw_write (regcache, regnum, buf);
d138e37a 731 else
68365089 732 gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
d8124050 733 regnum, buf);
61a0eb5b
AC
734}
735
06c0b04e
AC
736/* Perform a partial register transfer using a read, modify, write
737 operation. */
738
739typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
740 void *buf);
741typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
742 const void *buf);
743
b9362cc7 744static void
06c0b04e
AC
745regcache_xfer_part (struct regcache *regcache, int regnum,
746 int offset, int len, void *in, const void *out,
2d522557
AC
747 void (*read) (struct regcache *regcache, int regnum,
748 gdb_byte *buf),
749 void (*write) (struct regcache *regcache, int regnum,
750 const gdb_byte *buf))
06c0b04e
AC
751{
752 struct regcache_descr *descr = regcache->descr;
fc1a4b47 753 gdb_byte reg[MAX_REGISTER_SIZE];
06c0b04e
AC
754 gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
755 gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
756 /* Something to do? */
757 if (offset + len == 0)
758 return;
759 /* Read (when needed) ... */
760 if (in != NULL
761 || offset > 0
762 || offset + len < descr->sizeof_register[regnum])
763 {
764 gdb_assert (read != NULL);
765 read (regcache, regnum, reg);
766 }
767 /* ... modify ... */
768 if (in != NULL)
769 memcpy (in, reg + offset, len);
770 if (out != NULL)
771 memcpy (reg + offset, out, len);
772 /* ... write (when needed). */
773 if (out != NULL)
774 {
775 gdb_assert (write != NULL);
776 write (regcache, regnum, reg);
777 }
778}
779
780void
781regcache_raw_read_part (struct regcache *regcache, int regnum,
2d522557 782 int offset, int len, gdb_byte *buf)
06c0b04e
AC
783{
784 struct regcache_descr *descr = regcache->descr;
785 gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
786 regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
787 regcache_raw_read, regcache_raw_write);
788}
789
790void
791regcache_raw_write_part (struct regcache *regcache, int regnum,
2d522557 792 int offset, int len, const gdb_byte *buf)
06c0b04e
AC
793{
794 struct regcache_descr *descr = regcache->descr;
795 gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
796 regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
797 regcache_raw_read, regcache_raw_write);
798}
799
800void
801regcache_cooked_read_part (struct regcache *regcache, int regnum,
2d522557 802 int offset, int len, gdb_byte *buf)
06c0b04e
AC
803{
804 struct regcache_descr *descr = regcache->descr;
805 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
806 regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
807 regcache_cooked_read, regcache_cooked_write);
808}
809
810void
811regcache_cooked_write_part (struct regcache *regcache, int regnum,
2d522557 812 int offset, int len, const gdb_byte *buf)
06c0b04e
AC
813{
814 struct regcache_descr *descr = regcache->descr;
815 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
816 regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
817 regcache_cooked_read, regcache_cooked_write);
818}
32178cab 819
a16d75cc 820/* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
9a661b68
MK
821
822void
6618125d 823regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
9a661b68
MK
824{
825 void *regbuf;
826 size_t size;
827
a16d75cc 828 gdb_assert (regcache != NULL);
9a661b68
MK
829 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
830 gdb_assert (!regcache->readonly_p);
831
9a661b68
MK
832 regbuf = register_buffer (regcache, regnum);
833 size = regcache->descr->sizeof_register[regnum];
834
835 if (buf)
836 memcpy (regbuf, buf, size);
837 else
838 memset (regbuf, 0, size);
839
840 /* Mark the register as cached. */
841 regcache->register_valid_p[regnum] = 1;
842}
843
844/* Collect register REGNUM from REGCACHE and store its contents in BUF. */
845
846void
6618125d 847regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
9a661b68
MK
848{
849 const void *regbuf;
850 size_t size;
851
852 gdb_assert (regcache != NULL && buf != NULL);
853 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
854
855 regbuf = register_buffer (regcache, regnum);
856 size = regcache->descr->sizeof_register[regnum];
857 memcpy (buf, regbuf, size);
858}
859
193cb69f 860
515630c5 861/* Special handling for register PC. */
32178cab
MS
862
863CORE_ADDR
515630c5 864regcache_read_pc (struct regcache *regcache)
32178cab 865{
61a1198a
UW
866 struct gdbarch *gdbarch = get_regcache_arch (regcache);
867
32178cab
MS
868 CORE_ADDR pc_val;
869
61a1198a
UW
870 if (gdbarch_read_pc_p (gdbarch))
871 pc_val = gdbarch_read_pc (gdbarch, regcache);
cde9ea48 872 /* Else use per-frame method on get_current_frame. */
214e098a 873 else if (gdbarch_pc_regnum (gdbarch) >= 0)
cde9ea48 874 {
61a1198a 875 ULONGEST raw_val;
3e8c568d 876 regcache_cooked_read_unsigned (regcache,
214e098a 877 gdbarch_pc_regnum (gdbarch),
3e8c568d 878 &raw_val);
214e098a 879 pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
cde9ea48
AC
880 }
881 else
515630c5
UW
882 internal_error (__FILE__, __LINE__,
883 _("regcache_read_pc: Unable to find PC"));
32178cab
MS
884 return pc_val;
885}
886
32178cab 887void
515630c5 888regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
32178cab 889{
61a1198a
UW
890 struct gdbarch *gdbarch = get_regcache_arch (regcache);
891
61a1198a
UW
892 if (gdbarch_write_pc_p (gdbarch))
893 gdbarch_write_pc (gdbarch, regcache, pc);
214e098a 894 else if (gdbarch_pc_regnum (gdbarch) >= 0)
3e8c568d 895 regcache_cooked_write_unsigned (regcache,
214e098a 896 gdbarch_pc_regnum (gdbarch), pc);
61a1198a
UW
897 else
898 internal_error (__FILE__, __LINE__,
515630c5 899 _("regcache_write_pc: Unable to update PC"));
edb3359d
DJ
900
901 /* Writing the PC (for instance, from "load") invalidates the
902 current frame. */
903 reinit_frame_cache ();
32178cab
MS
904}
905
32178cab 906
705152c5
MS
907static void
908reg_flush_command (char *command, int from_tty)
909{
910 /* Force-flush the register cache. */
911 registers_changed ();
912 if (from_tty)
a3f17187 913 printf_filtered (_("Register cache flushed.\n"));
705152c5
MS
914}
915
af030b9a
AC
916static void
917dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
918 const unsigned char *buf, long len)
919{
920 int i;
921 switch (endian)
922 {
923 case BFD_ENDIAN_BIG:
924 for (i = 0; i < len; i++)
925 fprintf_unfiltered (file, "%02x", buf[i]);
926 break;
927 case BFD_ENDIAN_LITTLE:
928 for (i = len - 1; i >= 0; i--)
929 fprintf_unfiltered (file, "%02x", buf[i]);
930 break;
931 default:
e2e0b3e5 932 internal_error (__FILE__, __LINE__, _("Bad switch"));
af030b9a
AC
933 }
934}
935
936enum regcache_dump_what
937{
b59ff9d5 938 regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups
af030b9a
AC
939};
940
941static void
942regcache_dump (struct regcache *regcache, struct ui_file *file,
943 enum regcache_dump_what what_to_dump)
944{
945 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
b59ff9d5 946 struct gdbarch *gdbarch = regcache->descr->gdbarch;
af030b9a
AC
947 int regnum;
948 int footnote_nr = 0;
949 int footnote_register_size = 0;
950 int footnote_register_offset = 0;
951 int footnote_register_type_name_null = 0;
952 long register_offset = 0;
123a958e 953 unsigned char buf[MAX_REGISTER_SIZE];
af030b9a
AC
954
955#if 0
af030b9a
AC
956 fprintf_unfiltered (file, "nr_raw_registers %d\n",
957 regcache->descr->nr_raw_registers);
958 fprintf_unfiltered (file, "nr_cooked_registers %d\n",
959 regcache->descr->nr_cooked_registers);
960 fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
961 regcache->descr->sizeof_raw_registers);
962 fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
963 regcache->descr->sizeof_raw_register_valid_p);
f57d151a 964 fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
214e098a 965 gdbarch_num_regs (gdbarch));
f57d151a 966 fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
214e098a 967 gdbarch_num_pseudo_regs (gdbarch));
af030b9a
AC
968#endif
969
970 gdb_assert (regcache->descr->nr_cooked_registers
214e098a
UW
971 == (gdbarch_num_regs (gdbarch)
972 + gdbarch_num_pseudo_regs (gdbarch)));
af030b9a
AC
973
974 for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
975 {
976 /* Name. */
977 if (regnum < 0)
978 fprintf_unfiltered (file, " %-10s", "Name");
979 else
980 {
214e098a 981 const char *p = gdbarch_register_name (gdbarch, regnum);
af030b9a
AC
982 if (p == NULL)
983 p = "";
984 else if (p[0] == '\0')
985 p = "''";
986 fprintf_unfiltered (file, " %-10s", p);
987 }
988
989 /* Number. */
990 if (regnum < 0)
991 fprintf_unfiltered (file, " %4s", "Nr");
992 else
993 fprintf_unfiltered (file, " %4d", regnum);
994
995 /* Relative number. */
996 if (regnum < 0)
997 fprintf_unfiltered (file, " %4s", "Rel");
214e098a 998 else if (regnum < gdbarch_num_regs (gdbarch))
af030b9a
AC
999 fprintf_unfiltered (file, " %4d", regnum);
1000 else
f57d151a 1001 fprintf_unfiltered (file, " %4d",
214e098a 1002 (regnum - gdbarch_num_regs (gdbarch)));
af030b9a
AC
1003
1004 /* Offset. */
1005 if (regnum < 0)
1006 fprintf_unfiltered (file, " %6s ", "Offset");
1007 else
1008 {
1009 fprintf_unfiltered (file, " %6ld",
1010 regcache->descr->register_offset[regnum]);
a7e3c2ad 1011 if (register_offset != regcache->descr->register_offset[regnum]
d3b22ed5
AC
1012 || (regnum > 0
1013 && (regcache->descr->register_offset[regnum]
1014 != (regcache->descr->register_offset[regnum - 1]
1015 + regcache->descr->sizeof_register[regnum - 1])))
1016 )
af030b9a
AC
1017 {
1018 if (!footnote_register_offset)
1019 footnote_register_offset = ++footnote_nr;
1020 fprintf_unfiltered (file, "*%d", footnote_register_offset);
1021 }
1022 else
1023 fprintf_unfiltered (file, " ");
1024 register_offset = (regcache->descr->register_offset[regnum]
1025 + regcache->descr->sizeof_register[regnum]);
1026 }
1027
1028 /* Size. */
1029 if (regnum < 0)
1030 fprintf_unfiltered (file, " %5s ", "Size");
1031 else
01e1877c
AC
1032 fprintf_unfiltered (file, " %5ld",
1033 regcache->descr->sizeof_register[regnum]);
af030b9a
AC
1034
1035 /* Type. */
b59ff9d5
AC
1036 {
1037 const char *t;
1038 if (regnum < 0)
1039 t = "Type";
1040 else
1041 {
1042 static const char blt[] = "builtin_type";
1043 t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1044 if (t == NULL)
1045 {
1046 char *n;
1047 if (!footnote_register_type_name_null)
1048 footnote_register_type_name_null = ++footnote_nr;
b435e160 1049 n = xstrprintf ("*%d", footnote_register_type_name_null);
b59ff9d5
AC
1050 make_cleanup (xfree, n);
1051 t = n;
1052 }
1053 /* Chop a leading builtin_type. */
1054 if (strncmp (t, blt, strlen (blt)) == 0)
1055 t += strlen (blt);
1056 }
1057 fprintf_unfiltered (file, " %-15s", t);
1058 }
1059
1060 /* Leading space always present. */
1061 fprintf_unfiltered (file, " ");
af030b9a
AC
1062
1063 /* Value, raw. */
1064 if (what_to_dump == regcache_dump_raw)
1065 {
1066 if (regnum < 0)
1067 fprintf_unfiltered (file, "Raw value");
1068 else if (regnum >= regcache->descr->nr_raw_registers)
1069 fprintf_unfiltered (file, "<cooked>");
1070 else if (!regcache_valid_p (regcache, regnum))
1071 fprintf_unfiltered (file, "<invalid>");
1072 else
1073 {
1074 regcache_raw_read (regcache, regnum, buf);
1075 fprintf_unfiltered (file, "0x");
0d20ae72 1076 dump_endian_bytes (file,
214e098a 1077 gdbarch_byte_order (gdbarch), buf,
01e1877c 1078 regcache->descr->sizeof_register[regnum]);
af030b9a
AC
1079 }
1080 }
1081
1082 /* Value, cooked. */
1083 if (what_to_dump == regcache_dump_cooked)
1084 {
1085 if (regnum < 0)
1086 fprintf_unfiltered (file, "Cooked value");
1087 else
1088 {
1089 regcache_cooked_read (regcache, regnum, buf);
1090 fprintf_unfiltered (file, "0x");
0d20ae72 1091 dump_endian_bytes (file,
214e098a 1092 gdbarch_byte_order (gdbarch), buf,
01e1877c 1093 regcache->descr->sizeof_register[regnum]);
af030b9a
AC
1094 }
1095 }
1096
b59ff9d5
AC
1097 /* Group members. */
1098 if (what_to_dump == regcache_dump_groups)
1099 {
1100 if (regnum < 0)
1101 fprintf_unfiltered (file, "Groups");
1102 else
1103 {
b59ff9d5 1104 const char *sep = "";
6c7d17ba
AC
1105 struct reggroup *group;
1106 for (group = reggroup_next (gdbarch, NULL);
1107 group != NULL;
1108 group = reggroup_next (gdbarch, group))
b59ff9d5 1109 {
6c7d17ba 1110 if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
b59ff9d5 1111 {
6c7d17ba 1112 fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
b59ff9d5
AC
1113 sep = ",";
1114 }
1115 }
1116 }
1117 }
1118
af030b9a
AC
1119 fprintf_unfiltered (file, "\n");
1120 }
1121
1122 if (footnote_register_size)
1123 fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1124 footnote_register_size);
1125 if (footnote_register_offset)
1126 fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1127 footnote_register_offset);
1128 if (footnote_register_type_name_null)
1129 fprintf_unfiltered (file,
1130 "*%d: Register type's name NULL.\n",
1131 footnote_register_type_name_null);
1132 do_cleanups (cleanups);
1133}
1134
1135static void
1136regcache_print (char *args, enum regcache_dump_what what_to_dump)
1137{
1138 if (args == NULL)
28c38f10 1139 regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
af030b9a
AC
1140 else
1141 {
724b958c 1142 struct cleanup *cleanups;
af030b9a
AC
1143 struct ui_file *file = gdb_fopen (args, "w");
1144 if (file == NULL)
e2e0b3e5 1145 perror_with_name (_("maintenance print architecture"));
724b958c 1146 cleanups = make_cleanup_ui_file_delete (file);
28c38f10 1147 regcache_dump (get_current_regcache (), file, what_to_dump);
724b958c 1148 do_cleanups (cleanups);
af030b9a
AC
1149 }
1150}
1151
1152static void
1153maintenance_print_registers (char *args, int from_tty)
1154{
1155 regcache_print (args, regcache_dump_none);
1156}
1157
1158static void
1159maintenance_print_raw_registers (char *args, int from_tty)
1160{
1161 regcache_print (args, regcache_dump_raw);
1162}
1163
1164static void
1165maintenance_print_cooked_registers (char *args, int from_tty)
1166{
1167 regcache_print (args, regcache_dump_cooked);
1168}
1169
b59ff9d5
AC
1170static void
1171maintenance_print_register_groups (char *args, int from_tty)
1172{
1173 regcache_print (args, regcache_dump_groups);
1174}
1175
b9362cc7
AC
1176extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1177
32178cab
MS
1178void
1179_initialize_regcache (void)
1180{
030f20e1 1181 regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
705152c5 1182
f4c5303c 1183 observer_attach_target_changed (regcache_observer_target_changed);
5231c1fd 1184 observer_attach_thread_ptid_changed (regcache_thread_ptid_changed);
f4c5303c 1185
705152c5 1186 add_com ("flushregs", class_maintenance, reg_flush_command,
1bedd215 1187 _("Force gdb to flush its register cache (maintainer command)"));
39f77062 1188
1a966eab
AC
1189 add_cmd ("registers", class_maintenance, maintenance_print_registers, _("\
1190Print the internal register configuration.\n\
1191Takes an optional file parameter."), &maintenanceprintlist);
af030b9a 1192 add_cmd ("raw-registers", class_maintenance,
1a966eab
AC
1193 maintenance_print_raw_registers, _("\
1194Print the internal register configuration including raw values.\n\
1195Takes an optional file parameter."), &maintenanceprintlist);
af030b9a 1196 add_cmd ("cooked-registers", class_maintenance,
1a966eab
AC
1197 maintenance_print_cooked_registers, _("\
1198Print the internal register configuration including cooked values.\n\
1199Takes an optional file parameter."), &maintenanceprintlist);
b59ff9d5 1200 add_cmd ("register-groups", class_maintenance,
1a966eab
AC
1201 maintenance_print_register_groups, _("\
1202Print the internal register configuration including each register's group.\n\
1203Takes an optional file parameter."),
af030b9a
AC
1204 &maintenanceprintlist);
1205
32178cab 1206}
This page took 0.841647 seconds and 4 git commands to generate.