1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "reggroups.h"
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
55 long sizeof_raw_registers
;
57 /* The cooked register space. Each cooked register in the range
58 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
59 register. The remaining [NR_RAW_REGISTERS
60 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
61 both raw registers and memory by the architecture methods
62 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
63 int nr_cooked_registers
;
64 long sizeof_cooked_registers
;
66 /* Offset and size (in 8 bit bytes), of each register in the
67 register cache. All registers (including those in the range
68 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
70 long *register_offset
;
71 long *sizeof_register
;
73 /* Cached table containing the type of each register. */
74 struct type
**register_type
;
78 init_regcache_descr (struct gdbarch
*gdbarch
)
81 struct regcache_descr
*descr
;
82 gdb_assert (gdbarch
!= NULL
);
84 /* Create an initial, zero filled, table. */
85 descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct regcache_descr
);
86 descr
->gdbarch
= gdbarch
;
88 /* Total size of the register space. The raw registers are mapped
89 directly onto the raw register cache while the pseudo's are
90 either mapped onto raw-registers or memory. */
91 descr
->nr_cooked_registers
= gdbarch_num_regs (gdbarch
)
92 + gdbarch_num_pseudo_regs (gdbarch
);
94 /* Fill in a table of register types. */
96 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
,
98 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
99 descr
->register_type
[i
] = gdbarch_register_type (gdbarch
, i
);
101 /* Construct a strictly RAW register cache. Don't allow pseudo's
102 into the register cache. */
103 descr
->nr_raw_registers
= gdbarch_num_regs (gdbarch
);
105 /* Lay out the register cache.
107 NOTE: cagney/2002-05-22: Only register_type() is used when
108 constructing the register cache. It is assumed that the
109 register's raw size, virtual size and type length are all the
115 descr
->sizeof_register
116 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
117 descr
->register_offset
118 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
119 for (i
= 0; i
< descr
->nr_raw_registers
; i
++)
121 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
122 descr
->register_offset
[i
] = offset
;
123 offset
+= descr
->sizeof_register
[i
];
124 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
126 /* Set the real size of the raw register cache buffer. */
127 descr
->sizeof_raw_registers
= offset
;
129 for (; i
< descr
->nr_cooked_registers
; i
++)
131 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
132 descr
->register_offset
[i
] = offset
;
133 offset
+= descr
->sizeof_register
[i
];
134 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
136 /* Set the real size of the readonly register cache buffer. */
137 descr
->sizeof_cooked_registers
= offset
;
143 static struct regcache_descr
*
144 regcache_descr (struct gdbarch
*gdbarch
)
146 return (struct regcache_descr
*) gdbarch_data (gdbarch
,
147 regcache_descr_handle
);
150 /* Utility functions returning useful register attributes stored in
151 the regcache descr. */
154 register_type (struct gdbarch
*gdbarch
, int regnum
)
156 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
158 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
159 return descr
->register_type
[regnum
];
162 /* Utility functions returning useful register attributes stored in
163 the regcache descr. */
166 register_size (struct gdbarch
*gdbarch
, int regnum
)
168 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
171 gdb_assert (regnum
>= 0
172 && regnum
< (gdbarch_num_regs (gdbarch
)
173 + gdbarch_num_pseudo_regs (gdbarch
)));
174 size
= descr
->sizeof_register
[regnum
];
178 /* See common/common-regcache.h. */
181 regcache_register_size (const struct regcache
*regcache
, int n
)
183 return register_size (regcache
->arch (), n
);
186 regcache::regcache (gdbarch
*gdbarch
, address_space
*aspace_
,
188 : m_aspace (aspace_
), m_readonly_p (readonly_p_
)
190 gdb_assert (gdbarch
!= NULL
);
191 m_descr
= regcache_descr (gdbarch
);
195 m_registers
= XCNEWVEC (gdb_byte
, m_descr
->sizeof_cooked_registers
);
196 m_register_status
= XCNEWVEC (signed char,
197 m_descr
->nr_cooked_registers
);
201 m_registers
= XCNEWVEC (gdb_byte
, m_descr
->sizeof_raw_registers
);
202 m_register_status
= XCNEWVEC (signed char,
203 m_descr
->nr_raw_registers
);
205 m_ptid
= minus_one_ptid
;
208 static enum register_status
209 do_cooked_read (void *src
, int regnum
, gdb_byte
*buf
)
211 struct regcache
*regcache
= (struct regcache
*) src
;
213 return regcache_cooked_read (regcache
, regnum
, buf
);
216 regcache::regcache (readonly_t
, const regcache
&src
)
217 : regcache (src
.arch (), src
.aspace (), true)
219 gdb_assert (!src
.m_readonly_p
);
220 save (do_cooked_read
, (void *) &src
);
224 regcache::arch () const
226 return m_descr
->gdbarch
;
229 /* See regcache.h. */
232 regcache_get_ptid (const struct regcache
*regcache
)
234 gdb_assert (!ptid_equal (regcache
->ptid (), minus_one_ptid
));
236 return regcache
->ptid ();
239 /* Cleanup class for invalidating a register. */
241 class regcache_invalidator
245 regcache_invalidator (struct regcache
*regcache
, int regnum
)
246 : m_regcache (regcache
),
251 ~regcache_invalidator ()
253 if (m_regcache
!= nullptr)
254 regcache_invalidate (m_regcache
, m_regnum
);
257 DISABLE_COPY_AND_ASSIGN (regcache_invalidator
);
261 m_regcache
= nullptr;
266 struct regcache
*m_regcache
;
270 struct address_space
*
271 get_regcache_aspace (const struct regcache
*regcache
)
273 return regcache
->aspace ();
276 /* Return a pointer to register REGNUM's buffer cache. */
279 regcache::register_buffer (int regnum
) const
281 return m_registers
+ m_descr
->register_offset
[regnum
];
285 regcache_save (struct regcache
*regcache
,
286 regcache_cooked_read_ftype
*cooked_read
, void *src
)
288 regcache
->save (cooked_read
, src
);
292 regcache::save (regcache_cooked_read_ftype
*cooked_read
,
295 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
298 /* The DST should be `read-only', if it wasn't then the save would
299 end up trying to write the register values back out to the
301 gdb_assert (m_readonly_p
);
302 /* Clear the dest. */
303 memset (m_registers
, 0, m_descr
->sizeof_cooked_registers
);
304 memset (m_register_status
, 0, m_descr
->nr_cooked_registers
);
305 /* Copy over any registers (identified by their membership in the
306 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
307 gdbarch_num_pseudo_regs) range is checked since some architectures need
308 to save/restore `cooked' registers that live in memory. */
309 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
311 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
313 gdb_byte
*dst_buf
= register_buffer (regnum
);
314 enum register_status status
= cooked_read (src
, regnum
, dst_buf
);
316 gdb_assert (status
!= REG_UNKNOWN
);
318 if (status
!= REG_VALID
)
319 memset (dst_buf
, 0, register_size (gdbarch
, regnum
));
321 m_register_status
[regnum
] = status
;
327 regcache::restore (struct regcache
*src
)
329 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
332 /* The dst had better not be read-only. If it is, the `restore'
333 doesn't make much sense. */
334 gdb_assert (!m_readonly_p
);
335 gdb_assert (src
->m_readonly_p
);
336 /* Copy over any registers, being careful to only restore those that
337 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
338 + gdbarch_num_pseudo_regs) range is checked since some architectures need
339 to save/restore `cooked' registers that live in memory. */
340 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
342 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
344 if (src
->m_register_status
[regnum
] == REG_VALID
)
345 cooked_write (regnum
, src
->register_buffer (regnum
));
351 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
353 gdb_assert (src
!= NULL
&& dst
!= NULL
);
354 gdb_assert (src
->m_descr
->gdbarch
== dst
->m_descr
->gdbarch
);
355 gdb_assert (src
!= dst
);
356 gdb_assert (src
->m_readonly_p
&& !dst
->m_readonly_p
);
362 regcache_dup (struct regcache
*src
)
364 return new regcache (regcache::readonly
, *src
);
368 regcache_register_status (const struct regcache
*regcache
, int regnum
)
370 gdb_assert (regcache
!= NULL
);
371 return regcache
->get_register_status (regnum
);
375 regcache::get_register_status (int regnum
) const
377 gdb_assert (regnum
>= 0);
379 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
381 gdb_assert (regnum
< m_descr
->nr_raw_registers
);
383 return (enum register_status
) m_register_status
[regnum
];
387 regcache_invalidate (struct regcache
*regcache
, int regnum
)
389 gdb_assert (regcache
!= NULL
);
390 regcache
->invalidate (regnum
);
394 regcache::invalidate (int regnum
)
396 gdb_assert (regnum
>= 0);
397 gdb_assert (!m_readonly_p
);
398 gdb_assert (regnum
< m_descr
->nr_raw_registers
);
399 m_register_status
[regnum
] = REG_UNKNOWN
;
402 /* Global structure containing the current regcache. */
404 /* NOTE: this is a write-through cache. There is no "dirty" bit for
405 recording if the register values have been changed (eg. by the
406 user). Therefore all registers must be written back to the
407 target when appropriate. */
408 std::forward_list
<regcache
*> regcache::current_regcache
;
411 get_thread_arch_aspace_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
,
412 struct address_space
*aspace
)
414 for (const auto ®cache
: regcache::current_regcache
)
415 if (ptid_equal (regcache
->ptid (), ptid
) && regcache
->arch () == gdbarch
)
418 regcache
*new_regcache
= new regcache (gdbarch
, aspace
, false);
420 regcache::current_regcache
.push_front (new_regcache
);
421 new_regcache
->set_ptid (ptid
);
427 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
429 address_space
*aspace
= target_thread_address_space (ptid
);
431 return get_thread_arch_aspace_regcache (ptid
, gdbarch
, aspace
);
434 static ptid_t current_thread_ptid
;
435 static struct gdbarch
*current_thread_arch
;
438 get_thread_regcache (ptid_t ptid
)
440 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
442 current_thread_ptid
= ptid
;
443 current_thread_arch
= target_thread_architecture (ptid
);
446 return get_thread_arch_regcache (ptid
, current_thread_arch
);
450 get_current_regcache (void)
452 return get_thread_regcache (inferior_ptid
);
455 /* See common/common-regcache.h. */
458 get_thread_regcache_for_ptid (ptid_t ptid
)
460 return get_thread_regcache (ptid
);
463 /* Observer for the target_changed event. */
466 regcache_observer_target_changed (struct target_ops
*target
)
468 registers_changed ();
471 /* Update global variables old ptids to hold NEW_PTID if they were
474 regcache::regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
476 for (auto ®cache
: regcache::current_regcache
)
478 if (ptid_equal (regcache
->ptid (), old_ptid
))
479 regcache
->set_ptid (new_ptid
);
483 /* Low level examining and depositing of registers.
485 The caller is responsible for making sure that the inferior is
486 stopped before calling the fetching routines, or it will get
487 garbage. (a change from GDB version 3, in which the caller got the
488 value from the last stop). */
490 /* REGISTERS_CHANGED ()
492 Indicate that registers may have changed, so invalidate the cache. */
495 registers_changed_ptid (ptid_t ptid
)
497 for (auto oit
= regcache::current_regcache
.before_begin (),
498 it
= std::next (oit
);
499 it
!= regcache::current_regcache
.end ();
502 if (ptid_match ((*it
)->ptid (), ptid
))
505 it
= regcache::current_regcache
.erase_after (oit
);
511 if (ptid_match (current_thread_ptid
, ptid
))
513 current_thread_ptid
= null_ptid
;
514 current_thread_arch
= NULL
;
517 if (ptid_match (inferior_ptid
, ptid
))
519 /* We just deleted the regcache of the current thread. Need to
520 forget about any frames we have cached, too. */
521 reinit_frame_cache ();
526 registers_changed (void)
528 registers_changed_ptid (minus_one_ptid
);
530 /* Force cleanup of any alloca areas if using C alloca instead of
531 a builtin alloca. This particular call is used to clean up
532 areas allocated by low level target code which may build up
533 during lengthy interactions between gdb and the target before
534 gdb gives control to the user (ie watchpoints). */
539 regcache_raw_update (struct regcache
*regcache
, int regnum
)
541 gdb_assert (regcache
!= NULL
);
543 regcache
->raw_update (regnum
);
547 regcache::raw_update (int regnum
)
549 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
551 /* Make certain that the register cache is up-to-date with respect
552 to the current thread. This switching shouldn't be necessary
553 only there is still only one target side register cache. Sigh!
554 On the bright side, at least there is a regcache object. */
556 if (!m_readonly_p
&& get_register_status (regnum
) == REG_UNKNOWN
)
558 target_fetch_registers (this, regnum
);
560 /* A number of targets can't access the whole set of raw
561 registers (because the debug API provides no means to get at
563 if (m_register_status
[regnum
] == REG_UNKNOWN
)
564 m_register_status
[regnum
] = REG_UNAVAILABLE
;
569 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
571 return regcache
->raw_read (regnum
, buf
);
575 regcache::raw_read (int regnum
, gdb_byte
*buf
)
577 gdb_assert (buf
!= NULL
);
580 if (m_register_status
[regnum
] != REG_VALID
)
581 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
583 memcpy (buf
, register_buffer (regnum
),
584 m_descr
->sizeof_register
[regnum
]);
586 return (enum register_status
) m_register_status
[regnum
];
590 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
592 gdb_assert (regcache
!= NULL
);
593 return regcache
->raw_read (regnum
, val
);
596 template<typename T
, typename
>
598 regcache::raw_read (int regnum
, T
*val
)
601 enum register_status status
;
603 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
604 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
605 status
= raw_read (regnum
, buf
);
606 if (status
== REG_VALID
)
607 *val
= extract_integer
<T
> (buf
,
608 m_descr
->sizeof_register
[regnum
],
609 gdbarch_byte_order (m_descr
->gdbarch
));
616 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
619 gdb_assert (regcache
!= NULL
);
620 return regcache
->raw_read (regnum
, val
);
624 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
626 gdb_assert (regcache
!= NULL
);
627 regcache
->raw_write (regnum
, val
);
630 template<typename T
, typename
>
632 regcache::raw_write (int regnum
, T val
)
636 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_raw_registers
);
637 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
638 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
639 gdbarch_byte_order (m_descr
->gdbarch
), val
);
640 raw_write (regnum
, buf
);
644 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
647 gdb_assert (regcache
!= NULL
);
648 regcache
->raw_write (regnum
, val
);
652 regcache_raw_get_signed (struct regcache
*regcache
, int regnum
)
655 enum register_status status
;
657 status
= regcache_raw_read_signed (regcache
, regnum
, &value
);
658 if (status
== REG_UNAVAILABLE
)
659 throw_error (NOT_AVAILABLE_ERROR
,
660 _("Register %d is not available"), regnum
);
665 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
667 return regcache
->cooked_read (regnum
, buf
);
671 regcache::cooked_read (int regnum
, gdb_byte
*buf
)
673 gdb_assert (regnum
>= 0);
674 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
675 if (regnum
< m_descr
->nr_raw_registers
)
676 return raw_read (regnum
, buf
);
677 else if (m_readonly_p
678 && m_register_status
[regnum
] != REG_UNKNOWN
)
680 /* Read-only register cache, perhaps the cooked value was
682 if (m_register_status
[regnum
] == REG_VALID
)
683 memcpy (buf
, register_buffer (regnum
),
684 m_descr
->sizeof_register
[regnum
]);
686 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
688 return (enum register_status
) m_register_status
[regnum
];
690 else if (gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
692 struct value
*mark
, *computed
;
693 enum register_status result
= REG_VALID
;
695 mark
= value_mark ();
697 computed
= gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
699 if (value_entirely_available (computed
))
700 memcpy (buf
, value_contents_raw (computed
),
701 m_descr
->sizeof_register
[regnum
]);
704 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
705 result
= REG_UNAVAILABLE
;
708 value_free_to_mark (mark
);
713 return gdbarch_pseudo_register_read (m_descr
->gdbarch
, this,
718 regcache_cooked_read_value (struct regcache
*regcache
, int regnum
)
720 return regcache
->cooked_read_value (regnum
);
724 regcache::cooked_read_value (int regnum
)
726 gdb_assert (regnum
>= 0);
727 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
729 if (regnum
< m_descr
->nr_raw_registers
730 || (m_readonly_p
&& m_register_status
[regnum
] != REG_UNKNOWN
)
731 || !gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
733 struct value
*result
;
735 result
= allocate_value (register_type (m_descr
->gdbarch
, regnum
));
736 VALUE_LVAL (result
) = lval_register
;
737 VALUE_REGNUM (result
) = regnum
;
739 /* It is more efficient in general to do this delegation in this
740 direction than in the other one, even though the value-based
742 if (cooked_read (regnum
,
743 value_contents_raw (result
)) == REG_UNAVAILABLE
)
744 mark_value_bytes_unavailable (result
, 0,
745 TYPE_LENGTH (value_type (result
)));
750 return gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
755 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
758 gdb_assert (regcache
!= NULL
);
759 return regcache
->cooked_read (regnum
, val
);
762 template<typename T
, typename
>
764 regcache::cooked_read (int regnum
, T
*val
)
766 enum register_status status
;
769 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
770 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
771 status
= cooked_read (regnum
, buf
);
772 if (status
== REG_VALID
)
773 *val
= extract_integer
<T
> (buf
, m_descr
->sizeof_register
[regnum
],
774 gdbarch_byte_order (m_descr
->gdbarch
));
781 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
784 gdb_assert (regcache
!= NULL
);
785 return regcache
->cooked_read (regnum
, val
);
789 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
792 gdb_assert (regcache
!= NULL
);
793 regcache
->cooked_write (regnum
, val
);
796 template<typename T
, typename
>
798 regcache::cooked_write (int regnum
, T val
)
802 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
803 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
804 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
805 gdbarch_byte_order (m_descr
->gdbarch
), val
);
806 cooked_write (regnum
, buf
);
810 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
813 gdb_assert (regcache
!= NULL
);
814 regcache
->cooked_write (regnum
, val
);
817 /* See regcache.h. */
820 regcache_raw_set_cached_value (struct regcache
*regcache
, int regnum
,
823 regcache
->raw_set_cached_value (regnum
, buf
);
827 regcache::raw_set_cached_value (int regnum
, const gdb_byte
*buf
)
829 memcpy (register_buffer (regnum
), buf
,
830 m_descr
->sizeof_register
[regnum
]);
831 m_register_status
[regnum
] = REG_VALID
;
835 regcache_raw_write (struct regcache
*regcache
, int regnum
,
838 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
839 regcache
->raw_write (regnum
, buf
);
843 regcache::raw_write (int regnum
, const gdb_byte
*buf
)
846 gdb_assert (buf
!= NULL
);
847 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
848 gdb_assert (!m_readonly_p
);
850 /* On the sparc, writing %g0 is a no-op, so we don't even want to
851 change the registers array if something writes to this register. */
852 if (gdbarch_cannot_store_register (arch (), regnum
))
855 /* If we have a valid copy of the register, and new value == old
856 value, then don't bother doing the actual store. */
857 if (get_register_status (regnum
) == REG_VALID
858 && (memcmp (register_buffer (regnum
), buf
,
859 m_descr
->sizeof_register
[regnum
]) == 0))
862 target_prepare_to_store (this);
863 raw_set_cached_value (regnum
, buf
);
865 /* Invalidate the register after it is written, in case of a
867 regcache_invalidator
invalidator (this, regnum
);
869 target_store_registers (this, regnum
);
871 /* The target did not throw an error so we can discard invalidating
873 invalidator
.release ();
877 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
880 regcache
->cooked_write (regnum
, buf
);
884 regcache::cooked_write (int regnum
, const gdb_byte
*buf
)
886 gdb_assert (regnum
>= 0);
887 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
888 if (regnum
< m_descr
->nr_raw_registers
)
889 raw_write (regnum
, buf
);
891 gdbarch_pseudo_register_write (m_descr
->gdbarch
, this,
895 /* Perform a partial register transfer using a read, modify, write
898 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
900 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
904 regcache::xfer_part (int regnum
, int offset
, int len
, void *in
,
905 const void *out
, bool is_raw
)
907 struct gdbarch
*gdbarch
= arch ();
908 gdb_byte
*reg
= (gdb_byte
*) alloca (register_size (gdbarch
, regnum
));
910 gdb_assert (offset
>= 0 && offset
<= m_descr
->sizeof_register
[regnum
]);
911 gdb_assert (len
>= 0 && offset
+ len
<= m_descr
->sizeof_register
[regnum
]);
912 /* Something to do? */
913 if (offset
+ len
== 0)
915 /* Read (when needed) ... */
918 || offset
+ len
< m_descr
->sizeof_register
[regnum
])
920 enum register_status status
;
923 status
= raw_read (regnum
, reg
);
925 status
= cooked_read (regnum
, reg
);
926 if (status
!= REG_VALID
)
931 memcpy (in
, reg
+ offset
, len
);
933 memcpy (reg
+ offset
, out
, len
);
934 /* ... write (when needed). */
938 raw_write (regnum
, reg
);
940 cooked_write (regnum
, reg
);
947 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
948 int offset
, int len
, gdb_byte
*buf
)
950 return regcache
->raw_read_part (regnum
, offset
, len
, buf
);
954 regcache::raw_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
956 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
957 return xfer_part (regnum
, offset
, len
, buf
, NULL
, true);
961 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
962 int offset
, int len
, const gdb_byte
*buf
)
964 regcache
->raw_write_part (regnum
, offset
, len
, buf
);
968 regcache::raw_write_part (int regnum
, int offset
, int len
,
971 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
972 xfer_part (regnum
, offset
, len
, NULL
, buf
, true);
976 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
977 int offset
, int len
, gdb_byte
*buf
)
979 return regcache
->cooked_read_part (regnum
, offset
, len
, buf
);
984 regcache::cooked_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
986 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
987 return xfer_part (regnum
, offset
, len
, buf
, NULL
, false);
991 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
992 int offset
, int len
, const gdb_byte
*buf
)
994 regcache
->cooked_write_part (regnum
, offset
, len
, buf
);
998 regcache::cooked_write_part (int regnum
, int offset
, int len
,
1001 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1002 xfer_part (regnum
, offset
, len
, NULL
, buf
, false);
1005 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
1008 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
1010 gdb_assert (regcache
!= NULL
);
1011 regcache
->raw_supply (regnum
, buf
);
1015 regcache::raw_supply (int regnum
, const void *buf
)
1020 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1021 gdb_assert (!m_readonly_p
);
1023 regbuf
= register_buffer (regnum
);
1024 size
= m_descr
->sizeof_register
[regnum
];
1028 memcpy (regbuf
, buf
, size
);
1029 m_register_status
[regnum
] = REG_VALID
;
1033 /* This memset not strictly necessary, but better than garbage
1034 in case the register value manages to escape somewhere (due
1035 to a bug, no less). */
1036 memset (regbuf
, 0, size
);
1037 m_register_status
[regnum
] = REG_UNAVAILABLE
;
1041 /* Supply register REGNUM to REGCACHE. Value to supply is an integer stored at
1042 address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED. If
1043 the register size is greater than ADDR_LEN, then the integer will be sign or
1044 zero extended. If the register size is smaller than the integer, then the
1045 most significant bytes of the integer will be truncated. */
1048 regcache::raw_supply_integer (int regnum
, const gdb_byte
*addr
, int addr_len
,
1051 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1055 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1056 gdb_assert (!m_readonly_p
);
1058 regbuf
= register_buffer (regnum
);
1059 regsize
= m_descr
->sizeof_register
[regnum
];
1061 copy_integer_to_size (regbuf
, regsize
, addr
, addr_len
, is_signed
,
1063 m_register_status
[regnum
] = REG_VALID
;
1066 /* Supply register REGNUM with zeroed value to REGCACHE. This is not the same
1067 as calling raw_supply with NULL (which will set the state to
1071 regcache::raw_supply_zeroed (int regnum
)
1076 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1077 gdb_assert (!m_readonly_p
);
1079 regbuf
= register_buffer (regnum
);
1080 size
= m_descr
->sizeof_register
[regnum
];
1082 memset (regbuf
, 0, size
);
1083 m_register_status
[regnum
] = REG_VALID
;
1086 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1089 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
1091 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
1092 regcache
->raw_collect (regnum
, buf
);
1096 regcache::raw_collect (int regnum
, void *buf
) const
1101 gdb_assert (buf
!= NULL
);
1102 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1104 regbuf
= register_buffer (regnum
);
1105 size
= m_descr
->sizeof_register
[regnum
];
1106 memcpy (buf
, regbuf
, size
);
1109 /* Transfer a single or all registers belonging to a certain register
1110 set to or from a buffer. This is the main worker function for
1111 regcache_supply_regset and regcache_collect_regset. */
1113 /* Collect register REGNUM from REGCACHE. Store collected value as an integer
1114 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
1115 If ADDR_LEN is greater than the register size, then the integer will be sign
1116 or zero extended. If ADDR_LEN is smaller than the register size, then the
1117 most significant bytes of the integer will be truncated. */
1120 regcache::raw_collect_integer (int regnum
, gdb_byte
*addr
, int addr_len
,
1121 bool is_signed
) const
1123 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1124 const gdb_byte
*regbuf
;
1127 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1129 regbuf
= register_buffer (regnum
);
1130 regsize
= m_descr
->sizeof_register
[regnum
];
1132 copy_integer_to_size (addr
, addr_len
, regbuf
, regsize
, is_signed
,
1137 regcache::transfer_regset (const struct regset
*regset
,
1138 struct regcache
*out_regcache
,
1139 int regnum
, const void *in_buf
,
1140 void *out_buf
, size_t size
) const
1142 const struct regcache_map_entry
*map
;
1143 int offs
= 0, count
;
1145 for (map
= (const struct regcache_map_entry
*) regset
->regmap
;
1146 (count
= map
->count
) != 0;
1149 int regno
= map
->regno
;
1150 int slot_size
= map
->size
;
1152 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1153 slot_size
= m_descr
->sizeof_register
[regno
];
1155 if (regno
== REGCACHE_MAP_SKIP
1157 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1158 offs
+= count
* slot_size
;
1160 else if (regnum
== -1)
1161 for (; count
--; regno
++, offs
+= slot_size
)
1163 if (offs
+ slot_size
> size
)
1167 raw_collect (regno
, (gdb_byte
*) out_buf
+ offs
);
1169 out_regcache
->raw_supply (regno
, in_buf
1170 ? (const gdb_byte
*) in_buf
+ offs
1175 /* Transfer a single register and return. */
1176 offs
+= (regnum
- regno
) * slot_size
;
1177 if (offs
+ slot_size
> size
)
1181 raw_collect (regnum
, (gdb_byte
*) out_buf
+ offs
);
1183 out_regcache
->raw_supply (regnum
, in_buf
1184 ? (const gdb_byte
*) in_buf
+ offs
1191 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1192 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1193 If BUF is NULL, set the register(s) to "unavailable" status. */
1196 regcache_supply_regset (const struct regset
*regset
,
1197 struct regcache
*regcache
,
1198 int regnum
, const void *buf
, size_t size
)
1200 regcache
->supply_regset (regset
, regnum
, buf
, size
);
1204 regcache::supply_regset (const struct regset
*regset
,
1205 int regnum
, const void *buf
, size_t size
)
1207 transfer_regset (regset
, this, regnum
, buf
, NULL
, size
);
1210 /* Collect register REGNUM from REGCACHE to BUF, using the register
1211 map in REGSET. If REGNUM is -1, do this for all registers in
1215 regcache_collect_regset (const struct regset
*regset
,
1216 const struct regcache
*regcache
,
1217 int regnum
, void *buf
, size_t size
)
1219 regcache
->collect_regset (regset
, regnum
, buf
, size
);
1223 regcache::collect_regset (const struct regset
*regset
,
1224 int regnum
, void *buf
, size_t size
) const
1226 transfer_regset (regset
, NULL
, regnum
, NULL
, buf
, size
);
1230 /* Special handling for register PC. */
1233 regcache_read_pc (struct regcache
*regcache
)
1235 struct gdbarch
*gdbarch
= regcache
->arch ();
1239 if (gdbarch_read_pc_p (gdbarch
))
1240 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1241 /* Else use per-frame method on get_current_frame. */
1242 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1246 if (regcache_cooked_read_unsigned (regcache
,
1247 gdbarch_pc_regnum (gdbarch
),
1248 &raw_val
) == REG_UNAVAILABLE
)
1249 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1251 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1254 internal_error (__FILE__
, __LINE__
,
1255 _("regcache_read_pc: Unable to find PC"));
1260 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1262 struct gdbarch
*gdbarch
= regcache
->arch ();
1264 if (gdbarch_write_pc_p (gdbarch
))
1265 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1266 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1267 regcache_cooked_write_unsigned (regcache
,
1268 gdbarch_pc_regnum (gdbarch
), pc
);
1270 internal_error (__FILE__
, __LINE__
,
1271 _("regcache_write_pc: Unable to update PC"));
1273 /* Writing the PC (for instance, from "load") invalidates the
1275 reinit_frame_cache ();
1279 regcache::debug_print_register (const char *func
, int regno
)
1281 struct gdbarch
*gdbarch
= arch ();
1283 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1284 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
1285 && gdbarch_register_name (gdbarch
, regno
) != NULL
1286 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
1287 fprintf_unfiltered (gdb_stdlog
, "(%s)",
1288 gdbarch_register_name (gdbarch
, regno
));
1290 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1291 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
1293 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1294 int size
= register_size (gdbarch
, regno
);
1295 gdb_byte
*buf
= register_buffer (regno
);
1297 fprintf_unfiltered (gdb_stdlog
, " = ");
1298 for (int i
= 0; i
< size
; i
++)
1300 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1302 if (size
<= sizeof (LONGEST
))
1304 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
1306 fprintf_unfiltered (gdb_stdlog
, " %s %s",
1307 core_addr_to_string_nz (val
), plongest (val
));
1310 fprintf_unfiltered (gdb_stdlog
, "\n");
1314 reg_flush_command (char *command
, int from_tty
)
1316 /* Force-flush the register cache. */
1317 registers_changed ();
1319 printf_filtered (_("Register cache flushed.\n"));
1323 regcache::dump (ui_file
*file
, enum regcache_dump_what what_to_dump
)
1325 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
1327 int footnote_nr
= 0;
1328 int footnote_register_size
= 0;
1329 int footnote_register_offset
= 0;
1330 int footnote_register_type_name_null
= 0;
1331 long register_offset
= 0;
1334 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1335 m_descr
->nr_raw_registers
);
1336 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1337 m_descr
->nr_cooked_registers
);
1338 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1339 m_descr
->sizeof_raw_registers
);
1340 fprintf_unfiltered (file
, "sizeof_raw_register_status %ld\n",
1341 m_descr
->nr_raw_registers
);
1342 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
1343 gdbarch_num_regs (gdbarch
));
1344 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
1345 gdbarch_num_pseudo_regs (gdbarch
));
1348 gdb_assert (m_descr
->nr_cooked_registers
1349 == (gdbarch_num_regs (gdbarch
)
1350 + gdbarch_num_pseudo_regs (gdbarch
)));
1352 for (regnum
= -1; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
1356 fprintf_unfiltered (file
, " %-10s", "Name");
1359 const char *p
= gdbarch_register_name (gdbarch
, regnum
);
1363 else if (p
[0] == '\0')
1365 fprintf_unfiltered (file
, " %-10s", p
);
1370 fprintf_unfiltered (file
, " %4s", "Nr");
1372 fprintf_unfiltered (file
, " %4d", regnum
);
1374 /* Relative number. */
1376 fprintf_unfiltered (file
, " %4s", "Rel");
1377 else if (regnum
< gdbarch_num_regs (gdbarch
))
1378 fprintf_unfiltered (file
, " %4d", regnum
);
1380 fprintf_unfiltered (file
, " %4d",
1381 (regnum
- gdbarch_num_regs (gdbarch
)));
1385 fprintf_unfiltered (file
, " %6s ", "Offset");
1388 fprintf_unfiltered (file
, " %6ld",
1389 m_descr
->register_offset
[regnum
]);
1390 if (register_offset
!= m_descr
->register_offset
[regnum
]
1392 && (m_descr
->register_offset
[regnum
]
1393 != (m_descr
->register_offset
[regnum
- 1]
1394 + m_descr
->sizeof_register
[regnum
- 1])))
1397 if (!footnote_register_offset
)
1398 footnote_register_offset
= ++footnote_nr
;
1399 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1402 fprintf_unfiltered (file
, " ");
1403 register_offset
= (m_descr
->register_offset
[regnum
]
1404 + m_descr
->sizeof_register
[regnum
]);
1409 fprintf_unfiltered (file
, " %5s ", "Size");
1411 fprintf_unfiltered (file
, " %5ld", m_descr
->sizeof_register
[regnum
]);
1416 std::string name_holder
;
1422 static const char blt
[] = "builtin_type";
1424 t
= TYPE_NAME (register_type (arch (), regnum
));
1427 if (!footnote_register_type_name_null
)
1428 footnote_register_type_name_null
= ++footnote_nr
;
1429 name_holder
= string_printf ("*%d",
1430 footnote_register_type_name_null
);
1431 t
= name_holder
.c_str ();
1433 /* Chop a leading builtin_type. */
1434 if (startswith (t
, blt
))
1437 fprintf_unfiltered (file
, " %-15s", t
);
1440 /* Leading space always present. */
1441 fprintf_unfiltered (file
, " ");
1444 if (what_to_dump
== regcache_dump_raw
)
1447 fprintf_unfiltered (file
, "Raw value");
1448 else if (regnum
>= m_descr
->nr_raw_registers
)
1449 fprintf_unfiltered (file
, "<cooked>");
1450 else if (get_register_status (regnum
) == REG_UNKNOWN
)
1451 fprintf_unfiltered (file
, "<invalid>");
1452 else if (get_register_status (regnum
) == REG_UNAVAILABLE
)
1453 fprintf_unfiltered (file
, "<unavailable>");
1456 raw_update (regnum
);
1457 print_hex_chars (file
, register_buffer (regnum
),
1458 m_descr
->sizeof_register
[regnum
],
1459 gdbarch_byte_order (gdbarch
), true);
1463 /* Value, cooked. */
1464 if (what_to_dump
== regcache_dump_cooked
)
1467 fprintf_unfiltered (file
, "Cooked value");
1470 const gdb_byte
*buf
= NULL
;
1471 enum register_status status
;
1472 struct value
*value
= NULL
;
1474 if (regnum
< m_descr
->nr_raw_registers
)
1476 raw_update (regnum
);
1477 status
= get_register_status (regnum
);
1478 buf
= register_buffer (regnum
);
1482 value
= cooked_read_value (regnum
);
1484 if (!value_optimized_out (value
)
1485 && value_entirely_available (value
))
1488 buf
= value_contents_all (value
);
1491 status
= REG_UNAVAILABLE
;
1494 if (status
== REG_UNKNOWN
)
1495 fprintf_unfiltered (file
, "<invalid>");
1496 else if (status
== REG_UNAVAILABLE
)
1497 fprintf_unfiltered (file
, "<unavailable>");
1499 print_hex_chars (file
, buf
,
1500 m_descr
->sizeof_register
[regnum
],
1501 gdbarch_byte_order (gdbarch
), true);
1505 release_value (value
);
1511 /* Group members. */
1512 if (what_to_dump
== regcache_dump_groups
)
1515 fprintf_unfiltered (file
, "Groups");
1518 const char *sep
= "";
1519 struct reggroup
*group
;
1521 for (group
= reggroup_next (gdbarch
, NULL
);
1523 group
= reggroup_next (gdbarch
, group
))
1525 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1527 fprintf_unfiltered (file
,
1528 "%s%s", sep
, reggroup_name (group
));
1535 /* Remote packet configuration. */
1536 if (what_to_dump
== regcache_dump_remote
)
1540 fprintf_unfiltered (file
, "Rmt Nr g/G Offset");
1542 else if (regnum
< m_descr
->nr_raw_registers
)
1546 if (remote_register_number_and_offset (arch (), regnum
,
1548 fprintf_unfiltered (file
, "%7d %11d", pnum
, poffset
);
1552 fprintf_unfiltered (file
, "\n");
1555 if (footnote_register_size
)
1556 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1557 footnote_register_size
);
1558 if (footnote_register_offset
)
1559 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1560 footnote_register_offset
);
1561 if (footnote_register_type_name_null
)
1562 fprintf_unfiltered (file
,
1563 "*%d: Register type's name NULL.\n",
1564 footnote_register_type_name_null
);
1568 regcache_print (const char *args
, enum regcache_dump_what what_to_dump
)
1570 /* Where to send output. */
1578 if (!file
.open (args
, "w"))
1579 perror_with_name (_("maintenance print architecture"));
1583 if (target_has_registers
)
1584 get_current_regcache ()->dump (out
, what_to_dump
);
1587 /* For the benefit of "maint print registers" & co when
1588 debugging an executable, allow dumping a regcache even when
1589 there is no thread selected / no registers. */
1590 regcache
dummy_regs (target_gdbarch (), nullptr);
1591 dummy_regs
.dump (out
, what_to_dump
);
1596 maintenance_print_registers (const char *args
, int from_tty
)
1598 regcache_print (args
, regcache_dump_none
);
1602 maintenance_print_raw_registers (const char *args
, int from_tty
)
1604 regcache_print (args
, regcache_dump_raw
);
1608 maintenance_print_cooked_registers (const char *args
, int from_tty
)
1610 regcache_print (args
, regcache_dump_cooked
);
1614 maintenance_print_register_groups (const char *args
, int from_tty
)
1616 regcache_print (args
, regcache_dump_groups
);
1620 maintenance_print_remote_registers (const char *args
, int from_tty
)
1622 regcache_print (args
, regcache_dump_remote
);
1626 #include "selftest.h"
1628 namespace selftests
{
1630 class regcache_access
: public regcache
1634 /* Return the number of elements in current_regcache. */
1637 current_regcache_size ()
1639 return std::distance (regcache::current_regcache
.begin (),
1640 regcache::current_regcache
.end ());
1645 current_regcache_test (void)
1647 /* It is empty at the start. */
1648 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1650 ptid_t
ptid1 (1), ptid2 (2), ptid3 (3);
1652 /* Get regcache from ptid1, a new regcache is added to
1653 current_regcache. */
1654 regcache
*regcache
= get_thread_arch_aspace_regcache (ptid1
,
1658 SELF_CHECK (regcache
!= NULL
);
1659 SELF_CHECK (regcache
->ptid () == ptid1
);
1660 SELF_CHECK (regcache_access::current_regcache_size () == 1);
1662 /* Get regcache from ptid2, a new regcache is added to
1663 current_regcache. */
1664 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1667 SELF_CHECK (regcache
!= NULL
);
1668 SELF_CHECK (regcache
->ptid () == ptid2
);
1669 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1671 /* Get regcache from ptid3, a new regcache is added to
1672 current_regcache. */
1673 regcache
= get_thread_arch_aspace_regcache (ptid3
,
1676 SELF_CHECK (regcache
!= NULL
);
1677 SELF_CHECK (regcache
->ptid () == ptid3
);
1678 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1680 /* Get regcache from ptid2 again, nothing is added to
1681 current_regcache. */
1682 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1685 SELF_CHECK (regcache
!= NULL
);
1686 SELF_CHECK (regcache
->ptid () == ptid2
);
1687 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1689 /* Mark ptid2 is changed, so regcache of ptid2 should be removed from
1690 current_regcache. */
1691 registers_changed_ptid (ptid2
);
1692 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1695 } // namespace selftests
1696 #endif /* GDB_SELF_TEST */
1699 _initialize_regcache (void)
1701 regcache_descr_handle
1702 = gdbarch_data_register_post_init (init_regcache_descr
);
1704 observer_attach_target_changed (regcache_observer_target_changed
);
1705 observer_attach_thread_ptid_changed (regcache::regcache_thread_ptid_changed
);
1707 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1708 _("Force gdb to flush its register cache (maintainer command)"));
1710 add_cmd ("registers", class_maintenance
, maintenance_print_registers
,
1711 _("Print the internal register configuration.\n"
1712 "Takes an optional file parameter."), &maintenanceprintlist
);
1713 add_cmd ("raw-registers", class_maintenance
,
1714 maintenance_print_raw_registers
,
1715 _("Print the internal register configuration "
1716 "including raw values.\n"
1717 "Takes an optional file parameter."), &maintenanceprintlist
);
1718 add_cmd ("cooked-registers", class_maintenance
,
1719 maintenance_print_cooked_registers
,
1720 _("Print the internal register configuration "
1721 "including cooked values.\n"
1722 "Takes an optional file parameter."), &maintenanceprintlist
);
1723 add_cmd ("register-groups", class_maintenance
,
1724 maintenance_print_register_groups
,
1725 _("Print the internal register configuration "
1726 "including each register's group.\n"
1727 "Takes an optional file parameter."),
1728 &maintenanceprintlist
);
1729 add_cmd ("remote-registers", class_maintenance
,
1730 maintenance_print_remote_registers
, _("\
1731 Print the internal register configuration including each register's\n\
1732 remote register number and buffer offset in the g/G packets.\n\
1733 Takes an optional file parameter."),
1734 &maintenanceprintlist
);
1737 selftests::register_test ("current_regcache", selftests::current_regcache_test
);