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/>. */
22 #include "gdbthread.h"
27 #include "reggroups.h"
28 #include "observable.h"
30 #include <forward_list>
35 * Here is the actual register cache.
38 /* Per-architecture object describing the layout of a register cache.
39 Computed once when the architecture is created. */
41 struct gdbarch_data
*regcache_descr_handle
;
45 /* The architecture this descriptor belongs to. */
46 struct gdbarch
*gdbarch
;
48 /* The raw register cache. Each raw (or hard) register is supplied
49 by the target interface. The raw cache should not contain
50 redundant information - if the PC is constructed from two
51 registers then those registers and not the PC lives in the raw
53 long sizeof_raw_registers
;
55 /* The cooked register space. Each cooked register in the range
56 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
57 register. The remaining [NR_RAW_REGISTERS
58 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
59 both raw registers and memory by the architecture methods
60 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
61 int nr_cooked_registers
;
62 long sizeof_cooked_registers
;
64 /* Offset and size (in 8 bit bytes), of each register in the
65 register cache. All registers (including those in the range
66 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
68 long *register_offset
;
69 long *sizeof_register
;
71 /* Cached table containing the type of each register. */
72 struct type
**register_type
;
76 init_regcache_descr (struct gdbarch
*gdbarch
)
79 struct regcache_descr
*descr
;
80 gdb_assert (gdbarch
!= NULL
);
82 /* Create an initial, zero filled, table. */
83 descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct regcache_descr
);
84 descr
->gdbarch
= gdbarch
;
86 /* Total size of the register space. The raw registers are mapped
87 directly onto the raw register cache while the pseudo's are
88 either mapped onto raw-registers or memory. */
89 descr
->nr_cooked_registers
= gdbarch_num_regs (gdbarch
)
90 + gdbarch_num_pseudo_regs (gdbarch
);
92 /* Fill in a table of register types. */
94 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
,
96 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
97 descr
->register_type
[i
] = gdbarch_register_type (gdbarch
, i
);
99 /* Construct a strictly RAW register cache. Don't allow pseudo's
100 into the register cache. */
102 /* Lay out the register cache.
104 NOTE: cagney/2002-05-22: Only register_type() is used when
105 constructing the register cache. It is assumed that the
106 register's raw size, virtual size and type length are all the
112 descr
->sizeof_register
113 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
114 descr
->register_offset
115 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
116 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
118 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
119 descr
->register_offset
[i
] = offset
;
120 offset
+= descr
->sizeof_register
[i
];
122 /* Set the real size of the raw register cache buffer. */
123 descr
->sizeof_raw_registers
= offset
;
125 for (; i
< descr
->nr_cooked_registers
; i
++)
127 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
128 descr
->register_offset
[i
] = offset
;
129 offset
+= descr
->sizeof_register
[i
];
131 /* Set the real size of the readonly register cache buffer. */
132 descr
->sizeof_cooked_registers
= offset
;
138 static struct regcache_descr
*
139 regcache_descr (struct gdbarch
*gdbarch
)
141 return (struct regcache_descr
*) gdbarch_data (gdbarch
,
142 regcache_descr_handle
);
145 /* Utility functions returning useful register attributes stored in
146 the regcache descr. */
149 register_type (struct gdbarch
*gdbarch
, int regnum
)
151 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
153 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
154 return descr
->register_type
[regnum
];
157 /* Utility functions returning useful register attributes stored in
158 the regcache descr. */
161 register_size (struct gdbarch
*gdbarch
, int regnum
)
163 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
166 gdb_assert (regnum
>= 0
167 && regnum
< (gdbarch_num_regs (gdbarch
)
168 + gdbarch_num_pseudo_regs (gdbarch
)));
169 size
= descr
->sizeof_register
[regnum
];
173 /* See common/common-regcache.h. */
176 regcache_register_size (const struct regcache
*regcache
, int n
)
178 return register_size (regcache
->arch (), n
);
181 reg_buffer::reg_buffer (gdbarch
*gdbarch
, bool has_pseudo
)
182 : m_has_pseudo (has_pseudo
)
184 gdb_assert (gdbarch
!= NULL
);
185 m_descr
= regcache_descr (gdbarch
);
189 m_registers
.reset (new gdb_byte
[m_descr
->sizeof_cooked_registers
] ());
190 m_register_status
.reset
191 (new register_status
[m_descr
->nr_cooked_registers
] ());
195 m_registers
.reset (new gdb_byte
[m_descr
->sizeof_raw_registers
] ());
196 m_register_status
.reset
197 (new register_status
[gdbarch_num_regs (gdbarch
)] ());
201 regcache::regcache (gdbarch
*gdbarch
, const address_space
*aspace_
)
202 /* The register buffers. A read/write register cache can only hold
203 [0 .. gdbarch_num_regs). */
204 : detached_regcache (gdbarch
, false), m_aspace (aspace_
)
206 m_ptid
= minus_one_ptid
;
209 readonly_detached_regcache::readonly_detached_regcache (regcache
&src
)
210 : readonly_detached_regcache (src
.arch (),
211 [&src
] (int regnum
, gdb_byte
*buf
)
213 return src
.cooked_read (regnum
, buf
);
219 reg_buffer::arch () const
221 return m_descr
->gdbarch
;
224 /* Cleanup class for invalidating a register. */
226 class regcache_invalidator
230 regcache_invalidator (struct regcache
*regcache
, int regnum
)
231 : m_regcache (regcache
),
236 ~regcache_invalidator ()
238 if (m_regcache
!= nullptr)
239 m_regcache
->invalidate (m_regnum
);
242 DISABLE_COPY_AND_ASSIGN (regcache_invalidator
);
246 m_regcache
= nullptr;
251 struct regcache
*m_regcache
;
255 /* Return a pointer to register REGNUM's buffer cache. */
258 reg_buffer::register_buffer (int regnum
) const
260 return m_registers
.get () + m_descr
->register_offset
[regnum
];
264 reg_buffer::save (register_read_ftype cooked_read
)
266 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
269 /* It should have pseudo registers. */
270 gdb_assert (m_has_pseudo
);
271 /* Clear the dest. */
272 memset (m_registers
.get (), 0, m_descr
->sizeof_cooked_registers
);
273 memset (m_register_status
.get (), REG_UNKNOWN
, m_descr
->nr_cooked_registers
);
274 /* Copy over any registers (identified by their membership in the
275 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
276 gdbarch_num_pseudo_regs) range is checked since some architectures need
277 to save/restore `cooked' registers that live in memory. */
278 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
280 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
282 gdb_byte
*dst_buf
= register_buffer (regnum
);
283 enum register_status status
= cooked_read (regnum
, dst_buf
);
285 gdb_assert (status
!= REG_UNKNOWN
);
287 if (status
!= REG_VALID
)
288 memset (dst_buf
, 0, register_size (gdbarch
, regnum
));
290 m_register_status
[regnum
] = status
;
296 regcache::restore (readonly_detached_regcache
*src
)
298 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
301 gdb_assert (src
!= NULL
);
302 gdb_assert (src
->m_has_pseudo
);
304 gdb_assert (gdbarch
== src
->arch ());
306 /* Copy over any registers, being careful to only restore those that
307 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
308 + gdbarch_num_pseudo_regs) range is checked since some architectures need
309 to save/restore `cooked' registers that live in memory. */
310 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
312 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
314 if (src
->m_register_status
[regnum
] == REG_VALID
)
315 cooked_write (regnum
, src
->register_buffer (regnum
));
320 /* See common/common-regcache.h. */
323 reg_buffer::get_register_status (int regnum
) const
325 assert_regnum (regnum
);
327 return m_register_status
[regnum
];
331 reg_buffer::invalidate (int regnum
)
333 assert_regnum (regnum
);
334 m_register_status
[regnum
] = REG_UNKNOWN
;
338 reg_buffer::assert_regnum (int regnum
) const
340 gdb_assert (regnum
>= 0);
342 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
344 gdb_assert (regnum
< gdbarch_num_regs (arch ()));
347 /* Global structure containing the current regcache. */
349 /* NOTE: this is a write-through cache. There is no "dirty" bit for
350 recording if the register values have been changed (eg. by the
351 user). Therefore all registers must be written back to the
352 target when appropriate. */
353 std::forward_list
<regcache
*> regcache::current_regcache
;
356 get_thread_arch_aspace_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
,
357 struct address_space
*aspace
)
359 for (const auto ®cache
: regcache::current_regcache
)
360 if (ptid_equal (regcache
->ptid (), ptid
) && regcache
->arch () == gdbarch
)
363 regcache
*new_regcache
= new regcache (gdbarch
, aspace
);
365 regcache::current_regcache
.push_front (new_regcache
);
366 new_regcache
->set_ptid (ptid
);
372 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
374 address_space
*aspace
= target_thread_address_space (ptid
);
376 return get_thread_arch_aspace_regcache (ptid
, gdbarch
, aspace
);
379 static ptid_t current_thread_ptid
;
380 static struct gdbarch
*current_thread_arch
;
383 get_thread_regcache (ptid_t ptid
)
385 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
387 current_thread_ptid
= ptid
;
388 current_thread_arch
= target_thread_architecture (ptid
);
391 return get_thread_arch_regcache (ptid
, current_thread_arch
);
394 /* See regcache.h. */
397 get_thread_regcache (thread_info
*thread
)
399 return get_thread_regcache (thread
->ptid
);
403 get_current_regcache (void)
405 return get_thread_regcache (inferior_thread ());
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 ();
478 /* See regcache.h. */
481 registers_changed_thread (thread_info
*thread
)
483 registers_changed_ptid (thread
->ptid
);
487 registers_changed (void)
489 registers_changed_ptid (minus_one_ptid
);
491 /* Force cleanup of any alloca areas if using C alloca instead of
492 a builtin alloca. This particular call is used to clean up
493 areas allocated by low level target code which may build up
494 during lengthy interactions between gdb and the target before
495 gdb gives control to the user (ie watchpoints). */
500 regcache::raw_update (int regnum
)
502 assert_regnum (regnum
);
504 /* Make certain that the register cache is up-to-date with respect
505 to the current thread. This switching shouldn't be necessary
506 only there is still only one target side register cache. Sigh!
507 On the bright side, at least there is a regcache object. */
509 if (get_register_status (regnum
) == REG_UNKNOWN
)
511 target_fetch_registers (this, regnum
);
513 /* A number of targets can't access the whole set of raw
514 registers (because the debug API provides no means to get at
516 if (m_register_status
[regnum
] == REG_UNKNOWN
)
517 m_register_status
[regnum
] = REG_UNAVAILABLE
;
522 readable_regcache::raw_read (int regnum
, gdb_byte
*buf
)
524 gdb_assert (buf
!= NULL
);
527 if (m_register_status
[regnum
] != REG_VALID
)
528 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
530 memcpy (buf
, register_buffer (regnum
),
531 m_descr
->sizeof_register
[regnum
]);
533 return m_register_status
[regnum
];
537 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
539 gdb_assert (regcache
!= NULL
);
540 return regcache
->raw_read (regnum
, val
);
543 template<typename T
, typename
>
545 readable_regcache::raw_read (int regnum
, T
*val
)
548 enum register_status status
;
550 assert_regnum (regnum
);
551 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
552 status
= raw_read (regnum
, buf
);
553 if (status
== REG_VALID
)
554 *val
= extract_integer
<T
> (buf
,
555 m_descr
->sizeof_register
[regnum
],
556 gdbarch_byte_order (m_descr
->gdbarch
));
563 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
566 gdb_assert (regcache
!= NULL
);
567 return regcache
->raw_read (regnum
, val
);
571 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
573 gdb_assert (regcache
!= NULL
);
574 regcache
->raw_write (regnum
, val
);
577 template<typename T
, typename
>
579 regcache::raw_write (int regnum
, T val
)
583 assert_regnum (regnum
);
584 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
585 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
586 gdbarch_byte_order (m_descr
->gdbarch
), val
);
587 raw_write (regnum
, buf
);
591 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
594 gdb_assert (regcache
!= NULL
);
595 regcache
->raw_write (regnum
, val
);
599 regcache_raw_get_signed (struct regcache
*regcache
, int regnum
)
602 enum register_status status
;
604 status
= regcache_raw_read_signed (regcache
, regnum
, &value
);
605 if (status
== REG_UNAVAILABLE
)
606 throw_error (NOT_AVAILABLE_ERROR
,
607 _("Register %d is not available"), regnum
);
612 readable_regcache::cooked_read (int regnum
, gdb_byte
*buf
)
614 gdb_assert (regnum
>= 0);
615 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
616 if (regnum
< num_raw_registers ())
617 return raw_read (regnum
, buf
);
618 else if (m_has_pseudo
619 && m_register_status
[regnum
] != REG_UNKNOWN
)
621 if (m_register_status
[regnum
] == REG_VALID
)
622 memcpy (buf
, register_buffer (regnum
),
623 m_descr
->sizeof_register
[regnum
]);
625 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
627 return m_register_status
[regnum
];
629 else if (gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
631 struct value
*mark
, *computed
;
632 enum register_status result
= REG_VALID
;
634 mark
= value_mark ();
636 computed
= gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
638 if (value_entirely_available (computed
))
639 memcpy (buf
, value_contents_raw (computed
),
640 m_descr
->sizeof_register
[regnum
]);
643 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
644 result
= REG_UNAVAILABLE
;
647 value_free_to_mark (mark
);
652 return gdbarch_pseudo_register_read (m_descr
->gdbarch
, this,
657 readable_regcache::cooked_read_value (int regnum
)
659 gdb_assert (regnum
>= 0);
660 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
662 if (regnum
< num_raw_registers ()
663 || (m_has_pseudo
&& m_register_status
[regnum
] != REG_UNKNOWN
)
664 || !gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
666 struct value
*result
;
668 result
= allocate_value (register_type (m_descr
->gdbarch
, regnum
));
669 VALUE_LVAL (result
) = lval_register
;
670 VALUE_REGNUM (result
) = regnum
;
672 /* It is more efficient in general to do this delegation in this
673 direction than in the other one, even though the value-based
675 if (cooked_read (regnum
,
676 value_contents_raw (result
)) == REG_UNAVAILABLE
)
677 mark_value_bytes_unavailable (result
, 0,
678 TYPE_LENGTH (value_type (result
)));
683 return gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
688 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
691 gdb_assert (regcache
!= NULL
);
692 return regcache
->cooked_read (regnum
, val
);
695 template<typename T
, typename
>
697 readable_regcache::cooked_read (int regnum
, T
*val
)
699 enum register_status status
;
702 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
703 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
704 status
= cooked_read (regnum
, buf
);
705 if (status
== REG_VALID
)
706 *val
= extract_integer
<T
> (buf
, m_descr
->sizeof_register
[regnum
],
707 gdbarch_byte_order (m_descr
->gdbarch
));
714 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
717 gdb_assert (regcache
!= NULL
);
718 return regcache
->cooked_read (regnum
, val
);
722 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
725 gdb_assert (regcache
!= NULL
);
726 regcache
->cooked_write (regnum
, val
);
729 template<typename T
, typename
>
731 regcache::cooked_write (int regnum
, T val
)
735 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
736 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
737 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
738 gdbarch_byte_order (m_descr
->gdbarch
), val
);
739 cooked_write (regnum
, buf
);
743 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
746 gdb_assert (regcache
!= NULL
);
747 regcache
->cooked_write (regnum
, val
);
751 regcache::raw_write (int regnum
, const gdb_byte
*buf
)
754 gdb_assert (buf
!= NULL
);
755 assert_regnum (regnum
);
757 /* On the sparc, writing %g0 is a no-op, so we don't even want to
758 change the registers array if something writes to this register. */
759 if (gdbarch_cannot_store_register (arch (), regnum
))
762 /* If we have a valid copy of the register, and new value == old
763 value, then don't bother doing the actual store. */
764 if (get_register_status (regnum
) == REG_VALID
765 && (memcmp (register_buffer (regnum
), buf
,
766 m_descr
->sizeof_register
[regnum
]) == 0))
769 target_prepare_to_store (this);
770 raw_supply (regnum
, buf
);
772 /* Invalidate the register after it is written, in case of a
774 regcache_invalidator
invalidator (this, regnum
);
776 target_store_registers (this, regnum
);
778 /* The target did not throw an error so we can discard invalidating
780 invalidator
.release ();
784 regcache::cooked_write (int regnum
, const gdb_byte
*buf
)
786 gdb_assert (regnum
>= 0);
787 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
788 if (regnum
< num_raw_registers ())
789 raw_write (regnum
, buf
);
791 gdbarch_pseudo_register_write (m_descr
->gdbarch
, this,
795 /* See regcache.h. */
798 readable_regcache::read_part (int regnum
, int offset
, int len
,
799 gdb_byte
*out
, bool is_raw
)
801 int reg_size
= register_size (arch (), regnum
);
803 gdb_assert (out
!= NULL
);
804 gdb_assert (offset
>= 0 && len
>= 0 && offset
+ len
<= reg_size
);
806 if (offset
== 0 && len
== 0)
812 if (offset
== 0 && len
== reg_size
)
814 /* Read the full register. */
815 return (is_raw
) ? raw_read (regnum
, out
) : cooked_read (regnum
, out
);
818 enum register_status status
;
819 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
821 /* Read full register to buffer. */
822 status
= (is_raw
) ? raw_read (regnum
, reg
) : cooked_read (regnum
, reg
);
823 if (status
!= REG_VALID
)
827 memcpy (out
, reg
+ offset
, len
);
831 /* See regcache.h. */
834 regcache::write_part (int regnum
, int offset
, int len
,
835 const gdb_byte
*in
, bool is_raw
)
837 int reg_size
= register_size (arch (), regnum
);
839 gdb_assert (in
!= NULL
);
840 gdb_assert (offset
>= 0 && len
>= 0 && offset
+ len
<= reg_size
);
842 if (offset
== 0 && len
== 0)
848 if (offset
== 0 && len
== reg_size
)
850 /* Write the full register. */
851 (is_raw
) ? raw_write (regnum
, in
) : cooked_write (regnum
, in
);
855 enum register_status status
;
856 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
858 /* Read existing register to buffer. */
859 status
= (is_raw
) ? raw_read (regnum
, reg
) : cooked_read (regnum
, reg
);
860 if (status
!= REG_VALID
)
863 /* Update buffer, then write back to regcache. */
864 memcpy (reg
+ offset
, in
, len
);
865 is_raw
? raw_write (regnum
, reg
) : cooked_write (regnum
, reg
);
869 /* See regcache.h. */
872 readable_regcache::raw_read_part (int regnum
, int offset
, int len
,
875 assert_regnum (regnum
);
876 return read_part (regnum
, offset
, len
, buf
, true);
879 /* See regcache.h. */
882 regcache::raw_write_part (int regnum
, int offset
, int len
,
885 assert_regnum (regnum
);
886 write_part (regnum
, offset
, len
, buf
, true);
889 /* See regcache.h. */
892 readable_regcache::cooked_read_part (int regnum
, int offset
, int len
,
895 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
896 return read_part (regnum
, offset
, len
, buf
, false);
899 /* See regcache.h. */
902 regcache::cooked_write_part (int regnum
, int offset
, int len
,
905 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
906 write_part (regnum
, offset
, len
, buf
, false);
909 /* See common/common-regcache.h. */
912 reg_buffer::raw_supply (int regnum
, const void *buf
)
917 assert_regnum (regnum
);
919 regbuf
= register_buffer (regnum
);
920 size
= m_descr
->sizeof_register
[regnum
];
924 memcpy (regbuf
, buf
, size
);
925 m_register_status
[regnum
] = REG_VALID
;
929 /* This memset not strictly necessary, but better than garbage
930 in case the register value manages to escape somewhere (due
931 to a bug, no less). */
932 memset (regbuf
, 0, size
);
933 m_register_status
[regnum
] = REG_UNAVAILABLE
;
937 /* See regcache.h. */
940 reg_buffer::raw_supply_integer (int regnum
, const gdb_byte
*addr
,
941 int addr_len
, bool is_signed
)
943 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
947 assert_regnum (regnum
);
949 regbuf
= register_buffer (regnum
);
950 regsize
= m_descr
->sizeof_register
[regnum
];
952 copy_integer_to_size (regbuf
, regsize
, addr
, addr_len
, is_signed
,
954 m_register_status
[regnum
] = REG_VALID
;
957 /* See regcache.h. */
960 reg_buffer::raw_supply_zeroed (int regnum
)
965 assert_regnum (regnum
);
967 regbuf
= register_buffer (regnum
);
968 size
= m_descr
->sizeof_register
[regnum
];
970 memset (regbuf
, 0, size
);
971 m_register_status
[regnum
] = REG_VALID
;
974 /* See common/common-regcache.h. */
977 reg_buffer::raw_collect (int regnum
, void *buf
) const
982 gdb_assert (buf
!= NULL
);
983 assert_regnum (regnum
);
985 regbuf
= register_buffer (regnum
);
986 size
= m_descr
->sizeof_register
[regnum
];
987 memcpy (buf
, regbuf
, size
);
990 /* See regcache.h. */
993 reg_buffer::raw_collect_integer (int regnum
, gdb_byte
*addr
, int addr_len
,
994 bool is_signed
) const
996 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
997 const gdb_byte
*regbuf
;
1000 assert_regnum (regnum
);
1002 regbuf
= register_buffer (regnum
);
1003 regsize
= m_descr
->sizeof_register
[regnum
];
1005 copy_integer_to_size (addr
, addr_len
, regbuf
, regsize
, is_signed
,
1009 /* Transfer a single or all registers belonging to a certain register
1010 set to or from a buffer. This is the main worker function for
1011 regcache_supply_regset and regcache_collect_regset. */
1014 regcache::transfer_regset (const struct regset
*regset
,
1015 struct regcache
*out_regcache
,
1016 int regnum
, const void *in_buf
,
1017 void *out_buf
, size_t size
) const
1019 const struct regcache_map_entry
*map
;
1020 int offs
= 0, count
;
1022 for (map
= (const struct regcache_map_entry
*) regset
->regmap
;
1023 (count
= map
->count
) != 0;
1026 int regno
= map
->regno
;
1027 int slot_size
= map
->size
;
1029 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1030 slot_size
= m_descr
->sizeof_register
[regno
];
1032 if (regno
== REGCACHE_MAP_SKIP
1034 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1035 offs
+= count
* slot_size
;
1037 else if (regnum
== -1)
1038 for (; count
--; regno
++, offs
+= slot_size
)
1040 if (offs
+ slot_size
> size
)
1044 raw_collect (regno
, (gdb_byte
*) out_buf
+ offs
);
1046 out_regcache
->raw_supply (regno
, in_buf
1047 ? (const gdb_byte
*) in_buf
+ offs
1052 /* Transfer a single register and return. */
1053 offs
+= (regnum
- regno
) * slot_size
;
1054 if (offs
+ slot_size
> size
)
1058 raw_collect (regnum
, (gdb_byte
*) out_buf
+ offs
);
1060 out_regcache
->raw_supply (regnum
, in_buf
1061 ? (const gdb_byte
*) in_buf
+ offs
1068 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1069 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1070 If BUF is NULL, set the register(s) to "unavailable" status. */
1073 regcache_supply_regset (const struct regset
*regset
,
1074 struct regcache
*regcache
,
1075 int regnum
, const void *buf
, size_t size
)
1077 regcache
->supply_regset (regset
, regnum
, buf
, size
);
1081 regcache::supply_regset (const struct regset
*regset
,
1082 int regnum
, const void *buf
, size_t size
)
1084 transfer_regset (regset
, this, regnum
, buf
, NULL
, size
);
1087 /* Collect register REGNUM from REGCACHE to BUF, using the register
1088 map in REGSET. If REGNUM is -1, do this for all registers in
1092 regcache_collect_regset (const struct regset
*regset
,
1093 const struct regcache
*regcache
,
1094 int regnum
, void *buf
, size_t size
)
1096 regcache
->collect_regset (regset
, regnum
, buf
, size
);
1100 regcache::collect_regset (const struct regset
*regset
,
1101 int regnum
, void *buf
, size_t size
) const
1103 transfer_regset (regset
, NULL
, regnum
, NULL
, buf
, size
);
1106 /* See common/common-regcache.h. */
1109 reg_buffer::raw_compare (int regnum
, const void *buf
, int offset
) const
1111 gdb_assert (buf
!= NULL
);
1112 assert_regnum (regnum
);
1114 const char *regbuf
= (const char *) register_buffer (regnum
);
1115 size_t size
= m_descr
->sizeof_register
[regnum
];
1116 gdb_assert (size
>= offset
);
1118 return (memcmp (buf
, regbuf
+ offset
, size
- offset
) == 0);
1121 /* Special handling for register PC. */
1124 regcache_read_pc (struct regcache
*regcache
)
1126 struct gdbarch
*gdbarch
= regcache
->arch ();
1130 if (gdbarch_read_pc_p (gdbarch
))
1131 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1132 /* Else use per-frame method on get_current_frame. */
1133 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1137 if (regcache_cooked_read_unsigned (regcache
,
1138 gdbarch_pc_regnum (gdbarch
),
1139 &raw_val
) == REG_UNAVAILABLE
)
1140 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1142 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1145 internal_error (__FILE__
, __LINE__
,
1146 _("regcache_read_pc: Unable to find PC"));
1151 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1153 struct gdbarch
*gdbarch
= regcache
->arch ();
1155 if (gdbarch_write_pc_p (gdbarch
))
1156 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1157 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1158 regcache_cooked_write_unsigned (regcache
,
1159 gdbarch_pc_regnum (gdbarch
), pc
);
1161 internal_error (__FILE__
, __LINE__
,
1162 _("regcache_write_pc: Unable to update PC"));
1164 /* Writing the PC (for instance, from "load") invalidates the
1166 reinit_frame_cache ();
1170 reg_buffer::num_raw_registers () const
1172 return gdbarch_num_regs (arch ());
1176 regcache::debug_print_register (const char *func
, int regno
)
1178 struct gdbarch
*gdbarch
= arch ();
1180 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1181 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
1182 && gdbarch_register_name (gdbarch
, regno
) != NULL
1183 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
1184 fprintf_unfiltered (gdb_stdlog
, "(%s)",
1185 gdbarch_register_name (gdbarch
, regno
));
1187 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1188 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
1190 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1191 int size
= register_size (gdbarch
, regno
);
1192 gdb_byte
*buf
= register_buffer (regno
);
1194 fprintf_unfiltered (gdb_stdlog
, " = ");
1195 for (int i
= 0; i
< size
; i
++)
1197 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1199 if (size
<= sizeof (LONGEST
))
1201 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
1203 fprintf_unfiltered (gdb_stdlog
, " %s %s",
1204 core_addr_to_string_nz (val
), plongest (val
));
1207 fprintf_unfiltered (gdb_stdlog
, "\n");
1211 reg_flush_command (const char *command
, int from_tty
)
1213 /* Force-flush the register cache. */
1214 registers_changed ();
1216 printf_filtered (_("Register cache flushed.\n"));
1220 register_dump::dump (ui_file
*file
)
1222 auto descr
= regcache_descr (m_gdbarch
);
1224 int footnote_nr
= 0;
1225 int footnote_register_offset
= 0;
1226 int footnote_register_type_name_null
= 0;
1227 long register_offset
= 0;
1229 gdb_assert (descr
->nr_cooked_registers
1230 == (gdbarch_num_regs (m_gdbarch
)
1231 + gdbarch_num_pseudo_regs (m_gdbarch
)));
1233 for (regnum
= -1; regnum
< descr
->nr_cooked_registers
; regnum
++)
1237 fprintf_unfiltered (file
, " %-10s", "Name");
1240 const char *p
= gdbarch_register_name (m_gdbarch
, regnum
);
1244 else if (p
[0] == '\0')
1246 fprintf_unfiltered (file
, " %-10s", p
);
1251 fprintf_unfiltered (file
, " %4s", "Nr");
1253 fprintf_unfiltered (file
, " %4d", regnum
);
1255 /* Relative number. */
1257 fprintf_unfiltered (file
, " %4s", "Rel");
1258 else if (regnum
< gdbarch_num_regs (m_gdbarch
))
1259 fprintf_unfiltered (file
, " %4d", regnum
);
1261 fprintf_unfiltered (file
, " %4d",
1262 (regnum
- gdbarch_num_regs (m_gdbarch
)));
1266 fprintf_unfiltered (file
, " %6s ", "Offset");
1269 fprintf_unfiltered (file
, " %6ld",
1270 descr
->register_offset
[regnum
]);
1271 if (register_offset
!= descr
->register_offset
[regnum
]
1273 && (descr
->register_offset
[regnum
]
1274 != (descr
->register_offset
[regnum
- 1]
1275 + descr
->sizeof_register
[regnum
- 1])))
1278 if (!footnote_register_offset
)
1279 footnote_register_offset
= ++footnote_nr
;
1280 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1283 fprintf_unfiltered (file
, " ");
1284 register_offset
= (descr
->register_offset
[regnum
]
1285 + descr
->sizeof_register
[regnum
]);
1290 fprintf_unfiltered (file
, " %5s ", "Size");
1292 fprintf_unfiltered (file
, " %5ld", descr
->sizeof_register
[regnum
]);
1297 std::string name_holder
;
1303 static const char blt
[] = "builtin_type";
1305 t
= TYPE_NAME (register_type (m_gdbarch
, regnum
));
1308 if (!footnote_register_type_name_null
)
1309 footnote_register_type_name_null
= ++footnote_nr
;
1310 name_holder
= string_printf ("*%d",
1311 footnote_register_type_name_null
);
1312 t
= name_holder
.c_str ();
1314 /* Chop a leading builtin_type. */
1315 if (startswith (t
, blt
))
1318 fprintf_unfiltered (file
, " %-15s", t
);
1321 /* Leading space always present. */
1322 fprintf_unfiltered (file
, " ");
1324 dump_reg (file
, regnum
);
1326 fprintf_unfiltered (file
, "\n");
1329 if (footnote_register_offset
)
1330 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1331 footnote_register_offset
);
1332 if (footnote_register_type_name_null
)
1333 fprintf_unfiltered (file
,
1334 "*%d: Register type's name NULL.\n",
1335 footnote_register_type_name_null
);
1339 #include "selftest.h"
1340 #include "selftest-arch.h"
1341 #include "gdbthread.h"
1342 #include "target-float.h"
1344 namespace selftests
{
1346 class regcache_access
: public regcache
1350 /* Return the number of elements in current_regcache. */
1353 current_regcache_size ()
1355 return std::distance (regcache::current_regcache
.begin (),
1356 regcache::current_regcache
.end ());
1361 current_regcache_test (void)
1363 /* It is empty at the start. */
1364 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1366 ptid_t
ptid1 (1), ptid2 (2), ptid3 (3);
1368 /* Get regcache from ptid1, a new regcache is added to
1369 current_regcache. */
1370 regcache
*regcache
= get_thread_arch_aspace_regcache (ptid1
,
1374 SELF_CHECK (regcache
!= NULL
);
1375 SELF_CHECK (regcache
->ptid () == ptid1
);
1376 SELF_CHECK (regcache_access::current_regcache_size () == 1);
1378 /* Get regcache from ptid2, a new regcache is added to
1379 current_regcache. */
1380 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1383 SELF_CHECK (regcache
!= NULL
);
1384 SELF_CHECK (regcache
->ptid () == ptid2
);
1385 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1387 /* Get regcache from ptid3, a new regcache is added to
1388 current_regcache. */
1389 regcache
= get_thread_arch_aspace_regcache (ptid3
,
1392 SELF_CHECK (regcache
!= NULL
);
1393 SELF_CHECK (regcache
->ptid () == ptid3
);
1394 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1396 /* Get regcache from ptid2 again, nothing is added to
1397 current_regcache. */
1398 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1401 SELF_CHECK (regcache
!= NULL
);
1402 SELF_CHECK (regcache
->ptid () == ptid2
);
1403 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1405 /* Mark ptid2 is changed, so regcache of ptid2 should be removed from
1406 current_regcache. */
1407 registers_changed_ptid (ptid2
);
1408 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1411 class target_ops_no_register
: public test_target_ops
1414 target_ops_no_register ()
1415 : test_target_ops
{}
1420 fetch_registers_called
= 0;
1421 store_registers_called
= 0;
1422 xfer_partial_called
= 0;
1425 void fetch_registers (regcache
*regs
, int regno
) override
;
1426 void store_registers (regcache
*regs
, int regno
) override
;
1428 enum target_xfer_status
xfer_partial (enum target_object object
,
1429 const char *annex
, gdb_byte
*readbuf
,
1430 const gdb_byte
*writebuf
,
1431 ULONGEST offset
, ULONGEST len
,
1432 ULONGEST
*xfered_len
) override
;
1434 unsigned int fetch_registers_called
= 0;
1435 unsigned int store_registers_called
= 0;
1436 unsigned int xfer_partial_called
= 0;
1440 target_ops_no_register::fetch_registers (regcache
*regs
, int regno
)
1442 /* Mark register available. */
1443 regs
->raw_supply_zeroed (regno
);
1444 this->fetch_registers_called
++;
1448 target_ops_no_register::store_registers (regcache
*regs
, int regno
)
1450 this->store_registers_called
++;
1453 enum target_xfer_status
1454 target_ops_no_register::xfer_partial (enum target_object object
,
1455 const char *annex
, gdb_byte
*readbuf
,
1456 const gdb_byte
*writebuf
,
1457 ULONGEST offset
, ULONGEST len
,
1458 ULONGEST
*xfered_len
)
1460 this->xfer_partial_called
++;
1463 return TARGET_XFER_OK
;
1466 class readwrite_regcache
: public regcache
1469 readwrite_regcache (struct gdbarch
*gdbarch
)
1470 : regcache (gdbarch
, nullptr)
1474 /* Test regcache::cooked_read gets registers from raw registers and
1475 memory instead of target to_{fetch,store}_registers. */
1478 cooked_read_test (struct gdbarch
*gdbarch
)
1480 /* Error out if debugging something, because we're going to push the
1481 test target, which would pop any existing target. */
1482 if (current_top_target ()->to_stratum
>= process_stratum
)
1483 error (_("target already pushed"));
1485 /* Create a mock environment. An inferior with a thread, with a
1486 process_stratum target pushed. */
1488 target_ops_no_register mock_target
;
1489 ptid_t
mock_ptid (1, 1);
1490 inferior
mock_inferior (mock_ptid
.pid ());
1491 address_space mock_aspace
{};
1492 mock_inferior
.gdbarch
= gdbarch
;
1493 mock_inferior
.aspace
= &mock_aspace
;
1494 thread_info
mock_thread (&mock_inferior
, mock_ptid
);
1496 scoped_restore restore_thread_list
1497 = make_scoped_restore (&thread_list
, &mock_thread
);
1499 /* Add the mock inferior to the inferior list so that look ups by
1500 target+ptid can find it. */
1501 scoped_restore restore_inferior_list
1502 = make_scoped_restore (&inferior_list
);
1503 inferior_list
= &mock_inferior
;
1505 /* Switch to the mock inferior. */
1506 scoped_restore_current_inferior restore_current_inferior
;
1507 set_current_inferior (&mock_inferior
);
1509 /* Push the process_stratum target so we can mock accessing
1511 push_target (&mock_target
);
1513 /* Pop it again on exit (return/exception). */
1518 pop_all_targets_at_and_above (process_stratum
);
1522 /* Switch to the mock thread. */
1523 scoped_restore restore_inferior_ptid
1524 = make_scoped_restore (&inferior_ptid
, mock_ptid
);
1526 /* Test that read one raw register from regcache_no_target will go
1527 to the target layer. */
1530 /* Find a raw register which size isn't zero. */
1531 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1533 if (register_size (gdbarch
, regnum
) != 0)
1537 readwrite_regcache
readwrite (gdbarch
);
1538 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
));
1540 readwrite
.raw_read (regnum
, buf
.data ());
1542 /* raw_read calls target_fetch_registers. */
1543 SELF_CHECK (mock_target
.fetch_registers_called
> 0);
1544 mock_target
.reset ();
1546 /* Mark all raw registers valid, so the following raw registers
1547 accesses won't go to target. */
1548 for (auto i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1549 readwrite
.raw_update (i
);
1551 mock_target
.reset ();
1552 /* Then, read all raw and pseudo registers, and don't expect calling
1553 to_{fetch,store}_registers. */
1554 for (int regnum
= 0;
1555 regnum
< gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1558 if (register_size (gdbarch
, regnum
) == 0)
1561 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
));
1563 SELF_CHECK (REG_VALID
== readwrite
.cooked_read (regnum
, buf
.data ()));
1565 SELF_CHECK (mock_target
.fetch_registers_called
== 0);
1566 SELF_CHECK (mock_target
.store_registers_called
== 0);
1568 /* Some SPU pseudo registers are got via TARGET_OBJECT_SPU. */
1569 if (gdbarch_bfd_arch_info (gdbarch
)->arch
!= bfd_arch_spu
)
1570 SELF_CHECK (mock_target
.xfer_partial_called
== 0);
1572 mock_target
.reset ();
1575 readonly_detached_regcache
readonly (readwrite
);
1577 /* GDB may go to target layer to fetch all registers and memory for
1578 readonly regcache. */
1579 mock_target
.reset ();
1581 for (int regnum
= 0;
1582 regnum
< gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1585 if (register_size (gdbarch
, regnum
) == 0)
1588 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
));
1589 enum register_status status
= readonly
.cooked_read (regnum
,
1592 if (regnum
< gdbarch_num_regs (gdbarch
))
1594 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1596 if (bfd_arch
== bfd_arch_frv
|| bfd_arch
== bfd_arch_h8300
1597 || bfd_arch
== bfd_arch_m32c
|| bfd_arch
== bfd_arch_sh
1598 || bfd_arch
== bfd_arch_alpha
|| bfd_arch
== bfd_arch_v850
1599 || bfd_arch
== bfd_arch_msp430
|| bfd_arch
== bfd_arch_mep
1600 || bfd_arch
== bfd_arch_mips
|| bfd_arch
== bfd_arch_v850_rh850
1601 || bfd_arch
== bfd_arch_tic6x
|| bfd_arch
== bfd_arch_mn10300
1602 || bfd_arch
== bfd_arch_rl78
|| bfd_arch
== bfd_arch_score
1603 || bfd_arch
== bfd_arch_riscv
)
1605 /* Raw registers. If raw registers are not in save_reggroup,
1606 their status are unknown. */
1607 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1608 SELF_CHECK (status
== REG_VALID
);
1610 SELF_CHECK (status
== REG_UNKNOWN
);
1613 SELF_CHECK (status
== REG_VALID
);
1617 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1618 SELF_CHECK (status
== REG_VALID
);
1621 /* If pseudo registers are not in save_reggroup, some of
1622 them can be computed from saved raw registers, but some
1623 of them are unknown. */
1624 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1626 if (bfd_arch
== bfd_arch_frv
1627 || bfd_arch
== bfd_arch_m32c
1628 || bfd_arch
== bfd_arch_mep
1629 || bfd_arch
== bfd_arch_sh
)
1630 SELF_CHECK (status
== REG_VALID
|| status
== REG_UNKNOWN
);
1631 else if (bfd_arch
== bfd_arch_mips
1632 || bfd_arch
== bfd_arch_h8300
)
1633 SELF_CHECK (status
== REG_UNKNOWN
);
1635 SELF_CHECK (status
== REG_VALID
);
1639 SELF_CHECK (mock_target
.fetch_registers_called
== 0);
1640 SELF_CHECK (mock_target
.store_registers_called
== 0);
1641 SELF_CHECK (mock_target
.xfer_partial_called
== 0);
1643 mock_target
.reset ();
1647 /* Test regcache::cooked_write by writing some expected contents to
1648 registers, and checking that contents read from registers and the
1649 expected contents are the same. */
1652 cooked_write_test (struct gdbarch
*gdbarch
)
1654 /* Error out if debugging something, because we're going to push the
1655 test target, which would pop any existing target. */
1656 if (current_top_target ()->to_stratum
>= process_stratum
)
1657 error (_("target already pushed"));
1659 /* Create a mock environment. A process_stratum target pushed. */
1661 target_ops_no_register mock_target
;
1663 /* Push the process_stratum target so we can mock accessing
1665 push_target (&mock_target
);
1667 /* Pop it again on exit (return/exception). */
1672 pop_all_targets_at_and_above (process_stratum
);
1676 readwrite_regcache
readwrite (gdbarch
);
1678 const int num_regs
= (gdbarch_num_regs (gdbarch
)
1679 + gdbarch_num_pseudo_regs (gdbarch
));
1681 for (auto regnum
= 0; regnum
< num_regs
; regnum
++)
1683 if (register_size (gdbarch
, regnum
) == 0
1684 || gdbarch_cannot_store_register (gdbarch
, regnum
))
1687 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1689 if ((bfd_arch
== bfd_arch_sparc
1690 /* SPARC64_CWP_REGNUM, SPARC64_PSTATE_REGNUM,
1691 SPARC64_ASI_REGNUM and SPARC64_CCR_REGNUM are hard to test. */
1692 && gdbarch_ptr_bit (gdbarch
) == 64
1693 && (regnum
>= gdbarch_num_regs (gdbarch
)
1694 && regnum
<= gdbarch_num_regs (gdbarch
) + 4))
1695 || (bfd_arch
== bfd_arch_spu
1696 /* SPU pseudo registers except SPU_SP_REGNUM are got by
1697 TARGET_OBJECT_SPU. */
1698 && regnum
>= gdbarch_num_regs (gdbarch
) && regnum
!= 130))
1701 std::vector
<gdb_byte
> expected (register_size (gdbarch
, regnum
), 0);
1702 std::vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
), 0);
1703 const auto type
= register_type (gdbarch
, regnum
);
1705 if (TYPE_CODE (type
) == TYPE_CODE_FLT
1706 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1708 /* Generate valid float format. */
1709 target_float_from_string (expected
.data (), type
, "1.25");
1711 else if (TYPE_CODE (type
) == TYPE_CODE_INT
1712 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1713 || TYPE_CODE (type
) == TYPE_CODE_PTR
1714 || TYPE_CODE (type
) == TYPE_CODE_UNION
1715 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1717 if (bfd_arch
== bfd_arch_ia64
1718 || (regnum
>= gdbarch_num_regs (gdbarch
)
1719 && (bfd_arch
== bfd_arch_xtensa
1720 || bfd_arch
== bfd_arch_bfin
1721 || bfd_arch
== bfd_arch_m32c
1722 /* m68hc11 pseudo registers are in memory. */
1723 || bfd_arch
== bfd_arch_m68hc11
1724 || bfd_arch
== bfd_arch_m68hc12
1725 || bfd_arch
== bfd_arch_s390
))
1726 || (bfd_arch
== bfd_arch_frv
1727 /* FRV pseudo registers except iacc0. */
1728 && regnum
> gdbarch_num_regs (gdbarch
)))
1730 /* Skip setting the expected values for some architecture
1733 else if (bfd_arch
== bfd_arch_rl78
&& regnum
== 40)
1735 /* RL78_PC_REGNUM */
1736 for (auto j
= 0; j
< register_size (gdbarch
, regnum
) - 1; j
++)
1741 for (auto j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1745 else if (TYPE_CODE (type
) == TYPE_CODE_FLAGS
)
1747 /* No idea how to test flags. */
1752 /* If we don't know how to create the expected value for the
1753 this type, make it fail. */
1757 readwrite
.cooked_write (regnum
, expected
.data ());
1759 SELF_CHECK (readwrite
.cooked_read (regnum
, buf
.data ()) == REG_VALID
);
1760 SELF_CHECK (expected
== buf
);
1764 } // namespace selftests
1765 #endif /* GDB_SELF_TEST */
1768 _initialize_regcache (void)
1770 regcache_descr_handle
1771 = gdbarch_data_register_post_init (init_regcache_descr
);
1773 gdb::observers::target_changed
.attach (regcache_observer_target_changed
);
1774 gdb::observers::thread_ptid_changed
.attach
1775 (regcache::regcache_thread_ptid_changed
);
1777 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1778 _("Force gdb to flush its register cache (maintainer command)"));
1781 selftests::register_test ("current_regcache", selftests::current_regcache_test
);
1783 selftests::register_test_foreach_arch ("regcache::cooked_read_test",
1784 selftests::cooked_read_test
);
1785 selftests::register_test_foreach_arch ("regcache::cooked_write_test",
1786 selftests::cooked_write_test
);