1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 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 common/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 (gdbarch
*gdbarch
, const address_space
*aspace_
)
200 /* The register buffers. A read/write register cache can only hold
201 [0 .. gdbarch_num_regs). */
202 : detached_regcache (gdbarch
, false), m_aspace (aspace_
)
204 m_ptid
= minus_one_ptid
;
207 readonly_detached_regcache::readonly_detached_regcache (regcache
&src
)
208 : readonly_detached_regcache (src
.arch (),
209 [&src
] (int regnum
, gdb_byte
*buf
)
211 return src
.cooked_read (regnum
, buf
);
217 reg_buffer::arch () const
219 return m_descr
->gdbarch
;
222 /* Cleanup class for invalidating a register. */
224 class regcache_invalidator
228 regcache_invalidator (struct regcache
*regcache
, int regnum
)
229 : m_regcache (regcache
),
234 ~regcache_invalidator ()
236 if (m_regcache
!= nullptr)
237 m_regcache
->invalidate (m_regnum
);
240 DISABLE_COPY_AND_ASSIGN (regcache_invalidator
);
244 m_regcache
= nullptr;
249 struct regcache
*m_regcache
;
253 /* Return a pointer to register REGNUM's buffer cache. */
256 reg_buffer::register_buffer (int regnum
) const
258 return m_registers
.get () + m_descr
->register_offset
[regnum
];
262 reg_buffer::save (register_read_ftype cooked_read
)
264 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
267 /* It should have pseudo registers. */
268 gdb_assert (m_has_pseudo
);
269 /* Clear the dest. */
270 memset (m_registers
.get (), 0, m_descr
->sizeof_cooked_registers
);
271 memset (m_register_status
.get (), REG_UNKNOWN
, m_descr
->nr_cooked_registers
);
272 /* Copy over any registers (identified by their membership in the
273 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
274 gdbarch_num_pseudo_regs) range is checked since some architectures need
275 to save/restore `cooked' registers that live in memory. */
276 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
278 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
280 gdb_byte
*dst_buf
= register_buffer (regnum
);
281 enum register_status status
= cooked_read (regnum
, dst_buf
);
283 gdb_assert (status
!= REG_UNKNOWN
);
285 if (status
!= REG_VALID
)
286 memset (dst_buf
, 0, register_size (gdbarch
, regnum
));
288 m_register_status
[regnum
] = status
;
294 regcache::restore (readonly_detached_regcache
*src
)
296 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
299 gdb_assert (src
!= NULL
);
300 gdb_assert (src
->m_has_pseudo
);
302 gdb_assert (gdbarch
== src
->arch ());
304 /* Copy over any registers, being careful to only restore those that
305 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
306 + gdbarch_num_pseudo_regs) range is checked since some architectures need
307 to save/restore `cooked' registers that live in memory. */
308 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
310 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
312 if (src
->m_register_status
[regnum
] == REG_VALID
)
313 cooked_write (regnum
, src
->register_buffer (regnum
));
318 /* See common/common-regcache.h. */
321 reg_buffer::get_register_status (int regnum
) const
323 assert_regnum (regnum
);
325 return m_register_status
[regnum
];
329 reg_buffer::invalidate (int regnum
)
331 assert_regnum (regnum
);
332 m_register_status
[regnum
] = REG_UNKNOWN
;
336 reg_buffer::assert_regnum (int regnum
) const
338 gdb_assert (regnum
>= 0);
340 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
342 gdb_assert (regnum
< gdbarch_num_regs (arch ()));
345 /* Global structure containing the current regcache. */
347 /* NOTE: this is a write-through cache. There is no "dirty" bit for
348 recording if the register values have been changed (eg. by the
349 user). Therefore all registers must be written back to the
350 target when appropriate. */
351 std::forward_list
<regcache
*> regcache::current_regcache
;
354 get_thread_arch_aspace_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
,
355 struct address_space
*aspace
)
357 for (const auto ®cache
: regcache::current_regcache
)
358 if (regcache
->ptid () == ptid
&& regcache
->arch () == gdbarch
)
361 regcache
*new_regcache
= new regcache (gdbarch
, aspace
);
363 regcache::current_regcache
.push_front (new_regcache
);
364 new_regcache
->set_ptid (ptid
);
370 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
372 address_space
*aspace
= target_thread_address_space (ptid
);
374 return get_thread_arch_aspace_regcache (ptid
, gdbarch
, aspace
);
377 static ptid_t current_thread_ptid
;
378 static struct gdbarch
*current_thread_arch
;
381 get_thread_regcache (ptid_t ptid
)
383 if (!current_thread_arch
|| current_thread_ptid
!= ptid
)
385 current_thread_ptid
= ptid
;
386 current_thread_arch
= target_thread_architecture (ptid
);
389 return get_thread_arch_regcache (ptid
, current_thread_arch
);
392 /* See regcache.h. */
395 get_thread_regcache (thread_info
*thread
)
397 return get_thread_regcache (thread
->ptid
);
401 get_current_regcache (void)
403 return get_thread_regcache (inferior_thread ());
406 /* See common/common-regcache.h. */
409 get_thread_regcache_for_ptid (ptid_t ptid
)
411 return get_thread_regcache (ptid
);
414 /* Observer for the target_changed event. */
417 regcache_observer_target_changed (struct target_ops
*target
)
419 registers_changed ();
422 /* Update global variables old ptids to hold NEW_PTID if they were
425 regcache::regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
427 for (auto ®cache
: regcache::current_regcache
)
429 if (regcache
->ptid () == old_ptid
)
430 regcache
->set_ptid (new_ptid
);
434 /* Low level examining and depositing of registers.
436 The caller is responsible for making sure that the inferior is
437 stopped before calling the fetching routines, or it will get
438 garbage. (a change from GDB version 3, in which the caller got the
439 value from the last stop). */
441 /* REGISTERS_CHANGED ()
443 Indicate that registers may have changed, so invalidate the cache. */
446 registers_changed_ptid (ptid_t ptid
)
448 for (auto oit
= regcache::current_regcache
.before_begin (),
449 it
= std::next (oit
);
450 it
!= regcache::current_regcache
.end ();
453 if ((*it
)->ptid ().matches (ptid
))
456 it
= regcache::current_regcache
.erase_after (oit
);
462 if (current_thread_ptid
.matches (ptid
))
464 current_thread_ptid
= null_ptid
;
465 current_thread_arch
= NULL
;
468 if (inferior_ptid
.matches (ptid
))
470 /* We just deleted the regcache of the current thread. Need to
471 forget about any frames we have cached, too. */
472 reinit_frame_cache ();
476 /* See regcache.h. */
479 registers_changed_thread (thread_info
*thread
)
481 registers_changed_ptid (thread
->ptid
);
485 registers_changed (void)
487 registers_changed_ptid (minus_one_ptid
);
489 /* Force cleanup of any alloca areas if using C alloca instead of
490 a builtin alloca. This particular call is used to clean up
491 areas allocated by low level target code which may build up
492 during lengthy interactions between gdb and the target before
493 gdb gives control to the user (ie watchpoints). */
498 regcache::raw_update (int regnum
)
500 assert_regnum (regnum
);
502 /* Make certain that the register cache is up-to-date with respect
503 to the current thread. This switching shouldn't be necessary
504 only there is still only one target side register cache. Sigh!
505 On the bright side, at least there is a regcache object. */
507 if (get_register_status (regnum
) == REG_UNKNOWN
)
509 target_fetch_registers (this, regnum
);
511 /* A number of targets can't access the whole set of raw
512 registers (because the debug API provides no means to get at
514 if (m_register_status
[regnum
] == REG_UNKNOWN
)
515 m_register_status
[regnum
] = REG_UNAVAILABLE
;
520 readable_regcache::raw_read (int regnum
, gdb_byte
*buf
)
522 gdb_assert (buf
!= NULL
);
525 if (m_register_status
[regnum
] != REG_VALID
)
526 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
528 memcpy (buf
, register_buffer (regnum
),
529 m_descr
->sizeof_register
[regnum
]);
531 return m_register_status
[regnum
];
535 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
537 gdb_assert (regcache
!= NULL
);
538 return regcache
->raw_read (regnum
, val
);
541 template<typename T
, typename
>
543 readable_regcache::raw_read (int regnum
, T
*val
)
546 enum register_status status
;
548 assert_regnum (regnum
);
549 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
550 status
= raw_read (regnum
, buf
);
551 if (status
== REG_VALID
)
552 *val
= extract_integer
<T
> (buf
,
553 m_descr
->sizeof_register
[regnum
],
554 gdbarch_byte_order (m_descr
->gdbarch
));
561 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
564 gdb_assert (regcache
!= NULL
);
565 return regcache
->raw_read (regnum
, val
);
569 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
571 gdb_assert (regcache
!= NULL
);
572 regcache
->raw_write (regnum
, val
);
575 template<typename T
, typename
>
577 regcache::raw_write (int regnum
, T val
)
581 assert_regnum (regnum
);
582 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
583 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
584 gdbarch_byte_order (m_descr
->gdbarch
), val
);
585 raw_write (regnum
, buf
);
589 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
592 gdb_assert (regcache
!= NULL
);
593 regcache
->raw_write (regnum
, val
);
597 regcache_raw_get_signed (struct regcache
*regcache
, int regnum
)
600 enum register_status status
;
602 status
= regcache_raw_read_signed (regcache
, regnum
, &value
);
603 if (status
== REG_UNAVAILABLE
)
604 throw_error (NOT_AVAILABLE_ERROR
,
605 _("Register %d is not available"), regnum
);
610 readable_regcache::cooked_read (int regnum
, gdb_byte
*buf
)
612 gdb_assert (regnum
>= 0);
613 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
614 if (regnum
< num_raw_registers ())
615 return raw_read (regnum
, buf
);
616 else if (m_has_pseudo
617 && m_register_status
[regnum
] != REG_UNKNOWN
)
619 if (m_register_status
[regnum
] == REG_VALID
)
620 memcpy (buf
, register_buffer (regnum
),
621 m_descr
->sizeof_register
[regnum
]);
623 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
625 return m_register_status
[regnum
];
627 else if (gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
629 struct value
*mark
, *computed
;
630 enum register_status result
= REG_VALID
;
632 mark
= value_mark ();
634 computed
= gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
636 if (value_entirely_available (computed
))
637 memcpy (buf
, value_contents_raw (computed
),
638 m_descr
->sizeof_register
[regnum
]);
641 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
642 result
= REG_UNAVAILABLE
;
645 value_free_to_mark (mark
);
650 return gdbarch_pseudo_register_read (m_descr
->gdbarch
, this,
655 readable_regcache::cooked_read_value (int regnum
)
657 gdb_assert (regnum
>= 0);
658 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
660 if (regnum
< num_raw_registers ()
661 || (m_has_pseudo
&& m_register_status
[regnum
] != REG_UNKNOWN
)
662 || !gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
664 struct value
*result
;
666 result
= allocate_value (register_type (m_descr
->gdbarch
, regnum
));
667 VALUE_LVAL (result
) = lval_register
;
668 VALUE_REGNUM (result
) = regnum
;
670 /* It is more efficient in general to do this delegation in this
671 direction than in the other one, even though the value-based
673 if (cooked_read (regnum
,
674 value_contents_raw (result
)) == REG_UNAVAILABLE
)
675 mark_value_bytes_unavailable (result
, 0,
676 TYPE_LENGTH (value_type (result
)));
681 return gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
686 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
689 gdb_assert (regcache
!= NULL
);
690 return regcache
->cooked_read (regnum
, val
);
693 template<typename T
, typename
>
695 readable_regcache::cooked_read (int regnum
, T
*val
)
697 enum register_status status
;
700 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
701 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
702 status
= cooked_read (regnum
, buf
);
703 if (status
== REG_VALID
)
704 *val
= extract_integer
<T
> (buf
, m_descr
->sizeof_register
[regnum
],
705 gdbarch_byte_order (m_descr
->gdbarch
));
712 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
715 gdb_assert (regcache
!= NULL
);
716 return regcache
->cooked_read (regnum
, val
);
720 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
723 gdb_assert (regcache
!= NULL
);
724 regcache
->cooked_write (regnum
, val
);
727 template<typename T
, typename
>
729 regcache::cooked_write (int regnum
, T val
)
733 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
734 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
735 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
736 gdbarch_byte_order (m_descr
->gdbarch
), val
);
737 cooked_write (regnum
, buf
);
741 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
744 gdb_assert (regcache
!= NULL
);
745 regcache
->cooked_write (regnum
, val
);
749 regcache::raw_write (int regnum
, const gdb_byte
*buf
)
752 gdb_assert (buf
!= NULL
);
753 assert_regnum (regnum
);
755 /* On the sparc, writing %g0 is a no-op, so we don't even want to
756 change the registers array if something writes to this register. */
757 if (gdbarch_cannot_store_register (arch (), regnum
))
760 /* If we have a valid copy of the register, and new value == old
761 value, then don't bother doing the actual store. */
762 if (get_register_status (regnum
) == REG_VALID
763 && (memcmp (register_buffer (regnum
), buf
,
764 m_descr
->sizeof_register
[regnum
]) == 0))
767 target_prepare_to_store (this);
768 raw_supply (regnum
, buf
);
770 /* Invalidate the register after it is written, in case of a
772 regcache_invalidator
invalidator (this, regnum
);
774 target_store_registers (this, regnum
);
776 /* The target did not throw an error so we can discard invalidating
778 invalidator
.release ();
782 regcache::cooked_write (int regnum
, const gdb_byte
*buf
)
784 gdb_assert (regnum
>= 0);
785 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
786 if (regnum
< num_raw_registers ())
787 raw_write (regnum
, buf
);
789 gdbarch_pseudo_register_write (m_descr
->gdbarch
, this,
793 /* See regcache.h. */
796 readable_regcache::read_part (int regnum
, int offset
, int len
,
797 gdb_byte
*out
, bool is_raw
)
799 int reg_size
= register_size (arch (), regnum
);
801 gdb_assert (out
!= NULL
);
802 gdb_assert (offset
>= 0 && offset
<= reg_size
);
803 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
805 if (offset
== 0 && len
== 0)
811 if (offset
== 0 && len
== reg_size
)
813 /* Read the full register. */
814 return (is_raw
) ? raw_read (regnum
, out
) : cooked_read (regnum
, out
);
817 enum register_status status
;
818 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
820 /* Read full register to buffer. */
821 status
= (is_raw
) ? raw_read (regnum
, reg
) : cooked_read (regnum
, reg
);
822 if (status
!= REG_VALID
)
826 memcpy (out
, reg
+ offset
, len
);
830 /* See regcache.h. */
833 reg_buffer::raw_collect_part (int regnum
, int offset
, int len
,
836 int reg_size
= register_size (arch (), regnum
);
838 gdb_assert (out
!= nullptr);
839 gdb_assert (offset
>= 0 && offset
<= reg_size
);
840 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
842 if (offset
== 0 && len
== 0)
848 if (offset
== 0 && len
== reg_size
)
850 /* Collect the full register. */
851 return raw_collect (regnum
, out
);
854 /* Read to buffer, then write out. */
855 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
856 raw_collect (regnum
, reg
);
857 memcpy (out
, reg
+ offset
, len
);
860 /* See regcache.h. */
863 regcache::write_part (int regnum
, int offset
, int len
,
864 const gdb_byte
*in
, bool is_raw
)
866 int reg_size
= register_size (arch (), regnum
);
868 gdb_assert (in
!= NULL
);
869 gdb_assert (offset
>= 0 && offset
<= reg_size
);
870 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
872 if (offset
== 0 && len
== 0)
878 if (offset
== 0 && len
== reg_size
)
880 /* Write the full register. */
881 (is_raw
) ? raw_write (regnum
, in
) : cooked_write (regnum
, in
);
885 enum register_status status
;
886 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
888 /* Read existing register to buffer. */
889 status
= (is_raw
) ? raw_read (regnum
, reg
) : cooked_read (regnum
, reg
);
890 if (status
!= REG_VALID
)
893 /* Update buffer, then write back to regcache. */
894 memcpy (reg
+ offset
, in
, len
);
895 is_raw
? raw_write (regnum
, reg
) : cooked_write (regnum
, reg
);
899 /* See regcache.h. */
902 reg_buffer::raw_supply_part (int regnum
, int offset
, int len
,
905 int reg_size
= register_size (arch (), regnum
);
907 gdb_assert (in
!= nullptr);
908 gdb_assert (offset
>= 0 && offset
<= reg_size
);
909 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
911 if (offset
== 0 && len
== 0)
917 if (offset
== 0 && len
== reg_size
)
919 /* Supply the full register. */
920 return raw_supply (regnum
, in
);
923 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
925 /* Read existing value to buffer. */
926 raw_collect (regnum
, reg
);
928 /* Write to buffer, then write out. */
929 memcpy (reg
+ offset
, in
, len
);
930 raw_supply (regnum
, reg
);
934 readable_regcache::raw_read_part (int regnum
, int offset
, int len
,
937 assert_regnum (regnum
);
938 return read_part (regnum
, offset
, len
, buf
, true);
941 /* See regcache.h. */
944 regcache::raw_write_part (int regnum
, int offset
, int len
,
947 assert_regnum (regnum
);
948 write_part (regnum
, offset
, len
, buf
, true);
951 /* See regcache.h. */
954 readable_regcache::cooked_read_part (int regnum
, int offset
, int len
,
957 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
958 return read_part (regnum
, offset
, len
, buf
, false);
961 /* See regcache.h. */
964 regcache::cooked_write_part (int regnum
, int offset
, int len
,
967 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
968 write_part (regnum
, offset
, len
, buf
, false);
971 /* See common/common-regcache.h. */
974 reg_buffer::raw_supply (int regnum
, const void *buf
)
979 assert_regnum (regnum
);
981 regbuf
= register_buffer (regnum
);
982 size
= m_descr
->sizeof_register
[regnum
];
986 memcpy (regbuf
, buf
, size
);
987 m_register_status
[regnum
] = REG_VALID
;
991 /* This memset not strictly necessary, but better than garbage
992 in case the register value manages to escape somewhere (due
993 to a bug, no less). */
994 memset (regbuf
, 0, size
);
995 m_register_status
[regnum
] = REG_UNAVAILABLE
;
999 /* See regcache.h. */
1002 reg_buffer::raw_supply_integer (int regnum
, const gdb_byte
*addr
,
1003 int addr_len
, bool is_signed
)
1005 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1009 assert_regnum (regnum
);
1011 regbuf
= register_buffer (regnum
);
1012 regsize
= m_descr
->sizeof_register
[regnum
];
1014 copy_integer_to_size (regbuf
, regsize
, addr
, addr_len
, is_signed
,
1016 m_register_status
[regnum
] = REG_VALID
;
1019 /* See regcache.h. */
1022 reg_buffer::raw_supply_zeroed (int regnum
)
1027 assert_regnum (regnum
);
1029 regbuf
= register_buffer (regnum
);
1030 size
= m_descr
->sizeof_register
[regnum
];
1032 memset (regbuf
, 0, size
);
1033 m_register_status
[regnum
] = REG_VALID
;
1036 /* See common/common-regcache.h. */
1039 reg_buffer::raw_collect (int regnum
, void *buf
) const
1044 gdb_assert (buf
!= NULL
);
1045 assert_regnum (regnum
);
1047 regbuf
= register_buffer (regnum
);
1048 size
= m_descr
->sizeof_register
[regnum
];
1049 memcpy (buf
, regbuf
, size
);
1052 /* See regcache.h. */
1055 reg_buffer::raw_collect_integer (int regnum
, gdb_byte
*addr
, int addr_len
,
1056 bool is_signed
) const
1058 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1059 const gdb_byte
*regbuf
;
1062 assert_regnum (regnum
);
1064 regbuf
= register_buffer (regnum
);
1065 regsize
= m_descr
->sizeof_register
[regnum
];
1067 copy_integer_to_size (addr
, addr_len
, regbuf
, regsize
, is_signed
,
1071 /* See regcache.h. */
1074 regcache::transfer_regset_register (struct regcache
*out_regcache
, int regnum
,
1075 const gdb_byte
*in_buf
, gdb_byte
*out_buf
,
1076 int slot_size
, int offs
) const
1078 struct gdbarch
*gdbarch
= arch ();
1079 int reg_size
= std::min (register_size (gdbarch
, regnum
), slot_size
);
1081 /* Use part versions and reg_size to prevent possible buffer overflows when
1082 accessing the regcache. */
1084 if (out_buf
!= nullptr)
1086 raw_collect_part (regnum
, 0, reg_size
, out_buf
+ offs
);
1088 /* Ensure any additional space is cleared. */
1089 if (slot_size
> reg_size
)
1090 memset (out_buf
+ offs
+ reg_size
, 0, slot_size
- reg_size
);
1092 else if (in_buf
!= nullptr)
1093 out_regcache
->raw_supply_part (regnum
, 0, reg_size
, in_buf
+ offs
);
1096 /* Invalidate the register. */
1097 out_regcache
->raw_supply (regnum
, nullptr);
1101 /* See regcache.h. */
1104 regcache::transfer_regset (const struct regset
*regset
,
1105 struct regcache
*out_regcache
,
1106 int regnum
, const gdb_byte
*in_buf
,
1107 gdb_byte
*out_buf
, size_t size
) const
1109 const struct regcache_map_entry
*map
;
1110 int offs
= 0, count
;
1112 for (map
= (const struct regcache_map_entry
*) regset
->regmap
;
1113 (count
= map
->count
) != 0;
1116 int regno
= map
->regno
;
1117 int slot_size
= map
->size
;
1119 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1120 slot_size
= m_descr
->sizeof_register
[regno
];
1122 if (regno
== REGCACHE_MAP_SKIP
1124 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1125 offs
+= count
* slot_size
;
1127 else if (regnum
== -1)
1128 for (; count
--; regno
++, offs
+= slot_size
)
1130 if (offs
+ slot_size
> size
)
1133 transfer_regset_register (out_regcache
, regno
, in_buf
, out_buf
,
1138 /* Transfer a single register and return. */
1139 offs
+= (regnum
- regno
) * slot_size
;
1140 if (offs
+ slot_size
> size
)
1143 transfer_regset_register (out_regcache
, regnum
, in_buf
, out_buf
,
1150 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1151 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1152 If BUF is NULL, set the register(s) to "unavailable" status. */
1155 regcache_supply_regset (const struct regset
*regset
,
1156 struct regcache
*regcache
,
1157 int regnum
, const void *buf
, size_t size
)
1159 regcache
->supply_regset (regset
, regnum
, (const gdb_byte
*) buf
, size
);
1163 regcache::supply_regset (const struct regset
*regset
,
1164 int regnum
, const void *buf
, size_t size
)
1166 transfer_regset (regset
, this, regnum
, (const gdb_byte
*) buf
, nullptr, size
);
1169 /* Collect register REGNUM from REGCACHE to BUF, using the register
1170 map in REGSET. If REGNUM is -1, do this for all registers in
1174 regcache_collect_regset (const struct regset
*regset
,
1175 const struct regcache
*regcache
,
1176 int regnum
, void *buf
, size_t size
)
1178 regcache
->collect_regset (regset
, regnum
, (gdb_byte
*) buf
, size
);
1182 regcache::collect_regset (const struct regset
*regset
,
1183 int regnum
, void *buf
, size_t size
) const
1185 transfer_regset (regset
, nullptr, regnum
, nullptr, (gdb_byte
*) buf
, size
);
1188 /* See common/common-regcache.h. */
1191 reg_buffer::raw_compare (int regnum
, const void *buf
, int offset
) const
1193 gdb_assert (buf
!= NULL
);
1194 assert_regnum (regnum
);
1196 const char *regbuf
= (const char *) register_buffer (regnum
);
1197 size_t size
= m_descr
->sizeof_register
[regnum
];
1198 gdb_assert (size
>= offset
);
1200 return (memcmp (buf
, regbuf
+ offset
, size
- offset
) == 0);
1203 /* Special handling for register PC. */
1206 regcache_read_pc (struct regcache
*regcache
)
1208 struct gdbarch
*gdbarch
= regcache
->arch ();
1212 if (gdbarch_read_pc_p (gdbarch
))
1213 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1214 /* Else use per-frame method on get_current_frame. */
1215 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1219 if (regcache_cooked_read_unsigned (regcache
,
1220 gdbarch_pc_regnum (gdbarch
),
1221 &raw_val
) == REG_UNAVAILABLE
)
1222 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1224 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1227 internal_error (__FILE__
, __LINE__
,
1228 _("regcache_read_pc: Unable to find PC"));
1233 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1235 struct gdbarch
*gdbarch
= regcache
->arch ();
1237 if (gdbarch_write_pc_p (gdbarch
))
1238 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1239 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1240 regcache_cooked_write_unsigned (regcache
,
1241 gdbarch_pc_regnum (gdbarch
), pc
);
1243 internal_error (__FILE__
, __LINE__
,
1244 _("regcache_write_pc: Unable to update PC"));
1246 /* Writing the PC (for instance, from "load") invalidates the
1248 reinit_frame_cache ();
1252 reg_buffer::num_raw_registers () const
1254 return gdbarch_num_regs (arch ());
1258 regcache::debug_print_register (const char *func
, int regno
)
1260 struct gdbarch
*gdbarch
= arch ();
1262 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1263 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
1264 && gdbarch_register_name (gdbarch
, regno
) != NULL
1265 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
1266 fprintf_unfiltered (gdb_stdlog
, "(%s)",
1267 gdbarch_register_name (gdbarch
, regno
));
1269 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1270 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
1272 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1273 int size
= register_size (gdbarch
, regno
);
1274 gdb_byte
*buf
= register_buffer (regno
);
1276 fprintf_unfiltered (gdb_stdlog
, " = ");
1277 for (int i
= 0; i
< size
; i
++)
1279 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1281 if (size
<= sizeof (LONGEST
))
1283 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
1285 fprintf_unfiltered (gdb_stdlog
, " %s %s",
1286 core_addr_to_string_nz (val
), plongest (val
));
1289 fprintf_unfiltered (gdb_stdlog
, "\n");
1293 reg_flush_command (const char *command
, int from_tty
)
1295 /* Force-flush the register cache. */
1296 registers_changed ();
1298 printf_filtered (_("Register cache flushed.\n"));
1302 register_dump::dump (ui_file
*file
)
1304 auto descr
= regcache_descr (m_gdbarch
);
1306 int footnote_nr
= 0;
1307 int footnote_register_offset
= 0;
1308 int footnote_register_type_name_null
= 0;
1309 long register_offset
= 0;
1311 gdb_assert (descr
->nr_cooked_registers
1312 == gdbarch_num_cooked_regs (m_gdbarch
));
1314 for (regnum
= -1; regnum
< descr
->nr_cooked_registers
; regnum
++)
1318 fprintf_unfiltered (file
, " %-10s", "Name");
1321 const char *p
= gdbarch_register_name (m_gdbarch
, regnum
);
1325 else if (p
[0] == '\0')
1327 fprintf_unfiltered (file
, " %-10s", p
);
1332 fprintf_unfiltered (file
, " %4s", "Nr");
1334 fprintf_unfiltered (file
, " %4d", regnum
);
1336 /* Relative number. */
1338 fprintf_unfiltered (file
, " %4s", "Rel");
1339 else if (regnum
< gdbarch_num_regs (m_gdbarch
))
1340 fprintf_unfiltered (file
, " %4d", regnum
);
1342 fprintf_unfiltered (file
, " %4d",
1343 (regnum
- gdbarch_num_regs (m_gdbarch
)));
1347 fprintf_unfiltered (file
, " %6s ", "Offset");
1350 fprintf_unfiltered (file
, " %6ld",
1351 descr
->register_offset
[regnum
]);
1352 if (register_offset
!= descr
->register_offset
[regnum
]
1354 && (descr
->register_offset
[regnum
]
1355 != (descr
->register_offset
[regnum
- 1]
1356 + descr
->sizeof_register
[regnum
- 1])))
1359 if (!footnote_register_offset
)
1360 footnote_register_offset
= ++footnote_nr
;
1361 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1364 fprintf_unfiltered (file
, " ");
1365 register_offset
= (descr
->register_offset
[regnum
]
1366 + descr
->sizeof_register
[regnum
]);
1371 fprintf_unfiltered (file
, " %5s ", "Size");
1373 fprintf_unfiltered (file
, " %5ld", descr
->sizeof_register
[regnum
]);
1378 std::string name_holder
;
1384 static const char blt
[] = "builtin_type";
1386 t
= TYPE_NAME (register_type (m_gdbarch
, regnum
));
1389 if (!footnote_register_type_name_null
)
1390 footnote_register_type_name_null
= ++footnote_nr
;
1391 name_holder
= string_printf ("*%d",
1392 footnote_register_type_name_null
);
1393 t
= name_holder
.c_str ();
1395 /* Chop a leading builtin_type. */
1396 if (startswith (t
, blt
))
1399 fprintf_unfiltered (file
, " %-15s", t
);
1402 /* Leading space always present. */
1403 fprintf_unfiltered (file
, " ");
1405 dump_reg (file
, regnum
);
1407 fprintf_unfiltered (file
, "\n");
1410 if (footnote_register_offset
)
1411 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1412 footnote_register_offset
);
1413 if (footnote_register_type_name_null
)
1414 fprintf_unfiltered (file
,
1415 "*%d: Register type's name NULL.\n",
1416 footnote_register_type_name_null
);
1420 #include "selftest.h"
1421 #include "selftest-arch.h"
1422 #include "gdbthread.h"
1423 #include "target-float.h"
1425 namespace selftests
{
1427 class regcache_access
: public regcache
1431 /* Return the number of elements in current_regcache. */
1434 current_regcache_size ()
1436 return std::distance (regcache::current_regcache
.begin (),
1437 regcache::current_regcache
.end ());
1442 current_regcache_test (void)
1444 /* It is empty at the start. */
1445 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1447 ptid_t
ptid1 (1), ptid2 (2), ptid3 (3);
1449 /* Get regcache from ptid1, a new regcache is added to
1450 current_regcache. */
1451 regcache
*regcache
= get_thread_arch_aspace_regcache (ptid1
,
1455 SELF_CHECK (regcache
!= NULL
);
1456 SELF_CHECK (regcache
->ptid () == ptid1
);
1457 SELF_CHECK (regcache_access::current_regcache_size () == 1);
1459 /* Get regcache from ptid2, a new regcache is added to
1460 current_regcache. */
1461 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1464 SELF_CHECK (regcache
!= NULL
);
1465 SELF_CHECK (regcache
->ptid () == ptid2
);
1466 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1468 /* Get regcache from ptid3, a new regcache is added to
1469 current_regcache. */
1470 regcache
= get_thread_arch_aspace_regcache (ptid3
,
1473 SELF_CHECK (regcache
!= NULL
);
1474 SELF_CHECK (regcache
->ptid () == ptid3
);
1475 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1477 /* Get regcache from ptid2 again, nothing is added to
1478 current_regcache. */
1479 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1482 SELF_CHECK (regcache
!= NULL
);
1483 SELF_CHECK (regcache
->ptid () == ptid2
);
1484 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1486 /* Mark ptid2 is changed, so regcache of ptid2 should be removed from
1487 current_regcache. */
1488 registers_changed_ptid (ptid2
);
1489 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1492 class target_ops_no_register
: public test_target_ops
1495 target_ops_no_register ()
1496 : test_target_ops
{}
1501 fetch_registers_called
= 0;
1502 store_registers_called
= 0;
1503 xfer_partial_called
= 0;
1506 void fetch_registers (regcache
*regs
, int regno
) override
;
1507 void store_registers (regcache
*regs
, int regno
) override
;
1509 enum target_xfer_status
xfer_partial (enum target_object object
,
1510 const char *annex
, gdb_byte
*readbuf
,
1511 const gdb_byte
*writebuf
,
1512 ULONGEST offset
, ULONGEST len
,
1513 ULONGEST
*xfered_len
) override
;
1515 unsigned int fetch_registers_called
= 0;
1516 unsigned int store_registers_called
= 0;
1517 unsigned int xfer_partial_called
= 0;
1521 target_ops_no_register::fetch_registers (regcache
*regs
, int regno
)
1523 /* Mark register available. */
1524 regs
->raw_supply_zeroed (regno
);
1525 this->fetch_registers_called
++;
1529 target_ops_no_register::store_registers (regcache
*regs
, int regno
)
1531 this->store_registers_called
++;
1534 enum target_xfer_status
1535 target_ops_no_register::xfer_partial (enum target_object object
,
1536 const char *annex
, gdb_byte
*readbuf
,
1537 const gdb_byte
*writebuf
,
1538 ULONGEST offset
, ULONGEST len
,
1539 ULONGEST
*xfered_len
)
1541 this->xfer_partial_called
++;
1544 return TARGET_XFER_OK
;
1547 class readwrite_regcache
: public regcache
1550 readwrite_regcache (struct gdbarch
*gdbarch
)
1551 : regcache (gdbarch
, nullptr)
1555 /* Test regcache::cooked_read gets registers from raw registers and
1556 memory instead of target to_{fetch,store}_registers. */
1559 cooked_read_test (struct gdbarch
*gdbarch
)
1561 /* Error out if debugging something, because we're going to push the
1562 test target, which would pop any existing target. */
1563 if (current_top_target ()->stratum () >= process_stratum
)
1564 error (_("target already pushed"));
1566 /* Create a mock environment. An inferior with a thread, with a
1567 process_stratum target pushed. */
1569 target_ops_no_register mock_target
;
1570 ptid_t
mock_ptid (1, 1);
1571 inferior
mock_inferior (mock_ptid
.pid ());
1572 address_space mock_aspace
{};
1573 mock_inferior
.gdbarch
= gdbarch
;
1574 mock_inferior
.aspace
= &mock_aspace
;
1575 thread_info
mock_thread (&mock_inferior
, mock_ptid
);
1577 /* Add the mock inferior to the inferior list so that look ups by
1578 target+ptid can find it. */
1579 scoped_restore restore_inferior_list
1580 = make_scoped_restore (&inferior_list
);
1581 inferior_list
= &mock_inferior
;
1583 /* Switch to the mock inferior. */
1584 scoped_restore_current_inferior restore_current_inferior
;
1585 set_current_inferior (&mock_inferior
);
1587 /* Push the process_stratum target so we can mock accessing
1589 push_target (&mock_target
);
1591 /* Pop it again on exit (return/exception). */
1596 pop_all_targets_at_and_above (process_stratum
);
1600 /* Switch to the mock thread. */
1601 scoped_restore restore_inferior_ptid
1602 = make_scoped_restore (&inferior_ptid
, mock_ptid
);
1604 /* Test that read one raw register from regcache_no_target will go
1605 to the target layer. */
1607 /* Find a raw register which size isn't zero. */
1609 for (nonzero_regnum
= 0;
1610 nonzero_regnum
< gdbarch_num_regs (gdbarch
);
1613 if (register_size (gdbarch
, nonzero_regnum
) != 0)
1617 readwrite_regcache
readwrite (gdbarch
);
1618 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, nonzero_regnum
));
1620 readwrite
.raw_read (nonzero_regnum
, buf
.data ());
1622 /* raw_read calls target_fetch_registers. */
1623 SELF_CHECK (mock_target
.fetch_registers_called
> 0);
1624 mock_target
.reset ();
1626 /* Mark all raw registers valid, so the following raw registers
1627 accesses won't go to target. */
1628 for (auto i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1629 readwrite
.raw_update (i
);
1631 mock_target
.reset ();
1632 /* Then, read all raw and pseudo registers, and don't expect calling
1633 to_{fetch,store}_registers. */
1634 for (int regnum
= 0; regnum
< gdbarch_num_cooked_regs (gdbarch
); regnum
++)
1636 if (register_size (gdbarch
, regnum
) == 0)
1639 gdb::def_vector
<gdb_byte
> inner_buf (register_size (gdbarch
, regnum
));
1641 SELF_CHECK (REG_VALID
== readwrite
.cooked_read (regnum
,
1642 inner_buf
.data ()));
1644 SELF_CHECK (mock_target
.fetch_registers_called
== 0);
1645 SELF_CHECK (mock_target
.store_registers_called
== 0);
1647 /* Some SPU pseudo registers are got via TARGET_OBJECT_SPU. */
1648 if (gdbarch_bfd_arch_info (gdbarch
)->arch
!= bfd_arch_spu
)
1649 SELF_CHECK (mock_target
.xfer_partial_called
== 0);
1651 mock_target
.reset ();
1654 readonly_detached_regcache
readonly (readwrite
);
1656 /* GDB may go to target layer to fetch all registers and memory for
1657 readonly regcache. */
1658 mock_target
.reset ();
1660 for (int regnum
= 0; regnum
< gdbarch_num_cooked_regs (gdbarch
); regnum
++)
1662 if (register_size (gdbarch
, regnum
) == 0)
1665 gdb::def_vector
<gdb_byte
> inner_buf (register_size (gdbarch
, regnum
));
1666 enum register_status status
= readonly
.cooked_read (regnum
,
1669 if (regnum
< gdbarch_num_regs (gdbarch
))
1671 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1673 if (bfd_arch
== bfd_arch_frv
|| bfd_arch
== bfd_arch_h8300
1674 || bfd_arch
== bfd_arch_m32c
|| bfd_arch
== bfd_arch_sh
1675 || bfd_arch
== bfd_arch_alpha
|| bfd_arch
== bfd_arch_v850
1676 || bfd_arch
== bfd_arch_msp430
|| bfd_arch
== bfd_arch_mep
1677 || bfd_arch
== bfd_arch_mips
|| bfd_arch
== bfd_arch_v850_rh850
1678 || bfd_arch
== bfd_arch_tic6x
|| bfd_arch
== bfd_arch_mn10300
1679 || bfd_arch
== bfd_arch_rl78
|| bfd_arch
== bfd_arch_score
1680 || bfd_arch
== bfd_arch_riscv
|| bfd_arch
== bfd_arch_csky
)
1682 /* Raw registers. If raw registers are not in save_reggroup,
1683 their status are unknown. */
1684 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1685 SELF_CHECK (status
== REG_VALID
);
1687 SELF_CHECK (status
== REG_UNKNOWN
);
1690 SELF_CHECK (status
== REG_VALID
);
1694 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1695 SELF_CHECK (status
== REG_VALID
);
1698 /* If pseudo registers are not in save_reggroup, some of
1699 them can be computed from saved raw registers, but some
1700 of them are unknown. */
1701 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1703 if (bfd_arch
== bfd_arch_frv
1704 || bfd_arch
== bfd_arch_m32c
1705 || bfd_arch
== bfd_arch_mep
1706 || bfd_arch
== bfd_arch_sh
)
1707 SELF_CHECK (status
== REG_VALID
|| status
== REG_UNKNOWN
);
1708 else if (bfd_arch
== bfd_arch_mips
1709 || bfd_arch
== bfd_arch_h8300
)
1710 SELF_CHECK (status
== REG_UNKNOWN
);
1712 SELF_CHECK (status
== REG_VALID
);
1716 SELF_CHECK (mock_target
.fetch_registers_called
== 0);
1717 SELF_CHECK (mock_target
.store_registers_called
== 0);
1718 SELF_CHECK (mock_target
.xfer_partial_called
== 0);
1720 mock_target
.reset ();
1724 /* Test regcache::cooked_write by writing some expected contents to
1725 registers, and checking that contents read from registers and the
1726 expected contents are the same. */
1729 cooked_write_test (struct gdbarch
*gdbarch
)
1731 /* Error out if debugging something, because we're going to push the
1732 test target, which would pop any existing target. */
1733 if (current_top_target ()->stratum () >= process_stratum
)
1734 error (_("target already pushed"));
1736 /* Create a mock environment. A process_stratum target pushed. */
1738 target_ops_no_register mock_target
;
1740 /* Push the process_stratum target so we can mock accessing
1742 push_target (&mock_target
);
1744 /* Pop it again on exit (return/exception). */
1749 pop_all_targets_at_and_above (process_stratum
);
1753 readwrite_regcache
readwrite (gdbarch
);
1755 const int num_regs
= gdbarch_num_cooked_regs (gdbarch
);
1757 for (auto regnum
= 0; regnum
< num_regs
; regnum
++)
1759 if (register_size (gdbarch
, regnum
) == 0
1760 || gdbarch_cannot_store_register (gdbarch
, regnum
))
1763 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1765 if ((bfd_arch
== bfd_arch_sparc
1766 /* SPARC64_CWP_REGNUM, SPARC64_PSTATE_REGNUM,
1767 SPARC64_ASI_REGNUM and SPARC64_CCR_REGNUM are hard to test. */
1768 && gdbarch_ptr_bit (gdbarch
) == 64
1769 && (regnum
>= gdbarch_num_regs (gdbarch
)
1770 && regnum
<= gdbarch_num_regs (gdbarch
) + 4))
1771 || (bfd_arch
== bfd_arch_spu
1772 /* SPU pseudo registers except SPU_SP_REGNUM are got by
1773 TARGET_OBJECT_SPU. */
1774 && regnum
>= gdbarch_num_regs (gdbarch
) && regnum
!= 130))
1777 std::vector
<gdb_byte
> expected (register_size (gdbarch
, regnum
), 0);
1778 std::vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
), 0);
1779 const auto type
= register_type (gdbarch
, regnum
);
1781 if (TYPE_CODE (type
) == TYPE_CODE_FLT
1782 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1784 /* Generate valid float format. */
1785 target_float_from_string (expected
.data (), type
, "1.25");
1787 else if (TYPE_CODE (type
) == TYPE_CODE_INT
1788 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1789 || TYPE_CODE (type
) == TYPE_CODE_PTR
1790 || TYPE_CODE (type
) == TYPE_CODE_UNION
1791 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1793 if (bfd_arch
== bfd_arch_ia64
1794 || (regnum
>= gdbarch_num_regs (gdbarch
)
1795 && (bfd_arch
== bfd_arch_xtensa
1796 || bfd_arch
== bfd_arch_bfin
1797 || bfd_arch
== bfd_arch_m32c
1798 /* m68hc11 pseudo registers are in memory. */
1799 || bfd_arch
== bfd_arch_m68hc11
1800 || bfd_arch
== bfd_arch_m68hc12
1801 || bfd_arch
== bfd_arch_s390
))
1802 || (bfd_arch
== bfd_arch_frv
1803 /* FRV pseudo registers except iacc0. */
1804 && regnum
> gdbarch_num_regs (gdbarch
)))
1806 /* Skip setting the expected values for some architecture
1809 else if (bfd_arch
== bfd_arch_rl78
&& regnum
== 40)
1811 /* RL78_PC_REGNUM */
1812 for (auto j
= 0; j
< register_size (gdbarch
, regnum
) - 1; j
++)
1817 for (auto j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1821 else if (TYPE_CODE (type
) == TYPE_CODE_FLAGS
)
1823 /* No idea how to test flags. */
1828 /* If we don't know how to create the expected value for the
1829 this type, make it fail. */
1833 readwrite
.cooked_write (regnum
, expected
.data ());
1835 SELF_CHECK (readwrite
.cooked_read (regnum
, buf
.data ()) == REG_VALID
);
1836 SELF_CHECK (expected
== buf
);
1840 } // namespace selftests
1841 #endif /* GDB_SELF_TEST */
1844 _initialize_regcache (void)
1846 regcache_descr_handle
1847 = gdbarch_data_register_post_init (init_regcache_descr
);
1849 gdb::observers::target_changed
.attach (regcache_observer_target_changed
);
1850 gdb::observers::thread_ptid_changed
.attach
1851 (regcache::regcache_thread_ptid_changed
);
1853 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1854 _("Force gdb to flush its register cache (maintainer command)"));
1857 selftests::register_test ("current_regcache", selftests::current_regcache_test
);
1859 selftests::register_test_foreach_arch ("regcache::cooked_read_test",
1860 selftests::cooked_read_test
);
1861 selftests::register_test_foreach_arch ("regcache::cooked_write_test",
1862 selftests::cooked_write_test
);