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 regcache_register_status (const struct regcache
*regcache
, int regnum
)
326 gdb_assert (regcache
!= NULL
);
327 return regcache
->get_register_status (regnum
);
331 reg_buffer::get_register_status (int regnum
) const
333 assert_regnum (regnum
);
335 return (enum register_status
) m_register_status
[regnum
];
339 regcache_invalidate (struct regcache
*regcache
, int regnum
)
341 gdb_assert (regcache
!= NULL
);
342 regcache
->invalidate (regnum
);
346 detached_regcache::invalidate (int regnum
)
348 assert_regnum (regnum
);
349 m_register_status
[regnum
] = REG_UNKNOWN
;
353 reg_buffer::assert_regnum (int regnum
) const
355 gdb_assert (regnum
>= 0);
357 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
359 gdb_assert (regnum
< gdbarch_num_regs (arch ()));
362 /* Global structure containing the current regcache. */
364 /* NOTE: this is a write-through cache. There is no "dirty" bit for
365 recording if the register values have been changed (eg. by the
366 user). Therefore all registers must be written back to the
367 target when appropriate. */
368 std::forward_list
<regcache
*> regcache::current_regcache
;
371 get_thread_arch_aspace_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
,
372 struct address_space
*aspace
)
374 for (const auto ®cache
: regcache::current_regcache
)
375 if (ptid_equal (regcache
->ptid (), ptid
) && regcache
->arch () == gdbarch
)
378 regcache
*new_regcache
= new regcache (gdbarch
, aspace
);
380 regcache::current_regcache
.push_front (new_regcache
);
381 new_regcache
->set_ptid (ptid
);
387 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
389 address_space
*aspace
= target_thread_address_space (ptid
);
391 return get_thread_arch_aspace_regcache (ptid
, gdbarch
, aspace
);
394 static ptid_t current_thread_ptid
;
395 static struct gdbarch
*current_thread_arch
;
398 get_thread_regcache (ptid_t ptid
)
400 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
402 current_thread_ptid
= ptid
;
403 current_thread_arch
= target_thread_architecture (ptid
);
406 return get_thread_arch_regcache (ptid
, current_thread_arch
);
410 get_current_regcache (void)
412 return get_thread_regcache (inferior_ptid
);
415 /* See common/common-regcache.h. */
418 get_thread_regcache_for_ptid (ptid_t ptid
)
420 return get_thread_regcache (ptid
);
423 /* Observer for the target_changed event. */
426 regcache_observer_target_changed (struct target_ops
*target
)
428 registers_changed ();
431 /* Update global variables old ptids to hold NEW_PTID if they were
434 regcache::regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
436 for (auto ®cache
: regcache::current_regcache
)
438 if (ptid_equal (regcache
->ptid (), old_ptid
))
439 regcache
->set_ptid (new_ptid
);
443 /* Low level examining and depositing of registers.
445 The caller is responsible for making sure that the inferior is
446 stopped before calling the fetching routines, or it will get
447 garbage. (a change from GDB version 3, in which the caller got the
448 value from the last stop). */
450 /* REGISTERS_CHANGED ()
452 Indicate that registers may have changed, so invalidate the cache. */
455 registers_changed_ptid (ptid_t ptid
)
457 for (auto oit
= regcache::current_regcache
.before_begin (),
458 it
= std::next (oit
);
459 it
!= regcache::current_regcache
.end ();
462 if (ptid_match ((*it
)->ptid (), ptid
))
465 it
= regcache::current_regcache
.erase_after (oit
);
471 if (ptid_match (current_thread_ptid
, ptid
))
473 current_thread_ptid
= null_ptid
;
474 current_thread_arch
= NULL
;
477 if (ptid_match (inferior_ptid
, ptid
))
479 /* We just deleted the regcache of the current thread. Need to
480 forget about any frames we have cached, too. */
481 reinit_frame_cache ();
486 registers_changed (void)
488 registers_changed_ptid (minus_one_ptid
);
490 /* Force cleanup of any alloca areas if using C alloca instead of
491 a builtin alloca. This particular call is used to clean up
492 areas allocated by low level target code which may build up
493 during lengthy interactions between gdb and the target before
494 gdb gives control to the user (ie watchpoints). */
499 regcache_raw_update (struct regcache
*regcache
, int regnum
)
501 gdb_assert (regcache
!= NULL
);
503 regcache
->raw_update (regnum
);
507 regcache::raw_update (int regnum
)
509 assert_regnum (regnum
);
511 /* Make certain that the register cache is up-to-date with respect
512 to the current thread. This switching shouldn't be necessary
513 only there is still only one target side register cache. Sigh!
514 On the bright side, at least there is a regcache object. */
516 if (get_register_status (regnum
) == REG_UNKNOWN
)
518 target_fetch_registers (this, regnum
);
520 /* A number of targets can't access the whole set of raw
521 registers (because the debug API provides no means to get at
523 if (m_register_status
[regnum
] == REG_UNKNOWN
)
524 m_register_status
[regnum
] = REG_UNAVAILABLE
;
529 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
531 return regcache
->raw_read (regnum
, buf
);
535 readable_regcache::raw_read (int regnum
, gdb_byte
*buf
)
537 gdb_assert (buf
!= NULL
);
540 if (m_register_status
[regnum
] != REG_VALID
)
541 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
543 memcpy (buf
, register_buffer (regnum
),
544 m_descr
->sizeof_register
[regnum
]);
546 return (enum register_status
) m_register_status
[regnum
];
550 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
552 gdb_assert (regcache
!= NULL
);
553 return regcache
->raw_read (regnum
, val
);
556 template<typename T
, typename
>
558 readable_regcache::raw_read (int regnum
, T
*val
)
561 enum register_status status
;
563 assert_regnum (regnum
);
564 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
565 status
= raw_read (regnum
, buf
);
566 if (status
== REG_VALID
)
567 *val
= extract_integer
<T
> (buf
,
568 m_descr
->sizeof_register
[regnum
],
569 gdbarch_byte_order (m_descr
->gdbarch
));
576 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
579 gdb_assert (regcache
!= NULL
);
580 return regcache
->raw_read (regnum
, val
);
584 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
586 gdb_assert (regcache
!= NULL
);
587 regcache
->raw_write (regnum
, val
);
590 template<typename T
, typename
>
592 regcache::raw_write (int regnum
, T val
)
596 assert_regnum (regnum
);
597 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
598 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
599 gdbarch_byte_order (m_descr
->gdbarch
), val
);
600 raw_write (regnum
, buf
);
604 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
607 gdb_assert (regcache
!= NULL
);
608 regcache
->raw_write (regnum
, val
);
612 regcache_raw_get_signed (struct regcache
*regcache
, int regnum
)
615 enum register_status status
;
617 status
= regcache_raw_read_signed (regcache
, regnum
, &value
);
618 if (status
== REG_UNAVAILABLE
)
619 throw_error (NOT_AVAILABLE_ERROR
,
620 _("Register %d is not available"), regnum
);
625 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
627 return regcache
->cooked_read (regnum
, buf
);
631 readable_regcache::cooked_read (int regnum
, gdb_byte
*buf
)
633 gdb_assert (regnum
>= 0);
634 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
635 if (regnum
< num_raw_registers ())
636 return raw_read (regnum
, buf
);
637 else if (m_has_pseudo
638 && m_register_status
[regnum
] != REG_UNKNOWN
)
640 if (m_register_status
[regnum
] == REG_VALID
)
641 memcpy (buf
, register_buffer (regnum
),
642 m_descr
->sizeof_register
[regnum
]);
644 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
646 return (enum register_status
) m_register_status
[regnum
];
648 else if (gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
650 struct value
*mark
, *computed
;
651 enum register_status result
= REG_VALID
;
653 mark
= value_mark ();
655 computed
= gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
657 if (value_entirely_available (computed
))
658 memcpy (buf
, value_contents_raw (computed
),
659 m_descr
->sizeof_register
[regnum
]);
662 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
663 result
= REG_UNAVAILABLE
;
666 value_free_to_mark (mark
);
671 return gdbarch_pseudo_register_read (m_descr
->gdbarch
, this,
676 regcache_cooked_read_value (struct regcache
*regcache
, int regnum
)
678 return regcache
->cooked_read_value (regnum
);
682 readable_regcache::cooked_read_value (int regnum
)
684 gdb_assert (regnum
>= 0);
685 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
687 if (regnum
< num_raw_registers ()
688 || (m_has_pseudo
&& m_register_status
[regnum
] != REG_UNKNOWN
)
689 || !gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
691 struct value
*result
;
693 result
= allocate_value (register_type (m_descr
->gdbarch
, regnum
));
694 VALUE_LVAL (result
) = lval_register
;
695 VALUE_REGNUM (result
) = regnum
;
697 /* It is more efficient in general to do this delegation in this
698 direction than in the other one, even though the value-based
700 if (cooked_read (regnum
,
701 value_contents_raw (result
)) == REG_UNAVAILABLE
)
702 mark_value_bytes_unavailable (result
, 0,
703 TYPE_LENGTH (value_type (result
)));
708 return gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
713 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
716 gdb_assert (regcache
!= NULL
);
717 return regcache
->cooked_read (regnum
, val
);
720 template<typename T
, typename
>
722 readable_regcache::cooked_read (int regnum
, T
*val
)
724 enum register_status status
;
727 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
728 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
729 status
= cooked_read (regnum
, buf
);
730 if (status
== REG_VALID
)
731 *val
= extract_integer
<T
> (buf
, m_descr
->sizeof_register
[regnum
],
732 gdbarch_byte_order (m_descr
->gdbarch
));
739 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
742 gdb_assert (regcache
!= NULL
);
743 return regcache
->cooked_read (regnum
, val
);
747 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
750 gdb_assert (regcache
!= NULL
);
751 regcache
->cooked_write (regnum
, val
);
754 template<typename T
, typename
>
756 regcache::cooked_write (int regnum
, T val
)
760 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
761 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
762 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
763 gdbarch_byte_order (m_descr
->gdbarch
), val
);
764 cooked_write (regnum
, buf
);
768 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
771 gdb_assert (regcache
!= NULL
);
772 regcache
->cooked_write (regnum
, val
);
776 regcache_raw_write (struct regcache
*regcache
, int regnum
,
779 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
780 regcache
->raw_write (regnum
, buf
);
784 regcache::raw_write (int regnum
, const gdb_byte
*buf
)
787 gdb_assert (buf
!= NULL
);
788 assert_regnum (regnum
);
790 /* On the sparc, writing %g0 is a no-op, so we don't even want to
791 change the registers array if something writes to this register. */
792 if (gdbarch_cannot_store_register (arch (), regnum
))
795 /* If we have a valid copy of the register, and new value == old
796 value, then don't bother doing the actual store. */
797 if (get_register_status (regnum
) == REG_VALID
798 && (memcmp (register_buffer (regnum
), buf
,
799 m_descr
->sizeof_register
[regnum
]) == 0))
802 target_prepare_to_store (this);
803 raw_supply (regnum
, buf
);
805 /* Invalidate the register after it is written, in case of a
807 regcache_invalidator
invalidator (this, regnum
);
809 target_store_registers (this, regnum
);
811 /* The target did not throw an error so we can discard invalidating
813 invalidator
.release ();
817 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
820 regcache
->cooked_write (regnum
, buf
);
824 regcache::cooked_write (int regnum
, const gdb_byte
*buf
)
826 gdb_assert (regnum
>= 0);
827 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
828 if (regnum
< num_raw_registers ())
829 raw_write (regnum
, buf
);
831 gdbarch_pseudo_register_write (m_descr
->gdbarch
, this,
835 /* Perform a partial register transfer using a read, modify, write
839 readable_regcache::read_part (int regnum
, int offset
, int len
, void *in
,
842 struct gdbarch
*gdbarch
= arch ();
843 gdb_byte
*reg
= (gdb_byte
*) alloca (register_size (gdbarch
, regnum
));
845 gdb_assert (in
!= 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) ... */
852 enum register_status status
;
855 status
= raw_read (regnum
, reg
);
857 status
= cooked_read (regnum
, reg
);
858 if (status
!= REG_VALID
)
862 memcpy (in
, reg
+ offset
, len
);
868 regcache::write_part (int regnum
, int offset
, int len
,
869 const void *out
, bool is_raw
)
871 struct gdbarch
*gdbarch
= arch ();
872 gdb_byte
*reg
= (gdb_byte
*) alloca (register_size (gdbarch
, regnum
));
874 gdb_assert (out
!= NULL
);
875 gdb_assert (offset
>= 0 && offset
<= m_descr
->sizeof_register
[regnum
]);
876 gdb_assert (len
>= 0 && offset
+ len
<= m_descr
->sizeof_register
[regnum
]);
877 /* Something to do? */
878 if (offset
+ len
== 0)
880 /* Read (when needed) ... */
882 || offset
+ len
< m_descr
->sizeof_register
[regnum
])
884 enum register_status status
;
887 status
= raw_read (regnum
, reg
);
889 status
= cooked_read (regnum
, reg
);
890 if (status
!= REG_VALID
)
894 memcpy (reg
+ offset
, out
, len
);
895 /* ... write (when needed). */
897 raw_write (regnum
, reg
);
899 cooked_write (regnum
, reg
);
905 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
906 int offset
, int len
, gdb_byte
*buf
)
908 return regcache
->raw_read_part (regnum
, offset
, len
, buf
);
912 readable_regcache::raw_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
914 assert_regnum (regnum
);
915 return read_part (regnum
, offset
, len
, buf
, true);
919 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
920 int offset
, int len
, const gdb_byte
*buf
)
922 regcache
->raw_write_part (regnum
, offset
, len
, buf
);
926 regcache::raw_write_part (int regnum
, int offset
, int len
,
929 assert_regnum (regnum
);
930 write_part (regnum
, offset
, len
, buf
, true);
934 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
935 int offset
, int len
, gdb_byte
*buf
)
937 return regcache
->cooked_read_part (regnum
, offset
, len
, buf
);
942 readable_regcache::cooked_read_part (int regnum
, int offset
, int len
,
945 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
946 return read_part (regnum
, offset
, len
, buf
, false);
950 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
951 int offset
, int len
, const gdb_byte
*buf
)
953 regcache
->cooked_write_part (regnum
, offset
, len
, buf
);
957 regcache::cooked_write_part (int regnum
, int offset
, int len
,
960 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
961 write_part (regnum
, offset
, len
, buf
, false);
964 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
967 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
969 gdb_assert (regcache
!= NULL
);
970 regcache
->raw_supply (regnum
, buf
);
974 detached_regcache::raw_supply (int regnum
, const void *buf
)
979 assert_regnum (regnum
);
981 regbuf
= register_buffer (regnum
);
982 size
= m_descr
->sizeof_register
[regnum
];
986 memcpy (regbuf
, buf
, size
);
987 m_register_status
[regnum
] = REG_VALID
;
991 /* This memset not strictly necessary, but better than garbage
992 in case the register value manages to escape somewhere (due
993 to a bug, no less). */
994 memset (regbuf
, 0, size
);
995 m_register_status
[regnum
] = REG_UNAVAILABLE
;
999 /* Supply register REGNUM to REGCACHE. Value to supply is an integer stored at
1000 address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED. If
1001 the register size is greater than ADDR_LEN, then the integer will be sign or
1002 zero extended. If the register size is smaller than the integer, then the
1003 most significant bytes of the integer will be truncated. */
1006 detached_regcache::raw_supply_integer (int regnum
, const gdb_byte
*addr
,
1007 int addr_len
, bool is_signed
)
1009 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1013 assert_regnum (regnum
);
1015 regbuf
= register_buffer (regnum
);
1016 regsize
= m_descr
->sizeof_register
[regnum
];
1018 copy_integer_to_size (regbuf
, regsize
, addr
, addr_len
, is_signed
,
1020 m_register_status
[regnum
] = REG_VALID
;
1023 /* Supply register REGNUM with zeroed value to REGCACHE. This is not the same
1024 as calling raw_supply with NULL (which will set the state to
1028 detached_regcache::raw_supply_zeroed (int regnum
)
1033 assert_regnum (regnum
);
1035 regbuf
= register_buffer (regnum
);
1036 size
= m_descr
->sizeof_register
[regnum
];
1038 memset (regbuf
, 0, size
);
1039 m_register_status
[regnum
] = REG_VALID
;
1042 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1045 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
1047 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
1048 regcache
->raw_collect (regnum
, buf
);
1052 regcache::raw_collect (int regnum
, void *buf
) const
1057 gdb_assert (buf
!= NULL
);
1058 assert_regnum (regnum
);
1060 regbuf
= register_buffer (regnum
);
1061 size
= m_descr
->sizeof_register
[regnum
];
1062 memcpy (buf
, regbuf
, size
);
1065 /* Transfer a single or all registers belonging to a certain register
1066 set to or from a buffer. This is the main worker function for
1067 regcache_supply_regset and regcache_collect_regset. */
1069 /* Collect register REGNUM from REGCACHE. Store collected value as an integer
1070 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
1071 If ADDR_LEN is greater than the register size, then the integer will be sign
1072 or zero extended. If ADDR_LEN is smaller than the register size, then the
1073 most significant bytes of the integer will be truncated. */
1076 regcache::raw_collect_integer (int regnum
, gdb_byte
*addr
, int addr_len
,
1077 bool is_signed
) const
1079 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1080 const gdb_byte
*regbuf
;
1083 assert_regnum (regnum
);
1085 regbuf
= register_buffer (regnum
);
1086 regsize
= m_descr
->sizeof_register
[regnum
];
1088 copy_integer_to_size (addr
, addr_len
, regbuf
, regsize
, is_signed
,
1093 regcache::transfer_regset (const struct regset
*regset
,
1094 struct regcache
*out_regcache
,
1095 int regnum
, const void *in_buf
,
1096 void *out_buf
, size_t size
) const
1098 const struct regcache_map_entry
*map
;
1099 int offs
= 0, count
;
1101 for (map
= (const struct regcache_map_entry
*) regset
->regmap
;
1102 (count
= map
->count
) != 0;
1105 int regno
= map
->regno
;
1106 int slot_size
= map
->size
;
1108 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1109 slot_size
= m_descr
->sizeof_register
[regno
];
1111 if (regno
== REGCACHE_MAP_SKIP
1113 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1114 offs
+= count
* slot_size
;
1116 else if (regnum
== -1)
1117 for (; count
--; regno
++, offs
+= slot_size
)
1119 if (offs
+ slot_size
> size
)
1123 raw_collect (regno
, (gdb_byte
*) out_buf
+ offs
);
1125 out_regcache
->raw_supply (regno
, in_buf
1126 ? (const gdb_byte
*) in_buf
+ offs
1131 /* Transfer a single register and return. */
1132 offs
+= (regnum
- regno
) * slot_size
;
1133 if (offs
+ slot_size
> size
)
1137 raw_collect (regnum
, (gdb_byte
*) out_buf
+ offs
);
1139 out_regcache
->raw_supply (regnum
, in_buf
1140 ? (const gdb_byte
*) in_buf
+ offs
1147 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1148 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1149 If BUF is NULL, set the register(s) to "unavailable" status. */
1152 regcache_supply_regset (const struct regset
*regset
,
1153 struct regcache
*regcache
,
1154 int regnum
, const void *buf
, size_t size
)
1156 regcache
->supply_regset (regset
, regnum
, buf
, size
);
1160 regcache::supply_regset (const struct regset
*regset
,
1161 int regnum
, const void *buf
, size_t size
)
1163 transfer_regset (regset
, this, regnum
, buf
, NULL
, size
);
1166 /* Collect register REGNUM from REGCACHE to BUF, using the register
1167 map in REGSET. If REGNUM is -1, do this for all registers in
1171 regcache_collect_regset (const struct regset
*regset
,
1172 const struct regcache
*regcache
,
1173 int regnum
, void *buf
, size_t size
)
1175 regcache
->collect_regset (regset
, regnum
, buf
, size
);
1179 regcache::collect_regset (const struct regset
*regset
,
1180 int regnum
, void *buf
, size_t size
) const
1182 transfer_regset (regset
, NULL
, regnum
, NULL
, buf
, size
);
1186 /* Special handling for register PC. */
1189 regcache_read_pc (struct regcache
*regcache
)
1191 struct gdbarch
*gdbarch
= regcache
->arch ();
1195 if (gdbarch_read_pc_p (gdbarch
))
1196 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1197 /* Else use per-frame method on get_current_frame. */
1198 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1202 if (regcache_cooked_read_unsigned (regcache
,
1203 gdbarch_pc_regnum (gdbarch
),
1204 &raw_val
) == REG_UNAVAILABLE
)
1205 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1207 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1210 internal_error (__FILE__
, __LINE__
,
1211 _("regcache_read_pc: Unable to find PC"));
1216 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1218 struct gdbarch
*gdbarch
= regcache
->arch ();
1220 if (gdbarch_write_pc_p (gdbarch
))
1221 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1222 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1223 regcache_cooked_write_unsigned (regcache
,
1224 gdbarch_pc_regnum (gdbarch
), pc
);
1226 internal_error (__FILE__
, __LINE__
,
1227 _("regcache_write_pc: Unable to update PC"));
1229 /* Writing the PC (for instance, from "load") invalidates the
1231 reinit_frame_cache ();
1235 reg_buffer::num_raw_registers () const
1237 return gdbarch_num_regs (arch ());
1241 regcache::debug_print_register (const char *func
, int regno
)
1243 struct gdbarch
*gdbarch
= arch ();
1245 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1246 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
1247 && gdbarch_register_name (gdbarch
, regno
) != NULL
1248 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
1249 fprintf_unfiltered (gdb_stdlog
, "(%s)",
1250 gdbarch_register_name (gdbarch
, regno
));
1252 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1253 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
1255 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1256 int size
= register_size (gdbarch
, regno
);
1257 gdb_byte
*buf
= register_buffer (regno
);
1259 fprintf_unfiltered (gdb_stdlog
, " = ");
1260 for (int i
= 0; i
< size
; i
++)
1262 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1264 if (size
<= sizeof (LONGEST
))
1266 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
1268 fprintf_unfiltered (gdb_stdlog
, " %s %s",
1269 core_addr_to_string_nz (val
), plongest (val
));
1272 fprintf_unfiltered (gdb_stdlog
, "\n");
1276 reg_flush_command (const char *command
, int from_tty
)
1278 /* Force-flush the register cache. */
1279 registers_changed ();
1281 printf_filtered (_("Register cache flushed.\n"));
1285 register_dump::dump (ui_file
*file
)
1287 auto descr
= regcache_descr (m_gdbarch
);
1289 int footnote_nr
= 0;
1290 int footnote_register_offset
= 0;
1291 int footnote_register_type_name_null
= 0;
1292 long register_offset
= 0;
1294 gdb_assert (descr
->nr_cooked_registers
1295 == (gdbarch_num_regs (m_gdbarch
)
1296 + gdbarch_num_pseudo_regs (m_gdbarch
)));
1298 for (regnum
= -1; regnum
< descr
->nr_cooked_registers
; regnum
++)
1302 fprintf_unfiltered (file
, " %-10s", "Name");
1305 const char *p
= gdbarch_register_name (m_gdbarch
, regnum
);
1309 else if (p
[0] == '\0')
1311 fprintf_unfiltered (file
, " %-10s", p
);
1316 fprintf_unfiltered (file
, " %4s", "Nr");
1318 fprintf_unfiltered (file
, " %4d", regnum
);
1320 /* Relative number. */
1322 fprintf_unfiltered (file
, " %4s", "Rel");
1323 else if (regnum
< gdbarch_num_regs (m_gdbarch
))
1324 fprintf_unfiltered (file
, " %4d", regnum
);
1326 fprintf_unfiltered (file
, " %4d",
1327 (regnum
- gdbarch_num_regs (m_gdbarch
)));
1331 fprintf_unfiltered (file
, " %6s ", "Offset");
1334 fprintf_unfiltered (file
, " %6ld",
1335 descr
->register_offset
[regnum
]);
1336 if (register_offset
!= descr
->register_offset
[regnum
]
1338 && (descr
->register_offset
[regnum
]
1339 != (descr
->register_offset
[regnum
- 1]
1340 + descr
->sizeof_register
[regnum
- 1])))
1343 if (!footnote_register_offset
)
1344 footnote_register_offset
= ++footnote_nr
;
1345 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1348 fprintf_unfiltered (file
, " ");
1349 register_offset
= (descr
->register_offset
[regnum
]
1350 + descr
->sizeof_register
[regnum
]);
1355 fprintf_unfiltered (file
, " %5s ", "Size");
1357 fprintf_unfiltered (file
, " %5ld", descr
->sizeof_register
[regnum
]);
1362 std::string name_holder
;
1368 static const char blt
[] = "builtin_type";
1370 t
= TYPE_NAME (register_type (m_gdbarch
, regnum
));
1373 if (!footnote_register_type_name_null
)
1374 footnote_register_type_name_null
= ++footnote_nr
;
1375 name_holder
= string_printf ("*%d",
1376 footnote_register_type_name_null
);
1377 t
= name_holder
.c_str ();
1379 /* Chop a leading builtin_type. */
1380 if (startswith (t
, blt
))
1383 fprintf_unfiltered (file
, " %-15s", t
);
1386 /* Leading space always present. */
1387 fprintf_unfiltered (file
, " ");
1389 dump_reg (file
, regnum
);
1391 fprintf_unfiltered (file
, "\n");
1394 if (footnote_register_offset
)
1395 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1396 footnote_register_offset
);
1397 if (footnote_register_type_name_null
)
1398 fprintf_unfiltered (file
,
1399 "*%d: Register type's name NULL.\n",
1400 footnote_register_type_name_null
);
1404 #include "selftest.h"
1405 #include "selftest-arch.h"
1406 #include "gdbthread.h"
1407 #include "target-float.h"
1409 namespace selftests
{
1411 class regcache_access
: public regcache
1415 /* Return the number of elements in current_regcache. */
1418 current_regcache_size ()
1420 return std::distance (regcache::current_regcache
.begin (),
1421 regcache::current_regcache
.end ());
1426 current_regcache_test (void)
1428 /* It is empty at the start. */
1429 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1431 ptid_t
ptid1 (1), ptid2 (2), ptid3 (3);
1433 /* Get regcache from ptid1, a new regcache is added to
1434 current_regcache. */
1435 regcache
*regcache
= get_thread_arch_aspace_regcache (ptid1
,
1439 SELF_CHECK (regcache
!= NULL
);
1440 SELF_CHECK (regcache
->ptid () == ptid1
);
1441 SELF_CHECK (regcache_access::current_regcache_size () == 1);
1443 /* Get regcache from ptid2, a new regcache is added to
1444 current_regcache. */
1445 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1448 SELF_CHECK (regcache
!= NULL
);
1449 SELF_CHECK (regcache
->ptid () == ptid2
);
1450 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1452 /* Get regcache from ptid3, a new regcache is added to
1453 current_regcache. */
1454 regcache
= get_thread_arch_aspace_regcache (ptid3
,
1457 SELF_CHECK (regcache
!= NULL
);
1458 SELF_CHECK (regcache
->ptid () == ptid3
);
1459 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1461 /* Get regcache from ptid2 again, nothing is added to
1462 current_regcache. */
1463 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1466 SELF_CHECK (regcache
!= NULL
);
1467 SELF_CHECK (regcache
->ptid () == ptid2
);
1468 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1470 /* Mark ptid2 is changed, so regcache of ptid2 should be removed from
1471 current_regcache. */
1472 registers_changed_ptid (ptid2
);
1473 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1476 class target_ops_no_register
: public test_target_ops
1479 target_ops_no_register ()
1480 : test_target_ops
{}
1485 fetch_registers_called
= 0;
1486 store_registers_called
= 0;
1487 xfer_partial_called
= 0;
1490 void fetch_registers (regcache
*regs
, int regno
) override
;
1491 void store_registers (regcache
*regs
, int regno
) override
;
1493 enum target_xfer_status
xfer_partial (enum target_object object
,
1494 const char *annex
, gdb_byte
*readbuf
,
1495 const gdb_byte
*writebuf
,
1496 ULONGEST offset
, ULONGEST len
,
1497 ULONGEST
*xfered_len
) override
;
1499 unsigned int fetch_registers_called
= 0;
1500 unsigned int store_registers_called
= 0;
1501 unsigned int xfer_partial_called
= 0;
1505 target_ops_no_register::fetch_registers (regcache
*regs
, int regno
)
1507 /* Mark register available. */
1508 regs
->raw_supply_zeroed (regno
);
1509 this->fetch_registers_called
++;
1513 target_ops_no_register::store_registers (regcache
*regs
, int regno
)
1515 this->store_registers_called
++;
1518 enum target_xfer_status
1519 target_ops_no_register::xfer_partial (enum target_object object
,
1520 const char *annex
, gdb_byte
*readbuf
,
1521 const gdb_byte
*writebuf
,
1522 ULONGEST offset
, ULONGEST len
,
1523 ULONGEST
*xfered_len
)
1525 this->xfer_partial_called
++;
1528 return TARGET_XFER_OK
;
1531 class readwrite_regcache
: public regcache
1534 readwrite_regcache (struct gdbarch
*gdbarch
)
1535 : regcache (gdbarch
, nullptr)
1539 /* Test regcache::cooked_read gets registers from raw registers and
1540 memory instead of target to_{fetch,store}_registers. */
1543 cooked_read_test (struct gdbarch
*gdbarch
)
1545 /* Error out if debugging something, because we're going to push the
1546 test target, which would pop any existing target. */
1547 if (target_stack
->to_stratum
>= process_stratum
)
1548 error (_("target already pushed"));
1550 /* Create a mock environment. An inferior with a thread, with a
1551 process_stratum target pushed. */
1553 target_ops_no_register mock_target
;
1554 ptid_t
mock_ptid (1, 1);
1555 inferior
mock_inferior (mock_ptid
.pid ());
1556 address_space mock_aspace
{};
1557 mock_inferior
.gdbarch
= gdbarch
;
1558 mock_inferior
.aspace
= &mock_aspace
;
1559 thread_info
mock_thread (&mock_inferior
, mock_ptid
);
1561 scoped_restore restore_thread_list
1562 = make_scoped_restore (&thread_list
, &mock_thread
);
1564 /* Add the mock inferior to the inferior list so that look ups by
1565 target+ptid can find it. */
1566 scoped_restore restore_inferior_list
1567 = make_scoped_restore (&inferior_list
);
1568 inferior_list
= &mock_inferior
;
1570 /* Switch to the mock inferior. */
1571 scoped_restore_current_inferior restore_current_inferior
;
1572 set_current_inferior (&mock_inferior
);
1574 /* Push the process_stratum target so we can mock accessing
1576 push_target (&mock_target
);
1578 /* Pop it again on exit (return/exception). */
1583 pop_all_targets_at_and_above (process_stratum
);
1587 /* Switch to the mock thread. */
1588 scoped_restore restore_inferior_ptid
1589 = make_scoped_restore (&inferior_ptid
, mock_ptid
);
1591 /* Test that read one raw register from regcache_no_target will go
1592 to the target layer. */
1595 /* Find a raw register which size isn't zero. */
1596 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1598 if (register_size (gdbarch
, regnum
) != 0)
1602 readwrite_regcache
readwrite (gdbarch
);
1603 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
));
1605 readwrite
.raw_read (regnum
, buf
.data ());
1607 /* raw_read calls target_fetch_registers. */
1608 SELF_CHECK (mock_target
.fetch_registers_called
> 0);
1609 mock_target
.reset ();
1611 /* Mark all raw registers valid, so the following raw registers
1612 accesses won't go to target. */
1613 for (auto i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1614 readwrite
.raw_update (i
);
1616 mock_target
.reset ();
1617 /* Then, read all raw and pseudo registers, and don't expect calling
1618 to_{fetch,store}_registers. */
1619 for (int regnum
= 0;
1620 regnum
< gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1623 if (register_size (gdbarch
, regnum
) == 0)
1626 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
));
1628 SELF_CHECK (REG_VALID
== readwrite
.cooked_read (regnum
, buf
.data ()));
1630 SELF_CHECK (mock_target
.fetch_registers_called
== 0);
1631 SELF_CHECK (mock_target
.store_registers_called
== 0);
1633 /* Some SPU pseudo registers are got via TARGET_OBJECT_SPU. */
1634 if (gdbarch_bfd_arch_info (gdbarch
)->arch
!= bfd_arch_spu
)
1635 SELF_CHECK (mock_target
.xfer_partial_called
== 0);
1637 mock_target
.reset ();
1640 readonly_detached_regcache
readonly (readwrite
);
1642 /* GDB may go to target layer to fetch all registers and memory for
1643 readonly regcache. */
1644 mock_target
.reset ();
1646 for (int regnum
= 0;
1647 regnum
< gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1650 if (register_size (gdbarch
, regnum
) == 0)
1653 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
));
1654 enum register_status status
= readonly
.cooked_read (regnum
,
1657 if (regnum
< gdbarch_num_regs (gdbarch
))
1659 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1661 if (bfd_arch
== bfd_arch_frv
|| bfd_arch
== bfd_arch_h8300
1662 || bfd_arch
== bfd_arch_m32c
|| bfd_arch
== bfd_arch_sh
1663 || bfd_arch
== bfd_arch_alpha
|| bfd_arch
== bfd_arch_v850
1664 || bfd_arch
== bfd_arch_msp430
|| bfd_arch
== bfd_arch_mep
1665 || bfd_arch
== bfd_arch_mips
|| bfd_arch
== bfd_arch_v850_rh850
1666 || bfd_arch
== bfd_arch_tic6x
|| bfd_arch
== bfd_arch_mn10300
1667 || bfd_arch
== bfd_arch_rl78
|| bfd_arch
== bfd_arch_score
1668 || bfd_arch
== bfd_arch_riscv
)
1670 /* Raw registers. If raw registers are not in save_reggroup,
1671 their status are unknown. */
1672 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1673 SELF_CHECK (status
== REG_VALID
);
1675 SELF_CHECK (status
== REG_UNKNOWN
);
1678 SELF_CHECK (status
== REG_VALID
);
1682 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1683 SELF_CHECK (status
== REG_VALID
);
1686 /* If pseudo registers are not in save_reggroup, some of
1687 them can be computed from saved raw registers, but some
1688 of them are unknown. */
1689 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1691 if (bfd_arch
== bfd_arch_frv
1692 || bfd_arch
== bfd_arch_m32c
1693 || bfd_arch
== bfd_arch_mep
1694 || bfd_arch
== bfd_arch_sh
)
1695 SELF_CHECK (status
== REG_VALID
|| status
== REG_UNKNOWN
);
1696 else if (bfd_arch
== bfd_arch_mips
1697 || bfd_arch
== bfd_arch_h8300
)
1698 SELF_CHECK (status
== REG_UNKNOWN
);
1700 SELF_CHECK (status
== REG_VALID
);
1704 SELF_CHECK (mock_target
.fetch_registers_called
== 0);
1705 SELF_CHECK (mock_target
.store_registers_called
== 0);
1706 SELF_CHECK (mock_target
.xfer_partial_called
== 0);
1708 mock_target
.reset ();
1712 /* Test regcache::cooked_write by writing some expected contents to
1713 registers, and checking that contents read from registers and the
1714 expected contents are the same. */
1717 cooked_write_test (struct gdbarch
*gdbarch
)
1719 /* Error out if debugging something, because we're going to push the
1720 test target, which would pop any existing target. */
1721 if (target_stack
->to_stratum
>= process_stratum
)
1722 error (_("target already pushed"));
1724 /* Create a mock environment. A process_stratum target pushed. */
1726 target_ops_no_register mock_target
;
1728 /* Push the process_stratum target so we can mock accessing
1730 push_target (&mock_target
);
1732 /* Pop it again on exit (return/exception). */
1737 pop_all_targets_at_and_above (process_stratum
);
1741 readwrite_regcache
readwrite (gdbarch
);
1743 const int num_regs
= (gdbarch_num_regs (gdbarch
)
1744 + gdbarch_num_pseudo_regs (gdbarch
));
1746 for (auto regnum
= 0; regnum
< num_regs
; regnum
++)
1748 if (register_size (gdbarch
, regnum
) == 0
1749 || gdbarch_cannot_store_register (gdbarch
, regnum
))
1752 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1754 if ((bfd_arch
== bfd_arch_sparc
1755 /* SPARC64_CWP_REGNUM, SPARC64_PSTATE_REGNUM,
1756 SPARC64_ASI_REGNUM and SPARC64_CCR_REGNUM are hard to test. */
1757 && gdbarch_ptr_bit (gdbarch
) == 64
1758 && (regnum
>= gdbarch_num_regs (gdbarch
)
1759 && regnum
<= gdbarch_num_regs (gdbarch
) + 4))
1760 || (bfd_arch
== bfd_arch_spu
1761 /* SPU pseudo registers except SPU_SP_REGNUM are got by
1762 TARGET_OBJECT_SPU. */
1763 && regnum
>= gdbarch_num_regs (gdbarch
) && regnum
!= 130))
1766 std::vector
<gdb_byte
> expected (register_size (gdbarch
, regnum
), 0);
1767 std::vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
), 0);
1768 const auto type
= register_type (gdbarch
, regnum
);
1770 if (TYPE_CODE (type
) == TYPE_CODE_FLT
1771 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1773 /* Generate valid float format. */
1774 target_float_from_string (expected
.data (), type
, "1.25");
1776 else if (TYPE_CODE (type
) == TYPE_CODE_INT
1777 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1778 || TYPE_CODE (type
) == TYPE_CODE_PTR
1779 || TYPE_CODE (type
) == TYPE_CODE_UNION
1780 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1782 if (bfd_arch
== bfd_arch_ia64
1783 || (regnum
>= gdbarch_num_regs (gdbarch
)
1784 && (bfd_arch
== bfd_arch_xtensa
1785 || bfd_arch
== bfd_arch_bfin
1786 || bfd_arch
== bfd_arch_m32c
1787 /* m68hc11 pseudo registers are in memory. */
1788 || bfd_arch
== bfd_arch_m68hc11
1789 || bfd_arch
== bfd_arch_m68hc12
1790 || bfd_arch
== bfd_arch_s390
))
1791 || (bfd_arch
== bfd_arch_frv
1792 /* FRV pseudo registers except iacc0. */
1793 && regnum
> gdbarch_num_regs (gdbarch
)))
1795 /* Skip setting the expected values for some architecture
1798 else if (bfd_arch
== bfd_arch_rl78
&& regnum
== 40)
1800 /* RL78_PC_REGNUM */
1801 for (auto j
= 0; j
< register_size (gdbarch
, regnum
) - 1; j
++)
1806 for (auto j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1810 else if (TYPE_CODE (type
) == TYPE_CODE_FLAGS
)
1812 /* No idea how to test flags. */
1817 /* If we don't know how to create the expected value for the
1818 this type, make it fail. */
1822 readwrite
.cooked_write (regnum
, expected
.data ());
1824 SELF_CHECK (readwrite
.cooked_read (regnum
, buf
.data ()) == REG_VALID
);
1825 SELF_CHECK (expected
== buf
);
1829 } // namespace selftests
1830 #endif /* GDB_SELF_TEST */
1833 _initialize_regcache (void)
1835 regcache_descr_handle
1836 = gdbarch_data_register_post_init (init_regcache_descr
);
1838 gdb::observers::target_changed
.attach (regcache_observer_target_changed
);
1839 gdb::observers::thread_ptid_changed
.attach
1840 (regcache::regcache_thread_ptid_changed
);
1842 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1843 _("Force gdb to flush its register cache (maintainer command)"));
1846 selftests::register_test ("current_regcache", selftests::current_regcache_test
);
1848 selftests::register_test_foreach_arch ("regcache::cooked_read_test",
1849 selftests::cooked_read_test
);
1850 selftests::register_test_foreach_arch ("regcache::cooked_write_test",
1851 selftests::cooked_write_test
);