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 readable_regcache::raw_read (int regnum, gdb_byte *buf)
516 gdb_assert (buf != NULL);
519 if (m_register_status[regnum] != REG_VALID)
520 memset (buf, 0, m_descr->sizeof_register[regnum]);
522 memcpy (buf, register_buffer (regnum),
523 m_descr->sizeof_register[regnum]);
525 return (enum register_status) m_register_status[regnum];
529 regcache_raw_read_signed (struct regcache *regcache, int regnum, LONGEST *val)
531 gdb_assert (regcache != NULL);
532 return regcache->raw_read (regnum, val);
535 template<typename T, typename>
537 readable_regcache::raw_read (int regnum, T *val)
540 enum register_status status;
542 assert_regnum (regnum);
543 buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]);
544 status = raw_read (regnum, buf);
545 if (status == REG_VALID)
546 *val = extract_integer<T> (buf,
547 m_descr->sizeof_register[regnum],
548 gdbarch_byte_order (m_descr->gdbarch));
555 regcache_raw_read_unsigned (struct regcache *regcache, int regnum,
558 gdb_assert (regcache != NULL);
559 return regcache->raw_read (regnum, val);
563 regcache_raw_write_signed (struct regcache *regcache, int regnum, LONGEST val)
565 gdb_assert (regcache != NULL);
566 regcache->raw_write (regnum, val);
569 template<typename T, typename>
571 regcache::raw_write (int regnum, T val)
575 assert_regnum (regnum);
576 buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]);
577 store_integer (buf, m_descr->sizeof_register[regnum],
578 gdbarch_byte_order (m_descr->gdbarch), val);
579 raw_write (regnum, buf);
583 regcache_raw_write_unsigned (struct regcache *regcache, int regnum,
586 gdb_assert (regcache != NULL);
587 regcache->raw_write (regnum, val);
591 regcache_raw_get_signed (struct regcache *regcache, int regnum)
594 enum register_status status;
596 status = regcache_raw_read_signed (regcache, regnum, &value);
597 if (status == REG_UNAVAILABLE)
598 throw_error (NOT_AVAILABLE_ERROR,
599 _("Register %d is not available"), regnum);
604 regcache_cooked_read (struct regcache *regcache, int regnum, gdb_byte *buf)
606 return regcache->cooked_read (regnum, buf);
610 readable_regcache::cooked_read (int regnum, gdb_byte *buf)
612 gdb_assert (regnum >= 0);
613 gdb_assert (regnum < m_descr->nr_cooked_registers);
614 if (regnum < num_raw_registers ())
615 return raw_read (regnum, buf);
616 else if (m_has_pseudo
617 && m_register_status[regnum] != REG_UNKNOWN)
619 if (m_register_status[regnum] == REG_VALID)
620 memcpy (buf, register_buffer (regnum),
621 m_descr->sizeof_register[regnum]);
623 memset (buf, 0, m_descr->sizeof_register[regnum]);
625 return (enum register_status) m_register_status[regnum];
627 else if (gdbarch_pseudo_register_read_value_p (m_descr->gdbarch))
629 struct value *mark, *computed;
630 enum register_status result = REG_VALID;
632 mark = value_mark ();
634 computed = gdbarch_pseudo_register_read_value (m_descr->gdbarch,
636 if (value_entirely_available (computed))
637 memcpy (buf, value_contents_raw (computed),
638 m_descr->sizeof_register[regnum]);
641 memset (buf, 0, m_descr->sizeof_register[regnum]);
642 result = REG_UNAVAILABLE;
645 value_free_to_mark (mark);
650 return gdbarch_pseudo_register_read (m_descr->gdbarch, this,
655 regcache_cooked_read_value (struct regcache *regcache, int regnum)
657 return regcache->cooked_read_value (regnum);
661 readable_regcache::cooked_read_value (int regnum)
663 gdb_assert (regnum >= 0);
664 gdb_assert (regnum < m_descr->nr_cooked_registers);
666 if (regnum < num_raw_registers ()
667 || (m_has_pseudo && m_register_status[regnum] != REG_UNKNOWN)
668 || !gdbarch_pseudo_register_read_value_p (m_descr->gdbarch))
670 struct value *result;
672 result = allocate_value (register_type (m_descr->gdbarch, regnum));
673 VALUE_LVAL (result) = lval_register;
674 VALUE_REGNUM (result) = regnum;
676 /* It is more efficient in general to do this delegation in this
677 direction than in the other one, even though the value-based
679 if (cooked_read (regnum,
680 value_contents_raw (result)) == REG_UNAVAILABLE)
681 mark_value_bytes_unavailable (result, 0,
682 TYPE_LENGTH (value_type (result)));
687 return gdbarch_pseudo_register_read_value (m_descr->gdbarch,
692 regcache_cooked_read_signed (struct regcache *regcache, int regnum,
695 gdb_assert (regcache != NULL);
696 return regcache->cooked_read (regnum, val);
699 template<typename T, typename>
701 readable_regcache::cooked_read (int regnum, T *val)
703 enum register_status status;
706 gdb_assert (regnum >= 0 && regnum < m_descr->nr_cooked_registers);
707 buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]);
708 status = cooked_read (regnum, buf);
709 if (status == REG_VALID)
710 *val = extract_integer<T> (buf, m_descr->sizeof_register[regnum],
711 gdbarch_byte_order (m_descr->gdbarch));
718 regcache_cooked_read_unsigned (struct regcache *regcache, int regnum,
721 gdb_assert (regcache != NULL);
722 return regcache->cooked_read (regnum, val);
726 regcache_cooked_write_signed (struct regcache *regcache, int regnum,
729 gdb_assert (regcache != NULL);
730 regcache->cooked_write (regnum, val);
733 template<typename T, typename>
735 regcache::cooked_write (int regnum, T val)
739 gdb_assert (regnum >=0 && regnum < m_descr->nr_cooked_registers);
740 buf = (gdb_byte *) alloca (m_descr->sizeof_register[regnum]);
741 store_integer (buf, m_descr->sizeof_register[regnum],
742 gdbarch_byte_order (m_descr->gdbarch), val);
743 cooked_write (regnum, buf);
747 regcache_cooked_write_unsigned (struct regcache *regcache, int regnum,
750 gdb_assert (regcache != NULL);
751 regcache->cooked_write (regnum, val);
755 regcache::raw_write (int regnum, const gdb_byte *buf)
758 gdb_assert (buf != NULL);
759 assert_regnum (regnum);
761 /* On the sparc, writing %g0 is a no-op, so we don't even want to
762 change the registers array if something writes to this register. */
763 if (gdbarch_cannot_store_register (arch (), regnum))
766 /* If we have a valid copy of the register, and new value == old
767 value, then don't bother doing the actual store. */
768 if (get_register_status (regnum) == REG_VALID
769 && (memcmp (register_buffer (regnum), buf,
770 m_descr->sizeof_register[regnum]) == 0))
773 target_prepare_to_store (this);
774 raw_supply (regnum, buf);
776 /* Invalidate the register after it is written, in case of a
778 regcache_invalidator invalidator (this, regnum);
780 target_store_registers (this, regnum);
782 /* The target did not throw an error so we can discard invalidating
784 invalidator.release ();
788 regcache_cooked_write (struct regcache *regcache, int regnum,
791 regcache->cooked_write (regnum, buf);
795 regcache::cooked_write (int regnum, const gdb_byte *buf)
797 gdb_assert (regnum >= 0);
798 gdb_assert (regnum < m_descr->nr_cooked_registers);
799 if (regnum < num_raw_registers ())
800 raw_write (regnum, buf);
802 gdbarch_pseudo_register_write (m_descr->gdbarch, this,
806 /* Perform a partial register transfer using a read, modify, write
810 readable_regcache::read_part (int regnum, int offset, int len, void *in,
813 struct gdbarch *gdbarch = arch ();
814 gdb_byte *reg = (gdb_byte *) alloca (register_size (gdbarch, regnum));
816 gdb_assert (in != NULL);
817 gdb_assert (offset >= 0 && offset <= m_descr->sizeof_register[regnum]);
818 gdb_assert (len >= 0 && offset + len <= m_descr->sizeof_register[regnum]);
819 /* Something to do? */
820 if (offset + len == 0)
822 /* Read (when needed) ... */
823 enum register_status status;
826 status = raw_read (regnum, reg);
828 status = cooked_read (regnum, reg);
829 if (status != REG_VALID)
833 memcpy (in, reg + offset, len);
839 regcache::write_part (int regnum, int offset, int len,
840 const void *out, bool is_raw)
842 struct gdbarch *gdbarch = arch ();
843 gdb_byte *reg = (gdb_byte *) alloca (register_size (gdbarch, regnum));
845 gdb_assert (out != NULL);
846 gdb_assert (offset >= 0 && offset <= m_descr->sizeof_register[regnum]);
847 gdb_assert (len >= 0 && offset + len <= m_descr->sizeof_register[regnum]);
848 /* Something to do? */
849 if (offset + len == 0)
851 /* Read (when needed) ... */
853 || offset + len < m_descr->sizeof_register[regnum])
855 enum register_status status;
858 status = raw_read (regnum, reg);
860 status = cooked_read (regnum, reg);
861 if (status != REG_VALID)
865 memcpy (reg + offset, out, len);
866 /* ... write (when needed). */
868 raw_write (regnum, reg);
870 cooked_write (regnum, reg);
876 regcache_raw_read_part (struct regcache *regcache, int regnum,
877 int offset, int len, gdb_byte *buf)
879 return regcache->raw_read_part (regnum, offset, len, buf);
883 readable_regcache::raw_read_part (int regnum, int offset, int len, gdb_byte *buf)
885 assert_regnum (regnum);
886 return read_part (regnum, offset, len, buf, true);
890 regcache_raw_write_part (struct regcache *regcache, int regnum,
891 int offset, int len, const gdb_byte *buf)
893 regcache->raw_write_part (regnum, offset, len, buf);
897 regcache::raw_write_part (int regnum, int offset, int len,
900 assert_regnum (regnum);
901 write_part (regnum, offset, len, buf, true);
905 regcache_cooked_read_part (struct regcache *regcache, int regnum,
906 int offset, int len, gdb_byte *buf)
908 return regcache->cooked_read_part (regnum, offset, len, buf);
913 readable_regcache::cooked_read_part (int regnum, int offset, int len,
916 gdb_assert (regnum >= 0 && regnum < m_descr->nr_cooked_registers);
917 return read_part (regnum, offset, len, buf, false);
921 regcache_cooked_write_part (struct regcache *regcache, int regnum,
922 int offset, int len, const gdb_byte *buf)
924 regcache->cooked_write_part (regnum, offset, len, buf);
928 regcache::cooked_write_part (int regnum, int offset, int len,
931 gdb_assert (regnum >= 0 && regnum < m_descr->nr_cooked_registers);
932 write_part (regnum, offset, len, buf, false);
935 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
938 regcache_raw_supply (struct regcache *regcache, int regnum, const void *buf)
940 gdb_assert (regcache != NULL);
941 regcache->raw_supply (regnum, buf);
945 detached_regcache::raw_supply (int regnum, const void *buf)
950 assert_regnum (regnum);
952 regbuf = register_buffer (regnum);
953 size = m_descr->sizeof_register[regnum];
957 memcpy (regbuf, buf, size);
958 m_register_status[regnum] = REG_VALID;
962 /* This memset not strictly necessary, but better than garbage
963 in case the register value manages to escape somewhere (due
964 to a bug, no less). */
965 memset (regbuf, 0, size);
966 m_register_status[regnum] = REG_UNAVAILABLE;
970 /* Supply register REGNUM to REGCACHE. Value to supply is an integer stored at
971 address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED. If
972 the register size is greater than ADDR_LEN, then the integer will be sign or
973 zero extended. If the register size is smaller than the integer, then the
974 most significant bytes of the integer will be truncated. */
977 detached_regcache::raw_supply_integer (int regnum, const gdb_byte *addr,
978 int addr_len, bool is_signed)
980 enum bfd_endian byte_order = gdbarch_byte_order (m_descr->gdbarch);
984 assert_regnum (regnum);
986 regbuf = register_buffer (regnum);
987 regsize = m_descr->sizeof_register[regnum];
989 copy_integer_to_size (regbuf, regsize, addr, addr_len, is_signed,
991 m_register_status[regnum] = REG_VALID;
994 /* Supply register REGNUM with zeroed value to REGCACHE. This is not the same
995 as calling raw_supply with NULL (which will set the state to
999 detached_regcache::raw_supply_zeroed (int regnum)
1004 assert_regnum (regnum);
1006 regbuf = register_buffer (regnum);
1007 size = m_descr->sizeof_register[regnum];
1009 memset (regbuf, 0, size);
1010 m_register_status[regnum] = REG_VALID;
1013 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1016 regcache_raw_collect (const struct regcache *regcache, int regnum, void *buf)
1018 gdb_assert (regcache != NULL && buf != NULL);
1019 regcache->raw_collect (regnum, buf);
1023 regcache::raw_collect (int regnum, void *buf) const
1028 gdb_assert (buf != NULL);
1029 assert_regnum (regnum);
1031 regbuf = register_buffer (regnum);
1032 size = m_descr->sizeof_register[regnum];
1033 memcpy (buf, regbuf, size);
1036 /* Transfer a single or all registers belonging to a certain register
1037 set to or from a buffer. This is the main worker function for
1038 regcache_supply_regset and regcache_collect_regset. */
1040 /* Collect register REGNUM from REGCACHE. Store collected value as an integer
1041 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
1042 If ADDR_LEN is greater than the register size, then the integer will be sign
1043 or zero extended. If ADDR_LEN is smaller than the register size, then the
1044 most significant bytes of the integer will be truncated. */
1047 regcache::raw_collect_integer (int regnum, gdb_byte *addr, int addr_len,
1048 bool is_signed) const
1050 enum bfd_endian byte_order = gdbarch_byte_order (m_descr->gdbarch);
1051 const gdb_byte *regbuf;
1054 assert_regnum (regnum);
1056 regbuf = register_buffer (regnum);
1057 regsize = m_descr->sizeof_register[regnum];
1059 copy_integer_to_size (addr, addr_len, regbuf, regsize, is_signed,
1064 regcache::transfer_regset (const struct regset *regset,
1065 struct regcache *out_regcache,
1066 int regnum, const void *in_buf,
1067 void *out_buf, size_t size) const
1069 const struct regcache_map_entry *map;
1070 int offs = 0, count;
1072 for (map = (const struct regcache_map_entry *) regset->regmap;
1073 (count = map->count) != 0;
1076 int regno = map->regno;
1077 int slot_size = map->size;
1079 if (slot_size == 0 && regno != REGCACHE_MAP_SKIP)
1080 slot_size = m_descr->sizeof_register[regno];
1082 if (regno == REGCACHE_MAP_SKIP
1084 && (regnum < regno || regnum >= regno + count)))
1085 offs += count * slot_size;
1087 else if (regnum == -1)
1088 for (; count--; regno++, offs += slot_size)
1090 if (offs + slot_size > size)
1094 raw_collect (regno, (gdb_byte *) out_buf + offs);
1096 out_regcache->raw_supply (regno, in_buf
1097 ? (const gdb_byte *) in_buf + offs
1102 /* Transfer a single register and return. */
1103 offs += (regnum - regno) * slot_size;
1104 if (offs + slot_size > size)
1108 raw_collect (regnum, (gdb_byte *) out_buf + offs);
1110 out_regcache->raw_supply (regnum, in_buf
1111 ? (const gdb_byte *) in_buf + offs
1118 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1119 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1120 If BUF is NULL, set the register(s) to "unavailable" status. */
1123 regcache_supply_regset (const struct regset *regset,
1124 struct regcache *regcache,
1125 int regnum, const void *buf, size_t size)
1127 regcache->supply_regset (regset, regnum, buf, size);
1131 regcache::supply_regset (const struct regset *regset,
1132 int regnum, const void *buf, size_t size)
1134 transfer_regset (regset, this, regnum, buf, NULL, size);
1137 /* Collect register REGNUM from REGCACHE to BUF, using the register
1138 map in REGSET. If REGNUM is -1, do this for all registers in
1142 regcache_collect_regset (const struct regset *regset,
1143 const struct regcache *regcache,
1144 int regnum, void *buf, size_t size)
1146 regcache->collect_regset (regset, regnum, buf, size);
1150 regcache::collect_regset (const struct regset *regset,
1151 int regnum, void *buf, size_t size) const
1153 transfer_regset (regset, NULL, regnum, NULL, buf, size);
1157 /* Special handling for register PC. */
1160 regcache_read_pc (struct regcache *regcache)
1162 struct gdbarch *gdbarch = regcache->arch ();
1166 if (gdbarch_read_pc_p (gdbarch))
1167 pc_val = gdbarch_read_pc (gdbarch, regcache);
1168 /* Else use per-frame method on get_current_frame. */
1169 else if (gdbarch_pc_regnum (gdbarch) >= 0)
1173 if (regcache_cooked_read_unsigned (regcache,
1174 gdbarch_pc_regnum (gdbarch),
1175 &raw_val) == REG_UNAVAILABLE)
1176 throw_error (NOT_AVAILABLE_ERROR, _("PC register is not available"));
1178 pc_val = gdbarch_addr_bits_remove (gdbarch, raw_val);
1181 internal_error (__FILE__, __LINE__,
1182 _("regcache_read_pc: Unable to find PC"));
1187 regcache_write_pc (struct regcache *regcache, CORE_ADDR pc)
1189 struct gdbarch *gdbarch = regcache->arch ();
1191 if (gdbarch_write_pc_p (gdbarch))
1192 gdbarch_write_pc (gdbarch, regcache, pc);
1193 else if (gdbarch_pc_regnum (gdbarch) >= 0)
1194 regcache_cooked_write_unsigned (regcache,
1195 gdbarch_pc_regnum (gdbarch), pc);
1197 internal_error (__FILE__, __LINE__,
1198 _("regcache_write_pc: Unable to update PC"));
1200 /* Writing the PC (for instance, from "load") invalidates the
1202 reinit_frame_cache ();
1206 reg_buffer::num_raw_registers () const
1208 return gdbarch_num_regs (arch ());
1212 regcache::debug_print_register (const char *func, int regno)
1214 struct gdbarch *gdbarch = arch ();
1216 fprintf_unfiltered (gdb_stdlog, "%s ", func);
1217 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch)
1218 && gdbarch_register_name (gdbarch, regno) != NULL
1219 && gdbarch_register_name (gdbarch, regno)[0] != '\0')
1220 fprintf_unfiltered (gdb_stdlog, "(%s)",
1221 gdbarch_register_name (gdbarch, regno));
1223 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
1224 if (regno >= 0 && regno < gdbarch_num_regs (gdbarch))
1226 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1227 int size = register_size (gdbarch, regno);
1228 gdb_byte *buf = register_buffer (regno);
1230 fprintf_unfiltered (gdb_stdlog, " = ");
1231 for (int i = 0; i < size; i++)
1233 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
1235 if (size <= sizeof (LONGEST))
1237 ULONGEST val = extract_unsigned_integer (buf, size, byte_order);
1239 fprintf_unfiltered (gdb_stdlog, " %s %s",
1240 core_addr_to_string_nz (val), plongest (val));
1243 fprintf_unfiltered (gdb_stdlog, "\n");
1247 reg_flush_command (const char *command, int from_tty)
1249 /* Force-flush the register cache. */
1250 registers_changed ();
1252 printf_filtered (_("Register cache flushed.\n"));
1256 register_dump::dump (ui_file *file)
1258 auto descr = regcache_descr (m_gdbarch);
1260 int footnote_nr = 0;
1261 int footnote_register_offset = 0;
1262 int footnote_register_type_name_null = 0;
1263 long register_offset = 0;
1265 gdb_assert (descr->nr_cooked_registers
1266 == (gdbarch_num_regs (m_gdbarch)
1267 + gdbarch_num_pseudo_regs (m_gdbarch)));
1269 for (regnum = -1; regnum < descr->nr_cooked_registers; regnum++)
1273 fprintf_unfiltered (file, " %-10s", "Name");
1276 const char *p = gdbarch_register_name (m_gdbarch, regnum);
1280 else if (p[0] == '\0')
1282 fprintf_unfiltered (file, " %-10s", p);
1287 fprintf_unfiltered (file, " %4s", "Nr");
1289 fprintf_unfiltered (file, " %4d", regnum);
1291 /* Relative number. */
1293 fprintf_unfiltered (file, " %4s", "Rel");
1294 else if (regnum < gdbarch_num_regs (m_gdbarch))
1295 fprintf_unfiltered (file, " %4d", regnum);
1297 fprintf_unfiltered (file, " %4d",
1298 (regnum - gdbarch_num_regs (m_gdbarch)));
1302 fprintf_unfiltered (file, " %6s ", "Offset");
1305 fprintf_unfiltered (file, " %6ld",
1306 descr->register_offset[regnum]);
1307 if (register_offset != descr->register_offset[regnum]
1309 && (descr->register_offset[regnum]
1310 != (descr->register_offset[regnum - 1]
1311 + descr->sizeof_register[regnum - 1])))
1314 if (!footnote_register_offset)
1315 footnote_register_offset = ++footnote_nr;
1316 fprintf_unfiltered (file, "*%d", footnote_register_offset);
1319 fprintf_unfiltered (file, " ");
1320 register_offset = (descr->register_offset[regnum]
1321 + descr->sizeof_register[regnum]);
1326 fprintf_unfiltered (file, " %5s ", "Size");
1328 fprintf_unfiltered (file, " %5ld", descr->sizeof_register[regnum]);
1333 std::string name_holder;
1339 static const char blt[] = "builtin_type";
1341 t = TYPE_NAME (register_type (m_gdbarch, regnum));
1344 if (!footnote_register_type_name_null)
1345 footnote_register_type_name_null = ++footnote_nr;
1346 name_holder = string_printf ("*%d",
1347 footnote_register_type_name_null);
1348 t = name_holder.c_str ();
1350 /* Chop a leading builtin_type. */
1351 if (startswith (t, blt))
1354 fprintf_unfiltered (file, " %-15s", t);
1357 /* Leading space always present. */
1358 fprintf_unfiltered (file, " ");
1360 dump_reg (file, regnum);
1362 fprintf_unfiltered (file, "\n");
1365 if (footnote_register_offset)
1366 fprintf_unfiltered (file, "*%d: Inconsistent register offsets.\n",
1367 footnote_register_offset);
1368 if (footnote_register_type_name_null)
1369 fprintf_unfiltered (file,
1370 "*%d: Register type's name NULL.\n",
1371 footnote_register_type_name_null);
1375 #include "selftest.h"
1376 #include "selftest-arch.h"
1377 #include "gdbthread.h"
1378 #include "target-float.h"
1380 namespace selftests {
1382 class regcache_access : public regcache
1386 /* Return the number of elements in current_regcache. */
1389 current_regcache_size ()
1391 return std::distance (regcache::current_regcache.begin (),
1392 regcache::current_regcache.end ());
1397 current_regcache_test (void)
1399 /* It is empty at the start. */
1400 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1402 ptid_t ptid1 (1), ptid2 (2), ptid3 (3);
1404 /* Get regcache from ptid1, a new regcache is added to
1405 current_regcache. */
1406 regcache *regcache = get_thread_arch_aspace_regcache (ptid1,
1410 SELF_CHECK (regcache != NULL);
1411 SELF_CHECK (regcache->ptid () == ptid1);
1412 SELF_CHECK (regcache_access::current_regcache_size () == 1);
1414 /* Get regcache from ptid2, a new regcache is added to
1415 current_regcache. */
1416 regcache = get_thread_arch_aspace_regcache (ptid2,
1419 SELF_CHECK (regcache != NULL);
1420 SELF_CHECK (regcache->ptid () == ptid2);
1421 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1423 /* Get regcache from ptid3, a new regcache is added to
1424 current_regcache. */
1425 regcache = get_thread_arch_aspace_regcache (ptid3,
1428 SELF_CHECK (regcache != NULL);
1429 SELF_CHECK (regcache->ptid () == ptid3);
1430 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1432 /* Get regcache from ptid2 again, nothing is added to
1433 current_regcache. */
1434 regcache = get_thread_arch_aspace_regcache (ptid2,
1437 SELF_CHECK (regcache != NULL);
1438 SELF_CHECK (regcache->ptid () == ptid2);
1439 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1441 /* Mark ptid2 is changed, so regcache of ptid2 should be removed from
1442 current_regcache. */
1443 registers_changed_ptid (ptid2);
1444 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1447 class target_ops_no_register : public test_target_ops
1450 target_ops_no_register ()
1451 : test_target_ops {}
1456 fetch_registers_called = 0;
1457 store_registers_called = 0;
1458 xfer_partial_called = 0;
1461 void fetch_registers (regcache *regs, int regno) override;
1462 void store_registers (regcache *regs, int regno) override;
1464 enum target_xfer_status xfer_partial (enum target_object object,
1465 const char *annex, gdb_byte *readbuf,
1466 const gdb_byte *writebuf,
1467 ULONGEST offset, ULONGEST len,
1468 ULONGEST *xfered_len) override;
1470 unsigned int fetch_registers_called = 0;
1471 unsigned int store_registers_called = 0;
1472 unsigned int xfer_partial_called = 0;
1476 target_ops_no_register::fetch_registers (regcache *regs, int regno)
1478 /* Mark register available. */
1479 regs->raw_supply_zeroed (regno);
1480 this->fetch_registers_called++;
1484 target_ops_no_register::store_registers (regcache *regs, int regno)
1486 this->store_registers_called++;
1489 enum target_xfer_status
1490 target_ops_no_register::xfer_partial (enum target_object object,
1491 const char *annex, gdb_byte *readbuf,
1492 const gdb_byte *writebuf,
1493 ULONGEST offset, ULONGEST len,
1494 ULONGEST *xfered_len)
1496 this->xfer_partial_called++;
1499 return TARGET_XFER_OK;
1502 class readwrite_regcache : public regcache
1505 readwrite_regcache (struct gdbarch *gdbarch)
1506 : regcache (gdbarch, nullptr)
1510 /* Test regcache::cooked_read gets registers from raw registers and
1511 memory instead of target to_{fetch,store}_registers. */
1514 cooked_read_test (struct gdbarch *gdbarch)
1516 /* Error out if debugging something, because we're going to push the
1517 test target, which would pop any existing target. */
1518 if (target_stack->to_stratum >= process_stratum)
1519 error (_("target already pushed"));
1521 /* Create a mock environment. An inferior with a thread, with a
1522 process_stratum target pushed. */
1524 target_ops_no_register mock_target;
1525 ptid_t mock_ptid (1, 1);
1526 inferior mock_inferior (mock_ptid.pid ());
1527 address_space mock_aspace {};
1528 mock_inferior.gdbarch = gdbarch;
1529 mock_inferior.aspace = &mock_aspace;
1530 thread_info mock_thread (&mock_inferior, mock_ptid);
1532 scoped_restore restore_thread_list
1533 = make_scoped_restore (&thread_list, &mock_thread);
1535 /* Add the mock inferior to the inferior list so that look ups by
1536 target+ptid can find it. */
1537 scoped_restore restore_inferior_list
1538 = make_scoped_restore (&inferior_list);
1539 inferior_list = &mock_inferior;
1541 /* Switch to the mock inferior. */
1542 scoped_restore_current_inferior restore_current_inferior;
1543 set_current_inferior (&mock_inferior);
1545 /* Push the process_stratum target so we can mock accessing
1547 push_target (&mock_target);
1549 /* Pop it again on exit (return/exception). */
1554 pop_all_targets_at_and_above (process_stratum);
1558 /* Switch to the mock thread. */
1559 scoped_restore restore_inferior_ptid
1560 = make_scoped_restore (&inferior_ptid, mock_ptid);
1562 /* Test that read one raw register from regcache_no_target will go
1563 to the target layer. */
1566 /* Find a raw register which size isn't zero. */
1567 for (regnum = 0; regnum < gdbarch_num_regs (gdbarch); regnum++)
1569 if (register_size (gdbarch, regnum) != 0)
1573 readwrite_regcache readwrite (gdbarch);
1574 gdb::def_vector<gdb_byte> buf (register_size (gdbarch, regnum));
1576 readwrite.raw_read (regnum, buf.data ());
1578 /* raw_read calls target_fetch_registers. */
1579 SELF_CHECK (mock_target.fetch_registers_called > 0);
1580 mock_target.reset ();
1582 /* Mark all raw registers valid, so the following raw registers
1583 accesses won't go to target. */
1584 for (auto i = 0; i < gdbarch_num_regs (gdbarch); i++)
1585 readwrite.raw_update (i);
1587 mock_target.reset ();
1588 /* Then, read all raw and pseudo registers, and don't expect calling
1589 to_{fetch,store}_registers. */
1590 for (int regnum = 0;
1591 regnum < gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1594 if (register_size (gdbarch, regnum) == 0)
1597 gdb::def_vector<gdb_byte> buf (register_size (gdbarch, regnum));
1599 SELF_CHECK (REG_VALID == readwrite.cooked_read (regnum, buf.data ()));
1601 SELF_CHECK (mock_target.fetch_registers_called == 0);
1602 SELF_CHECK (mock_target.store_registers_called == 0);
1604 /* Some SPU pseudo registers are got via TARGET_OBJECT_SPU. */
1605 if (gdbarch_bfd_arch_info (gdbarch)->arch != bfd_arch_spu)
1606 SELF_CHECK (mock_target.xfer_partial_called == 0);
1608 mock_target.reset ();
1611 readonly_detached_regcache readonly (readwrite);
1613 /* GDB may go to target layer to fetch all registers and memory for
1614 readonly regcache. */
1615 mock_target.reset ();
1617 for (int regnum = 0;
1618 regnum < gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1621 if (register_size (gdbarch, regnum) == 0)
1624 gdb::def_vector<gdb_byte> buf (register_size (gdbarch, regnum));
1625 enum register_status status = readonly.cooked_read (regnum,
1628 if (regnum < gdbarch_num_regs (gdbarch))
1630 auto bfd_arch = gdbarch_bfd_arch_info (gdbarch)->arch;
1632 if (bfd_arch == bfd_arch_frv || bfd_arch == bfd_arch_h8300
1633 || bfd_arch == bfd_arch_m32c || bfd_arch == bfd_arch_sh
1634 || bfd_arch == bfd_arch_alpha || bfd_arch == bfd_arch_v850
1635 || bfd_arch == bfd_arch_msp430 || bfd_arch == bfd_arch_mep
1636 || bfd_arch == bfd_arch_mips || bfd_arch == bfd_arch_v850_rh850
1637 || bfd_arch == bfd_arch_tic6x || bfd_arch == bfd_arch_mn10300
1638 || bfd_arch == bfd_arch_rl78 || bfd_arch == bfd_arch_score
1639 || bfd_arch == bfd_arch_riscv)
1641 /* Raw registers. If raw registers are not in save_reggroup,
1642 their status are unknown. */
1643 if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
1644 SELF_CHECK (status == REG_VALID);
1646 SELF_CHECK (status == REG_UNKNOWN);
1649 SELF_CHECK (status == REG_VALID);
1653 if (gdbarch_register_reggroup_p (gdbarch, regnum, save_reggroup))
1654 SELF_CHECK (status == REG_VALID);
1657 /* If pseudo registers are not in save_reggroup, some of
1658 them can be computed from saved raw registers, but some
1659 of them are unknown. */
1660 auto bfd_arch = gdbarch_bfd_arch_info (gdbarch)->arch;
1662 if (bfd_arch == bfd_arch_frv
1663 || bfd_arch == bfd_arch_m32c
1664 || bfd_arch == bfd_arch_mep
1665 || bfd_arch == bfd_arch_sh)
1666 SELF_CHECK (status == REG_VALID || status == REG_UNKNOWN);
1667 else if (bfd_arch == bfd_arch_mips
1668 || bfd_arch == bfd_arch_h8300)
1669 SELF_CHECK (status == REG_UNKNOWN);
1671 SELF_CHECK (status == REG_VALID);
1675 SELF_CHECK (mock_target.fetch_registers_called == 0);
1676 SELF_CHECK (mock_target.store_registers_called == 0);
1677 SELF_CHECK (mock_target.xfer_partial_called == 0);
1679 mock_target.reset ();
1683 /* Test regcache::cooked_write by writing some expected contents to
1684 registers, and checking that contents read from registers and the
1685 expected contents are the same. */
1688 cooked_write_test (struct gdbarch *gdbarch)
1690 /* Error out if debugging something, because we're going to push the
1691 test target, which would pop any existing target. */
1692 if (target_stack->to_stratum >= process_stratum)
1693 error (_("target already pushed"));
1695 /* Create a mock environment. A process_stratum target pushed. */
1697 target_ops_no_register mock_target;
1699 /* Push the process_stratum target so we can mock accessing
1701 push_target (&mock_target);
1703 /* Pop it again on exit (return/exception). */
1708 pop_all_targets_at_and_above (process_stratum);
1712 readwrite_regcache readwrite (gdbarch);
1714 const int num_regs = (gdbarch_num_regs (gdbarch)
1715 + gdbarch_num_pseudo_regs (gdbarch));
1717 for (auto regnum = 0; regnum < num_regs; regnum++)
1719 if (register_size (gdbarch, regnum) == 0
1720 || gdbarch_cannot_store_register (gdbarch, regnum))
1723 auto bfd_arch = gdbarch_bfd_arch_info (gdbarch)->arch;
1725 if ((bfd_arch == bfd_arch_sparc
1726 /* SPARC64_CWP_REGNUM, SPARC64_PSTATE_REGNUM,
1727 SPARC64_ASI_REGNUM and SPARC64_CCR_REGNUM are hard to test. */
1728 && gdbarch_ptr_bit (gdbarch) == 64
1729 && (regnum >= gdbarch_num_regs (gdbarch)
1730 && regnum <= gdbarch_num_regs (gdbarch) + 4))
1731 || (bfd_arch == bfd_arch_spu
1732 /* SPU pseudo registers except SPU_SP_REGNUM are got by
1733 TARGET_OBJECT_SPU. */
1734 && regnum >= gdbarch_num_regs (gdbarch) && regnum != 130))
1737 std::vector<gdb_byte> expected (register_size (gdbarch, regnum), 0);
1738 std::vector<gdb_byte> buf (register_size (gdbarch, regnum), 0);
1739 const auto type = register_type (gdbarch, regnum);
1741 if (TYPE_CODE (type) == TYPE_CODE_FLT
1742 || TYPE_CODE (type) == TYPE_CODE_DECFLOAT)
1744 /* Generate valid float format. */
1745 target_float_from_string (expected.data (), type, "1.25");
1747 else if (TYPE_CODE (type) == TYPE_CODE_INT
1748 || TYPE_CODE (type) == TYPE_CODE_ARRAY
1749 || TYPE_CODE (type) == TYPE_CODE_PTR
1750 || TYPE_CODE (type) == TYPE_CODE_UNION
1751 || TYPE_CODE (type) == TYPE_CODE_STRUCT)
1753 if (bfd_arch == bfd_arch_ia64
1754 || (regnum >= gdbarch_num_regs (gdbarch)
1755 && (bfd_arch == bfd_arch_xtensa
1756 || bfd_arch == bfd_arch_bfin
1757 || bfd_arch == bfd_arch_m32c
1758 /* m68hc11 pseudo registers are in memory. */
1759 || bfd_arch == bfd_arch_m68hc11
1760 || bfd_arch == bfd_arch_m68hc12
1761 || bfd_arch == bfd_arch_s390))
1762 || (bfd_arch == bfd_arch_frv
1763 /* FRV pseudo registers except iacc0. */
1764 && regnum > gdbarch_num_regs (gdbarch)))
1766 /* Skip setting the expected values for some architecture
1769 else if (bfd_arch == bfd_arch_rl78 && regnum == 40)
1771 /* RL78_PC_REGNUM */
1772 for (auto j = 0; j < register_size (gdbarch, regnum) - 1; j++)
1777 for (auto j = 0; j < register_size (gdbarch, regnum); j++)
1781 else if (TYPE_CODE (type) == TYPE_CODE_FLAGS)
1783 /* No idea how to test flags. */
1788 /* If we don't know how to create the expected value for the
1789 this type, make it fail. */
1793 readwrite.cooked_write (regnum, expected.data ());
1795 SELF_CHECK (readwrite.cooked_read (regnum, buf.data ()) == REG_VALID);
1796 SELF_CHECK (expected == buf);
1800 } // namespace selftests
1801 #endif /* GDB_SELF_TEST */
1804 _initialize_regcache (void)
1806 regcache_descr_handle
1807 = gdbarch_data_register_post_init (init_regcache_descr);
1809 gdb::observers::target_changed.attach (regcache_observer_target_changed);
1810 gdb::observers::thread_ptid_changed.attach
1811 (regcache::regcache_thread_ptid_changed);
1813 add_com ("flushregs", class_maintenance, reg_flush_command,
1814 _("Force gdb to flush its register cache (maintainer command)"));
1817 selftests::register_test ("current_regcache", selftests::current_regcache_test);
1819 selftests::register_test_foreach_arch ("regcache::cooked_read_test",
1820 selftests::cooked_read_test);
1821 selftests::register_test_foreach_arch ("regcache::cooked_write_test",
1822 selftests::cooked_write_test);