1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
4 2002, 2004, 2007, 2008 Free Software Foundation, Inc.
6 This file is part of GDB.
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
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
27 #include "reggroups.h"
28 #include "gdb_assert.h"
29 #include "gdb_string.h"
30 #include "gdbcmd.h" /* For maintenanceprintlist. */
36 * Here is the actual register cache.
39 /* Per-architecture object describing the layout of a register cache.
40 Computed once when the architecture is created */
42 struct gdbarch_data *regcache_descr_handle;
46 /* The architecture this descriptor belongs to. */
47 struct gdbarch *gdbarch;
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
52 registers then those registers and not the PC lives in the raw
55 long sizeof_raw_registers;
56 long sizeof_raw_register_valid_p;
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
61 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
62 both raw registers and memory by the architecture methods
63 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
64 int nr_cooked_registers;
65 long sizeof_cooked_registers;
66 long sizeof_cooked_register_valid_p;
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. */
74 long *register_offset;
75 long *sizeof_register;
77 /* Cached table containing the type of each register. */
78 struct type **register_type;
82 init_regcache_descr (struct gdbarch *gdbarch)
85 struct regcache_descr *descr;
86 gdb_assert (gdbarch != NULL);
88 /* Create an initial, zero filled, table. */
89 descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr);
90 descr->gdbarch = gdbarch;
92 /* Total size of the register space. The raw registers are mapped
93 directly onto the raw register cache while the pseudo's are
94 either mapped onto raw-registers or memory. */
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)
98 + gdbarch_num_pseudo_regs
101 /* Fill in a table of register types. */
103 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, struct type *);
104 for (i = 0; i < descr->nr_cooked_registers; i++)
105 descr->register_type[i] = gdbarch_register_type (gdbarch, i);
107 /* Construct a strictly RAW register cache. Don't allow pseudo's
108 into the register cache. */
109 descr->nr_raw_registers = gdbarch_num_regs (gdbarch);
111 /* FIXME: cagney/2002-08-13: Overallocate the register_valid_p
112 array. This pretects GDB from erant code that accesses elements
113 of the global register_valid_p[] array in the range
114 [gdbarch_num_regs .. gdbarch_num_regs + gdbarch_num_pseudo_regs). */
115 descr->sizeof_raw_register_valid_p = descr->sizeof_cooked_register_valid_p;
117 /* Lay out the register cache.
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
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);
130 for (i = 0; i < descr->nr_cooked_registers; i++)
132 descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
133 descr->register_offset[i] = offset;
134 offset += descr->sizeof_register[i];
135 gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
137 /* Set the real size of the register cache buffer. */
138 descr->sizeof_cooked_registers = offset;
141 /* FIXME: cagney/2002-05-22: Should only need to allocate space for
142 the raw registers. Unfortunately some code still accesses the
143 register array directly using the global registers[]. Until that
144 code has been purged, play safe and over allocating the register
146 descr->sizeof_raw_registers = descr->sizeof_cooked_registers;
151 static struct regcache_descr *
152 regcache_descr (struct gdbarch *gdbarch)
154 return gdbarch_data (gdbarch, regcache_descr_handle);
157 /* Utility functions returning useful register attributes stored in
158 the regcache descr. */
161 register_type (struct gdbarch *gdbarch, int regnum)
163 struct regcache_descr *descr = regcache_descr (gdbarch);
164 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
165 return descr->register_type[regnum];
168 /* Utility functions returning useful register attributes stored in
169 the regcache descr. */
172 register_size (struct gdbarch *gdbarch, int regnum)
174 struct regcache_descr *descr = regcache_descr (gdbarch);
176 gdb_assert (regnum >= 0
177 && regnum < (gdbarch_num_regs (gdbarch)
178 + gdbarch_num_pseudo_regs (gdbarch)));
179 size = descr->sizeof_register[regnum];
183 /* The register cache for storing raw register values. */
187 struct regcache_descr *descr;
188 /* The register buffers. A read-only register cache can hold the
189 full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
190 register cache can only hold [0 .. gdbarch_num_regs). */
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;
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. */
204 /* If this is a read-write cache, which thread's registers is
210 regcache_xmalloc (struct gdbarch *gdbarch)
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;
219 = XCALLOC (descr->sizeof_raw_registers, gdb_byte);
220 regcache->register_valid_p
221 = XCALLOC (descr->sizeof_raw_register_valid_p, gdb_byte);
222 regcache->readonly_p = 1;
223 regcache->ptid = minus_one_ptid;
228 regcache_xfree (struct regcache *regcache)
230 if (regcache == NULL)
232 xfree (regcache->registers);
233 xfree (regcache->register_valid_p);
238 do_regcache_xfree (void *data)
240 regcache_xfree (data);
244 make_cleanup_regcache_xfree (struct regcache *regcache)
246 return make_cleanup (do_regcache_xfree, regcache);
249 /* Return REGCACHE's architecture. */
252 get_regcache_arch (const struct regcache *regcache)
254 return regcache->descr->gdbarch;
257 /* Return a pointer to register REGNUM's buffer cache. */
260 register_buffer (const struct regcache *regcache, int regnum)
262 return regcache->registers + regcache->descr->register_offset[regnum];
266 regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
269 struct gdbarch *gdbarch = dst->descr->gdbarch;
270 gdb_byte buf[MAX_REGISTER_SIZE];
272 /* The DST should be `read-only', if it wasn't then the save would
273 end up trying to write the register values back out to the
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
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
282 to save/restore `cooked' registers that live in memory. */
283 for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
285 if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
287 int valid = cooked_read (src, regnum, buf);
290 memcpy (register_buffer (dst, regnum), buf,
291 register_size (gdbarch, regnum));
292 dst->register_valid_p[regnum] = 1;
299 regcache_restore (struct regcache *dst,
300 regcache_cooked_read_ftype *cooked_read,
301 void *cooked_read_context)
303 struct gdbarch *gdbarch = dst->descr->gdbarch;
304 gdb_byte buf[MAX_REGISTER_SIZE];
306 /* The dst had better not be read-only. If it is, the `restore'
307 doesn't make much sense. */
308 gdb_assert (!dst->readonly_p);
309 /* Copy over any registers, being careful to only restore those that
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
312 to save/restore `cooked' registers that live in memory. */
313 for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
315 if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
317 int valid = cooked_read (cooked_read_context, regnum, buf);
319 regcache_cooked_write (dst, regnum, buf);
325 do_cooked_read (void *src, int regnum, gdb_byte *buf)
327 struct regcache *regcache = src;
328 if (!regcache->register_valid_p[regnum] && regcache->readonly_p)
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. */
333 regcache_cooked_read (regcache, regnum, buf);
339 regcache_cpy (struct regcache *dst, struct regcache *src)
343 gdb_assert (src != NULL && dst != NULL);
344 gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
345 gdb_assert (src != dst);
346 gdb_assert (src->readonly_p || dst->readonly_p);
347 if (!src->readonly_p)
348 regcache_save (dst, do_cooked_read, src);
349 else if (!dst->readonly_p)
350 regcache_restore (dst, do_cooked_read, src);
352 regcache_cpy_no_passthrough (dst, src);
356 regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
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
362 move of data into the current regcache. Doing this would be
363 silly - it would mean that valid_p would be completely invalid. */
364 gdb_assert (dst->readonly_p);
365 memcpy (dst->registers, src->registers, dst->descr->sizeof_raw_registers);
366 memcpy (dst->register_valid_p, src->register_valid_p,
367 dst->descr->sizeof_raw_register_valid_p);
371 regcache_dup (struct regcache *src)
373 struct regcache *newbuf;
374 newbuf = regcache_xmalloc (src->descr->gdbarch);
375 regcache_cpy (newbuf, src);
380 regcache_dup_no_passthrough (struct regcache *src)
382 struct regcache *newbuf;
383 newbuf = regcache_xmalloc (src->descr->gdbarch);
384 regcache_cpy_no_passthrough (newbuf, src);
389 regcache_valid_p (const struct regcache *regcache, int regnum)
391 gdb_assert (regcache != NULL);
392 gdb_assert (regnum >= 0);
393 if (regcache->readonly_p)
394 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
396 gdb_assert (regnum < regcache->descr->nr_raw_registers);
398 return regcache->register_valid_p[regnum];
402 regcache_invalidate (struct regcache *regcache, int regnum)
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;
412 /* Global structure containing the current regcache. */
413 /* FIXME: cagney/2002-05-11: The two global arrays registers[] and
414 deprecated_register_valid[] currently point into this structure. */
415 static struct regcache *current_regcache;
417 /* NOTE: this is a write-through cache. There is no "dirty" bit for
418 recording if the register values have been changed (eg. by the
419 user). Therefore all registers must be written back to the
420 target when appropriate. */
422 struct regcache *get_thread_regcache (ptid_t ptid)
424 /* NOTE: uweigand/2007-05-05: We need to detect the thread's
425 current architecture at this point. */
426 struct gdbarch *thread_gdbarch = current_gdbarch;
428 if (current_regcache && ptid_equal (current_regcache->ptid, ptid)
429 && get_regcache_arch (current_regcache) == thread_gdbarch)
430 return current_regcache;
432 if (current_regcache)
433 regcache_xfree (current_regcache);
435 current_regcache = regcache_xmalloc (thread_gdbarch);
436 current_regcache->readonly_p = 0;
437 current_regcache->ptid = ptid;
439 return current_regcache;
442 struct regcache *get_current_regcache (void)
444 return get_thread_regcache (inferior_ptid);
448 /* Observer for the target_changed event. */
451 regcache_observer_target_changed (struct target_ops *target)
453 registers_changed ();
456 /* Low level examining and depositing of registers.
458 The caller is responsible for making sure that the inferior is
459 stopped before calling the fetching routines, or it will get
460 garbage. (a change from GDB version 3, in which the caller got the
461 value from the last stop). */
463 /* REGISTERS_CHANGED ()
465 Indicate that registers may have changed, so invalidate the cache. */
468 registers_changed (void)
472 regcache_xfree (current_regcache);
473 current_regcache = NULL;
475 /* Need to forget about any frames we have cached, too. */
476 reinit_frame_cache ();
478 /* Force cleanup of any alloca areas if using C alloca instead of
479 a builtin alloca. This particular call is used to clean up
480 areas allocated by low level target code which may build up
481 during lengthy interactions between gdb and the target before
482 gdb gives control to the user (ie watchpoints). */
488 regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
490 gdb_assert (regcache != NULL && buf != NULL);
491 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
492 /* Make certain that the register cache is up-to-date with respect
493 to the current thread. This switching shouldn't be necessary
494 only there is still only one target side register cache. Sigh!
495 On the bright side, at least there is a regcache object. */
496 if (!regcache->readonly_p)
498 if (!regcache_valid_p (regcache, regnum))
500 struct cleanup *old_chain = save_inferior_ptid ();
501 inferior_ptid = regcache->ptid;
502 target_fetch_registers (regcache, regnum);
503 do_cleanups (old_chain);
506 /* FIXME: cagney/2004-08-07: At present a number of targets
507 forget (or didn't know that they needed) to set this leading to
508 panics. Also is the problem that targets need to indicate
509 that a register is in one of the possible states: valid,
510 undefined, unknown. The last of which isn't yet
512 gdb_assert (regcache_valid_p (regcache, regnum));
515 /* Copy the value directly into the register cache. */
516 memcpy (buf, register_buffer (regcache, regnum),
517 regcache->descr->sizeof_register[regnum]);
521 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
524 gdb_assert (regcache != NULL);
525 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
526 buf = alloca (regcache->descr->sizeof_register[regnum]);
527 regcache_raw_read (regcache, regnum, buf);
528 (*val) = extract_signed_integer (buf,
529 regcache->descr->sizeof_register[regnum]);
533 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
537 gdb_assert (regcache != NULL);
538 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
539 buf = alloca (regcache->descr->sizeof_register[regnum]);
540 regcache_raw_read (regcache, regnum, buf);
541 (*val) = extract_unsigned_integer (buf,
542 regcache->descr->sizeof_register[regnum]);
546 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
549 gdb_assert (regcache != NULL);
550 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
551 buf = alloca (regcache->descr->sizeof_register[regnum]);
552 store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
553 regcache_raw_write (regcache, regnum, buf);
557 regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
561 gdb_assert (regcache != NULL);
562 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
563 buf = alloca (regcache->descr->sizeof_register[regnum]);
564 store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
565 regcache_raw_write (regcache, regnum, buf);
569 regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
571 gdb_assert (regnum >= 0);
572 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
573 if (regnum < regcache->descr->nr_raw_registers)
574 regcache_raw_read (regcache, regnum, buf);
575 else if (regcache->readonly_p
576 && regnum < regcache->descr->nr_cooked_registers
577 && regcache->register_valid_p[regnum])
578 /* Read-only register cache, perhaps the cooked value was cached? */
579 memcpy (buf, register_buffer (regcache, regnum),
580 regcache->descr->sizeof_register[regnum]);
582 gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
587 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
591 gdb_assert (regcache != NULL);
592 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
593 buf = alloca (regcache->descr->sizeof_register[regnum]);
594 regcache_cooked_read (regcache, regnum, buf);
595 (*val) = extract_signed_integer (buf,
596 regcache->descr->sizeof_register[regnum]);
600 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
604 gdb_assert (regcache != NULL);
605 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
606 buf = alloca (regcache->descr->sizeof_register[regnum]);
607 regcache_cooked_read (regcache, regnum, buf);
608 (*val) = extract_unsigned_integer (buf,
609 regcache->descr->sizeof_register[regnum]);
613 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
617 gdb_assert (regcache != NULL);
618 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
619 buf = alloca (regcache->descr->sizeof_register[regnum]);
620 store_signed_integer (buf, regcache->descr->sizeof_register[regnum], val);
621 regcache_cooked_write (regcache, regnum, buf);
625 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
629 gdb_assert (regcache != NULL);
630 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
631 buf = alloca (regcache->descr->sizeof_register[regnum]);
632 store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum], val);
633 regcache_cooked_write (regcache, regnum, buf);
637 regcache_raw_write (struct regcache *regcache, int regnum,
640 struct cleanup *old_chain;
642 gdb_assert (regcache != NULL && buf != NULL);
643 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
644 gdb_assert (!regcache->readonly_p);
646 /* On the sparc, writing %g0 is a no-op, so we don't even want to
647 change the registers array if something writes to this register. */
648 if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
651 /* If we have a valid copy of the register, and new value == old
652 value, then don't bother doing the actual store. */
653 if (regcache_valid_p (regcache, regnum)
654 && (memcmp (register_buffer (regcache, regnum), buf,
655 regcache->descr->sizeof_register[regnum]) == 0))
658 old_chain = save_inferior_ptid ();
659 inferior_ptid = regcache->ptid;
661 target_prepare_to_store (regcache);
662 memcpy (register_buffer (regcache, regnum), buf,
663 regcache->descr->sizeof_register[regnum]);
664 regcache->register_valid_p[regnum] = 1;
665 target_store_registers (regcache, regnum);
667 do_cleanups (old_chain);
671 regcache_cooked_write (struct regcache *regcache, int regnum,
674 gdb_assert (regnum >= 0);
675 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
676 if (regnum < regcache->descr->nr_raw_registers)
677 regcache_raw_write (regcache, regnum, buf);
679 gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
683 /* Perform a partial register transfer using a read, modify, write
686 typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
688 typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
692 regcache_xfer_part (struct regcache *regcache, int regnum,
693 int offset, int len, void *in, const void *out,
694 void (*read) (struct regcache *regcache, int regnum,
696 void (*write) (struct regcache *regcache, int regnum,
697 const gdb_byte *buf))
699 struct regcache_descr *descr = regcache->descr;
700 gdb_byte reg[MAX_REGISTER_SIZE];
701 gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
702 gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
703 /* Something to do? */
704 if (offset + len == 0)
706 /* Read (when needed) ... */
709 || offset + len < descr->sizeof_register[regnum])
711 gdb_assert (read != NULL);
712 read (regcache, regnum, reg);
716 memcpy (in, reg + offset, len);
718 memcpy (reg + offset, out, len);
719 /* ... write (when needed). */
722 gdb_assert (write != NULL);
723 write (regcache, regnum, reg);
728 regcache_raw_read_part (struct regcache *regcache, int regnum,
729 int offset, int len, gdb_byte *buf)
731 struct regcache_descr *descr = regcache->descr;
732 gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
733 regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
734 regcache_raw_read, regcache_raw_write);
738 regcache_raw_write_part (struct regcache *regcache, int regnum,
739 int offset, int len, const gdb_byte *buf)
741 struct regcache_descr *descr = regcache->descr;
742 gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
743 regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
744 regcache_raw_read, regcache_raw_write);
748 regcache_cooked_read_part (struct regcache *regcache, int regnum,
749 int offset, int len, gdb_byte *buf)
751 struct regcache_descr *descr = regcache->descr;
752 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
753 regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
754 regcache_cooked_read, regcache_cooked_write);
758 regcache_cooked_write_part (struct regcache *regcache, int regnum,
759 int offset, int len, const gdb_byte *buf)
761 struct regcache_descr *descr = regcache->descr;
762 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
763 regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
764 regcache_cooked_read, regcache_cooked_write);
767 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
770 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
775 gdb_assert (regcache != NULL);
776 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
777 gdb_assert (!regcache->readonly_p);
779 regbuf = register_buffer (regcache, regnum);
780 size = regcache->descr->sizeof_register[regnum];
783 memcpy (regbuf, buf, size);
785 memset (regbuf, 0, size);
787 /* Mark the register as cached. */
788 regcache->register_valid_p[regnum] = 1;
791 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
794 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
799 gdb_assert (regcache != NULL && buf != NULL);
800 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
802 regbuf = register_buffer (regcache, regnum);
803 size = regcache->descr->sizeof_register[regnum];
804 memcpy (buf, regbuf, size);
808 /* read_pc, write_pc, etc. Special handling for register PC. */
810 /* NOTE: cagney/2001-02-18: The functions read_pc_pid(), read_pc() and
811 read_sp(), will eventually be replaced by per-frame methods.
812 Instead of relying on the global INFERIOR_PTID, they will use the
813 contextual information provided by the FRAME. These functions do
814 not belong in the register cache. */
816 /* NOTE: cagney/2003-06-07: The functions generic_target_write_pc(),
817 write_pc_pid() and write_pc(), all need to be replaced by something
818 that does not rely on global state. But what? */
821 read_pc_pid (ptid_t ptid)
823 struct regcache *regcache = get_thread_regcache (ptid);
824 struct gdbarch *gdbarch = get_regcache_arch (regcache);
828 if (gdbarch_read_pc_p (gdbarch))
829 pc_val = gdbarch_read_pc (gdbarch, regcache);
830 /* Else use per-frame method on get_current_frame. */
831 else if (gdbarch_pc_regnum (gdbarch) >= 0)
834 regcache_cooked_read_unsigned (regcache,
835 gdbarch_pc_regnum (gdbarch),
837 pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
840 internal_error (__FILE__, __LINE__, _("read_pc_pid: Unable to find PC"));
848 return read_pc_pid (inferior_ptid);
852 write_pc_pid (CORE_ADDR pc, ptid_t ptid)
854 struct regcache *regcache = get_thread_regcache (ptid);
855 struct gdbarch *gdbarch = get_regcache_arch (regcache);
857 if (gdbarch_write_pc_p (gdbarch))
858 gdbarch_write_pc (gdbarch, regcache, pc);
859 else if (gdbarch_pc_regnum (gdbarch) >= 0)
860 regcache_cooked_write_unsigned (regcache,
861 gdbarch_pc_regnum (gdbarch), pc);
863 internal_error (__FILE__, __LINE__,
864 _("write_pc_pid: Unable to update PC"));
868 write_pc (CORE_ADDR pc)
870 write_pc_pid (pc, inferior_ptid);
875 reg_flush_command (char *command, int from_tty)
877 /* Force-flush the register cache. */
878 registers_changed ();
880 printf_filtered (_("Register cache flushed.\n"));
884 dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
885 const unsigned char *buf, long len)
891 for (i = 0; i < len; i++)
892 fprintf_unfiltered (file, "%02x", buf[i]);
894 case BFD_ENDIAN_LITTLE:
895 for (i = len - 1; i >= 0; i--)
896 fprintf_unfiltered (file, "%02x", buf[i]);
899 internal_error (__FILE__, __LINE__, _("Bad switch"));
903 enum regcache_dump_what
905 regcache_dump_none, regcache_dump_raw, regcache_dump_cooked, regcache_dump_groups
909 regcache_dump (struct regcache *regcache, struct ui_file *file,
910 enum regcache_dump_what what_to_dump)
912 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
913 struct gdbarch *gdbarch = regcache->descr->gdbarch;
916 int footnote_register_size = 0;
917 int footnote_register_offset = 0;
918 int footnote_register_type_name_null = 0;
919 long register_offset = 0;
920 unsigned char buf[MAX_REGISTER_SIZE];
923 fprintf_unfiltered (file, "nr_raw_registers %d\n",
924 regcache->descr->nr_raw_registers);
925 fprintf_unfiltered (file, "nr_cooked_registers %d\n",
926 regcache->descr->nr_cooked_registers);
927 fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
928 regcache->descr->sizeof_raw_registers);
929 fprintf_unfiltered (file, "sizeof_raw_register_valid_p %ld\n",
930 regcache->descr->sizeof_raw_register_valid_p);
931 fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
932 gdbarch_num_regs (gdbarch));
933 fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
934 gdbarch_num_pseudo_regs (gdbarch));
937 gdb_assert (regcache->descr->nr_cooked_registers
938 == (gdbarch_num_regs (gdbarch)
939 + gdbarch_num_pseudo_regs (gdbarch)));
941 for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
945 fprintf_unfiltered (file, " %-10s", "Name");
948 const char *p = gdbarch_register_name (gdbarch, regnum);
951 else if (p[0] == '\0')
953 fprintf_unfiltered (file, " %-10s", p);
958 fprintf_unfiltered (file, " %4s", "Nr");
960 fprintf_unfiltered (file, " %4d", regnum);
962 /* Relative number. */
964 fprintf_unfiltered (file, " %4s", "Rel");
965 else if (regnum < gdbarch_num_regs (gdbarch))
966 fprintf_unfiltered (file, " %4d", regnum);
968 fprintf_unfiltered (file, " %4d",
969 (regnum - gdbarch_num_regs (gdbarch)));
973 fprintf_unfiltered (file, " %6s ", "Offset");
976 fprintf_unfiltered (file, " %6ld",
977 regcache->descr->register_offset[regnum]);
978 if (register_offset != regcache->descr->register_offset[regnum]
980 && (regcache->descr->register_offset[regnum]
981 != (regcache->descr->register_offset[regnum - 1]
982 + regcache->descr->sizeof_register[regnum - 1])))
985 if (!footnote_register_offset)
986 footnote_register_offset = ++footnote_nr;
987 fprintf_unfiltered (file, "*%d", footnote_register_offset);
990 fprintf_unfiltered (file, " ");
991 register_offset = (regcache->descr->register_offset[regnum]
992 + regcache->descr->sizeof_register[regnum]);
997 fprintf_unfiltered (file, " %5s ", "Size");
999 fprintf_unfiltered (file, " %5ld",
1000 regcache->descr->sizeof_register[regnum]);
1009 static const char blt[] = "builtin_type";
1010 t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1014 if (!footnote_register_type_name_null)
1015 footnote_register_type_name_null = ++footnote_nr;
1016 n = xstrprintf ("*%d", footnote_register_type_name_null);
1017 make_cleanup (xfree, n);
1020 /* Chop a leading builtin_type. */
1021 if (strncmp (t, blt, strlen (blt)) == 0)
1024 fprintf_unfiltered (file, " %-15s", t);
1027 /* Leading space always present. */
1028 fprintf_unfiltered (file, " ");
1031 if (what_to_dump == regcache_dump_raw)
1034 fprintf_unfiltered (file, "Raw value");
1035 else if (regnum >= regcache->descr->nr_raw_registers)
1036 fprintf_unfiltered (file, "<cooked>");
1037 else if (!regcache_valid_p (regcache, regnum))
1038 fprintf_unfiltered (file, "<invalid>");
1041 regcache_raw_read (regcache, regnum, buf);
1042 fprintf_unfiltered (file, "0x");
1043 dump_endian_bytes (file,
1044 gdbarch_byte_order (gdbarch), buf,
1045 regcache->descr->sizeof_register[regnum]);
1049 /* Value, cooked. */
1050 if (what_to_dump == regcache_dump_cooked)
1053 fprintf_unfiltered (file, "Cooked value");
1056 regcache_cooked_read (regcache, regnum, buf);
1057 fprintf_unfiltered (file, "0x");
1058 dump_endian_bytes (file,
1059 gdbarch_byte_order (gdbarch), buf,
1060 regcache->descr->sizeof_register[regnum]);
1064 /* Group members. */
1065 if (what_to_dump == regcache_dump_groups)
1068 fprintf_unfiltered (file, "Groups");
1071 const char *sep = "";
1072 struct reggroup *group;
1073 for (group = reggroup_next (gdbarch, NULL);
1075 group = reggroup_next (gdbarch, group))
1077 if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1079 fprintf_unfiltered (file, "%s%s", sep, reggroup_name (group));
1086 fprintf_unfiltered (file, "\n");
1089 if (footnote_register_size)
1090 fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1091 footnote_register_size);
1092 if (footnote_register_offset)
1093 fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1094 footnote_register_offset);
1095 if (footnote_register_type_name_null)
1096 fprintf_unfiltered (file,
1097 "*%d: Register type's name NULL.\n",
1098 footnote_register_type_name_null);
1099 do_cleanups (cleanups);
1103 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1106 regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
1109 struct ui_file *file = gdb_fopen (args, "w");
1111 perror_with_name (_("maintenance print architecture"));
1112 regcache_dump (get_current_regcache (), file, what_to_dump);
1113 ui_file_delete (file);
1118 maintenance_print_registers (char *args, int from_tty)
1120 regcache_print (args, regcache_dump_none);
1124 maintenance_print_raw_registers (char *args, int from_tty)
1126 regcache_print (args, regcache_dump_raw);
1130 maintenance_print_cooked_registers (char *args, int from_tty)
1132 regcache_print (args, regcache_dump_cooked);
1136 maintenance_print_register_groups (char *args, int from_tty)
1138 regcache_print (args, regcache_dump_groups);
1141 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1144 _initialize_regcache (void)
1146 regcache_descr_handle = gdbarch_data_register_post_init (init_regcache_descr);
1148 observer_attach_target_changed (regcache_observer_target_changed);
1150 add_com ("flushregs", class_maintenance, reg_flush_command,
1151 _("Force gdb to flush its register cache (maintainer command)"));
1153 add_cmd ("registers", class_maintenance, maintenance_print_registers, _("\
1154 Print the internal register configuration.\n\
1155 Takes an optional file parameter."), &maintenanceprintlist);
1156 add_cmd ("raw-registers", class_maintenance,
1157 maintenance_print_raw_registers, _("\
1158 Print the internal register configuration including raw values.\n\
1159 Takes an optional file parameter."), &maintenanceprintlist);
1160 add_cmd ("cooked-registers", class_maintenance,
1161 maintenance_print_cooked_registers, _("\
1162 Print the internal register configuration including cooked values.\n\
1163 Takes an optional file parameter."), &maintenanceprintlist);
1164 add_cmd ("register-groups", class_maintenance,
1165 maintenance_print_register_groups, _("\
1166 Print the internal register configuration including each register's group.\n\
1167 Takes an optional file parameter."),
1168 &maintenanceprintlist);