1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986-2018 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"
27 #include "observable.h"
29 #include <forward_list>
34 * Here is the actual register cache.
37 /* Per-architecture object describing the layout of a register cache.
38 Computed once when the architecture is created. */
40 struct gdbarch_data *regcache_descr_handle;
44 /* The architecture this descriptor belongs to. */
45 struct gdbarch *gdbarch;
47 /* The raw register cache. Each raw (or hard) register is supplied
48 by the target interface. The raw cache should not contain
49 redundant information - if the PC is constructed from two
50 registers then those registers and not the PC lives in the raw
52 long sizeof_raw_registers;
54 /* The cooked register space. Each cooked register in the range
55 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
56 register. The remaining [NR_RAW_REGISTERS
57 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
58 both raw registers and memory by the architecture methods
59 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
60 int nr_cooked_registers;
61 long sizeof_cooked_registers;
63 /* Offset and size (in 8 bit bytes), of each register in the
64 register cache. All registers (including those in the range
65 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
67 long *register_offset;
68 long *sizeof_register;
70 /* Cached table containing the type of each register. */
71 struct type **register_type;
75 init_regcache_descr (struct gdbarch *gdbarch)
78 struct regcache_descr *descr;
79 gdb_assert (gdbarch != NULL);
81 /* Create an initial, zero filled, table. */
82 descr = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct regcache_descr);
83 descr->gdbarch = gdbarch;
85 /* Total size of the register space. The raw registers are mapped
86 directly onto the raw register cache while the pseudo's are
87 either mapped onto raw-registers or memory. */
88 descr->nr_cooked_registers = gdbarch_num_regs (gdbarch)
89 + gdbarch_num_pseudo_regs (gdbarch);
91 /* Fill in a table of register types. */
93 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers,
95 for (i = 0; i < descr->nr_cooked_registers; i++)
96 descr->register_type[i] = gdbarch_register_type (gdbarch, i);
98 /* Construct a strictly RAW register cache. Don't allow pseudo's
99 into the register cache. */
101 /* Lay out the register cache.
103 NOTE: cagney/2002-05-22: Only register_type() is used when
104 constructing the register cache. It is assumed that the
105 register's raw size, virtual size and type length are all the
111 descr->sizeof_register
112 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
113 descr->register_offset
114 = GDBARCH_OBSTACK_CALLOC (gdbarch, descr->nr_cooked_registers, long);
115 for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
117 descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
118 descr->register_offset[i] = offset;
119 offset += descr->sizeof_register[i];
121 /* Set the real size of the raw register cache buffer. */
122 descr->sizeof_raw_registers = offset;
124 for (; i < descr->nr_cooked_registers; i++)
126 descr->sizeof_register[i] = TYPE_LENGTH (descr->register_type[i]);
127 descr->register_offset[i] = offset;
128 offset += descr->sizeof_register[i];
130 /* Set the real size of the readonly register cache buffer. */
131 descr->sizeof_cooked_registers = offset;
137 static struct regcache_descr *
138 regcache_descr (struct gdbarch *gdbarch)
140 return (struct regcache_descr *) gdbarch_data (gdbarch,
141 regcache_descr_handle);
144 /* Utility functions returning useful register attributes stored in
145 the regcache descr. */
148 register_type (struct gdbarch *gdbarch, int regnum)
150 struct regcache_descr *descr = regcache_descr (gdbarch);
152 gdb_assert (regnum >= 0 && regnum < descr->nr_cooked_registers);
153 return descr->register_type[regnum];
156 /* Utility functions returning useful register attributes stored in
157 the regcache descr. */
160 register_size (struct gdbarch *gdbarch, int regnum)
162 struct regcache_descr *descr = regcache_descr (gdbarch);
165 gdb_assert (regnum >= 0
166 && regnum < (gdbarch_num_regs (gdbarch)
167 + gdbarch_num_pseudo_regs (gdbarch)));
168 size = descr->sizeof_register[regnum];
172 /* See common/common-regcache.h. */
175 regcache_register_size (const struct regcache *regcache, int n)
177 return register_size (regcache->arch (), n);
180 reg_buffer::reg_buffer (gdbarch *gdbarch, bool has_pseudo)
181 : m_has_pseudo (has_pseudo)
183 gdb_assert (gdbarch != NULL);
184 m_descr = regcache_descr (gdbarch);
188 m_registers = XCNEWVEC (gdb_byte, m_descr->sizeof_cooked_registers);
189 m_register_status = XCNEWVEC (signed char,
190 m_descr->nr_cooked_registers);
194 m_registers = XCNEWVEC (gdb_byte, m_descr->sizeof_raw_registers);
195 m_register_status = XCNEWVEC (signed char, gdbarch_num_regs (gdbarch));
199 regcache::regcache (gdbarch *gdbarch, const address_space *aspace_)
200 /* The register buffers. A read/write register cache can only hold
201 [0 .. gdbarch_num_regs). */
202 : detached_regcache (gdbarch, false), m_aspace (aspace_)
204 m_ptid = minus_one_ptid;
207 static enum register_status
208 do_cooked_read (void *src, int regnum, gdb_byte *buf)
210 struct regcache *regcache = (struct regcache *) src;
212 return regcache_cooked_read (regcache, regnum, buf);
215 readonly_detached_regcache::readonly_detached_regcache (const regcache &src)
216 : readonly_detached_regcache (src.arch (), do_cooked_read, (void *) &src)
221 reg_buffer::arch () const
223 return m_descr->gdbarch;
226 /* Cleanup class for invalidating a register. */
228 class regcache_invalidator
232 regcache_invalidator (struct regcache *regcache, int regnum)
233 : m_regcache (regcache),
238 ~regcache_invalidator ()
240 if (m_regcache != nullptr)
241 regcache_invalidate (m_regcache, m_regnum);
244 DISABLE_COPY_AND_ASSIGN (regcache_invalidator);
248 m_regcache = nullptr;
253 struct regcache *m_regcache;
257 /* Return a pointer to register REGNUM's buffer cache. */
260 reg_buffer::register_buffer (int regnum) const
262 return m_registers + m_descr->register_offset[regnum];
266 reg_buffer::save (regcache_cooked_read_ftype *cooked_read,
269 struct gdbarch *gdbarch = m_descr->gdbarch;
272 /* It should have pseudo registers. */
273 gdb_assert (m_has_pseudo);
274 /* Clear the dest. */
275 memset (m_registers, 0, m_descr->sizeof_cooked_registers);
276 memset (m_register_status, 0, m_descr->nr_cooked_registers);
277 /* Copy over any registers (identified by their membership in the
278 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
279 gdbarch_num_pseudo_regs) range is checked since some architectures need
280 to save/restore `cooked' registers that live in memory. */
281 for (regnum = 0; regnum < m_descr->nr_cooked_registers; regnum++)
283 if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
285 gdb_byte *dst_buf = register_buffer (regnum);
286 enum register_status status = cooked_read (src, regnum, dst_buf);
288 gdb_assert (status != REG_UNKNOWN);
290 if (status != REG_VALID)
291 memset (dst_buf, 0, register_size (gdbarch, regnum));
293 m_register_status[regnum] = status;
299 regcache::restore (readonly_detached_regcache *src)
301 struct gdbarch *gdbarch = m_descr->gdbarch;
304 gdb_assert (src != NULL);
305 gdb_assert (src->m_has_pseudo);
307 gdb_assert (gdbarch == src->arch ());
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 < m_descr->nr_cooked_registers; regnum++)
315 if (gdbarch_register_reggroup_p (gdbarch, regnum, restore_reggroup))
317 if (src->m_register_status[regnum] == REG_VALID)
318 cooked_write (regnum, src->register_buffer (regnum));
324 reg_buffer::get_register_status (int regnum) const
326 assert_regnum (regnum);
328 return (enum register_status) m_register_status[regnum];
332 regcache_invalidate (struct regcache *regcache, int regnum)
334 gdb_assert (regcache != NULL);
335 regcache->invalidate (regnum);
339 detached_regcache::invalidate (int regnum)
341 assert_regnum (regnum);
342 m_register_status[regnum] = REG_UNKNOWN;
346 reg_buffer::assert_regnum (int regnum) const
348 gdb_assert (regnum >= 0);
350 gdb_assert (regnum < m_descr->nr_cooked_registers);
352 gdb_assert (regnum < gdbarch_num_regs (arch ()));
355 /* Global structure containing the current regcache. */
357 /* NOTE: this is a write-through cache. There is no "dirty" bit for
358 recording if the register values have been changed (eg. by the
359 user). Therefore all registers must be written back to the
360 target when appropriate. */
361 std::forward_list<regcache *> regcache::current_regcache;
364 get_thread_arch_aspace_regcache (ptid_t ptid, struct gdbarch *gdbarch,
365 struct address_space *aspace)
367 for (const auto ®cache : regcache::current_regcache)
368 if (ptid_equal (regcache->ptid (), ptid) && regcache->arch () == gdbarch)
371 regcache *new_regcache = new regcache (gdbarch, aspace);
373 regcache::current_regcache.push_front (new_regcache);
374 new_regcache->set_ptid (ptid);
380 get_thread_arch_regcache (ptid_t ptid, struct gdbarch *gdbarch)
382 address_space *aspace = target_thread_address_space (ptid);
384 return get_thread_arch_aspace_regcache (ptid, gdbarch, aspace);
387 static ptid_t current_thread_ptid;
388 static struct gdbarch *current_thread_arch;
391 get_thread_regcache (ptid_t ptid)
393 if (!current_thread_arch || !ptid_equal (current_thread_ptid, ptid))
395 current_thread_ptid = ptid;
396 current_thread_arch = target_thread_architecture (ptid);
399 return get_thread_arch_regcache (ptid, current_thread_arch);
403 get_current_regcache (void)
405 return get_thread_regcache (inferior_ptid);
408 /* See common/common-regcache.h. */
411 get_thread_regcache_for_ptid (ptid_t ptid)
413 return get_thread_regcache (ptid);
416 /* Observer for the target_changed event. */
419 regcache_observer_target_changed (struct target_ops *target)
421 registers_changed ();
424 /* Update global variables old ptids to hold NEW_PTID if they were
427 regcache::regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid)
429 for (auto ®cache : regcache::current_regcache)
431 if (ptid_equal (regcache->ptid (), old_ptid))
432 regcache->set_ptid (new_ptid);
436 /* Low level examining and depositing of registers.
438 The caller is responsible for making sure that the inferior is
439 stopped before calling the fetching routines, or it will get
440 garbage. (a change from GDB version 3, in which the caller got the
441 value from the last stop). */
443 /* REGISTERS_CHANGED ()
445 Indicate that registers may have changed, so invalidate the cache. */
448 registers_changed_ptid (ptid_t ptid)
450 for (auto oit = regcache::current_regcache.before_begin (),
451 it = std::next (oit);
452 it != regcache::current_regcache.end ();
455 if (ptid_match ((*it)->ptid (), ptid))
458 it = regcache::current_regcache.erase_after (oit);
464 if (ptid_match (current_thread_ptid, ptid))
466 current_thread_ptid = null_ptid;
467 current_thread_arch = NULL;
470 if (ptid_match (inferior_ptid, ptid))
472 /* We just deleted the regcache of the current thread. Need to
473 forget about any frames we have cached, too. */
474 reinit_frame_cache ();
479 registers_changed (void)
481 registers_changed_ptid (minus_one_ptid);
483 /* Force cleanup of any alloca areas if using C alloca instead of
484 a builtin alloca. This particular call is used to clean up
485 areas allocated by low level target code which may build up
486 during lengthy interactions between gdb and the target before
487 gdb gives control to the user (ie watchpoints). */
492 regcache::raw_update (int regnum)
494 assert_regnum (regnum);
496 /* Make certain that the register cache is up-to-date with respect
497 to the current thread. This switching shouldn't be necessary
498 only there is still only one target side register cache. Sigh!
499 On the bright side, at least there is a regcache object. */
501 if (get_register_status (regnum) == REG_UNKNOWN)
503 target_fetch_registers (this, regnum);
505 /* A number of targets can't access the whole set of raw
506 registers (because the debug API provides no means to get at
508 if (m_register_status[regnum] == REG_UNKNOWN)
509 m_register_status[regnum] = REG_UNAVAILABLE;
514 regcache_raw_read (struct regcache *regcache, int regnum, gdb_byte *buf)
516 return regcache->raw_read (regnum, buf);
520 readable_regcache::raw_read (int regnum, gdb_byte *buf)
522 gdb_assert (buf != NULL);
525 if (m_register_status[regnum] != REG_VALID)
526 memset (buf, 0, m_descr->sizeof_register[regnum]);
528 memcpy (buf, register_buffer (regnum),
529 m_descr->sizeof_register[regnum]);
531 return (enum register_status) m_register_status[regnum];
535 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
537 gdb_assert (regcache != NULL);
538 return regcache->raw_read (regnum, val);
541 template<typename T, typename>
543 readable_regcache::raw_read (int regnum, T *val)
546 enum register_status status;
548 assert_regnum (regnum);
549 buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]);
550 status = raw_read (regnum, buf);
551 if (status == REG_VALID)
552 *val = extract_integer<T> (buf,
553 m_descr->sizeof_register[regnum],
554 gdbarch_byte_order (m_descr->gdbarch));
561 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
564 gdb_assert (regcache != NULL);
565 return regcache->raw_read (regnum, val);
569 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
571 gdb_assert (regcache != NULL);
572 regcache->raw_write (regnum, val);
575 template<typename T, typename>
577 regcache::raw_write (int regnum, T val)
581 assert_regnum (regnum);
582 buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]);
583 store_integer (buf, m_descr->sizeof_register[regnum],
584 gdbarch_byte_order (m_descr->gdbarch), val);
585 raw_write (regnum, buf);
589 regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
592 gdb_assert (regcache != NULL);
593 regcache->raw_write (regnum, val);
597 regcache_raw_get_signed (struct regcache *regcache, int regnum)
600 enum register_status status;
602 status = regcache_raw_read_signed (regcache, regnum, &value);
603 if (status == REG_UNAVAILABLE)
604 throw_error (NOT_AVAILABLE_ERROR,
605 _("Register %d is not available"), regnum);
610 regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
612 return regcache->cooked_read (regnum, buf);
616 readable_regcache::cooked_read (int regnum, gdb_byte *buf)
618 gdb_assert (regnum >= 0);
619 gdb_assert (regnum < m_descr->nr_cooked_registers);
620 if (regnum < num_raw_registers ())
621 return raw_read (regnum, buf);
622 else if (m_has_pseudo
623 && m_register_status[regnum] != REG_UNKNOWN)
625 if (m_register_status[regnum] == REG_VALID)
626 memcpy (buf, register_buffer (regnum),
627 m_descr->sizeof_register[regnum]);
629 memset (buf, 0, m_descr->sizeof_register[regnum]);
631 return (enum register_status) m_register_status[regnum];
633 else if (gdbarch_pseudo_register_read_value_p (m_descr->gdbarch))
635 struct value *mark, *computed;
636 enum register_status result = REG_VALID;
638 mark = value_mark ();
640 computed = gdbarch_pseudo_register_read_value (m_descr->gdbarch,
642 if (value_entirely_available (computed))
643 memcpy (buf, value_contents_raw (computed),
644 m_descr->sizeof_register[regnum]);
647 memset (buf, 0, m_descr->sizeof_register[regnum]);
648 result = REG_UNAVAILABLE;
651 value_free_to_mark (mark);
656 return gdbarch_pseudo_register_read (m_descr->gdbarch, this,
661 regcache_cooked_read_value (struct regcache *regcache, int regnum)
663 return regcache->cooked_read_value (regnum);
667 readable_regcache::cooked_read_value (int regnum)
669 gdb_assert (regnum >= 0);
670 gdb_assert (regnum < m_descr->nr_cooked_registers);
672 if (regnum < num_raw_registers ()
673 || (m_has_pseudo && m_register_status[regnum] != REG_UNKNOWN)
674 || !gdbarch_pseudo_register_read_value_p (m_descr->gdbarch))
676 struct value *result;
678 result = allocate_value (register_type (m_descr->gdbarch, regnum));
679 VALUE_LVAL (result) = lval_register;
680 VALUE_REGNUM (result) = regnum;
682 /* It is more efficient in general to do this delegation in this
683 direction than in the other one, even though the value-based
685 if (cooked_read (regnum,
686 value_contents_raw (result)) == REG_UNAVAILABLE)
687 mark_value_bytes_unavailable (result, 0,
688 TYPE_LENGTH (value_type (result)));
693 return gdbarch_pseudo_register_read_value (m_descr->gdbarch,
698 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
701 gdb_assert (regcache != NULL);
702 return regcache->cooked_read (regnum, val);
705 template<typename T, typename>
707 readable_regcache::cooked_read (int regnum, T *val)
709 enum register_status status;
712 gdb_assert (regnum >= 0 && regnum < m_descr->nr_cooked_registers);
713 buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]);
714 status = cooked_read (regnum, buf);
715 if (status == REG_VALID)
716 *val = extract_integer<T> (buf, m_descr->sizeof_register[regnum],
717 gdbarch_byte_order (m_descr->gdbarch));
724 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
727 gdb_assert (regcache != NULL);
728 return regcache->cooked_read (regnum, val);
732 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
735 gdb_assert (regcache != NULL);
736 regcache->cooked_write (regnum, val);
739 template<typename T, typename>
741 regcache::cooked_write (int regnum, T val)
745 gdb_assert (regnum >=0 && regnum < m_descr->nr_cooked_registers);
746 buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]);
747 store_integer (buf, m_descr->sizeof_register[regnum],
748 gdbarch_byte_order (m_descr->gdbarch), val);
749 cooked_write (regnum, buf);
753 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
756 gdb_assert (regcache != NULL);
757 regcache->cooked_write (regnum, val);
761 regcache_raw_write (struct regcache *regcache, int regnum,
764 gdb_assert (regcache != NULL && buf != NULL);
765 regcache->raw_write (regnum, buf);
769 regcache::raw_write (int regnum, const gdb_byte *buf)
772 gdb_assert (buf != NULL);
773 assert_regnum (regnum);
775 /* On the sparc, writing %g0 is a no-op, so we don't even want to
776 change the registers array if something writes to this register. */
777 if (gdbarch_cannot_store_register (arch (), regnum))
780 /* If we have a valid copy of the register, and new value == old
781 value, then don't bother doing the actual store. */
782 if (get_register_status (regnum) == REG_VALID
783 && (memcmp (register_buffer (regnum), buf,
784 m_descr->sizeof_register[regnum]) == 0))
787 target_prepare_to_store (this);
788 raw_supply (regnum, buf);
790 /* Invalidate the register after it is written, in case of a
792 regcache_invalidator invalidator (this, regnum);
794 target_store_registers (this, regnum);
796 /* The target did not throw an error so we can discard invalidating
798 invalidator.release ();
802 regcache_cooked_write (struct regcache *regcache, int regnum,
805 regcache->cooked_write (regnum, buf);
809 regcache::cooked_write (int regnum, const gdb_byte *buf)
811 gdb_assert (regnum >= 0);
812 gdb_assert (regnum < m_descr->nr_cooked_registers);
813 if (regnum < num_raw_registers ())
814 raw_write (regnum, buf);
816 gdbarch_pseudo_register_write (m_descr->gdbarch, this,
820 /* Perform a partial register transfer using a read, modify, write
824 readable_regcache::read_part (int regnum, int offset, int len, void *in,
827 struct gdbarch *gdbarch = arch ();
828 gdb_byte *reg = (gdb_byte *) alloca (register_size (gdbarch, regnum));
830 gdb_assert (in != NULL);
831 gdb_assert (offset >= 0 && offset <= m_descr->sizeof_register[regnum]);
832 gdb_assert (len >= 0 && offset + len <= m_descr->sizeof_register[regnum]);
833 /* Something to do? */
834 if (offset + len == 0)
836 /* Read (when needed) ... */
837 enum register_status status;
840 status = raw_read (regnum, reg);
842 status = cooked_read (regnum, reg);
843 if (status != REG_VALID)
847 memcpy (in, reg + offset, len);
853 regcache::write_part (int regnum, int offset, int len,
854 const void *out, bool is_raw)
856 struct gdbarch *gdbarch = arch ();
857 gdb_byte *reg = (gdb_byte *) alloca (register_size (gdbarch, regnum));
859 gdb_assert (out != NULL);
860 gdb_assert (offset >= 0 && offset <= m_descr->sizeof_register[regnum]);
861 gdb_assert (len >= 0 && offset + len <= m_descr->sizeof_register[regnum]);
862 /* Something to do? */
863 if (offset + len == 0)
865 /* Read (when needed) ... */
867 || offset + len < m_descr->sizeof_register[regnum])
869 enum register_status status;
872 status = raw_read (regnum, reg);
874 status = cooked_read (regnum, reg);
875 if (status != REG_VALID)
879 memcpy (reg + offset, out, len);
880 /* ... write (when needed). */
882 raw_write (regnum, reg);
884 cooked_write (regnum, reg);
890 regcache_raw_read_part (struct regcache *regcache, int regnum,
891 int offset, int len, gdb_byte *buf)
893 return regcache->raw_read_part (regnum, offset, len, buf);
897 readable_regcache::raw_read_part (int regnum, int offset, int len, gdb_byte *buf)
899 assert_regnum (regnum);
900 return read_part (regnum, offset, len, buf, true);
904 regcache_raw_write_part (struct regcache *regcache, int regnum,
905 int offset, int len, const gdb_byte *buf)
907 regcache->raw_write_part (regnum, offset, len, buf);
911 regcache::raw_write_part (int regnum, int offset, int len,
914 assert_regnum (regnum);
915 write_part (regnum, offset, len, buf, true);
919 regcache_cooked_read_part (struct regcache *regcache, int regnum,
920 int offset, int len, gdb_byte *buf)
922 return regcache->cooked_read_part (regnum, offset, len, buf);
927 readable_regcache::cooked_read_part (int regnum, int offset, int len,
930 gdb_assert (regnum >= 0 && regnum < m_descr->nr_cooked_registers);
931 return read_part (regnum, offset, len, buf, false);
935 regcache_cooked_write_part (struct regcache *regcache, int regnum,
936 int offset, int len, const gdb_byte *buf)
938 regcache->cooked_write_part (regnum, offset, len, buf);
942 regcache::cooked_write_part (int regnum, int offset, int len,
945 gdb_assert (regnum >= 0 && regnum < m_descr->nr_cooked_registers);
946 write_part (regnum, offset, len, buf, false);
949 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
952 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
954 gdb_assert (regcache != NULL);
955 regcache->raw_supply (regnum, buf);
959 detached_regcache::raw_supply (int regnum, const void *buf)
964 assert_regnum (regnum);
966 regbuf = register_buffer (regnum);
967 size = m_descr->sizeof_register[regnum];
971 memcpy (regbuf, buf, size);
972 m_register_status[regnum] = REG_VALID;
976 /* This memset not strictly necessary, but better than garbage
977 in case the register value manages to escape somewhere (due
978 to a bug, no less). */
979 memset (regbuf, 0, size);
980 m_register_status[regnum] = REG_UNAVAILABLE;
984 /* Supply register REGNUM to REGCACHE. Value to supply is an integer stored at
985 address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED. If
986 the register size is greater than ADDR_LEN, then the integer will be sign or
987 zero extended. If the register size is smaller than the integer, then the
988 most significant bytes of the integer will be truncated. */
991 detached_regcache::raw_supply_integer (int regnum, const gdb_byte *addr,
992 int addr_len, bool is_signed)
994 enum bfd_endian byte_order = gdbarch_byte_order (m_descr->gdbarch);
998 assert_regnum (regnum);
1000 regbuf = register_buffer (regnum);
1001 regsize = m_descr->sizeof_register[regnum];
1003 copy_integer_to_size (regbuf, regsize, addr, addr_len, is_signed,
1005 m_register_status[regnum] = REG_VALID;
1008 /* Supply register REGNUM with zeroed value to REGCACHE. This is not the same
1009 as calling raw_supply with NULL (which will set the state to
1013 detached_regcache::raw_supply_zeroed (int regnum)
1018 assert_regnum (regnum);
1020 regbuf = register_buffer (regnum);
1021 size = m_descr->sizeof_register[regnum];
1023 memset (regbuf, 0, size);
1024 m_register_status[regnum] = REG_VALID;
1027 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1030 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
1032 gdb_assert (regcache != NULL && buf != NULL);
1033 regcache->raw_collect (regnum, buf);
1037 regcache::raw_collect (int regnum, void *buf) const
1042 gdb_assert (buf != NULL);
1043 assert_regnum (regnum);
1045 regbuf = register_buffer (regnum);
1046 size = m_descr->sizeof_register[regnum];
1047 memcpy (buf, regbuf, size);
1050 /* Transfer a single or all registers belonging to a certain register
1051 set to or from a buffer. This is the main worker function for
1052 regcache_supply_regset and regcache_collect_regset. */
1054 /* Collect register REGNUM from REGCACHE. Store collected value as an integer
1055 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
1056 If ADDR_LEN is greater than the register size, then the integer will be sign
1057 or zero extended. If ADDR_LEN is smaller than the register size, then the
1058 most significant bytes of the integer will be truncated. */
1061 regcache::raw_collect_integer (int regnum, gdb_byte *addr, int addr_len,
1062 bool is_signed) const
1064 enum bfd_endian byte_order = gdbarch_byte_order (m_descr->gdbarch);
1065 const gdb_byte *regbuf;
1068 assert_regnum (regnum);
1070 regbuf = register_buffer (regnum);
1071 regsize = m_descr->sizeof_register[regnum];
1073 copy_integer_to_size (addr, addr_len, regbuf, regsize, is_signed,
1078 regcache::transfer_regset (const struct regset *regset,
1079 struct regcache *out_regcache,
1080 int regnum, const void *in_buf,
1081 void *out_buf, size_t size) const
1083 const struct regcache_map_entry *map;
1084 int offs = 0, count;
1086 for (map = (const struct regcache_map_entry *) regset->regmap;
1087 (count = map->count) != 0;
1090 int regno = map->regno;
1091 int slot_size = map->size;
1093 if (slot_size == 0 && regno != REGCACHE_MAP_SKIP)
1094 slot_size = m_descr->sizeof_register[regno];
1096 if (regno == REGCACHE_MAP_SKIP
1098 && (regnum < regno || regnum >= regno + count)))
1099 offs += count * slot_size;
1101 else if (regnum == -1)
1102 for (; count--; regno++, offs += slot_size)
1104 if (offs + slot_size > size)
1108 raw_collect (regno, (gdb_byte *) out_buf + offs);
1110 out_regcache->raw_supply (regno, in_buf
1111 ? (const gdb_byte *) in_buf + offs
1116 /* Transfer a single register and return. */
1117 offs += (regnum - regno) * slot_size;
1118 if (offs + slot_size > size)
1122 raw_collect (regnum, (gdb_byte *) out_buf + offs);
1124 out_regcache->raw_supply (regnum, in_buf
1125 ? (const gdb_byte *) in_buf + offs
1132 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1133 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1134 If BUF is NULL, set the register(s) to "unavailable" status. */
1137 regcache_supply_regset (const struct regset *regset,
1138 struct regcache *regcache,
1139 int regnum, const void *buf, size_t size)
1141 regcache->supply_regset (regset, regnum, buf, size);
1145 regcache::supply_regset (const struct regset *regset,
1146 int regnum, const void *buf, size_t size)
1148 transfer_regset (regset, this, regnum, buf, NULL, size);
1151 /* Collect register REGNUM from REGCACHE to BUF, using the register
1152 map in REGSET. If REGNUM is -1, do this for all registers in
1156 regcache_collect_regset (const struct regset *regset,
1157 const struct regcache *regcache,
1158 int regnum, void *buf, size_t size)
1160 regcache->collect_regset (regset, regnum, buf, size);
1164 regcache::collect_regset (const struct regset *regset,
1165 int regnum, void *buf, size_t size) const
1167 transfer_regset (regset, NULL, regnum, NULL, buf, size);
1171 /* Special handling for register PC. */
1174 regcache_read_pc (struct regcache *regcache)
1176 struct gdbarch *gdbarch = regcache->arch ();
1180 if (gdbarch_read_pc_p (gdbarch))
1181 pc_val = gdbarch_read_pc (gdbarch, regcache);
1182 /* Else use per-frame method on get_current_frame. */
1183 else if (gdbarch_pc_regnum (gdbarch) >= 0)
1187 if (regcache_cooked_read_unsigned (regcache,
1188 gdbarch_pc_regnum (gdbarch),
1189 &raw_val) == REG_UNAVAILABLE)
1190 throw_error (NOT_AVAILABLE_ERROR, _("PC register is not available"));
1192 pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
1195 internal_error (__FILE__, __LINE__,
1196 _("regcache_read_pc: Unable to find PC"));
1201 regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
1203 struct gdbarch *gdbarch = regcache->arch ();
1205 if (gdbarch_write_pc_p (gdbarch))
1206 gdbarch_write_pc (gdbarch, regcache, pc);
1207 else if (gdbarch_pc_regnum (gdbarch) >= 0)
1208 regcache_cooked_write_unsigned (regcache,
1209 gdbarch_pc_regnum (gdbarch), pc);
1211 internal_error (__FILE__, __LINE__,
1212 _("regcache_write_pc: Unable to update PC"));
1214 /* Writing the PC (for instance, from "load") invalidates the
1216 reinit_frame_cache ();
1220 reg_buffer::num_raw_registers () const
1222 return gdbarch_num_regs (arch ());
1226 regcache::debug_print_register (const char *func, int regno)
1228 struct gdbarch *gdbarch = arch ();
1230 fprintf_unfiltered (gdb_stdlog, "%s ", func);
1231 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
1232 && gdbarch_register_name (gdbarch, regno) != NULL
1233 && gdbarch_register_name (gdbarch, regno)[0] != '\0')
1234 fprintf_unfiltered (gdb_stdlog, "(%s)",
1235 gdbarch_register_name (gdbarch, regno));
1237 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
1238 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
1240 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1241 int size = register_size (gdbarch, regno);
1242 gdb_byte *buf = register_buffer (regno);
1244 fprintf_unfiltered (gdb_stdlog, " = ");
1245 for (int i = 0; i < size; i++)
1247 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
1249 if (size <= sizeof (LONGEST))
1251 ULONGEST val = extract_unsigned_integer (buf, size, byte_order);
1253 fprintf_unfiltered (gdb_stdlog, " %s %s",
1254 core_addr_to_string_nz (val), plongest (val));
1257 fprintf_unfiltered (gdb_stdlog, "\n");
1261 reg_flush_command (const char *command, int from_tty)
1263 /* Force-flush the register cache. */
1264 registers_changed ();
1266 printf_filtered (_("Register cache flushed.\n"));
1270 register_dump::dump (ui_file *file)
1272 auto descr = regcache_descr (m_gdbarch);
1274 int footnote_nr = 0;
1275 int footnote_register_offset = 0;
1276 int footnote_register_type_name_null = 0;
1277 long register_offset = 0;
1279 gdb_assert (descr->nr_cooked_registers
1280 == (gdbarch_num_regs (m_gdbarch)
1281 + gdbarch_num_pseudo_regs (m_gdbarch)));
1283 for (regnum = -1; regnum < descr->nr_cooked_registers; regnum++)
1287 fprintf_unfiltered (file, " %-10s", "Name");
1290 const char *p = gdbarch_register_name (m_gdbarch, regnum);
1294 else if (p[0] == '\0')
1296 fprintf_unfiltered (file, " %-10s", p);
1301 fprintf_unfiltered (file, " %4s", "Nr");
1303 fprintf_unfiltered (file, " %4d", regnum);
1305 /* Relative number. */
1307 fprintf_unfiltered (file, " %4s", "Rel");
1308 else if (regnum < gdbarch_num_regs (m_gdbarch))
1309 fprintf_unfiltered (file, " %4d", regnum);
1311 fprintf_unfiltered (file, " %4d",
1312 (regnum - gdbarch_num_regs (m_gdbarch)));
1316 fprintf_unfiltered (file, " %6s ", "Offset");
1319 fprintf_unfiltered (file, " %6ld",
1320 descr->register_offset[regnum]);
1321 if (register_offset != descr->register_offset[regnum]
1323 && (descr->register_offset[regnum]
1324 != (descr->register_offset[regnum - 1]
1325 + descr->sizeof_register[regnum - 1])))
1328 if (!footnote_register_offset)
1329 footnote_register_offset = ++footnote_nr;
1330 fprintf_unfiltered (file, "*%d", footnote_register_offset);
1333 fprintf_unfiltered (file, " ");
1334 register_offset = (descr->register_offset[regnum]
1335 + descr->sizeof_register[regnum]);
1340 fprintf_unfiltered (file, " %5s ", "Size");
1342 fprintf_unfiltered (file, " %5ld", descr->sizeof_register[regnum]);
1347 std::string name_holder;
1353 static const char blt[] = "builtin_type";
1355 t = TYPE_NAME (register_type (m_gdbarch, regnum));
1358 if (!footnote_register_type_name_null)
1359 footnote_register_type_name_null = ++footnote_nr;
1360 name_holder = string_printf ("*%d",
1361 footnote_register_type_name_null);
1362 t = name_holder.c_str ();
1364 /* Chop a leading builtin_type. */
1365 if (startswith (t, blt))
1368 fprintf_unfiltered (file, " %-15s", t);
1371 /* Leading space always present. */
1372 fprintf_unfiltered (file, " ");
1374 dump_reg (file, regnum);
1376 fprintf_unfiltered (file, "\n");
1379 if (footnote_register_offset)
1380 fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1381 footnote_register_offset);
1382 if (footnote_register_type_name_null)
1383 fprintf_unfiltered (file,
1384 "*%d: Register type's name NULL.\n",
1385 footnote_register_type_name_null);
1389 #include "selftest.h"
1390 #include "selftest-arch.h"
1391 #include "gdbthread.h"
1392 #include "target-float.h"
1394 namespace selftests {
1396 class regcache_access : public regcache
1400 /* Return the number of elements in current_regcache. */
1403 current_regcache_size ()
1405 return std::distance (regcache::current_regcache.begin (),
1406 regcache::current_regcache.end ());
1411 current_regcache_test (void)
1413 /* It is empty at the start. */
1414 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1416 ptid_t ptid1 (1), ptid2 (2), ptid3 (3);
1418 /* Get regcache from ptid1, a new regcache is added to
1419 current_regcache. */
1420 regcache *regcache = get_thread_arch_aspace_regcache (ptid1,
1424 SELF_CHECK (regcache != NULL);
1425 SELF_CHECK (regcache->ptid () == ptid1);
1426 SELF_CHECK (regcache_access::current_regcache_size () == 1);
1428 /* Get regcache from ptid2, a new regcache is added to
1429 current_regcache. */
1430 regcache = get_thread_arch_aspace_regcache (ptid2,
1433 SELF_CHECK (regcache != NULL);
1434 SELF_CHECK (regcache->ptid () == ptid2);
1435 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1437 /* Get regcache from ptid3, a new regcache is added to
1438 current_regcache. */
1439 regcache = get_thread_arch_aspace_regcache (ptid3,
1442 SELF_CHECK (regcache != NULL);
1443 SELF_CHECK (regcache->ptid () == ptid3);
1444 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1446 /* Get regcache from ptid2 again, nothing is added to
1447 current_regcache. */
1448 regcache = get_thread_arch_aspace_regcache (ptid2,
1451 SELF_CHECK (regcache != NULL);
1452 SELF_CHECK (regcache->ptid () == ptid2);
1453 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1455 /* Mark ptid2 is changed, so regcache of ptid2 should be removed from
1456 current_regcache. */
1457 registers_changed_ptid (ptid2);
1458 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1461 class target_ops_no_register : public test_target_ops
1464 target_ops_no_register ()
1465 : test_target_ops {}
1470 fetch_registers_called = 0;
1471 store_registers_called = 0;
1472 xfer_partial_called = 0;
1475 void fetch_registers (regcache *regs, int regno) override;
1476 void store_registers (regcache *regs, int regno) override;
1478 enum target_xfer_status xfer_partial (enum target_object object,
1479 const char *annex, gdb_byte *readbuf,
1480 const gdb_byte *writebuf,
1481 ULONGEST offset, ULONGEST len,
1482 ULONGEST *xfered_len) override;
1484 unsigned int fetch_registers_called = 0;
1485 unsigned int store_registers_called = 0;
1486 unsigned int xfer_partial_called = 0;
1490 target_ops_no_register::fetch_registers (regcache *regs, int regno)
1492 /* Mark register available. */
1493 regs->raw_supply_zeroed (regno);
1494 this->fetch_registers_called++;
1498 target_ops_no_register::store_registers (regcache *regs, int regno)
1500 this->store_registers_called++;
1503 enum target_xfer_status
1504 target_ops_no_register::xfer_partial (enum target_object object,
1505 const char *annex, gdb_byte *readbuf,
1506 const gdb_byte *writebuf,
1507 ULONGEST offset, ULONGEST len,
1508 ULONGEST *xfered_len)
1510 this->xfer_partial_called++;
1513 return TARGET_XFER_OK;
1516 class readwrite_regcache : public regcache
1519 readwrite_regcache (struct gdbarch *gdbarch)
1520 : regcache (gdbarch, nullptr)
1524 /* Test regcache::cooked_read gets registers from raw registers and
1525 memory instead of target to_{fetch,store}_registers. */
1528 cooked_read_test (struct gdbarch *gdbarch)
1530 /* Error out if debugging something, because we're going to push the
1531 test target, which would pop any existing target. */
1532 if (target_stack->to_stratum >= process_stratum)
1533 error (_("target already pushed"));
1535 /* Create a mock environment. An inferior with a thread, with a
1536 process_stratum target pushed. */
1538 target_ops_no_register mock_target;
1539 ptid_t mock_ptid (1, 1);
1540 inferior mock_inferior (mock_ptid.pid ());
1541 address_space mock_aspace {};
1542 mock_inferior.gdbarch = gdbarch;
1543 mock_inferior.aspace = &mock_aspace;
1544 thread_info mock_thread (&mock_inferior, mock_ptid);
1546 scoped_restore restore_thread_list
1547 = make_scoped_restore (&thread_list, &mock_thread);
1549 /* Add the mock inferior to the inferior list so that look ups by
1550 target+ptid can find it. */
1551 scoped_restore restore_inferior_list
1552 = make_scoped_restore (&inferior_list);
1553 inferior_list = &mock_inferior;
1555 /* Switch to the mock inferior. */
1556 scoped_restore_current_inferior restore_current_inferior;
1557 set_current_inferior (&mock_inferior);
1559 /* Push the process_stratum target so we can mock accessing
1561 push_target (&mock_target);
1563 /* Pop it again on exit (return/exception). */
1568 pop_all_targets_at_and_above (process_stratum);
1572 /* Switch to the mock thread. */
1573 scoped_restore restore_inferior_ptid
1574 = make_scoped_restore (&inferior_ptid, mock_ptid);
1576 /* Test that read one raw register from regcache_no_target will go
1577 to the target layer. */
1580 /* Find a raw register which size isn't zero. */
1581 for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
1583 if (register_size (gdbarch, regnum) != 0)
1587 readwrite_regcache readwrite (gdbarch);
1588 gdb::def_vector<gdb_byte> buf (register_size (gdbarch, regnum));
1590 readwrite.raw_read (regnum, buf.data ());
1592 /* raw_read calls target_fetch_registers. */
1593 SELF_CHECK (mock_target.fetch_registers_called > 0);
1594 mock_target.reset ();
1596 /* Mark all raw registers valid, so the following raw registers
1597 accesses won't go to target. */
1598 for (auto i = 0; i < gdbarch_num_regs (gdbarch); i++)
1599 readwrite.raw_update (i);
1601 mock_target.reset ();
1602 /* Then, read all raw and pseudo registers, and don't expect calling
1603 to_{fetch,store}_registers. */
1604 for (int regnum = 0;
1605 regnum < gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1608 if (register_size (gdbarch, regnum) == 0)
1611 gdb::def_vector<gdb_byte> buf (register_size (gdbarch, regnum));
1613 SELF_CHECK (REG_VALID == readwrite.cooked_read (regnum, buf.data ()));
1615 SELF_CHECK (mock_target.fetch_registers_called == 0);
1616 SELF_CHECK (mock_target.store_registers_called == 0);
1618 /* Some SPU pseudo registers are got via TARGET_OBJECT_SPU. */
1619 if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
1620 SELF_CHECK (mock_target.xfer_partial_called == 0);
1622 mock_target.reset ();
1625 readonly_detached_regcache readonly (readwrite);
1627 /* GDB may go to target layer to fetch all registers and memory for
1628 readonly regcache. */
1629 mock_target.reset ();
1631 for (int regnum = 0;
1632 regnum < gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1635 if (register_size (gdbarch, regnum) == 0)
1638 gdb::def_vector<gdb_byte> buf (register_size (gdbarch, regnum));
1639 enum register_status status = readonly.cooked_read (regnum,
1642 if (regnum < gdbarch_num_regs (gdbarch))
1644 auto bfd_arch = gdbarch_bfd_arch_info (gdbarch)->arch;
1646 if (bfd_arch == bfd_arch_frv || bfd_arch == bfd_arch_h8300
1647 || bfd_arch == bfd_arch_m32c || bfd_arch == bfd_arch_sh
1648 || bfd_arch == bfd_arch_alpha || bfd_arch == bfd_arch_v850
1649 || bfd_arch == bfd_arch_msp430 || bfd_arch == bfd_arch_mep
1650 || bfd_arch == bfd_arch_mips || bfd_arch == bfd_arch_v850_rh850
1651 || bfd_arch == bfd_arch_tic6x || bfd_arch == bfd_arch_mn10300
1652 || bfd_arch == bfd_arch_rl78 || bfd_arch == bfd_arch_score
1653 || bfd_arch == bfd_arch_riscv)
1655 /* Raw registers. If raw registers are not in save_reggroup,
1656 their status are unknown. */
1657 if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
1658 SELF_CHECK (status == REG_VALID);
1660 SELF_CHECK (status == REG_UNKNOWN);
1663 SELF_CHECK (status == REG_VALID);
1667 if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
1668 SELF_CHECK (status == REG_VALID);
1671 /* If pseudo registers are not in save_reggroup, some of
1672 them can be computed from saved raw registers, but some
1673 of them are unknown. */
1674 auto bfd_arch = gdbarch_bfd_arch_info (gdbarch)->arch;
1676 if (bfd_arch == bfd_arch_frv
1677 || bfd_arch == bfd_arch_m32c
1678 || bfd_arch == bfd_arch_mep
1679 || bfd_arch == bfd_arch_sh)
1680 SELF_CHECK (status == REG_VALID || status == REG_UNKNOWN);
1681 else if (bfd_arch == bfd_arch_mips
1682 || bfd_arch == bfd_arch_h8300)
1683 SELF_CHECK (status == REG_UNKNOWN);
1685 SELF_CHECK (status == REG_VALID);
1689 SELF_CHECK (mock_target.fetch_registers_called == 0);
1690 SELF_CHECK (mock_target.store_registers_called == 0);
1691 SELF_CHECK (mock_target.xfer_partial_called == 0);
1693 mock_target.reset ();
1697 /* Test regcache::cooked_write by writing some expected contents to
1698 registers, and checking that contents read from registers and the
1699 expected contents are the same. */
1702 cooked_write_test (struct gdbarch *gdbarch)
1704 /* Error out if debugging something, because we're going to push the
1705 test target, which would pop any existing target. */
1706 if (target_stack->to_stratum >= process_stratum)
1707 error (_("target already pushed"));
1709 /* Create a mock environment. A process_stratum target pushed. */
1711 target_ops_no_register mock_target;
1713 /* Push the process_stratum target so we can mock accessing
1715 push_target (&mock_target);
1717 /* Pop it again on exit (return/exception). */
1722 pop_all_targets_at_and_above (process_stratum);
1726 readwrite_regcache readwrite (gdbarch);
1728 const int num_regs = (gdbarch_num_regs (gdbarch)
1729 + gdbarch_num_pseudo_regs (gdbarch));
1731 for (auto regnum = 0; regnum < num_regs; regnum++)
1733 if (register_size (gdbarch, regnum) == 0
1734 || gdbarch_cannot_store_register (gdbarch, regnum))
1737 auto bfd_arch = gdbarch_bfd_arch_info (gdbarch)->arch;
1739 if ((bfd_arch == bfd_arch_sparc
1740 /* SPARC64_CWP_REGNUM, SPARC64_PSTATE_REGNUM,
1741 SPARC64_ASI_REGNUM and SPARC64_CCR_REGNUM are hard to test. */
1742 && gdbarch_ptr_bit (gdbarch) == 64
1743 && (regnum >= gdbarch_num_regs (gdbarch)
1744 && regnum <= gdbarch_num_regs (gdbarch) + 4))
1745 || (bfd_arch == bfd_arch_spu
1746 /* SPU pseudo registers except SPU_SP_REGNUM are got by
1747 TARGET_OBJECT_SPU. */
1748 && regnum >= gdbarch_num_regs (gdbarch) && regnum != 130))
1751 std::vector<gdb_byte> expected (register_size (gdbarch, regnum), 0);
1752 std::vector<gdb_byte> buf (register_size (gdbarch, regnum), 0);
1753 const auto type = register_type (gdbarch, regnum);
1755 if (TYPE_CODE (type) == TYPE_CODE_FLT
1756 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1758 /* Generate valid float format. */
1759 target_float_from_string (expected.data (), type, "1.25");
1761 else if (TYPE_CODE (type) == TYPE_CODE_INT
1762 || TYPE_CODE (type) == TYPE_CODE_ARRAY
1763 || TYPE_CODE (type) == TYPE_CODE_PTR
1764 || TYPE_CODE (type) == TYPE_CODE_UNION
1765 || TYPE_CODE (type) == TYPE_CODE_STRUCT)
1767 if (bfd_arch == bfd_arch_ia64
1768 || (regnum >= gdbarch_num_regs (gdbarch)
1769 && (bfd_arch == bfd_arch_xtensa
1770 || bfd_arch == bfd_arch_bfin
1771 || bfd_arch == bfd_arch_m32c
1772 /* m68hc11 pseudo registers are in memory. */
1773 || bfd_arch == bfd_arch_m68hc11
1774 || bfd_arch == bfd_arch_m68hc12
1775 || bfd_arch == bfd_arch_s390))
1776 || (bfd_arch == bfd_arch_frv
1777 /* FRV pseudo registers except iacc0. */
1778 && regnum > gdbarch_num_regs (gdbarch)))
1780 /* Skip setting the expected values for some architecture
1783 else if (bfd_arch == bfd_arch_rl78 && regnum == 40)
1785 /* RL78_PC_REGNUM */
1786 for (auto j = 0; j < register_size (gdbarch, regnum) - 1; j++)
1791 for (auto j = 0; j < register_size (gdbarch, regnum); j++)
1795 else if (TYPE_CODE (type) == TYPE_CODE_FLAGS)
1797 /* No idea how to test flags. */
1802 /* If we don't know how to create the expected value for the
1803 this type, make it fail. */
1807 readwrite.cooked_write (regnum, expected.data ());
1809 SELF_CHECK (readwrite.cooked_read (regnum, buf.data ()) == REG_VALID);
1810 SELF_CHECK (expected == buf);
1814 } // namespace selftests
1815 #endif /* GDB_SELF_TEST */
1818 _initialize_regcache (void)
1820 regcache_descr_handle
1821 = gdbarch_data_register_post_init (init_regcache_descr);
1823 gdb::observers::target_changed.attach (regcache_observer_target_changed);
1824 gdb::observers::thread_ptid_changed.attach
1825 (regcache::regcache_thread_ptid_changed);
1827 add_com ("flushregs", class_maintenance, reg_flush_command,
1828 _("Force gdb to flush its register cache (maintainer command)"));
1831 selftests::register_test ("current_regcache", selftests::current_regcache_test);
1833 selftests::register_test_foreach_arch ("regcache::cooked_read_test",
1834 selftests::cooked_read_test);
1835 selftests::register_test_foreach_arch ("regcache::cooked_write_test",
1836 selftests::cooked_write_test);