1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "reggroups.h"
35 * Here is the actual register cache.
38 /* Per-architecture object describing the layout of a register cache.
39 Computed once when the architecture is created. */
41 struct gdbarch_data *regcache_descr_handle;
45 /* The architecture this descriptor belongs to. */
46 struct gdbarch *gdbarch;
48 /* The raw register cache. Each raw (or hard) register is supplied
49 by the target interface. The raw cache should not contain
50 redundant information - if the PC is constructed from two
51 registers then those registers and not the PC lives in the raw
54 long sizeof_raw_registers;
55 long sizeof_raw_register_status;
57 /* The cooked register space. Each cooked register in the range
58 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
59 register. The remaining [NR_RAW_REGISTERS
60 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
61 both raw registers and memory by the architecture methods
62 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
63 int nr_cooked_registers;
64 long sizeof_cooked_registers;
65 long sizeof_cooked_register_status;
67 /* Offset and size (in 8 bit bytes), of each register in the
68 register cache. All registers (including those in the range
69 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
71 long *register_offset;
72 long *sizeof_register;
74 /* Cached table containing the type of each register. */
75 struct type **register_type;
79 init_regcache_descr (struct gdbarch *gdbarch)
82 struct regcache_descr *descr;
83 gdb_assert (gdbarch != NULL);
85 /* Create an initial, zero filled, table. */
86 descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr);
87 descr->gdbarch = gdbarch;
89 /* Total size of the register space. The raw registers are mapped
90 directly onto the raw register cache while the pseudo's are
91 either mapped onto raw-registers or memory. */
92 descr->nr_cooked_registers = gdbarch_num_regs (gdbarch)
93 + gdbarch_num_pseudo_regs (gdbarch);
94 descr->sizeof_cooked_register_status
95 = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
97 /* Fill in a table of register types. */
99 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers,
101 for (i = 0; i < descr->nr_cooked_registers; i++)
102 descr->register_type[i] = gdbarch_register_type (gdbarch, i);
104 /* Construct a strictly RAW register cache. Don't allow pseudo's
105 into the register cache. */
106 descr->nr_raw_registers = gdbarch_num_regs (gdbarch);
107 descr->sizeof_raw_register_status = gdbarch_num_regs (gdbarch);
109 /* Lay out the register cache.
111 NOTE: cagney/2002-05-22: Only register_type() is used when
112 constructing the register cache. It is assumed that the
113 register's raw size, virtual size and type length are all the
119 descr->sizeof_register
120 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
121 descr->register_offset
122 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
123 for (i = 0; i < descr->nr_raw_registers; i++)
125 descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
126 descr->register_offset[i] = offset;
127 offset += descr->sizeof_register[i];
128 gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
130 /* Set the real size of the raw register cache buffer. */
131 descr->sizeof_raw_registers = offset;
133 for (; i < descr->nr_cooked_registers; i++)
135 descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
136 descr->register_offset[i] = offset;
137 offset += descr->sizeof_register[i];
138 gdb_assert (MAX_REGISTER_SIZE >= descr->sizeof_register[i]);
140 /* Set the real size of the readonly register cache buffer. */
141 descr->sizeof_cooked_registers = offset;
147 static struct regcache_descr *
148 regcache_descr (struct gdbarch *gdbarch)
150 return (struct regcache_descr *) gdbarch_data (gdbarch,
151 regcache_descr_handle);
154 /* Utility functions returning useful register attributes stored in
155 the regcache descr. */
158 register_type (struct gdbarch *gdbarch, int regnum)
160 struct regcache_descr *descr = regcache_descr (gdbarch);
162 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
163 return descr->register_type[regnum];
166 /* Utility functions returning useful register attributes stored in
167 the regcache descr. */
170 register_size (struct gdbarch *gdbarch, int regnum)
172 struct regcache_descr *descr = regcache_descr (gdbarch);
175 gdb_assert (regnum >= 0
176 && regnum < (gdbarch_num_regs (gdbarch)
177 + gdbarch_num_pseudo_regs (gdbarch)));
178 size = descr->sizeof_register[regnum];
182 /* See common/common-regcache.h. */
185 regcache_register_size (const struct regcache *regcache, int n)
187 return register_size (get_regcache_arch (regcache), n);
190 /* The register cache for storing raw register values. */
194 struct regcache_descr *descr;
196 /* The address space of this register cache (for registers where it
197 makes sense, like PC or SP). */
198 struct address_space *aspace;
200 /* The register buffers. A read-only register cache can hold the
201 full [0 .. gdbarch_num_regs + gdbarch_num_pseudo_regs) while a read/write
202 register cache can only hold [0 .. gdbarch_num_regs). */
204 /* Register cache status. */
205 signed char *register_status;
206 /* Is this a read-only cache? A read-only cache is used for saving
207 the target's register state (e.g, across an inferior function
208 call or just before forcing a function return). A read-only
209 cache can only be updated via the methods regcache_dup() and
210 regcache_cpy(). The actual contents are determined by the
211 reggroup_save and reggroup_restore methods. */
213 /* If this is a read-write cache, which thread's registers is
218 /* See regcache.h. */
221 regcache_get_ptid (const struct regcache *regcache)
223 gdb_assert (!ptid_equal (regcache->ptid, minus_one_ptid));
225 return regcache->ptid;
228 static struct regcache *
229 regcache_xmalloc_1 (struct gdbarch *gdbarch, struct address_space *aspace,
232 struct regcache_descr *descr;
233 struct regcache *regcache;
235 gdb_assert (gdbarch != NULL);
236 descr = regcache_descr (gdbarch);
237 regcache = XNEW (struct regcache);
238 regcache->descr = descr;
239 regcache->readonly_p = readonly_p;
243 = XCNEWVEC (gdb_byte, descr->sizeof_cooked_registers);
244 regcache->register_status
245 = XCNEWVEC (signed char, descr->sizeof_cooked_register_status);
250 = XCNEWVEC (gdb_byte, descr->sizeof_raw_registers);
251 regcache->register_status
252 = XCNEWVEC (signed char, descr->sizeof_raw_register_status);
254 regcache->aspace = aspace;
255 regcache->ptid = minus_one_ptid;
260 regcache_xmalloc (struct gdbarch *gdbarch, struct address_space *aspace)
262 return regcache_xmalloc_1 (gdbarch, aspace, 1);
266 regcache_xfree (struct regcache *regcache)
268 if (regcache == NULL)
270 xfree (regcache->registers);
271 xfree (regcache->register_status);
276 do_regcache_xfree (void *data)
278 regcache_xfree ((struct regcache *) data);
282 make_cleanup_regcache_xfree (struct regcache *regcache)
284 return make_cleanup (do_regcache_xfree, regcache);
287 /* Cleanup routines for invalidating a register. */
289 struct register_to_invalidate
291 struct regcache *regcache;
296 do_regcache_invalidate (void *data)
298 struct register_to_invalidate *reg = (struct register_to_invalidate *) data;
300 regcache_invalidate (reg->regcache, reg->regnum);
303 static struct cleanup *
304 make_cleanup_regcache_invalidate (struct regcache *regcache, int regnum)
306 struct register_to_invalidate* reg = XNEW (struct register_to_invalidate);
308 reg->regcache = regcache;
309 reg->regnum = regnum;
310 return make_cleanup_dtor (do_regcache_invalidate, (void *) reg, xfree);
313 /* Return REGCACHE's architecture. */
316 get_regcache_arch (const struct regcache *regcache)
318 return regcache->descr->gdbarch;
321 struct address_space *
322 get_regcache_aspace (const struct regcache *regcache)
324 return regcache->aspace;
327 /* Return a pointer to register REGNUM's buffer cache. */
330 register_buffer (const struct regcache *regcache, int regnum)
332 return regcache->registers + regcache->descr->register_offset[regnum];
336 regcache_save (struct regcache *dst, regcache_cooked_read_ftype *cooked_read,
339 struct gdbarch *gdbarch = dst->descr->gdbarch;
340 gdb_byte buf[MAX_REGISTER_SIZE];
343 /* The DST should be `read-only', if it wasn't then the save would
344 end up trying to write the register values back out to the
346 gdb_assert (dst->readonly_p);
347 /* Clear the dest. */
348 memset (dst->registers, 0, dst->descr->sizeof_cooked_registers);
349 memset (dst->register_status, 0,
350 dst->descr->sizeof_cooked_register_status);
351 /* Copy over any registers (identified by their membership in the
352 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
353 gdbarch_num_pseudo_regs) range is checked since some architectures need
354 to save/restore `cooked' registers that live in memory. */
355 for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
357 if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
359 enum register_status status = cooked_read (src, regnum, buf);
361 if (status == REG_VALID)
362 memcpy (register_buffer (dst, regnum), buf,
363 register_size (gdbarch, regnum));
366 gdb_assert (status != REG_UNKNOWN);
368 memset (register_buffer (dst, regnum), 0,
369 register_size (gdbarch, regnum));
371 dst->register_status[regnum] = status;
377 regcache_restore (struct regcache *dst,
378 regcache_cooked_read_ftype *cooked_read,
379 void *cooked_read_context)
381 struct gdbarch *gdbarch = dst->descr->gdbarch;
382 gdb_byte buf[MAX_REGISTER_SIZE];
385 /* The dst had better not be read-only. If it is, the `restore'
386 doesn't make much sense. */
387 gdb_assert (!dst->readonly_p);
388 /* Copy over any registers, being careful to only restore those that
389 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
390 + gdbarch_num_pseudo_regs) range is checked since some architectures need
391 to save/restore `cooked' registers that live in memory. */
392 for (regnum = 0; regnum < dst->descr->nr_cooked_registers; regnum++)
394 if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
396 enum register_status status;
398 status = cooked_read (cooked_read_context, regnum, buf);
399 if (status == REG_VALID)
400 regcache_cooked_write (dst, regnum, buf);
405 static enum register_status
406 do_cooked_read (void *src, int regnum, gdb_byte *buf)
408 struct regcache *regcache = (struct regcache *) src;
410 return regcache_cooked_read (regcache, regnum, buf);
413 static void regcache_cpy_no_passthrough (struct regcache *dst,
414 struct regcache *src);
417 regcache_cpy (struct regcache *dst, struct regcache *src)
419 gdb_assert (src != NULL && dst != NULL);
420 gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
421 gdb_assert (src != dst);
422 gdb_assert (src->readonly_p || dst->readonly_p);
424 if (!src->readonly_p)
425 regcache_save (dst, do_cooked_read, src);
426 else if (!dst->readonly_p)
427 regcache_restore (dst, do_cooked_read, src);
429 regcache_cpy_no_passthrough (dst, src);
432 /* Copy/duplicate the contents of a register cache. Unlike regcache_cpy,
433 which is pass-through, this does not go through to the target.
434 Only values values already in the cache are transferred. The SRC and DST
435 buffers must not overlap. */
438 regcache_cpy_no_passthrough (struct regcache *dst, struct regcache *src)
440 gdb_assert (src != NULL && dst != NULL);
441 gdb_assert (src->descr->gdbarch == dst->descr->gdbarch);
442 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
443 move of data into a thread's regcache. Doing this would be silly
444 - it would mean that regcache->register_status would be
445 completely invalid. */
446 gdb_assert (dst->readonly_p && src->readonly_p);
448 memcpy (dst->registers, src->registers,
449 dst->descr->sizeof_cooked_registers);
450 memcpy (dst->register_status, src->register_status,
451 dst->descr->sizeof_cooked_register_status);
455 regcache_dup (struct regcache *src)
457 struct regcache *newbuf;
459 newbuf = regcache_xmalloc (src->descr->gdbarch, get_regcache_aspace (src));
460 regcache_cpy (newbuf, src);
465 regcache_register_status (const struct regcache *regcache, int regnum)
467 gdb_assert (regcache != NULL);
468 gdb_assert (regnum >= 0);
469 if (regcache->readonly_p)
470 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
472 gdb_assert (regnum < regcache->descr->nr_raw_registers);
474 return (enum register_status) regcache->register_status[regnum];
478 regcache_invalidate (struct regcache *regcache, int regnum)
480 gdb_assert (regcache != NULL);
481 gdb_assert (regnum >= 0);
482 gdb_assert (!regcache->readonly_p);
483 gdb_assert (regnum < regcache->descr->nr_raw_registers);
484 regcache->register_status[regnum] = REG_UNKNOWN;
488 /* Global structure containing the current regcache. */
490 /* NOTE: this is a write-through cache. There is no "dirty" bit for
491 recording if the register values have been changed (eg. by the
492 user). Therefore all registers must be written back to the
493 target when appropriate. */
497 struct regcache *regcache;
498 struct regcache_list *next;
501 static struct regcache_list *current_regcache;
504 get_thread_arch_aspace_regcache (ptid_t ptid, struct gdbarch *gdbarch,
505 struct address_space *aspace)
507 struct regcache_list *list;
508 struct regcache *new_regcache;
510 for (list = current_regcache; list; list = list->next)
511 if (ptid_equal (list->regcache->ptid, ptid)
512 && get_regcache_arch (list->regcache) == gdbarch)
513 return list->regcache;
515 new_regcache = regcache_xmalloc_1 (gdbarch, aspace, 0);
516 new_regcache->ptid = ptid;
518 list = XNEW (struct regcache_list);
519 list->regcache = new_regcache;
520 list->next = current_regcache;
521 current_regcache = list;
527 get_thread_arch_regcache (ptid_t ptid, struct gdbarch *gdbarch)
529 struct address_space *aspace;
531 /* For the benefit of "maint print registers" & co when debugging an
532 executable, allow dumping the regcache even when there is no
533 thread selected (target_thread_address_space internal-errors if
534 no address space is found). Note that normal user commands will
535 fail higher up on the call stack due to no
536 target_has_registers. */
537 aspace = (ptid_equal (null_ptid, ptid)
539 : target_thread_address_space (ptid));
541 return get_thread_arch_aspace_regcache (ptid, gdbarch, aspace);
544 static ptid_t current_thread_ptid;
545 static struct gdbarch *current_thread_arch;
548 get_thread_regcache (ptid_t ptid)
550 if (!current_thread_arch || !ptid_equal (current_thread_ptid, ptid))
552 current_thread_ptid = ptid;
553 current_thread_arch = target_thread_architecture (ptid);
556 return get_thread_arch_regcache (ptid, current_thread_arch);
560 get_current_regcache (void)
562 return get_thread_regcache (inferior_ptid);
565 /* See common/common-regcache.h. */
568 get_thread_regcache_for_ptid (ptid_t ptid)
570 return get_thread_regcache (ptid);
573 /* Observer for the target_changed event. */
576 regcache_observer_target_changed (struct target_ops *target)
578 registers_changed ();
581 /* Update global variables old ptids to hold NEW_PTID if they were
584 regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
586 struct regcache_list *list;
588 for (list = current_regcache; list; list = list->next)
589 if (ptid_equal (list->regcache->ptid, old_ptid))
590 list->regcache->ptid = new_ptid;
593 /* Low level examining and depositing of registers.
595 The caller is responsible for making sure that the inferior is
596 stopped before calling the fetching routines, or it will get
597 garbage. (a change from GDB version 3, in which the caller got the
598 value from the last stop). */
600 /* REGISTERS_CHANGED ()
602 Indicate that registers may have changed, so invalidate the cache. */
605 registers_changed_ptid (ptid_t ptid)
607 struct regcache_list *list, **list_link;
609 list = current_regcache;
610 list_link = ¤t_regcache;
613 if (ptid_match (list->regcache->ptid, ptid))
615 struct regcache_list *dead = list;
617 *list_link = list->next;
618 regcache_xfree (list->regcache);
624 list_link = &list->next;
628 if (ptid_match (current_thread_ptid, ptid))
630 current_thread_ptid = null_ptid;
631 current_thread_arch = NULL;
634 if (ptid_match (inferior_ptid, ptid))
636 /* We just deleted the regcache of the current thread. Need to
637 forget about any frames we have cached, too. */
638 reinit_frame_cache ();
643 registers_changed (void)
645 registers_changed_ptid (minus_one_ptid);
647 /* Force cleanup of any alloca areas if using C alloca instead of
648 a builtin alloca. This particular call is used to clean up
649 areas allocated by low level target code which may build up
650 during lengthy interactions between gdb and the target before
651 gdb gives control to the user (ie watchpoints). */
656 regcache_raw_update (struct regcache *regcache, int regnum)
658 gdb_assert (regcache != NULL);
659 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
661 /* Make certain that the register cache is up-to-date with respect
662 to the current thread. This switching shouldn't be necessary
663 only there is still only one target side register cache. Sigh!
664 On the bright side, at least there is a regcache object. */
666 if (!regcache->readonly_p
667 && regcache_register_status (regcache, regnum) == REG_UNKNOWN)
669 struct cleanup *old_chain = save_inferior_ptid ();
671 inferior_ptid = regcache->ptid;
672 target_fetch_registers (regcache, regnum);
673 do_cleanups (old_chain);
675 /* A number of targets can't access the whole set of raw
676 registers (because the debug API provides no means to get at
678 if (regcache->register_status[regnum] == REG_UNKNOWN)
679 regcache->register_status[regnum] = REG_UNAVAILABLE;
684 regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
686 gdb_assert (buf != NULL);
687 regcache_raw_update (regcache, regnum);
689 if (regcache->register_status[regnum] != REG_VALID)
690 memset (buf, 0, regcache->descr->sizeof_register[regnum]);
692 memcpy (buf, register_buffer (regcache, regnum),
693 regcache->descr->sizeof_register[regnum]);
695 return (enum register_status) regcache->register_status[regnum];
699 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
702 enum register_status status;
704 gdb_assert (regcache != NULL);
705 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
706 buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
707 status = regcache_raw_read (regcache, regnum, buf);
708 if (status == REG_VALID)
709 *val = extract_signed_integer
710 (buf, regcache->descr->sizeof_register[regnum],
711 gdbarch_byte_order (regcache->descr->gdbarch));
718 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
722 enum register_status status;
724 gdb_assert (regcache != NULL);
725 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
726 buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
727 status = regcache_raw_read (regcache, regnum, buf);
728 if (status == REG_VALID)
729 *val = extract_unsigned_integer
730 (buf, regcache->descr->sizeof_register[regnum],
731 gdbarch_byte_order (regcache->descr->gdbarch));
738 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
742 gdb_assert (regcache != NULL);
743 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
744 buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
745 store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
746 gdbarch_byte_order (regcache->descr->gdbarch), val);
747 regcache_raw_write (regcache, regnum, buf);
751 regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
756 gdb_assert (regcache != NULL);
757 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_raw_registers);
758 buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
759 store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
760 gdbarch_byte_order (regcache->descr->gdbarch), val);
761 regcache_raw_write (regcache, regnum, buf);
765 regcache_raw_get_signed (struct regcache *regcache, int regnum)
768 enum register_status status;
770 status = regcache_raw_read_signed (regcache, regnum, &value);
771 if (status == REG_UNAVAILABLE)
772 throw_error (NOT_AVAILABLE_ERROR,
773 _("Register %d is not available"), regnum);
778 regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
780 gdb_assert (regnum >= 0);
781 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
782 if (regnum < regcache->descr->nr_raw_registers)
783 return regcache_raw_read (regcache, regnum, buf);
784 else if (regcache->readonly_p
785 && regcache->register_status[regnum] != REG_UNKNOWN)
787 /* Read-only register cache, perhaps the cooked value was
789 if (regcache->register_status[regnum] == REG_VALID)
790 memcpy (buf, register_buffer (regcache, regnum),
791 regcache->descr->sizeof_register[regnum]);
793 memset (buf, 0, regcache->descr->sizeof_register[regnum]);
795 return (enum register_status) regcache->register_status[regnum];
797 else if (gdbarch_pseudo_register_read_value_p (regcache->descr->gdbarch))
799 struct value *mark, *computed;
800 enum register_status result = REG_VALID;
802 mark = value_mark ();
804 computed = gdbarch_pseudo_register_read_value (regcache->descr->gdbarch,
806 if (value_entirely_available (computed))
807 memcpy (buf, value_contents_raw (computed),
808 regcache->descr->sizeof_register[regnum]);
811 memset (buf, 0, regcache->descr->sizeof_register[regnum]);
812 result = REG_UNAVAILABLE;
815 value_free_to_mark (mark);
820 return gdbarch_pseudo_register_read (regcache->descr->gdbarch, regcache,
825 regcache_cooked_read_value (struct regcache *regcache, int regnum)
827 gdb_assert (regnum >= 0);
828 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
830 if (regnum < regcache->descr->nr_raw_registers
831 || (regcache->readonly_p
832 && regcache->register_status[regnum] != REG_UNKNOWN)
833 || !gdbarch_pseudo_register_read_value_p (regcache->descr->gdbarch))
835 struct value *result;
837 result = allocate_value (register_type (regcache->descr->gdbarch,
839 VALUE_LVAL (result) = lval_register;
840 VALUE_REGNUM (result) = regnum;
842 /* It is more efficient in general to do this delegation in this
843 direction than in the other one, even though the value-based
845 if (regcache_cooked_read (regcache, regnum,
846 value_contents_raw (result)) == REG_UNAVAILABLE)
847 mark_value_bytes_unavailable (result, 0,
848 TYPE_LENGTH (value_type (result)));
853 return gdbarch_pseudo_register_read_value (regcache->descr->gdbarch,
858 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
861 enum register_status status;
864 gdb_assert (regcache != NULL);
865 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
866 buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
867 status = regcache_cooked_read (regcache, regnum, buf);
868 if (status == REG_VALID)
869 *val = extract_signed_integer
870 (buf, regcache->descr->sizeof_register[regnum],
871 gdbarch_byte_order (regcache->descr->gdbarch));
878 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
881 enum register_status status;
884 gdb_assert (regcache != NULL);
885 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_cooked_registers);
886 buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
887 status = regcache_cooked_read (regcache, regnum, buf);
888 if (status == REG_VALID)
889 *val = extract_unsigned_integer
890 (buf, regcache->descr->sizeof_register[regnum],
891 gdbarch_byte_order (regcache->descr->gdbarch));
898 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
903 gdb_assert (regcache != NULL);
904 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
905 buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
906 store_signed_integer (buf, regcache->descr->sizeof_register[regnum],
907 gdbarch_byte_order (regcache->descr->gdbarch), val);
908 regcache_cooked_write (regcache, regnum, buf);
912 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
917 gdb_assert (regcache != NULL);
918 gdb_assert (regnum >=0 && regnum < regcache->descr->nr_cooked_registers);
919 buf = (gdb_byte *) alloca (regcache->descr->sizeof_register[regnum]);
920 store_unsigned_integer (buf, regcache->descr->sizeof_register[regnum],
921 gdbarch_byte_order (regcache->descr->gdbarch), val);
922 regcache_cooked_write (regcache, regnum, buf);
925 /* See regcache.h. */
928 regcache_raw_set_cached_value (struct regcache *regcache, int regnum,
931 memcpy (register_buffer (regcache, regnum), buf,
932 regcache->descr->sizeof_register[regnum]);
933 regcache->register_status[regnum] = REG_VALID;
937 regcache_raw_write (struct regcache *regcache, int regnum,
940 struct cleanup *chain_before_save_inferior;
941 struct cleanup *chain_before_invalidate_register;
943 gdb_assert (regcache != NULL && buf != NULL);
944 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
945 gdb_assert (!regcache->readonly_p);
947 /* On the sparc, writing %g0 is a no-op, so we don't even want to
948 change the registers array if something writes to this register. */
949 if (gdbarch_cannot_store_register (get_regcache_arch (regcache), regnum))
952 /* If we have a valid copy of the register, and new value == old
953 value, then don't bother doing the actual store. */
954 if (regcache_register_status (regcache, regnum) == REG_VALID
955 && (memcmp (register_buffer (regcache, regnum), buf,
956 regcache->descr->sizeof_register[regnum]) == 0))
959 chain_before_save_inferior = save_inferior_ptid ();
960 inferior_ptid = regcache->ptid;
962 target_prepare_to_store (regcache);
963 regcache_raw_set_cached_value (regcache, regnum, buf);
965 /* Register a cleanup function for invalidating the register after it is
966 written, in case of a failure. */
967 chain_before_invalidate_register
968 = make_cleanup_regcache_invalidate (regcache, regnum);
970 target_store_registers (regcache, regnum);
972 /* The target did not throw an error so we can discard invalidating the
973 register and restore the cleanup chain to what it was. */
974 discard_cleanups (chain_before_invalidate_register);
976 do_cleanups (chain_before_save_inferior);
980 regcache_cooked_write (struct regcache *regcache, int regnum,
983 gdb_assert (regnum >= 0);
984 gdb_assert (regnum < regcache->descr->nr_cooked_registers);
985 if (regnum < regcache->descr->nr_raw_registers)
986 regcache_raw_write (regcache, regnum, buf);
988 gdbarch_pseudo_register_write (regcache->descr->gdbarch, regcache,
992 /* Perform a partial register transfer using a read, modify, write
995 typedef void (regcache_read_ftype) (struct regcache *regcache, int regnum,
997 typedef void (regcache_write_ftype) (struct regcache *regcache, int regnum,
1000 static enum register_status
1001 regcache_xfer_part (struct regcache *regcache, int regnum,
1002 int offset, int len, void *in, const void *out,
1003 enum register_status (*read) (struct regcache *regcache,
1006 void (*write) (struct regcache *regcache, int regnum,
1007 const gdb_byte *buf))
1009 struct regcache_descr *descr = regcache->descr;
1010 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1011 gdb_byte *reg = (gdb_byte *) alloca (register_size (gdbarch, regnum));
1013 gdb_assert (offset >= 0 && offset <= descr->sizeof_register[regnum]);
1014 gdb_assert (len >= 0 && offset + len <= descr->sizeof_register[regnum]);
1015 /* Something to do? */
1016 if (offset + len == 0)
1018 /* Read (when needed) ... */
1021 || offset + len < descr->sizeof_register[regnum])
1023 enum register_status status;
1025 gdb_assert (read != NULL);
1026 status = read (regcache, regnum, reg);
1027 if (status != REG_VALID)
1030 /* ... modify ... */
1032 memcpy (in, reg + offset, len);
1034 memcpy (reg + offset, out, len);
1035 /* ... write (when needed). */
1038 gdb_assert (write != NULL);
1039 write (regcache, regnum, reg);
1045 enum register_status
1046 regcache_raw_read_part (struct regcache *regcache, int regnum,
1047 int offset, int len, gdb_byte *buf)
1049 struct regcache_descr *descr = regcache->descr;
1051 gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
1052 return regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
1053 regcache_raw_read, regcache_raw_write);
1057 regcache_raw_write_part (struct regcache *regcache, int regnum,
1058 int offset, int len, const gdb_byte *buf)
1060 struct regcache_descr *descr = regcache->descr;
1062 gdb_assert (regnum >= 0 && regnum < descr->nr_raw_registers);
1063 regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
1064 regcache_raw_read, regcache_raw_write);
1067 enum register_status
1068 regcache_cooked_read_part (struct regcache *regcache, int regnum,
1069 int offset, int len, gdb_byte *buf)
1071 struct regcache_descr *descr = regcache->descr;
1073 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
1074 return regcache_xfer_part (regcache, regnum, offset, len, buf, NULL,
1075 regcache_cooked_read, regcache_cooked_write);
1079 regcache_cooked_write_part (struct regcache *regcache, int regnum,
1080 int offset, int len, const gdb_byte *buf)
1082 struct regcache_descr *descr = regcache->descr;
1084 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
1085 regcache_xfer_part (regcache, regnum, offset, len, NULL, buf,
1086 regcache_cooked_read, regcache_cooked_write);
1089 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
1092 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
1097 gdb_assert (regcache != NULL);
1098 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1099 gdb_assert (!regcache->readonly_p);
1101 regbuf = register_buffer (regcache, regnum);
1102 size = regcache->descr->sizeof_register[regnum];
1106 memcpy (regbuf, buf, size);
1107 regcache->register_status[regnum] = REG_VALID;
1111 /* This memset not strictly necessary, but better than garbage
1112 in case the register value manages to escape somewhere (due
1113 to a bug, no less). */
1114 memset (regbuf, 0, size);
1115 regcache->register_status[regnum] = REG_UNAVAILABLE;
1119 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1122 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
1127 gdb_assert (regcache != NULL && buf != NULL);
1128 gdb_assert (regnum >= 0 && regnum < regcache->descr->nr_raw_registers);
1130 regbuf = register_buffer (regcache, regnum);
1131 size = regcache->descr->sizeof_register[regnum];
1132 memcpy (buf, regbuf, size);
1135 /* Transfer a single or all registers belonging to a certain register
1136 set to or from a buffer. This is the main worker function for
1137 regcache_supply_regset and regcache_collect_regset. */
1140 regcache_transfer_regset (const struct regset *regset,
1141 const struct regcache *regcache,
1142 struct regcache *out_regcache,
1143 int regnum, const void *in_buf,
1144 void *out_buf, size_t size)
1146 const struct regcache_map_entry *map;
1147 int offs = 0, count;
1149 for (map = (const struct regcache_map_entry *) regset->regmap;
1150 (count = map->count) != 0;
1153 int regno = map->regno;
1154 int slot_size = map->size;
1156 if (slot_size == 0 && regno != REGCACHE_MAP_SKIP)
1157 slot_size = regcache->descr->sizeof_register[regno];
1159 if (regno == REGCACHE_MAP_SKIP
1161 && (regnum < regno || regnum >= regno + count)))
1162 offs += count * slot_size;
1164 else if (regnum == -1)
1165 for (; count--; regno++, offs += slot_size)
1167 if (offs + slot_size > size)
1171 regcache_raw_collect (regcache, regno,
1172 (gdb_byte *) out_buf + offs);
1174 regcache_raw_supply (out_regcache, regno, in_buf
1175 ? (const gdb_byte *) in_buf + offs
1180 /* Transfer a single register and return. */
1181 offs += (regnum - regno) * slot_size;
1182 if (offs + slot_size > size)
1186 regcache_raw_collect (regcache, regnum,
1187 (gdb_byte *) out_buf + offs);
1189 regcache_raw_supply (out_regcache, regnum, in_buf
1190 ? (const gdb_byte *) in_buf + offs
1197 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1198 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1199 If BUF is NULL, set the register(s) to "unavailable" status. */
1202 regcache_supply_regset (const struct regset *regset,
1203 struct regcache *regcache,
1204 int regnum, const void *buf, size_t size)
1206 regcache_transfer_regset (regset, regcache, regcache, regnum,
1210 /* Collect register REGNUM from REGCACHE to BUF, using the register
1211 map in REGSET. If REGNUM is -1, do this for all registers in
1215 regcache_collect_regset (const struct regset *regset,
1216 const struct regcache *regcache,
1217 int regnum, void *buf, size_t size)
1219 regcache_transfer_regset (regset, regcache, NULL, regnum,
1224 /* Special handling for register PC. */
1227 regcache_read_pc (struct regcache *regcache)
1229 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1233 if (gdbarch_read_pc_p (gdbarch))
1234 pc_val = gdbarch_read_pc (gdbarch, regcache);
1235 /* Else use per-frame method on get_current_frame. */
1236 else if (gdbarch_pc_regnum (gdbarch) >= 0)
1240 if (regcache_cooked_read_unsigned (regcache,
1241 gdbarch_pc_regnum (gdbarch),
1242 &raw_val) == REG_UNAVAILABLE)
1243 throw_error (NOT_AVAILABLE_ERROR, _("PC register is not available"));
1245 pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
1248 internal_error (__FILE__, __LINE__,
1249 _("regcache_read_pc: Unable to find PC"));
1254 regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
1256 struct gdbarch *gdbarch = get_regcache_arch (regcache);
1258 if (gdbarch_write_pc_p (gdbarch))
1259 gdbarch_write_pc (gdbarch, regcache, pc);
1260 else if (gdbarch_pc_regnum (gdbarch) >= 0)
1261 regcache_cooked_write_unsigned (regcache,
1262 gdbarch_pc_regnum (gdbarch), pc);
1264 internal_error (__FILE__, __LINE__,
1265 _("regcache_write_pc: Unable to update PC"));
1267 /* Writing the PC (for instance, from "load") invalidates the
1269 reinit_frame_cache ();
1274 reg_flush_command (char *command, int from_tty)
1276 /* Force-flush the register cache. */
1277 registers_changed ();
1279 printf_filtered (_("Register cache flushed.\n"));
1282 enum regcache_dump_what
1284 regcache_dump_none, regcache_dump_raw,
1285 regcache_dump_cooked, regcache_dump_groups,
1286 regcache_dump_remote
1290 regcache_dump (struct regcache *regcache, struct ui_file *file,
1291 enum regcache_dump_what what_to_dump)
1293 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1294 struct gdbarch *gdbarch = regcache->descr->gdbarch;
1296 int footnote_nr = 0;
1297 int footnote_register_size = 0;
1298 int footnote_register_offset = 0;
1299 int footnote_register_type_name_null = 0;
1300 long register_offset = 0;
1301 gdb_byte buf[MAX_REGISTER_SIZE];
1304 fprintf_unfiltered (file, "nr_raw_registers %d\n",
1305 regcache->descr->nr_raw_registers);
1306 fprintf_unfiltered (file, "nr_cooked_registers %d\n",
1307 regcache->descr->nr_cooked_registers);
1308 fprintf_unfiltered (file, "sizeof_raw_registers %ld\n",
1309 regcache->descr->sizeof_raw_registers);
1310 fprintf_unfiltered (file, "sizeof_raw_register_status %ld\n",
1311 regcache->descr->sizeof_raw_register_status);
1312 fprintf_unfiltered (file, "gdbarch_num_regs %d\n",
1313 gdbarch_num_regs (gdbarch));
1314 fprintf_unfiltered (file, "gdbarch_num_pseudo_regs %d\n",
1315 gdbarch_num_pseudo_regs (gdbarch));
1318 gdb_assert (regcache->descr->nr_cooked_registers
1319 == (gdbarch_num_regs (gdbarch)
1320 + gdbarch_num_pseudo_regs (gdbarch)));
1322 for (regnum = -1; regnum < regcache->descr->nr_cooked_registers; regnum++)
1326 fprintf_unfiltered (file, " %-10s", "Name");
1329 const char *p = gdbarch_register_name (gdbarch, regnum);
1333 else if (p[0] == '\0')
1335 fprintf_unfiltered (file, " %-10s", p);
1340 fprintf_unfiltered (file, " %4s", "Nr");
1342 fprintf_unfiltered (file, " %4d", regnum);
1344 /* Relative number. */
1346 fprintf_unfiltered (file, " %4s", "Rel");
1347 else if (regnum < gdbarch_num_regs (gdbarch))
1348 fprintf_unfiltered (file, " %4d", regnum);
1350 fprintf_unfiltered (file, " %4d",
1351 (regnum - gdbarch_num_regs (gdbarch)));
1355 fprintf_unfiltered (file, " %6s ", "Offset");
1358 fprintf_unfiltered (file, " %6ld",
1359 regcache->descr->register_offset[regnum]);
1360 if (register_offset != regcache->descr->register_offset[regnum]
1362 && (regcache->descr->register_offset[regnum]
1363 != (regcache->descr->register_offset[regnum - 1]
1364 + regcache->descr->sizeof_register[regnum - 1])))
1367 if (!footnote_register_offset)
1368 footnote_register_offset = ++footnote_nr;
1369 fprintf_unfiltered (file, "*%d", footnote_register_offset);
1372 fprintf_unfiltered (file, " ");
1373 register_offset = (regcache->descr->register_offset[regnum]
1374 + regcache->descr->sizeof_register[regnum]);
1379 fprintf_unfiltered (file, " %5s ", "Size");
1381 fprintf_unfiltered (file, " %5ld",
1382 regcache->descr->sizeof_register[regnum]);
1392 static const char blt[] = "builtin_type";
1394 t = TYPE_NAME (register_type (regcache->descr->gdbarch, regnum));
1399 if (!footnote_register_type_name_null)
1400 footnote_register_type_name_null = ++footnote_nr;
1401 n = xstrprintf ("*%d", footnote_register_type_name_null);
1402 make_cleanup (xfree, n);
1405 /* Chop a leading builtin_type. */
1406 if (startswith (t, blt))
1409 fprintf_unfiltered (file, " %-15s", t);
1412 /* Leading space always present. */
1413 fprintf_unfiltered (file, " ");
1416 if (what_to_dump == regcache_dump_raw)
1419 fprintf_unfiltered (file, "Raw value");
1420 else if (regnum >= regcache->descr->nr_raw_registers)
1421 fprintf_unfiltered (file, "<cooked>");
1422 else if (regcache_register_status (regcache, regnum) == REG_UNKNOWN)
1423 fprintf_unfiltered (file, "<invalid>");
1424 else if (regcache_register_status (regcache, regnum) == REG_UNAVAILABLE)
1425 fprintf_unfiltered (file, "<unavailable>");
1428 regcache_raw_read (regcache, regnum, buf);
1429 print_hex_chars (file, buf,
1430 regcache->descr->sizeof_register[regnum],
1431 gdbarch_byte_order (gdbarch));
1435 /* Value, cooked. */
1436 if (what_to_dump == regcache_dump_cooked)
1439 fprintf_unfiltered (file, "Cooked value");
1442 enum register_status status;
1444 status = regcache_cooked_read (regcache, regnum, buf);
1445 if (status == REG_UNKNOWN)
1446 fprintf_unfiltered (file, "<invalid>");
1447 else if (status == REG_UNAVAILABLE)
1448 fprintf_unfiltered (file, "<unavailable>");
1450 print_hex_chars (file, buf,
1451 regcache->descr->sizeof_register[regnum],
1452 gdbarch_byte_order (gdbarch));
1456 /* Group members. */
1457 if (what_to_dump == regcache_dump_groups)
1460 fprintf_unfiltered (file, "Groups");
1463 const char *sep = "";
1464 struct reggroup *group;
1466 for (group = reggroup_next (gdbarch, NULL);
1468 group = reggroup_next (gdbarch, group))
1470 if (gdbarch_register_reggroup_p (gdbarch, regnum, group))
1472 fprintf_unfiltered (file,
1473 "%s%s", sep, reggroup_name (group));
1480 /* Remote packet configuration. */
1481 if (what_to_dump == regcache_dump_remote)
1485 fprintf_unfiltered (file, "Rmt Nr g/G Offset");
1487 else if (regnum < regcache->descr->nr_raw_registers)
1491 if (remote_register_number_and_offset (get_regcache_arch (regcache), regnum,
1493 fprintf_unfiltered (file, "%7d %11d", pnum, poffset);
1497 fprintf_unfiltered (file, "\n");
1500 if (footnote_register_size)
1501 fprintf_unfiltered (file, "*%d: Inconsistent register sizes.\n",
1502 footnote_register_size);
1503 if (footnote_register_offset)
1504 fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1505 footnote_register_offset);
1506 if (footnote_register_type_name_null)
1507 fprintf_unfiltered (file,
1508 "*%d: Register type's name NULL.\n",
1509 footnote_register_type_name_null);
1510 do_cleanups (cleanups);
1514 regcache_print (char *args, enum regcache_dump_what what_to_dump)
1517 regcache_dump (get_current_regcache (), gdb_stdout, what_to_dump);
1522 if (!file.open (args, "w"))
1523 perror_with_name (_("maintenance print architecture"));
1524 regcache_dump (get_current_regcache (), &file, what_to_dump);
1529 maintenance_print_registers (char *args, int from_tty)
1531 regcache_print (args, regcache_dump_none);
1535 maintenance_print_raw_registers (char *args, int from_tty)
1537 regcache_print (args, regcache_dump_raw);
1541 maintenance_print_cooked_registers (char *args, int from_tty)
1543 regcache_print (args, regcache_dump_cooked);
1547 maintenance_print_register_groups (char *args, int from_tty)
1549 regcache_print (args, regcache_dump_groups);
1553 maintenance_print_remote_registers (char *args, int from_tty)
1555 regcache_print (args, regcache_dump_remote);
1558 extern initialize_file_ftype _initialize_regcache; /* -Wmissing-prototype */
1561 _initialize_regcache (void)
1563 regcache_descr_handle
1564 = gdbarch_data_register_post_init (init_regcache_descr);
1566 observer_attach_target_changed (regcache_observer_target_changed);
1567 observer_attach_thread_ptid_changed (regcache_thread_ptid_changed);
1569 add_com ("flushregs", class_maintenance, reg_flush_command,
1570 _("Force gdb to flush its register cache (maintainer command)"));
1572 add_cmd ("registers", class_maintenance, maintenance_print_registers,
1573 _("Print the internal register configuration.\n"
1574 "Takes an optional file parameter."), &maintenanceprintlist);
1575 add_cmd ("raw-registers", class_maintenance,
1576 maintenance_print_raw_registers,
1577 _("Print the internal register configuration "
1578 "including raw values.\n"
1579 "Takes an optional file parameter."), &maintenanceprintlist);
1580 add_cmd ("cooked-registers", class_maintenance,
1581 maintenance_print_cooked_registers,
1582 _("Print the internal register configuration "
1583 "including cooked values.\n"
1584 "Takes an optional file parameter."), &maintenanceprintlist);
1585 add_cmd ("register-groups", class_maintenance,
1586 maintenance_print_register_groups,
1587 _("Print the internal register configuration "
1588 "including each register's group.\n"
1589 "Takes an optional file parameter."),
1590 &maintenanceprintlist);
1591 add_cmd ("remote-registers", class_maintenance,
1592 maintenance_print_remote_registers, _("\
1593 Print the internal register configuration including each register's\n\
1594 remote register number and buffer offset in the g/G packets.\n\
1595 Takes an optional file parameter."),
1596 &maintenanceprintlist);