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, 2009, 2010, 2011 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. */
32 #include "exceptions.h"
38 * Here is the actual register cache.
41 /* Per-architecture object describing the layout of a register cache.
42 Computed once when the architecture is created. */
44 struct gdbarch_data *regcache_descr_handle;
48 /* The architecture this descriptor belongs to. */
49 struct gdbarch *gdbarch;
51 /* The raw register cache. Each raw (or hard) register is supplied
52 by the target interface. The raw cache should not contain
53 redundant information - if the PC is constructed from two
54 registers then those registers and not the PC lives in the raw
57 long sizeof_raw_registers;
58 long sizeof_raw_register_status;
60 /* The cooked register space. Each cooked register in the range
61 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
62 register. The remaining [NR_RAW_REGISTERS
63 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
64 both raw registers and memory by the architecture methods
65 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
66 int nr_cooked_registers;
67 long sizeof_cooked_registers;
68 long sizeof_cooked_register_status;
70 /* Offset and size (in 8 bit bytes), of each register in the
71 register cache. All registers (including those in the range
72 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
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_status
98 = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
100 /* Fill in a table of register types. */
102 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers,
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);
110 descr->sizeof_raw_register_status = gdbarch_num_regs (gdbarch);
112 /* Lay out the register cache.
114 NOTE: cagney/2002-05-22: Only register_type() is used when
115 constructing the register cache. It is assumed that the
116 register's raw size, virtual size and type length are all the
122 descr->sizeof_register
123 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
124 descr->register_offset
125 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
126 for (i = 0; i < descr->nr_raw_registers; i++)
128 descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
129 descr->register_offset[i] = offset;
130 offset += descr->sizeof_register[i];
131 gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
133 /* Set the real size of the raw register cache buffer. */
134 descr->sizeof_raw_registers = offset;
136 for (; i < descr->nr_cooked_registers; i++)
138 descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
139 descr->register_offset[i] = offset;
140 offset += descr->sizeof_register[i];
141 gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
143 /* Set the real size of the readonly register cache buffer. */
144 descr->sizeof_cooked_registers = offset;
150 static struct regcache_descr *
151 regcache_descr (struct gdbarch *gdbarch)
153 return gdbarch_data (gdbarch, regcache_descr_handle);
156 /* Utility functions returning useful register attributes stored in
157 the regcache descr. */
160 register_type (struct gdbarch *gdbarch, int regnum)
162 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);
177 gdb_assert (regnum >= 0
178 && regnum < (gdbarch_num_regs (gdbarch)
179 + gdbarch_num_pseudo_regs (gdbarch)));
180 size = descr->sizeof_register[regnum];
184 /* The register cache for storing raw register values. */
188 struct regcache_descr *descr;
190 /* The address space of this register cache (for registers where it
191 makes sense, like PC or SP). */
192 struct address_space *aspace;
194 /* The register buffers. A read-only register cache can hold the
195 full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
196 register cache can only hold [0 .. gdbarch_num_regs). */
198 /* Register cache status. */
199 signed char *register_status;
200 /* Is this a read-only cache? A read-only cache is used for saving
201 the target's register state (e.g, across an inferior function
202 call or just before forcing a function return). A read-only
203 cache can only be updated via the methods regcache_dup() and
204 regcache_cpy(). The actual contents are determined by the
205 reggroup_save and reggroup_restore methods. */
207 /* If this is a read-write cache, which thread's registers is
212 static struct regcache *
213 regcache_xmalloc_1 (struct gdbarch *gdbarch, struct address_space *aspace,
216 struct regcache_descr *descr;
217 struct regcache *regcache;
219 gdb_assert (gdbarch != NULL);
220 descr = regcache_descr (gdbarch);
221 regcache = XMALLOC (struct regcache);
222 regcache->descr = descr;
223 regcache->readonly_p = readonly_p;
227 = XCALLOC (descr->sizeof_cooked_registers, gdb_byte);
228 regcache->register_status
229 = XCALLOC (descr->sizeof_cooked_register_status, gdb_byte);
234 = XCALLOC (descr->sizeof_raw_registers, gdb_byte);
235 regcache->register_status
236 = XCALLOC (descr->sizeof_raw_register_status, gdb_byte);
238 regcache->aspace = aspace;
239 regcache->ptid = minus_one_ptid;
244 regcache_xmalloc (struct gdbarch *gdbarch, struct address_space *aspace)
246 return regcache_xmalloc_1 (gdbarch, aspace, 1);
250 regcache_xfree (struct regcache *regcache)
252 if (regcache == NULL)
254 xfree (regcache->registers);
255 xfree (regcache->register_status);
260 do_regcache_xfree (void *data)
262 regcache_xfree (data);
266 make_cleanup_regcache_xfree (struct regcache *regcache)
268 return make_cleanup (do_regcache_xfree, regcache);
271 /* Return REGCACHE's architecture. */
274 get_regcache_arch (const struct regcache *regcache)
276 return regcache->descr->gdbarch;
279 struct address_space *
280 get_regcache_aspace (const struct regcache *regcache)
282 return regcache->aspace;
285 /* Return a pointer to register REGNUM's buffer cache. */
288 register_buffer (const struct regcache *regcache, int regnum)
290 return regcache->registers + regcache->descr->register_offset[regnum];
294 regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
297 struct gdbarch *gdbarch = dst->descr->gdbarch;
298 gdb_byte buf[MAX_REGISTER_SIZE];
301 /* The DST should be `read-only', if it wasn't then the save would
302 end up trying to write the register values back out to the
304 gdb_assert (dst->readonly_p);
305 /* Clear the dest. */
306 memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
307 memset (dst->register_status, 0,
308 dst->descr->sizeof_cooked_register_status);
309 /* Copy over any registers (identified by their membership in the
310 save_reggroup) and mark them as valid. 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, save_reggroup))
317 enum register_status status = cooked_read (src, regnum, buf);
319 if (status == REG_VALID)
320 memcpy (register_buffer (dst, regnum), buf,
321 register_size (gdbarch, regnum));
324 gdb_assert (status != REG_UNKNOWN);
326 memset (register_buffer (dst, regnum), 0,
327 register_size (gdbarch, regnum));
329 dst->register_status[regnum] = status;
335 regcache_restore (struct regcache *dst,
336 regcache_cooked_read_ftype *cooked_read,
337 void *cooked_read_context)
339 struct gdbarch *gdbarch = dst->descr->gdbarch;
340 gdb_byte buf[MAX_REGISTER_SIZE];
343 /* The dst had better not be read-only. If it is, the `restore'
344 doesn't make much sense. */
345 gdb_assert (!dst->readonly_p);
346 /* Copy over any registers, being careful to only restore those that
347 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
348 + gdbarch_num_pseudo_regs) range is checked since some architectures need
349 to save/restore `cooked' registers that live in memory. */
350 for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
352 if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
354 enum register_status status;
356 status = cooked_read (cooked_read_context, regnum, buf);
357 if (status == REG_VALID)
358 regcache_cooked_write (dst, regnum, buf);
363 static enum register_status
364 do_cooked_read (void *src, int regnum, gdb_byte *buf)
366 struct regcache *regcache = src;
368 return regcache_cooked_read (regcache, regnum, buf);
372 regcache_cpy (struct regcache *dst, struct regcache *src)
374 gdb_assert (src != NULL && dst != NULL);
375 gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
376 gdb_assert (src != dst);
377 gdb_assert (src->readonly_p || dst->readonly_p);
379 if (!src->readonly_p)
380 regcache_save (dst, do_cooked_read, src);
381 else if (!dst->readonly_p)
382 regcache_restore (dst, do_cooked_read, src);
384 regcache_cpy_no_passthrough (dst, src);
388 regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
390 gdb_assert (src != NULL && dst != NULL);
391 gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
392 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
393 move of data into a thread's regcache. Doing this would be silly
394 - it would mean that regcache->register_status would be
395 completely invalid. */
396 gdb_assert (dst->readonly_p && src->readonly_p);
398 memcpy (dst->registers, src->registers,
399 dst->descr->sizeof_cooked_registers);
400 memcpy (dst->register_status, src->register_status,
401 dst->descr->sizeof_cooked_register_status);
405 regcache_dup (struct regcache *src)
407 struct regcache *newbuf;
409 newbuf = regcache_xmalloc (src->descr->gdbarch, get_regcache_aspace (src));
410 regcache_cpy (newbuf, src);
415 regcache_register_status (const struct regcache *regcache, int regnum)
417 gdb_assert (regcache != NULL);
418 gdb_assert (regnum >= 0);
419 if (regcache->readonly_p)
420 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
422 gdb_assert (regnum < regcache->descr->nr_raw_registers);
424 return regcache->register_status[regnum];
428 regcache_invalidate (struct regcache *regcache, int regnum)
430 gdb_assert (regcache != NULL);
431 gdb_assert (regnum >= 0);
432 gdb_assert (!regcache->readonly_p);
433 gdb_assert (regnum < regcache->descr->nr_raw_registers);
434 regcache->register_status[regnum] = REG_UNKNOWN;
438 /* Global structure containing the current regcache. */
440 /* NOTE: this is a write-through cache. There is no "dirty" bit for
441 recording if the register values have been changed (eg. by the
442 user). Therefore all registers must be written back to the
443 target when appropriate. */
447 struct regcache *regcache;
448 struct regcache_list *next;
451 static struct regcache_list *current_regcache;
454 get_thread_arch_aspace_regcache (ptid_t ptid, struct gdbarch *gdbarch,
455 struct address_space *aspace)
457 struct regcache_list *list;
458 struct regcache *new_regcache;
460 for (list = current_regcache; list; list = list->next)
461 if (ptid_equal (list->regcache->ptid, ptid)
462 && get_regcache_arch (list->regcache) == gdbarch)
463 return list->regcache;
465 new_regcache = regcache_xmalloc_1 (gdbarch, aspace, 0);
466 new_regcache->ptid = ptid;
468 list = xmalloc (sizeof (struct regcache_list));
469 list->regcache = new_regcache;
470 list->next = current_regcache;
471 current_regcache = list;
477 get_thread_arch_regcache (ptid_t ptid, struct gdbarch *gdbarch)
479 struct address_space *aspace;
481 /* For the benefit of "maint print registers" & co when debugging an
482 executable, allow dumping the regcache even when there is no
483 thread selected (target_thread_address_space internal-errors if
484 no address space is found). Note that normal user commands will
485 fail higher up on the call stack due to no
486 target_has_registers. */
487 aspace = (ptid_equal (null_ptid, ptid)
489 : target_thread_address_space (ptid));
491 return get_thread_arch_aspace_regcache (ptid, gdbarch, aspace);
494 static ptid_t current_thread_ptid;
495 static struct gdbarch *current_thread_arch;
498 get_thread_regcache (ptid_t ptid)
500 if (!current_thread_arch || !ptid_equal (current_thread_ptid, ptid))
502 current_thread_ptid = ptid;
503 current_thread_arch = target_thread_architecture (ptid);
506 return get_thread_arch_regcache (ptid, current_thread_arch);
510 get_current_regcache (void)
512 return get_thread_regcache (inferior_ptid);
516 /* Observer for the target_changed event. */
519 regcache_observer_target_changed (struct target_ops *target)
521 registers_changed ();
524 /* Update global variables old ptids to hold NEW_PTID if they were
527 regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
529 struct regcache_list *list;
531 for (list = current_regcache; list; list = list->next)
532 if (ptid_equal (list->regcache->ptid, old_ptid))
533 list->regcache->ptid = new_ptid;
536 /* Low level examining and depositing of registers.
538 The caller is responsible for making sure that the inferior is
539 stopped before calling the fetching routines, or it will get
540 garbage. (a change from GDB version 3, in which the caller got the
541 value from the last stop). */
543 /* REGISTERS_CHANGED ()
545 Indicate that registers may have changed, so invalidate the cache. */
548 registers_changed_ptid (ptid_t ptid)
550 struct regcache_list *list, **list_link;
551 int wildcard = ptid_equal (ptid, minus_one_ptid);
553 list = current_regcache;
554 list_link = ¤t_regcache;
557 if (ptid_match (list->regcache->ptid, ptid))
559 struct regcache_list *dead = list;
561 *list_link = list->next;
562 regcache_xfree (list->regcache);
568 list_link = &list->next;
572 if (wildcard || ptid_equal (ptid, current_thread_ptid))
574 current_thread_ptid = null_ptid;
575 current_thread_arch = NULL;
578 if (wildcard || ptid_equal (ptid, inferior_ptid))
580 /* We just deleted the regcache of the current thread. Need to
581 forget about any frames we have cached, too. */
582 reinit_frame_cache ();
587 registers_changed (void)
589 registers_changed_ptid (minus_one_ptid);
591 /* Force cleanup of any alloca areas if using C alloca instead of
592 a builtin alloca. This particular call is used to clean up
593 areas allocated by low level target code which may build up
594 during lengthy interactions between gdb and the target before
595 gdb gives control to the user (ie watchpoints). */
600 regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
602 gdb_assert (regcache != NULL && buf != NULL);
603 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
604 /* Make certain that the register cache is up-to-date with respect
605 to the current thread. This switching shouldn't be necessary
606 only there is still only one target side register cache. Sigh!
607 On the bright side, at least there is a regcache object. */
608 if (!regcache->readonly_p
609 && regcache_register_status (regcache, regnum) == REG_UNKNOWN)
611 struct cleanup *old_chain = save_inferior_ptid ();
613 inferior_ptid = regcache->ptid;
614 target_fetch_registers (regcache, regnum);
615 do_cleanups (old_chain);
617 /* A number of targets can't access the whole set of raw
618 registers (because the debug API provides no means to get at
620 if (regcache->register_status[regnum] == REG_UNKNOWN)
621 regcache->register_status[regnum] = REG_UNAVAILABLE;
624 if (regcache->register_status[regnum] != REG_VALID)
625 memset (buf, 0, regcache->descr->sizeof_register[regnum]);
627 memcpy (buf, register_buffer (regcache, regnum),
628 regcache->descr->sizeof_register[regnum]);
630 return regcache->register_status[regnum];
634 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
637 enum register_status status;
639 gdb_assert (regcache != NULL);
640 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
641 buf = alloca (regcache->descr->sizeof_register[regnum]);
642 status = regcache_raw_read (regcache, regnum, buf);
643 if (status == REG_VALID)
644 *val = extract_signed_integer
645 (buf, regcache->descr->sizeof_register[regnum],
646 gdbarch_byte_order (regcache->descr->gdbarch));
653 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
657 enum register_status status;
659 gdb_assert (regcache != NULL);
660 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
661 buf = alloca (regcache->descr->sizeof_register[regnum]);
662 status = regcache_raw_read (regcache, regnum, buf);
663 if (status == REG_VALID)
664 *val = extract_unsigned_integer
665 (buf, regcache->descr->sizeof_register[regnum],
666 gdbarch_byte_order (regcache->descr->gdbarch));
673 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
677 gdb_assert (regcache != NULL);
678 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
679 buf = alloca (regcache->descr->sizeof_register[regnum]);
680 store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
681 gdbarch_byte_order (regcache->descr->gdbarch), val);
682 regcache_raw_write (regcache, regnum, buf);
686 regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
691 gdb_assert (regcache != NULL);
692 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
693 buf = alloca (regcache->descr->sizeof_register[regnum]);
694 store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
695 gdbarch_byte_order (regcache->descr->gdbarch), val);
696 regcache_raw_write (regcache, regnum, buf);
700 regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
702 gdb_assert (regnum >= 0);
703 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
704 if (regnum < regcache->descr->nr_raw_registers)
705 return regcache_raw_read (regcache, regnum, buf);
706 else if (regcache->readonly_p
707 && regcache->register_status[regnum] != REG_UNKNOWN)
709 /* Read-only register cache, perhaps the cooked value was
711 struct gdbarch *gdbarch = regcache->descr->gdbarch;
713 if (regcache->register_status[regnum] == REG_VALID)
714 memcpy (buf, register_buffer (regcache, regnum),
715 regcache->descr->sizeof_register[regnum]);
717 memset (buf, 0, regcache->descr->sizeof_register[regnum]);
719 return regcache->register_status[regnum];
721 else if (gdbarch_pseudo_register_read_value_p (regcache->descr->gdbarch))
723 struct value *mark, *computed;
724 enum register_status result = REG_VALID;
726 mark = value_mark ();
728 computed = gdbarch_pseudo_register_read_value (regcache->descr->gdbarch,
730 if (value_entirely_available (computed))
731 memcpy (buf, value_contents_raw (computed),
732 regcache->descr->sizeof_register[regnum]);
735 memset (buf, 0, regcache->descr->sizeof_register[regnum]);
736 result = REG_UNAVAILABLE;
739 value_free_to_mark (mark);
744 return gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
749 regcache_cooked_read_value (struct regcache *regcache, int regnum)
751 gdb_assert (regnum >= 0);
752 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
754 if (regnum < regcache->descr->nr_raw_registers
755 || (regcache->readonly_p
756 && regcache->register_status[regnum] != REG_UNKNOWN)
757 || !gdbarch_pseudo_register_read_value_p (regcache->descr->gdbarch))
759 struct value *result;
761 result = allocate_value (register_type (regcache->descr->gdbarch,
763 VALUE_LVAL (result) = lval_register;
764 VALUE_REGNUM (result) = regnum;
766 /* It is more efficient in general to do this delegation in this
767 direction than in the other one, even though the value-based
769 if (regcache_cooked_read (regcache, regnum,
770 value_contents_raw (result)) == REG_UNAVAILABLE)
771 mark_value_bytes_unavailable (result, 0,
772 TYPE_LENGTH (value_type (result)));
777 return gdbarch_pseudo_register_read_value (regcache->descr->gdbarch,
782 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
785 enum register_status status;
788 gdb_assert (regcache != NULL);
789 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
790 buf = alloca (regcache->descr->sizeof_register[regnum]);
791 status = regcache_cooked_read (regcache, regnum, buf);
792 if (status == REG_VALID)
793 *val = extract_signed_integer
794 (buf, regcache->descr->sizeof_register[regnum],
795 gdbarch_byte_order (regcache->descr->gdbarch));
802 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
805 enum register_status status;
808 gdb_assert (regcache != NULL);
809 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
810 buf = alloca (regcache->descr->sizeof_register[regnum]);
811 status = regcache_cooked_read (regcache, regnum, buf);
812 if (status == REG_VALID)
813 *val = extract_unsigned_integer
814 (buf, regcache->descr->sizeof_register[regnum],
815 gdbarch_byte_order (regcache->descr->gdbarch));
822 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
827 gdb_assert (regcache != NULL);
828 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
829 buf = alloca (regcache->descr->sizeof_register[regnum]);
830 store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
831 gdbarch_byte_order (regcache->descr->gdbarch), val);
832 regcache_cooked_write (regcache, regnum, buf);
836 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
841 gdb_assert (regcache != NULL);
842 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
843 buf = alloca (regcache->descr->sizeof_register[regnum]);
844 store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
845 gdbarch_byte_order (regcache->descr->gdbarch), val);
846 regcache_cooked_write (regcache, regnum, buf);
850 regcache_raw_write (struct regcache *regcache, int regnum,
853 struct cleanup *old_chain;
855 gdb_assert (regcache != NULL && buf != NULL);
856 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
857 gdb_assert (!regcache->readonly_p);
859 /* On the sparc, writing %g0 is a no-op, so we don't even want to
860 change the registers array if something writes to this register. */
861 if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
864 /* If we have a valid copy of the register, and new value == old
865 value, then don't bother doing the actual store. */
866 if (regcache_register_status (regcache, regnum) == REG_VALID
867 && (memcmp (register_buffer (regcache, regnum), buf,
868 regcache->descr->sizeof_register[regnum]) == 0))
871 old_chain = save_inferior_ptid ();
872 inferior_ptid = regcache->ptid;
874 target_prepare_to_store (regcache);
875 memcpy (register_buffer (regcache, regnum), buf,
876 regcache->descr->sizeof_register[regnum]);
877 regcache->register_status[regnum] = REG_VALID;
878 target_store_registers (regcache, regnum);
880 do_cleanups (old_chain);
884 regcache_cooked_write (struct regcache *regcache, int regnum,
887 gdb_assert (regnum >= 0);
888 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
889 if (regnum < regcache->descr->nr_raw_registers)
890 regcache_raw_write (regcache, regnum, buf);
892 gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
896 /* Perform a partial register transfer using a read, modify, write
899 typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
901 typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
904 static enum register_status
905 regcache_xfer_part (struct regcache *regcache, int regnum,
906 int offset, int len, void *in, const void *out,
907 enum register_status (*read) (struct regcache *regcache,
910 void (*write) (struct regcache *regcache, int regnum,
911 const gdb_byte *buf))
913 struct regcache_descr *descr = regcache->descr;
914 gdb_byte reg[MAX_REGISTER_SIZE];
916 gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
917 gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
918 /* Something to do? */
919 if (offset + len == 0)
921 /* Read (when needed) ... */
924 || offset + len < descr->sizeof_register[regnum])
926 enum register_status status;
928 gdb_assert (read != NULL);
929 status = read (regcache, regnum, reg);
930 if (status != REG_VALID)
935 memcpy (in, reg + offset, len);
937 memcpy (reg + offset, out, len);
938 /* ... write (when needed). */
941 gdb_assert (write != NULL);
942 write (regcache, regnum, reg);
949 regcache_raw_read_part (struct regcache *regcache, int regnum,
950 int offset, int len, gdb_byte *buf)
952 struct regcache_descr *descr = regcache->descr;
954 gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
955 return regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
956 regcache_raw_read, regcache_raw_write);
960 regcache_raw_write_part (struct regcache *regcache, int regnum,
961 int offset, int len, const gdb_byte *buf)
963 struct regcache_descr *descr = regcache->descr;
965 gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
966 regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
967 regcache_raw_read, regcache_raw_write);
971 regcache_cooked_read_part (struct regcache *regcache, int regnum,
972 int offset, int len, gdb_byte *buf)
974 struct regcache_descr *descr = regcache->descr;
976 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
977 return regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
978 regcache_cooked_read, regcache_cooked_write);
982 regcache_cooked_write_part (struct regcache *regcache, int regnum,
983 int offset, int len, const gdb_byte *buf)
985 struct regcache_descr *descr = regcache->descr;
987 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
988 regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
989 regcache_cooked_read, regcache_cooked_write);
992 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
995 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
1000 gdb_assert (regcache != NULL);
1001 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1002 gdb_assert (!regcache->readonly_p);
1004 regbuf = register_buffer (regcache, regnum);
1005 size = regcache->descr->sizeof_register[regnum];
1009 memcpy (regbuf, buf, size);
1010 regcache->register_status[regnum] = REG_VALID;
1014 /* This memset not strictly necessary, but better than garbage
1015 in case the register value manages to escape somewhere (due
1016 to a bug, no less). */
1017 memset (regbuf, 0, size);
1018 regcache->register_status[regnum] = REG_UNAVAILABLE;
1022 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1025 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
1030 gdb_assert (regcache != NULL && buf != NULL);
1031 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1033 regbuf = register_buffer (regcache, regnum);
1034 size = regcache->descr->sizeof_register[regnum];
1035 memcpy (buf, regbuf, size);
1039 /* Special handling for register PC. */
1042 regcache_read_pc (struct regcache *regcache)
1044 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1048 if (gdbarch_read_pc_p (gdbarch))
1049 pc_val = gdbarch_read_pc (gdbarch, regcache);
1050 /* Else use per-frame method on get_current_frame. */
1051 else if (gdbarch_pc_regnum (gdbarch) >= 0)
1055 if (regcache_cooked_read_unsigned (regcache,
1056 gdbarch_pc_regnum (gdbarch),
1057 &raw_val) == REG_UNAVAILABLE)
1058 throw_error (NOT_AVAILABLE_ERROR, _("PC register is not available"));
1060 pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
1063 internal_error (__FILE__, __LINE__,
1064 _("regcache_read_pc: Unable to find PC"));
1069 regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
1071 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1073 if (gdbarch_write_pc_p (gdbarch))
1074 gdbarch_write_pc (gdbarch, regcache, pc);
1075 else if (gdbarch_pc_regnum (gdbarch) >= 0)
1076 regcache_cooked_write_unsigned (regcache,
1077 gdbarch_pc_regnum (gdbarch), pc);
1079 internal_error (__FILE__, __LINE__,
1080 _("regcache_write_pc: Unable to update PC"));
1082 /* Writing the PC (for instance, from "load") invalidates the
1084 reinit_frame_cache ();
1089 reg_flush_command (char *command, int from_tty)
1091 /* Force-flush the register cache. */
1092 registers_changed ();
1094 printf_filtered (_("Register cache flushed.\n"));
1098 dump_endian_bytes (struct ui_file *file, enum bfd_endian endian,
1099 const unsigned char *buf, long len)
1105 case BFD_ENDIAN_BIG:
1106 for (i = 0; i < len; i++)
1107 fprintf_unfiltered (file, "%02x", buf[i]);
1109 case BFD_ENDIAN_LITTLE:
1110 for (i = len - 1; i >= 0; i--)
1111 fprintf_unfiltered (file, "%02x", buf[i]);
1114 internal_error (__FILE__, __LINE__, _("Bad switch"));
1118 enum regcache_dump_what
1120 regcache_dump_none, regcache_dump_raw,
1121 regcache_dump_cooked, regcache_dump_groups,
1122 regcache_dump_remote
1126 regcache_dump (struct regcache *regcache, struct ui_file *file,
1127 enum regcache_dump_what what_to_dump)
1129 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1130 struct gdbarch *gdbarch = regcache->descr->gdbarch;
1132 int footnote_nr = 0;
1133 int footnote_register_size = 0;
1134 int footnote_register_offset = 0;
1135 int footnote_register_type_name_null = 0;
1136 long register_offset = 0;
1137 unsigned char buf[MAX_REGISTER_SIZE];
1140 fprintf_unfiltered (file, "nr_raw_registers %d\n",
1141 regcache->descr->nr_raw_registers);
1142 fprintf_unfiltered (file, "nr_cooked_registers %d\n",
1143 regcache->descr->nr_cooked_registers);
1144 fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
1145 regcache->descr->sizeof_raw_registers);
1146 fprintf_unfiltered (file, "sizeof_raw_register_status %ld\n",
1147 regcache->descr->sizeof_raw_register_status);
1148 fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
1149 gdbarch_num_regs (gdbarch));
1150 fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
1151 gdbarch_num_pseudo_regs (gdbarch));
1154 gdb_assert (regcache->descr->nr_cooked_registers
1155 == (gdbarch_num_regs (gdbarch)
1156 + gdbarch_num_pseudo_regs (gdbarch)));
1158 for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
1162 fprintf_unfiltered (file, " %-10s", "Name");
1165 const char *p = gdbarch_register_name (gdbarch, regnum);
1169 else if (p[0] == '\0')
1171 fprintf_unfiltered (file, " %-10s", p);
1176 fprintf_unfiltered (file, " %4s", "Nr");
1178 fprintf_unfiltered (file, " %4d", regnum);
1180 /* Relative number. */
1182 fprintf_unfiltered (file, " %4s", "Rel");
1183 else if (regnum < gdbarch_num_regs (gdbarch))
1184 fprintf_unfiltered (file, " %4d", regnum);
1186 fprintf_unfiltered (file, " %4d",
1187 (regnum - gdbarch_num_regs (gdbarch)));
1191 fprintf_unfiltered (file, " %6s ", "Offset");
1194 fprintf_unfiltered (file, " %6ld",
1195 regcache->descr->register_offset[regnum]);
1196 if (register_offset != regcache->descr->register_offset[regnum]
1198 && (regcache->descr->register_offset[regnum]
1199 != (regcache->descr->register_offset[regnum - 1]
1200 + regcache->descr->sizeof_register[regnum - 1])))
1203 if (!footnote_register_offset)
1204 footnote_register_offset = ++footnote_nr;
1205 fprintf_unfiltered (file, "*%d", footnote_register_offset);
1208 fprintf_unfiltered (file, " ");
1209 register_offset = (regcache->descr->register_offset[regnum]
1210 + regcache->descr->sizeof_register[regnum]);
1215 fprintf_unfiltered (file, " %5s ", "Size");
1217 fprintf_unfiltered (file, " %5ld",
1218 regcache->descr->sizeof_register[regnum]);
1228 static const char blt[] = "builtin_type";
1230 t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1235 if (!footnote_register_type_name_null)
1236 footnote_register_type_name_null = ++footnote_nr;
1237 n = xstrprintf ("*%d", footnote_register_type_name_null);
1238 make_cleanup (xfree, n);
1241 /* Chop a leading builtin_type. */
1242 if (strncmp (t, blt, strlen (blt)) == 0)
1245 fprintf_unfiltered (file, " %-15s", t);
1248 /* Leading space always present. */
1249 fprintf_unfiltered (file, " ");
1252 if (what_to_dump == regcache_dump_raw)
1255 fprintf_unfiltered (file, "Raw value");
1256 else if (regnum >= regcache->descr->nr_raw_registers)
1257 fprintf_unfiltered (file, "<cooked>");
1258 else if (regcache_register_status (regcache, regnum) == REG_UNKNOWN)
1259 fprintf_unfiltered (file, "<invalid>");
1260 else if (regcache_register_status (regcache, regnum) == REG_UNAVAILABLE)
1261 fprintf_unfiltered (file, "<unavailable>");
1264 regcache_raw_read (regcache, regnum, buf);
1265 fprintf_unfiltered (file, "0x");
1266 dump_endian_bytes (file,
1267 gdbarch_byte_order (gdbarch), buf,
1268 regcache->descr->sizeof_register[regnum]);
1272 /* Value, cooked. */
1273 if (what_to_dump == regcache_dump_cooked)
1276 fprintf_unfiltered (file, "Cooked value");
1279 enum register_status status;
1281 status = regcache_cooked_read (regcache, regnum, buf);
1282 if (status == REG_UNKNOWN)
1283 fprintf_unfiltered (file, "<invalid>");
1284 else if (status == REG_UNAVAILABLE)
1285 fprintf_unfiltered (file, "<unavailable>");
1288 fprintf_unfiltered (file, "0x");
1289 dump_endian_bytes (file,
1290 gdbarch_byte_order (gdbarch), buf,
1291 regcache->descr->sizeof_register[regnum]);
1296 /* Group members. */
1297 if (what_to_dump == regcache_dump_groups)
1300 fprintf_unfiltered (file, "Groups");
1303 const char *sep = "";
1304 struct reggroup *group;
1306 for (group = reggroup_next (gdbarch, NULL);
1308 group = reggroup_next (gdbarch, group))
1310 if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1312 fprintf_unfiltered (file,
1313 "%s%s", sep, reggroup_name (group));
1320 /* Remote packet configuration. */
1321 if (what_to_dump == regcache_dump_remote)
1325 fprintf_unfiltered (file, "Rmt Nr g/G Offset");
1327 else if (regnum < regcache->descr->nr_raw_registers)
1331 if (remote_register_number_and_offset (get_regcache_arch (regcache), regnum,
1333 fprintf_unfiltered (file, "%7d %11d", pnum, poffset);
1337 fprintf_unfiltered (file, "\n");
1340 if (footnote_register_size)
1341 fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1342 footnote_register_size);
1343 if (footnote_register_offset)
1344 fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1345 footnote_register_offset);
1346 if (footnote_register_type_name_null)
1347 fprintf_unfiltered (file,
1348 "*%d: Register type's name NULL.\n",
1349 footnote_register_type_name_null);
1350 do_cleanups (cleanups);
1354 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1357 regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
1360 struct cleanup *cleanups;
1361 struct ui_file *file = gdb_fopen (args, "w");
1364 perror_with_name (_("maintenance print architecture"));
1365 cleanups = make_cleanup_ui_file_delete (file);
1366 regcache_dump (get_current_regcache (), file, what_to_dump);
1367 do_cleanups (cleanups);
1372 maintenance_print_registers (char *args, int from_tty)
1374 regcache_print (args, regcache_dump_none);
1378 maintenance_print_raw_registers (char *args, int from_tty)
1380 regcache_print (args, regcache_dump_raw);
1384 maintenance_print_cooked_registers (char *args, int from_tty)
1386 regcache_print (args, regcache_dump_cooked);
1390 maintenance_print_register_groups (char *args, int from_tty)
1392 regcache_print (args, regcache_dump_groups);
1396 maintenance_print_remote_registers (char *args, int from_tty)
1398 regcache_print (args, regcache_dump_remote);
1401 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1404 _initialize_regcache (void)
1406 regcache_descr_handle
1407 = gdbarch_data_register_post_init (init_regcache_descr);
1409 observer_attach_target_changed (regcache_observer_target_changed);
1410 observer_attach_thread_ptid_changed (regcache_thread_ptid_changed);
1412 add_com ("flushregs", class_maintenance, reg_flush_command,
1413 _("Force gdb to flush its register cache (maintainer command)"));
1415 add_cmd ("registers", class_maintenance, maintenance_print_registers,
1416 _("Print the internal register configuration.\n"
1417 "Takes an optional file parameter."), &maintenanceprintlist);
1418 add_cmd ("raw-registers", class_maintenance,
1419 maintenance_print_raw_registers,
1420 _("Print the internal register configuration "
1421 "including raw values.\n"
1422 "Takes an optional file parameter."), &maintenanceprintlist);
1423 add_cmd ("cooked-registers", class_maintenance,
1424 maintenance_print_cooked_registers,
1425 _("Print the internal register configuration "
1426 "including cooked values.\n"
1427 "Takes an optional file parameter."), &maintenanceprintlist);
1428 add_cmd ("register-groups", class_maintenance,
1429 maintenance_print_register_groups,
1430 _("Print the internal register configuration "
1431 "including each register's group.\n"
1432 "Takes an optional file parameter."),
1433 &maintenanceprintlist);
1434 add_cmd ("remote-registers", class_maintenance,
1435 maintenance_print_remote_registers, _("\
1436 Print the internal register configuration including each register's\n\
1437 remote register number and buffer offset in the g/G packets.\n\
1438 Takes an optional file parameter."),
1439 &maintenanceprintlist);