1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986-2020 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"
24 #include "test-target.h"
28 #include "reggroups.h"
29 #include "observable.h"
31 #include <forward_list>
36 * Here is the actual register cache.
39 /* Per-architecture object describing the layout of a register cache.
40 Computed once when the architecture is created. */
42 struct gdbarch_data
*regcache_descr_handle
;
46 /* The architecture this descriptor belongs to. */
47 struct gdbarch
*gdbarch
;
49 /* The raw register cache. Each raw (or hard) register is supplied
50 by the target interface. The raw cache should not contain
51 redundant information - if the PC is constructed from two
52 registers then those registers and not the PC lives in the raw
54 long sizeof_raw_registers
;
56 /* The cooked register space. Each cooked register in the range
57 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
58 register. The remaining [NR_RAW_REGISTERS
59 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
60 both raw registers and memory by the architecture methods
61 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
62 int nr_cooked_registers
;
63 long sizeof_cooked_registers
;
65 /* Offset and size (in 8 bit bytes), of each register in the
66 register cache. All registers (including those in the range
67 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
69 long *register_offset
;
70 long *sizeof_register
;
72 /* Cached table containing the type of each register. */
73 struct type
**register_type
;
77 init_regcache_descr (struct gdbarch
*gdbarch
)
80 struct regcache_descr
*descr
;
81 gdb_assert (gdbarch
!= NULL
);
83 /* Create an initial, zero filled, table. */
84 descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct regcache_descr
);
85 descr
->gdbarch
= gdbarch
;
87 /* Total size of the register space. The raw registers are mapped
88 directly onto the raw register cache while the pseudo's are
89 either mapped onto raw-registers or memory. */
90 descr
->nr_cooked_registers
= gdbarch_num_cooked_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 && regnum
< gdbarch_num_cooked_regs (gdbarch
));
167 size
= descr
->sizeof_register
[regnum
];
171 /* See gdbsupport/common-regcache.h. */
174 regcache_register_size (const struct regcache
*regcache
, int n
)
176 return register_size (regcache
->arch (), n
);
179 reg_buffer::reg_buffer (gdbarch
*gdbarch
, bool has_pseudo
)
180 : m_has_pseudo (has_pseudo
)
182 gdb_assert (gdbarch
!= NULL
);
183 m_descr
= regcache_descr (gdbarch
);
187 m_registers
.reset (new gdb_byte
[m_descr
->sizeof_cooked_registers
] ());
188 m_register_status
.reset
189 (new register_status
[m_descr
->nr_cooked_registers
] ());
193 m_registers
.reset (new gdb_byte
[m_descr
->sizeof_raw_registers
] ());
194 m_register_status
.reset
195 (new register_status
[gdbarch_num_regs (gdbarch
)] ());
199 regcache::regcache (process_stratum_target
*target
, gdbarch
*gdbarch
,
200 const address_space
*aspace_
)
201 /* The register buffers. A read/write register cache can only hold
202 [0 .. gdbarch_num_regs). */
203 : detached_regcache (gdbarch
, false), m_aspace (aspace_
), m_target (target
)
205 m_ptid
= minus_one_ptid
;
208 readonly_detached_regcache::readonly_detached_regcache (regcache
&src
)
209 : readonly_detached_regcache (src
.arch (),
210 [&src
] (int regnum
, gdb_byte
*buf
)
212 return src
.cooked_read (regnum
, buf
);
218 reg_buffer::arch () const
220 return m_descr
->gdbarch
;
223 /* Return a pointer to register REGNUM's buffer cache. */
226 reg_buffer::register_buffer (int regnum
) const
228 return m_registers
.get () + m_descr
->register_offset
[regnum
];
232 reg_buffer::save (register_read_ftype cooked_read
)
234 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
237 /* It should have pseudo registers. */
238 gdb_assert (m_has_pseudo
);
239 /* Clear the dest. */
240 memset (m_registers
.get (), 0, m_descr
->sizeof_cooked_registers
);
241 memset (m_register_status
.get (), REG_UNKNOWN
, m_descr
->nr_cooked_registers
);
242 /* Copy over any registers (identified by their membership in the
243 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
244 gdbarch_num_pseudo_regs) range is checked since some architectures need
245 to save/restore `cooked' registers that live in memory. */
246 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
248 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
250 gdb_byte
*dst_buf
= register_buffer (regnum
);
251 enum register_status status
= cooked_read (regnum
, dst_buf
);
253 gdb_assert (status
!= REG_UNKNOWN
);
255 if (status
!= REG_VALID
)
256 memset (dst_buf
, 0, register_size (gdbarch
, regnum
));
258 m_register_status
[regnum
] = status
;
264 regcache::restore (readonly_detached_regcache
*src
)
266 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
269 gdb_assert (src
!= NULL
);
270 gdb_assert (src
->m_has_pseudo
);
272 gdb_assert (gdbarch
== src
->arch ());
274 /* Copy over any registers, being careful to only restore those that
275 were both saved and need to be restored. 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
, restore_reggroup
))
282 if (src
->m_register_status
[regnum
] == REG_VALID
)
283 cooked_write (regnum
, src
->register_buffer (regnum
));
288 /* See gdbsupport/common-regcache.h. */
291 reg_buffer::get_register_status (int regnum
) const
293 assert_regnum (regnum
);
295 return m_register_status
[regnum
];
299 reg_buffer::invalidate (int regnum
)
301 assert_regnum (regnum
);
302 m_register_status
[regnum
] = REG_UNKNOWN
;
306 reg_buffer::assert_regnum (int regnum
) const
308 gdb_assert (regnum
>= 0);
310 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
312 gdb_assert (regnum
< gdbarch_num_regs (arch ()));
315 /* Global structure containing the current regcache. */
317 /* NOTE: this is a write-through cache. There is no "dirty" bit for
318 recording if the register values have been changed (eg. by the
319 user). Therefore all registers must be written back to the
320 target when appropriate. */
321 std::forward_list
<regcache
*> regcache::current_regcache
;
324 get_thread_arch_aspace_regcache (process_stratum_target
*target
,
325 ptid_t ptid
, struct gdbarch
*gdbarch
,
326 struct address_space
*aspace
)
328 gdb_assert (target
!= nullptr);
330 for (const auto ®cache
: regcache::current_regcache
)
331 if (regcache
->target () == target
332 && regcache
->ptid () == ptid
333 && regcache
->arch () == gdbarch
)
336 regcache
*new_regcache
= new regcache (target
, gdbarch
, aspace
);
338 regcache::current_regcache
.push_front (new_regcache
);
339 new_regcache
->set_ptid (ptid
);
345 get_thread_arch_regcache (process_stratum_target
*target
, ptid_t ptid
,
346 struct gdbarch
*gdbarch
)
348 scoped_restore_current_inferior restore_current_inferior
;
349 set_current_inferior (find_inferior_ptid (target
, ptid
));
350 address_space
*aspace
= target_thread_address_space (ptid
);
352 return get_thread_arch_aspace_regcache (target
, ptid
, gdbarch
, aspace
);
355 static process_stratum_target
*current_thread_target
;
356 static ptid_t current_thread_ptid
;
357 static struct gdbarch
*current_thread_arch
;
360 get_thread_regcache (process_stratum_target
*target
, ptid_t ptid
)
362 if (!current_thread_arch
363 || target
!= current_thread_target
364 || current_thread_ptid
!= ptid
)
366 gdb_assert (ptid
!= null_ptid
);
368 current_thread_ptid
= ptid
;
369 current_thread_target
= target
;
371 scoped_restore_current_inferior restore_current_inferior
;
372 set_current_inferior (find_inferior_ptid (target
, ptid
));
373 current_thread_arch
= target_thread_architecture (ptid
);
376 return get_thread_arch_regcache (target
, ptid
, current_thread_arch
);
379 /* See regcache.h. */
382 get_thread_regcache (thread_info
*thread
)
384 return get_thread_regcache (thread
->inf
->process_target (),
389 get_current_regcache (void)
391 return get_thread_regcache (inferior_thread ());
394 /* See gdbsupport/common-regcache.h. */
397 get_thread_regcache_for_ptid (ptid_t ptid
)
399 /* This function doesn't take a process_stratum_target parameter
400 because it's a gdbsupport/ routine implemented by both gdb and
401 gdbserver. It always refers to a ptid of the current target. */
402 process_stratum_target
*proc_target
= current_inferior ()->process_target ();
403 return get_thread_regcache (proc_target
, ptid
);
406 /* Observer for the target_changed event. */
409 regcache_observer_target_changed (struct target_ops
*target
)
411 registers_changed ();
414 /* Update global variables old ptids to hold NEW_PTID if they were
417 regcache::regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
419 for (auto ®cache
: regcache::current_regcache
)
421 if (regcache
->ptid () == old_ptid
)
422 regcache
->set_ptid (new_ptid
);
426 /* Low level examining and depositing of registers.
428 The caller is responsible for making sure that the inferior is
429 stopped before calling the fetching routines, or it will get
430 garbage. (a change from GDB version 3, in which the caller got the
431 value from the last stop). */
433 /* REGISTERS_CHANGED ()
435 Indicate that registers may have changed, so invalidate the cache. */
438 registers_changed_ptid (process_stratum_target
*target
, ptid_t ptid
)
440 for (auto oit
= regcache::current_regcache
.before_begin (),
441 it
= std::next (oit
);
442 it
!= regcache::current_regcache
.end ();
445 struct regcache
*regcache
= *it
;
446 if ((target
== nullptr || regcache
->target () == target
)
447 && regcache
->ptid ().matches (ptid
))
450 it
= regcache::current_regcache
.erase_after (oit
);
456 if ((target
== nullptr || current_thread_target
== target
)
457 && current_thread_ptid
.matches (ptid
))
459 current_thread_target
= NULL
;
460 current_thread_ptid
= null_ptid
;
461 current_thread_arch
= NULL
;
464 if ((target
== nullptr || current_inferior ()->process_target () == target
)
465 && inferior_ptid
.matches (ptid
))
467 /* We just deleted the regcache of the current thread. Need to
468 forget about any frames we have cached, too. */
469 reinit_frame_cache ();
473 /* See regcache.h. */
476 registers_changed_thread (thread_info
*thread
)
478 registers_changed_ptid (thread
->inf
->process_target (), thread
->ptid
);
482 registers_changed (void)
484 registers_changed_ptid (nullptr, minus_one_ptid
);
488 regcache::raw_update (int regnum
)
490 assert_regnum (regnum
);
492 /* Make certain that the register cache is up-to-date with respect
493 to the current thread. This switching shouldn't be necessary
494 only there is still only one target side register cache. Sigh!
495 On the bright side, at least there is a regcache object. */
497 if (get_register_status (regnum
) == REG_UNKNOWN
)
499 target_fetch_registers (this, regnum
);
501 /* A number of targets can't access the whole set of raw
502 registers (because the debug API provides no means to get at
504 if (m_register_status
[regnum
] == REG_UNKNOWN
)
505 m_register_status
[regnum
] = REG_UNAVAILABLE
;
510 readable_regcache::raw_read (int regnum
, gdb_byte
*buf
)
512 gdb_assert (buf
!= NULL
);
515 if (m_register_status
[regnum
] != REG_VALID
)
516 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
518 memcpy (buf
, register_buffer (regnum
),
519 m_descr
->sizeof_register
[regnum
]);
521 return m_register_status
[regnum
];
525 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
527 gdb_assert (regcache
!= NULL
);
528 return regcache
->raw_read (regnum
, val
);
531 template<typename T
, typename
>
533 readable_regcache::raw_read (int regnum
, T
*val
)
536 enum register_status status
;
538 assert_regnum (regnum
);
539 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
540 status
= raw_read (regnum
, buf
);
541 if (status
== REG_VALID
)
542 *val
= extract_integer
<T
> (buf
,
543 m_descr
->sizeof_register
[regnum
],
544 gdbarch_byte_order (m_descr
->gdbarch
));
551 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
554 gdb_assert (regcache
!= NULL
);
555 return regcache
->raw_read (regnum
, val
);
559 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
561 gdb_assert (regcache
!= NULL
);
562 regcache
->raw_write (regnum
, val
);
565 template<typename T
, typename
>
567 regcache::raw_write (int regnum
, T val
)
571 assert_regnum (regnum
);
572 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
573 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
574 gdbarch_byte_order (m_descr
->gdbarch
), val
);
575 raw_write (regnum
, buf
);
579 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
582 gdb_assert (regcache
!= NULL
);
583 regcache
->raw_write (regnum
, val
);
587 regcache_raw_get_signed (struct regcache
*regcache
, int regnum
)
590 enum register_status status
;
592 status
= regcache_raw_read_signed (regcache
, regnum
, &value
);
593 if (status
== REG_UNAVAILABLE
)
594 throw_error (NOT_AVAILABLE_ERROR
,
595 _("Register %d is not available"), regnum
);
600 readable_regcache::cooked_read (int regnum
, gdb_byte
*buf
)
602 gdb_assert (regnum
>= 0);
603 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
604 if (regnum
< num_raw_registers ())
605 return raw_read (regnum
, buf
);
606 else if (m_has_pseudo
607 && m_register_status
[regnum
] != REG_UNKNOWN
)
609 if (m_register_status
[regnum
] == REG_VALID
)
610 memcpy (buf
, register_buffer (regnum
),
611 m_descr
->sizeof_register
[regnum
]);
613 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
615 return m_register_status
[regnum
];
617 else if (gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
619 struct value
*mark
, *computed
;
620 enum register_status result
= REG_VALID
;
622 mark
= value_mark ();
624 computed
= gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
626 if (value_entirely_available (computed
))
627 memcpy (buf
, value_contents_raw (computed
),
628 m_descr
->sizeof_register
[regnum
]);
631 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
632 result
= REG_UNAVAILABLE
;
635 value_free_to_mark (mark
);
640 return gdbarch_pseudo_register_read (m_descr
->gdbarch
, this,
645 readable_regcache::cooked_read_value (int regnum
)
647 gdb_assert (regnum
>= 0);
648 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
650 if (regnum
< num_raw_registers ()
651 || (m_has_pseudo
&& m_register_status
[regnum
] != REG_UNKNOWN
)
652 || !gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
654 struct value
*result
;
656 result
= allocate_value (register_type (m_descr
->gdbarch
, regnum
));
657 VALUE_LVAL (result
) = lval_register
;
658 VALUE_REGNUM (result
) = regnum
;
660 /* It is more efficient in general to do this delegation in this
661 direction than in the other one, even though the value-based
663 if (cooked_read (regnum
,
664 value_contents_raw (result
)) == REG_UNAVAILABLE
)
665 mark_value_bytes_unavailable (result
, 0,
666 TYPE_LENGTH (value_type (result
)));
671 return gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
676 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
679 gdb_assert (regcache
!= NULL
);
680 return regcache
->cooked_read (regnum
, val
);
683 template<typename T
, typename
>
685 readable_regcache::cooked_read (int regnum
, T
*val
)
687 enum register_status status
;
690 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
691 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
692 status
= cooked_read (regnum
, buf
);
693 if (status
== REG_VALID
)
694 *val
= extract_integer
<T
> (buf
, m_descr
->sizeof_register
[regnum
],
695 gdbarch_byte_order (m_descr
->gdbarch
));
702 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
705 gdb_assert (regcache
!= NULL
);
706 return regcache
->cooked_read (regnum
, val
);
710 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
713 gdb_assert (regcache
!= NULL
);
714 regcache
->cooked_write (regnum
, val
);
717 template<typename T
, typename
>
719 regcache::cooked_write (int regnum
, T val
)
723 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
724 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
725 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
726 gdbarch_byte_order (m_descr
->gdbarch
), val
);
727 cooked_write (regnum
, buf
);
731 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
734 gdb_assert (regcache
!= NULL
);
735 regcache
->cooked_write (regnum
, val
);
739 regcache::raw_write (int regnum
, const gdb_byte
*buf
)
742 gdb_assert (buf
!= NULL
);
743 assert_regnum (regnum
);
745 /* On the sparc, writing %g0 is a no-op, so we don't even want to
746 change the registers array if something writes to this register. */
747 if (gdbarch_cannot_store_register (arch (), regnum
))
750 /* If we have a valid copy of the register, and new value == old
751 value, then don't bother doing the actual store. */
752 if (get_register_status (regnum
) == REG_VALID
753 && (memcmp (register_buffer (regnum
), buf
,
754 m_descr
->sizeof_register
[regnum
]) == 0))
757 target_prepare_to_store (this);
758 raw_supply (regnum
, buf
);
760 /* Invalidate the register after it is written, in case of a
763 = make_scope_exit ([&] { this->invalidate (regnum
); });
765 target_store_registers (this, regnum
);
767 /* The target did not throw an error so we can discard invalidating
769 invalidator
.release ();
773 regcache::cooked_write (int regnum
, const gdb_byte
*buf
)
775 gdb_assert (regnum
>= 0);
776 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
777 if (regnum
< num_raw_registers ())
778 raw_write (regnum
, buf
);
780 gdbarch_pseudo_register_write (m_descr
->gdbarch
, this,
784 /* See regcache.h. */
787 readable_regcache::read_part (int regnum
, int offset
, int len
,
788 gdb_byte
*out
, bool is_raw
)
790 int reg_size
= register_size (arch (), regnum
);
792 gdb_assert (out
!= NULL
);
793 gdb_assert (offset
>= 0 && offset
<= reg_size
);
794 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
796 if (offset
== 0 && len
== 0)
802 if (offset
== 0 && len
== reg_size
)
804 /* Read the full register. */
805 return (is_raw
) ? raw_read (regnum
, out
) : cooked_read (regnum
, out
);
808 enum register_status status
;
809 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
811 /* Read full register to buffer. */
812 status
= (is_raw
) ? raw_read (regnum
, reg
) : cooked_read (regnum
, reg
);
813 if (status
!= REG_VALID
)
817 memcpy (out
, reg
+ offset
, len
);
821 /* See regcache.h. */
824 reg_buffer::raw_collect_part (int regnum
, int offset
, int len
,
827 int reg_size
= register_size (arch (), regnum
);
829 gdb_assert (out
!= nullptr);
830 gdb_assert (offset
>= 0 && offset
<= reg_size
);
831 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
833 if (offset
== 0 && len
== 0)
839 if (offset
== 0 && len
== reg_size
)
841 /* Collect the full register. */
842 return raw_collect (regnum
, out
);
845 /* Read to buffer, then write out. */
846 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
847 raw_collect (regnum
, reg
);
848 memcpy (out
, reg
+ offset
, len
);
851 /* See regcache.h. */
854 regcache::write_part (int regnum
, int offset
, int len
,
855 const gdb_byte
*in
, bool is_raw
)
857 int reg_size
= register_size (arch (), regnum
);
859 gdb_assert (in
!= NULL
);
860 gdb_assert (offset
>= 0 && offset
<= reg_size
);
861 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
863 if (offset
== 0 && len
== 0)
869 if (offset
== 0 && len
== reg_size
)
871 /* Write the full register. */
872 (is_raw
) ? raw_write (regnum
, in
) : cooked_write (regnum
, in
);
876 enum register_status status
;
877 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
879 /* Read existing register to buffer. */
880 status
= (is_raw
) ? raw_read (regnum
, reg
) : cooked_read (regnum
, reg
);
881 if (status
!= REG_VALID
)
884 /* Update buffer, then write back to regcache. */
885 memcpy (reg
+ offset
, in
, len
);
886 is_raw
? raw_write (regnum
, reg
) : cooked_write (regnum
, reg
);
890 /* See regcache.h. */
893 reg_buffer::raw_supply_part (int regnum
, int offset
, int len
,
896 int reg_size
= register_size (arch (), regnum
);
898 gdb_assert (in
!= nullptr);
899 gdb_assert (offset
>= 0 && offset
<= reg_size
);
900 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
902 if (offset
== 0 && len
== 0)
908 if (offset
== 0 && len
== reg_size
)
910 /* Supply the full register. */
911 return raw_supply (regnum
, in
);
914 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
916 /* Read existing value to buffer. */
917 raw_collect (regnum
, reg
);
919 /* Write to buffer, then write out. */
920 memcpy (reg
+ offset
, in
, len
);
921 raw_supply (regnum
, reg
);
925 readable_regcache::raw_read_part (int regnum
, int offset
, int len
,
928 assert_regnum (regnum
);
929 return read_part (regnum
, offset
, len
, buf
, true);
932 /* See regcache.h. */
935 regcache::raw_write_part (int regnum
, int offset
, int len
,
938 assert_regnum (regnum
);
939 write_part (regnum
, offset
, len
, buf
, true);
942 /* See regcache.h. */
945 readable_regcache::cooked_read_part (int regnum
, int offset
, int len
,
948 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
949 return read_part (regnum
, offset
, len
, buf
, false);
952 /* See regcache.h. */
955 regcache::cooked_write_part (int regnum
, int offset
, int len
,
958 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
959 write_part (regnum
, offset
, len
, buf
, false);
962 /* See gdbsupport/common-regcache.h. */
965 reg_buffer::raw_supply (int regnum
, const void *buf
)
970 assert_regnum (regnum
);
972 regbuf
= register_buffer (regnum
);
973 size
= m_descr
->sizeof_register
[regnum
];
977 memcpy (regbuf
, buf
, size
);
978 m_register_status
[regnum
] = REG_VALID
;
982 /* This memset not strictly necessary, but better than garbage
983 in case the register value manages to escape somewhere (due
984 to a bug, no less). */
985 memset (regbuf
, 0, size
);
986 m_register_status
[regnum
] = REG_UNAVAILABLE
;
990 /* See regcache.h. */
993 reg_buffer::raw_supply_integer (int regnum
, const gdb_byte
*addr
,
994 int addr_len
, bool is_signed
)
996 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1000 assert_regnum (regnum
);
1002 regbuf
= register_buffer (regnum
);
1003 regsize
= m_descr
->sizeof_register
[regnum
];
1005 copy_integer_to_size (regbuf
, regsize
, addr
, addr_len
, is_signed
,
1007 m_register_status
[regnum
] = REG_VALID
;
1010 /* See regcache.h. */
1013 reg_buffer::raw_supply_zeroed (int regnum
)
1018 assert_regnum (regnum
);
1020 regbuf
= register_buffer (regnum
);
1021 size
= m_descr
->sizeof_register
[regnum
];
1023 memset (regbuf
, 0, size
);
1024 m_register_status
[regnum
] = REG_VALID
;
1027 /* See gdbsupport/common-regcache.h. */
1030 reg_buffer::raw_collect (int regnum
, void *buf
) const
1035 gdb_assert (buf
!= NULL
);
1036 assert_regnum (regnum
);
1038 regbuf
= register_buffer (regnum
);
1039 size
= m_descr
->sizeof_register
[regnum
];
1040 memcpy (buf
, regbuf
, size
);
1043 /* See regcache.h. */
1046 reg_buffer::raw_collect_integer (int regnum
, gdb_byte
*addr
, int addr_len
,
1047 bool is_signed
) const
1049 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1050 const gdb_byte
*regbuf
;
1053 assert_regnum (regnum
);
1055 regbuf
= register_buffer (regnum
);
1056 regsize
= m_descr
->sizeof_register
[regnum
];
1058 copy_integer_to_size (addr
, addr_len
, regbuf
, regsize
, is_signed
,
1062 /* See regcache.h. */
1065 regcache::transfer_regset_register (struct regcache
*out_regcache
, int regnum
,
1066 const gdb_byte
*in_buf
, gdb_byte
*out_buf
,
1067 int slot_size
, int offs
) const
1069 struct gdbarch
*gdbarch
= arch ();
1070 int reg_size
= std::min (register_size (gdbarch
, regnum
), slot_size
);
1072 /* Use part versions and reg_size to prevent possible buffer overflows when
1073 accessing the regcache. */
1075 if (out_buf
!= nullptr)
1077 raw_collect_part (regnum
, 0, reg_size
, out_buf
+ offs
);
1079 /* Ensure any additional space is cleared. */
1080 if (slot_size
> reg_size
)
1081 memset (out_buf
+ offs
+ reg_size
, 0, slot_size
- reg_size
);
1083 else if (in_buf
!= nullptr)
1084 out_regcache
->raw_supply_part (regnum
, 0, reg_size
, in_buf
+ offs
);
1087 /* Invalidate the register. */
1088 out_regcache
->raw_supply (regnum
, nullptr);
1092 /* See regcache.h. */
1095 regcache::transfer_regset (const struct regset
*regset
,
1096 struct regcache
*out_regcache
,
1097 int regnum
, const gdb_byte
*in_buf
,
1098 gdb_byte
*out_buf
, size_t size
) const
1100 const struct regcache_map_entry
*map
;
1101 int offs
= 0, count
;
1103 for (map
= (const struct regcache_map_entry
*) regset
->regmap
;
1104 (count
= map
->count
) != 0;
1107 int regno
= map
->regno
;
1108 int slot_size
= map
->size
;
1110 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1111 slot_size
= m_descr
->sizeof_register
[regno
];
1113 if (regno
== REGCACHE_MAP_SKIP
1115 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1116 offs
+= count
* slot_size
;
1118 else if (regnum
== -1)
1119 for (; count
--; regno
++, offs
+= slot_size
)
1121 if (offs
+ slot_size
> size
)
1124 transfer_regset_register (out_regcache
, regno
, in_buf
, out_buf
,
1129 /* Transfer a single register and return. */
1130 offs
+= (regnum
- regno
) * slot_size
;
1131 if (offs
+ slot_size
> size
)
1134 transfer_regset_register (out_regcache
, regnum
, in_buf
, out_buf
,
1141 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1142 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1143 If BUF is NULL, set the register(s) to "unavailable" status. */
1146 regcache_supply_regset (const struct regset
*regset
,
1147 struct regcache
*regcache
,
1148 int regnum
, const void *buf
, size_t size
)
1150 regcache
->supply_regset (regset
, regnum
, (const gdb_byte
*) buf
, size
);
1154 regcache::supply_regset (const struct regset
*regset
,
1155 int regnum
, const void *buf
, size_t size
)
1157 transfer_regset (regset
, this, regnum
, (const gdb_byte
*) buf
, nullptr, size
);
1160 /* Collect register REGNUM from REGCACHE to BUF, using the register
1161 map in REGSET. If REGNUM is -1, do this for all registers in
1165 regcache_collect_regset (const struct regset
*regset
,
1166 const struct regcache
*regcache
,
1167 int regnum
, void *buf
, size_t size
)
1169 regcache
->collect_regset (regset
, regnum
, (gdb_byte
*) buf
, size
);
1173 regcache::collect_regset (const struct regset
*regset
,
1174 int regnum
, void *buf
, size_t size
) const
1176 transfer_regset (regset
, nullptr, regnum
, nullptr, (gdb_byte
*) buf
, size
);
1179 /* See gdbsupport/common-regcache.h. */
1182 reg_buffer::raw_compare (int regnum
, const void *buf
, int offset
) const
1184 gdb_assert (buf
!= NULL
);
1185 assert_regnum (regnum
);
1187 const char *regbuf
= (const char *) register_buffer (regnum
);
1188 size_t size
= m_descr
->sizeof_register
[regnum
];
1189 gdb_assert (size
>= offset
);
1191 return (memcmp (buf
, regbuf
+ offset
, size
- offset
) == 0);
1194 /* Special handling for register PC. */
1197 regcache_read_pc (struct regcache
*regcache
)
1199 struct gdbarch
*gdbarch
= regcache
->arch ();
1203 if (gdbarch_read_pc_p (gdbarch
))
1204 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1205 /* Else use per-frame method on get_current_frame. */
1206 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1210 if (regcache_cooked_read_unsigned (regcache
,
1211 gdbarch_pc_regnum (gdbarch
),
1212 &raw_val
) == REG_UNAVAILABLE
)
1213 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1215 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1218 internal_error (__FILE__
, __LINE__
,
1219 _("regcache_read_pc: Unable to find PC"));
1223 /* See gdbsupport/common-regcache.h. */
1226 regcache_read_pc_protected (regcache
*regcache
)
1231 pc
= regcache_read_pc (regcache
);
1233 catch (const gdb_exception_error
&ex
)
1242 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1244 struct gdbarch
*gdbarch
= regcache
->arch ();
1246 if (gdbarch_write_pc_p (gdbarch
))
1247 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1248 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1249 regcache_cooked_write_unsigned (regcache
,
1250 gdbarch_pc_regnum (gdbarch
), pc
);
1252 internal_error (__FILE__
, __LINE__
,
1253 _("regcache_write_pc: Unable to update PC"));
1255 /* Writing the PC (for instance, from "load") invalidates the
1257 reinit_frame_cache ();
1261 reg_buffer::num_raw_registers () const
1263 return gdbarch_num_regs (arch ());
1267 regcache::debug_print_register (const char *func
, int regno
)
1269 struct gdbarch
*gdbarch
= arch ();
1271 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1272 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
1273 && gdbarch_register_name (gdbarch
, regno
) != NULL
1274 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
1275 fprintf_unfiltered (gdb_stdlog
, "(%s)",
1276 gdbarch_register_name (gdbarch
, regno
));
1278 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1279 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
1281 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1282 int size
= register_size (gdbarch
, regno
);
1283 gdb_byte
*buf
= register_buffer (regno
);
1285 fprintf_unfiltered (gdb_stdlog
, " = ");
1286 for (int i
= 0; i
< size
; i
++)
1288 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1290 if (size
<= sizeof (LONGEST
))
1292 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
1294 fprintf_unfiltered (gdb_stdlog
, " %s %s",
1295 core_addr_to_string_nz (val
), plongest (val
));
1298 fprintf_unfiltered (gdb_stdlog
, "\n");
1302 reg_flush_command (const char *command
, int from_tty
)
1304 /* Force-flush the register cache. */
1305 registers_changed ();
1307 printf_filtered (_("Register cache flushed.\n"));
1311 register_dump::dump (ui_file
*file
)
1313 auto descr
= regcache_descr (m_gdbarch
);
1315 int footnote_nr
= 0;
1316 int footnote_register_offset
= 0;
1317 int footnote_register_type_name_null
= 0;
1318 long register_offset
= 0;
1320 gdb_assert (descr
->nr_cooked_registers
1321 == gdbarch_num_cooked_regs (m_gdbarch
));
1323 for (regnum
= -1; regnum
< descr
->nr_cooked_registers
; regnum
++)
1327 fprintf_unfiltered (file
, " %-10s", "Name");
1330 const char *p
= gdbarch_register_name (m_gdbarch
, regnum
);
1334 else if (p
[0] == '\0')
1336 fprintf_unfiltered (file
, " %-10s", p
);
1341 fprintf_unfiltered (file
, " %4s", "Nr");
1343 fprintf_unfiltered (file
, " %4d", regnum
);
1345 /* Relative number. */
1347 fprintf_unfiltered (file
, " %4s", "Rel");
1348 else if (regnum
< gdbarch_num_regs (m_gdbarch
))
1349 fprintf_unfiltered (file
, " %4d", regnum
);
1351 fprintf_unfiltered (file
, " %4d",
1352 (regnum
- gdbarch_num_regs (m_gdbarch
)));
1356 fprintf_unfiltered (file
, " %6s ", "Offset");
1359 fprintf_unfiltered (file
, " %6ld",
1360 descr
->register_offset
[regnum
]);
1361 if (register_offset
!= descr
->register_offset
[regnum
]
1363 && (descr
->register_offset
[regnum
]
1364 != (descr
->register_offset
[regnum
- 1]
1365 + descr
->sizeof_register
[regnum
- 1])))
1368 if (!footnote_register_offset
)
1369 footnote_register_offset
= ++footnote_nr
;
1370 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1373 fprintf_unfiltered (file
, " ");
1374 register_offset
= (descr
->register_offset
[regnum
]
1375 + descr
->sizeof_register
[regnum
]);
1380 fprintf_unfiltered (file
, " %5s ", "Size");
1382 fprintf_unfiltered (file
, " %5ld", descr
->sizeof_register
[regnum
]);
1387 std::string name_holder
;
1393 static const char blt
[] = "builtin_type";
1395 t
= TYPE_NAME (register_type (m_gdbarch
, regnum
));
1398 if (!footnote_register_type_name_null
)
1399 footnote_register_type_name_null
= ++footnote_nr
;
1400 name_holder
= string_printf ("*%d",
1401 footnote_register_type_name_null
);
1402 t
= name_holder
.c_str ();
1404 /* Chop a leading builtin_type. */
1405 if (startswith (t
, blt
))
1408 fprintf_unfiltered (file
, " %-15s", t
);
1411 /* Leading space always present. */
1412 fprintf_unfiltered (file
, " ");
1414 dump_reg (file
, regnum
);
1416 fprintf_unfiltered (file
, "\n");
1419 if (footnote_register_offset
)
1420 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1421 footnote_register_offset
);
1422 if (footnote_register_type_name_null
)
1423 fprintf_unfiltered (file
,
1424 "*%d: Register type's name NULL.\n",
1425 footnote_register_type_name_null
);
1429 #include "gdbsupport/selftest.h"
1430 #include "selftest-arch.h"
1431 #include "target-float.h"
1433 namespace selftests
{
1435 class regcache_access
: public regcache
1439 /* Return the number of elements in current_regcache. */
1442 current_regcache_size ()
1444 return std::distance (regcache::current_regcache
.begin (),
1445 regcache::current_regcache
.end ());
1449 /* Wrapper around get_thread_arch_aspace_regcache that does some self checks. */
1452 test_get_thread_arch_aspace_regcache (process_stratum_target
*target
,
1453 ptid_t ptid
, struct gdbarch
*gdbarch
,
1454 address_space
*aspace
)
1456 struct regcache
*regcache
1457 = get_thread_arch_aspace_regcache (target
, ptid
, gdbarch
, aspace
);
1458 SELF_CHECK (regcache
!= NULL
);
1459 SELF_CHECK (regcache
->target () == target
);
1460 SELF_CHECK (regcache
->ptid () == ptid
);
1461 SELF_CHECK (regcache
->aspace () == aspace
);
1465 current_regcache_test (void)
1467 /* It is empty at the start. */
1468 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1470 ptid_t
ptid1 (1), ptid2 (2), ptid3 (3);
1472 test_target_ops test_target1
;
1473 test_target_ops test_target2
;
1475 /* Get regcache from (target1,ptid1), a new regcache is added to
1476 current_regcache. */
1477 test_get_thread_arch_aspace_regcache (&test_target1
, ptid1
,
1480 SELF_CHECK (regcache_access::current_regcache_size () == 1);
1482 /* Get regcache from (target1,ptid2), a new regcache is added to
1483 current_regcache. */
1484 test_get_thread_arch_aspace_regcache (&test_target1
, ptid2
,
1487 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1489 /* Get regcache from (target1,ptid3), a new regcache is added to
1490 current_regcache. */
1491 test_get_thread_arch_aspace_regcache (&test_target1
, ptid3
,
1494 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1496 /* Get regcache from (target1,ptid2) again, nothing is added to
1497 current_regcache. */
1498 test_get_thread_arch_aspace_regcache (&test_target1
, ptid2
,
1501 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1503 /* Get regcache from (target2,ptid2), a new regcache is added to
1504 current_regcache, since this time we're using a differen
1506 test_get_thread_arch_aspace_regcache (&test_target2
, ptid2
,
1509 SELF_CHECK (regcache_access::current_regcache_size () == 4);
1511 /* Mark that (target1,ptid2) changed. The regcache of (target1,
1512 ptid2) should be removed from current_regcache. */
1513 registers_changed_ptid (&test_target1
, ptid2
);
1514 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1516 /* Get the regcache from (target2,ptid2) again, confirming the
1517 registers_changed_ptid call above did not delete it. */
1518 test_get_thread_arch_aspace_regcache (&test_target2
, ptid2
,
1521 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1523 /* Confirm that marking all regcaches of all targets as changed
1524 clears current_regcache. */
1525 registers_changed_ptid (nullptr, minus_one_ptid
);
1526 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1529 class target_ops_no_register
: public test_target_ops
1532 target_ops_no_register ()
1533 : test_target_ops
{}
1538 fetch_registers_called
= 0;
1539 store_registers_called
= 0;
1540 xfer_partial_called
= 0;
1543 void fetch_registers (regcache
*regs
, int regno
) override
;
1544 void store_registers (regcache
*regs
, int regno
) override
;
1546 enum target_xfer_status
xfer_partial (enum target_object object
,
1547 const char *annex
, gdb_byte
*readbuf
,
1548 const gdb_byte
*writebuf
,
1549 ULONGEST offset
, ULONGEST len
,
1550 ULONGEST
*xfered_len
) override
;
1552 unsigned int fetch_registers_called
= 0;
1553 unsigned int store_registers_called
= 0;
1554 unsigned int xfer_partial_called
= 0;
1558 target_ops_no_register::fetch_registers (regcache
*regs
, int regno
)
1560 /* Mark register available. */
1561 regs
->raw_supply_zeroed (regno
);
1562 this->fetch_registers_called
++;
1566 target_ops_no_register::store_registers (regcache
*regs
, int regno
)
1568 this->store_registers_called
++;
1571 enum target_xfer_status
1572 target_ops_no_register::xfer_partial (enum target_object object
,
1573 const char *annex
, gdb_byte
*readbuf
,
1574 const gdb_byte
*writebuf
,
1575 ULONGEST offset
, ULONGEST len
,
1576 ULONGEST
*xfered_len
)
1578 this->xfer_partial_called
++;
1581 return TARGET_XFER_OK
;
1584 class readwrite_regcache
: public regcache
1587 readwrite_regcache (process_stratum_target
*target
,
1588 struct gdbarch
*gdbarch
)
1589 : regcache (target
, gdbarch
, nullptr)
1593 /* Test regcache::cooked_read gets registers from raw registers and
1594 memory instead of target to_{fetch,store}_registers. */
1597 cooked_read_test (struct gdbarch
*gdbarch
)
1599 /* Error out if debugging something, because we're going to push the
1600 test target, which would pop any existing target. */
1601 if (current_top_target ()->stratum () >= process_stratum
)
1602 error (_("target already pushed"));
1604 /* Create a mock environment. An inferior with a thread, with a
1605 process_stratum target pushed. */
1607 target_ops_no_register mock_target
;
1608 ptid_t
mock_ptid (1, 1);
1609 inferior
mock_inferior (mock_ptid
.pid ());
1610 address_space mock_aspace
{};
1611 mock_inferior
.gdbarch
= gdbarch
;
1612 mock_inferior
.aspace
= &mock_aspace
;
1613 thread_info
mock_thread (&mock_inferior
, mock_ptid
);
1614 mock_inferior
.thread_list
= &mock_thread
;
1616 /* Add the mock inferior to the inferior list so that look ups by
1617 target+ptid can find it. */
1618 scoped_restore restore_inferior_list
1619 = make_scoped_restore (&inferior_list
);
1620 inferior_list
= &mock_inferior
;
1622 /* Switch to the mock inferior. */
1623 scoped_restore_current_inferior restore_current_inferior
;
1624 set_current_inferior (&mock_inferior
);
1626 /* Push the process_stratum target so we can mock accessing
1628 push_target (&mock_target
);
1630 /* Pop it again on exit (return/exception). */
1635 pop_all_targets_at_and_above (process_stratum
);
1639 /* Switch to the mock thread. */
1640 scoped_restore restore_inferior_ptid
1641 = make_scoped_restore (&inferior_ptid
, mock_ptid
);
1643 /* Test that read one raw register from regcache_no_target will go
1644 to the target layer. */
1646 /* Find a raw register which size isn't zero. */
1648 for (nonzero_regnum
= 0;
1649 nonzero_regnum
< gdbarch_num_regs (gdbarch
);
1652 if (register_size (gdbarch
, nonzero_regnum
) != 0)
1656 readwrite_regcache
readwrite (&mock_target
, gdbarch
);
1657 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, nonzero_regnum
));
1659 readwrite
.raw_read (nonzero_regnum
, buf
.data ());
1661 /* raw_read calls target_fetch_registers. */
1662 SELF_CHECK (mock_target
.fetch_registers_called
> 0);
1663 mock_target
.reset ();
1665 /* Mark all raw registers valid, so the following raw registers
1666 accesses won't go to target. */
1667 for (auto i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1668 readwrite
.raw_update (i
);
1670 mock_target
.reset ();
1671 /* Then, read all raw and pseudo registers, and don't expect calling
1672 to_{fetch,store}_registers. */
1673 for (int regnum
= 0; regnum
< gdbarch_num_cooked_regs (gdbarch
); regnum
++)
1675 if (register_size (gdbarch
, regnum
) == 0)
1678 gdb::def_vector
<gdb_byte
> inner_buf (register_size (gdbarch
, regnum
));
1680 SELF_CHECK (REG_VALID
== readwrite
.cooked_read (regnum
,
1681 inner_buf
.data ()));
1683 SELF_CHECK (mock_target
.fetch_registers_called
== 0);
1684 SELF_CHECK (mock_target
.store_registers_called
== 0);
1685 SELF_CHECK (mock_target
.xfer_partial_called
== 0);
1687 mock_target
.reset ();
1690 readonly_detached_regcache
readonly (readwrite
);
1692 /* GDB may go to target layer to fetch all registers and memory for
1693 readonly regcache. */
1694 mock_target
.reset ();
1696 for (int regnum
= 0; regnum
< gdbarch_num_cooked_regs (gdbarch
); regnum
++)
1698 if (register_size (gdbarch
, regnum
) == 0)
1701 gdb::def_vector
<gdb_byte
> inner_buf (register_size (gdbarch
, regnum
));
1702 enum register_status status
= readonly
.cooked_read (regnum
,
1705 if (regnum
< gdbarch_num_regs (gdbarch
))
1707 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1709 if (bfd_arch
== bfd_arch_frv
|| bfd_arch
== bfd_arch_h8300
1710 || bfd_arch
== bfd_arch_m32c
|| bfd_arch
== bfd_arch_sh
1711 || bfd_arch
== bfd_arch_alpha
|| bfd_arch
== bfd_arch_v850
1712 || bfd_arch
== bfd_arch_msp430
|| bfd_arch
== bfd_arch_mep
1713 || bfd_arch
== bfd_arch_mips
|| bfd_arch
== bfd_arch_v850_rh850
1714 || bfd_arch
== bfd_arch_tic6x
|| bfd_arch
== bfd_arch_mn10300
1715 || bfd_arch
== bfd_arch_rl78
|| bfd_arch
== bfd_arch_score
1716 || bfd_arch
== bfd_arch_riscv
|| bfd_arch
== bfd_arch_csky
)
1718 /* Raw registers. If raw registers are not in save_reggroup,
1719 their status are unknown. */
1720 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1721 SELF_CHECK (status
== REG_VALID
);
1723 SELF_CHECK (status
== REG_UNKNOWN
);
1726 SELF_CHECK (status
== REG_VALID
);
1730 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1731 SELF_CHECK (status
== REG_VALID
);
1734 /* If pseudo registers are not in save_reggroup, some of
1735 them can be computed from saved raw registers, but some
1736 of them are unknown. */
1737 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1739 if (bfd_arch
== bfd_arch_frv
1740 || bfd_arch
== bfd_arch_m32c
1741 || bfd_arch
== bfd_arch_mep
1742 || bfd_arch
== bfd_arch_sh
)
1743 SELF_CHECK (status
== REG_VALID
|| status
== REG_UNKNOWN
);
1744 else if (bfd_arch
== bfd_arch_mips
1745 || bfd_arch
== bfd_arch_h8300
)
1746 SELF_CHECK (status
== REG_UNKNOWN
);
1748 SELF_CHECK (status
== REG_VALID
);
1752 SELF_CHECK (mock_target
.fetch_registers_called
== 0);
1753 SELF_CHECK (mock_target
.store_registers_called
== 0);
1754 SELF_CHECK (mock_target
.xfer_partial_called
== 0);
1756 mock_target
.reset ();
1760 /* Test regcache::cooked_write by writing some expected contents to
1761 registers, and checking that contents read from registers and the
1762 expected contents are the same. */
1765 cooked_write_test (struct gdbarch
*gdbarch
)
1767 /* Error out if debugging something, because we're going to push the
1768 test target, which would pop any existing target. */
1769 if (current_top_target ()->stratum () >= process_stratum
)
1770 error (_("target already pushed"));
1772 /* Create a mock environment. A process_stratum target pushed. */
1774 target_ops_no_register mock_target
;
1776 /* Push the process_stratum target so we can mock accessing
1778 push_target (&mock_target
);
1780 /* Pop it again on exit (return/exception). */
1785 pop_all_targets_at_and_above (process_stratum
);
1789 readwrite_regcache
readwrite (&mock_target
, gdbarch
);
1791 const int num_regs
= gdbarch_num_cooked_regs (gdbarch
);
1793 for (auto regnum
= 0; regnum
< num_regs
; regnum
++)
1795 if (register_size (gdbarch
, regnum
) == 0
1796 || gdbarch_cannot_store_register (gdbarch
, regnum
))
1799 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1801 if (bfd_arch
== bfd_arch_sparc
1802 /* SPARC64_CWP_REGNUM, SPARC64_PSTATE_REGNUM,
1803 SPARC64_ASI_REGNUM and SPARC64_CCR_REGNUM are hard to test. */
1804 && gdbarch_ptr_bit (gdbarch
) == 64
1805 && (regnum
>= gdbarch_num_regs (gdbarch
)
1806 && regnum
<= gdbarch_num_regs (gdbarch
) + 4))
1809 std::vector
<gdb_byte
> expected (register_size (gdbarch
, regnum
), 0);
1810 std::vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
), 0);
1811 const auto type
= register_type (gdbarch
, regnum
);
1813 if (type
->code () == TYPE_CODE_FLT
1814 || type
->code () == TYPE_CODE_DECFLOAT
)
1816 /* Generate valid float format. */
1817 target_float_from_string (expected
.data (), type
, "1.25");
1819 else if (type
->code () == TYPE_CODE_INT
1820 || type
->code () == TYPE_CODE_ARRAY
1821 || type
->code () == TYPE_CODE_PTR
1822 || type
->code () == TYPE_CODE_UNION
1823 || type
->code () == TYPE_CODE_STRUCT
)
1825 if (bfd_arch
== bfd_arch_ia64
1826 || (regnum
>= gdbarch_num_regs (gdbarch
)
1827 && (bfd_arch
== bfd_arch_xtensa
1828 || bfd_arch
== bfd_arch_bfin
1829 || bfd_arch
== bfd_arch_m32c
1830 /* m68hc11 pseudo registers are in memory. */
1831 || bfd_arch
== bfd_arch_m68hc11
1832 || bfd_arch
== bfd_arch_m68hc12
1833 || bfd_arch
== bfd_arch_s390
))
1834 || (bfd_arch
== bfd_arch_frv
1835 /* FRV pseudo registers except iacc0. */
1836 && regnum
> gdbarch_num_regs (gdbarch
)))
1838 /* Skip setting the expected values for some architecture
1841 else if (bfd_arch
== bfd_arch_rl78
&& regnum
== 40)
1843 /* RL78_PC_REGNUM */
1844 for (auto j
= 0; j
< register_size (gdbarch
, regnum
) - 1; j
++)
1849 for (auto j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1853 else if (type
->code () == TYPE_CODE_FLAGS
)
1855 /* No idea how to test flags. */
1860 /* If we don't know how to create the expected value for the
1861 this type, make it fail. */
1865 readwrite
.cooked_write (regnum
, expected
.data ());
1867 SELF_CHECK (readwrite
.cooked_read (regnum
, buf
.data ()) == REG_VALID
);
1868 SELF_CHECK (expected
== buf
);
1872 } // namespace selftests
1873 #endif /* GDB_SELF_TEST */
1875 void _initialize_regcache ();
1877 _initialize_regcache ()
1879 regcache_descr_handle
1880 = gdbarch_data_register_post_init (init_regcache_descr
);
1882 gdb::observers::target_changed
.attach (regcache_observer_target_changed
);
1883 gdb::observers::thread_ptid_changed
.attach
1884 (regcache::regcache_thread_ptid_changed
);
1886 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1887 _("Force gdb to flush its register cache (maintainer command)."));
1890 selftests::register_test ("current_regcache", selftests::current_regcache_test
);
1892 selftests::register_test_foreach_arch ("regcache::cooked_read_test",
1893 selftests::cooked_read_test
);
1894 selftests::register_test_foreach_arch ("regcache::cooked_write_test",
1895 selftests::cooked_write_test
);