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
;
56 long sizeof_raw_register_status
;
58 /* The cooked register space. Each cooked register in the range
59 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
60 register. The remaining [NR_RAW_REGISTERS
61 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
62 both raw registers and memory by the architecture methods
63 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
64 int nr_cooked_registers
;
65 long sizeof_cooked_registers
;
66 long sizeof_cooked_register_status
;
68 /* Offset and size (in 8 bit bytes), of each register in the
69 register cache. All registers (including those in the range
70 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
72 long *register_offset
;
73 long *sizeof_register
;
75 /* Cached table containing the type of each register. */
76 struct type
**register_type
;
80 init_regcache_descr (struct gdbarch
*gdbarch
)
83 struct regcache_descr
*descr
;
84 gdb_assert (gdbarch
!= NULL
);
86 /* Create an initial, zero filled, table. */
87 descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct regcache_descr
);
88 descr
->gdbarch
= gdbarch
;
90 /* Total size of the register space. The raw registers are mapped
91 directly onto the raw register cache while the pseudo's are
92 either mapped onto raw-registers or memory. */
93 descr
->nr_cooked_registers
= gdbarch_num_regs (gdbarch
)
94 + gdbarch_num_pseudo_regs (gdbarch
);
95 descr
->sizeof_cooked_register_status
96 = gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
98 /* Fill in a table of register types. */
100 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
,
102 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
103 descr
->register_type
[i
] = gdbarch_register_type (gdbarch
, i
);
105 /* Construct a strictly RAW register cache. Don't allow pseudo's
106 into the register cache. */
107 descr
->nr_raw_registers
= gdbarch_num_regs (gdbarch
);
108 descr
->sizeof_raw_register_status
= gdbarch_num_regs (gdbarch
);
110 /* Lay out the register cache.
112 NOTE: cagney/2002-05-22: Only register_type() is used when
113 constructing the register cache. It is assumed that the
114 register's raw size, virtual size and type length are all the
120 descr
->sizeof_register
121 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
122 descr
->register_offset
123 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
124 for (i
= 0; i
< descr
->nr_raw_registers
; i
++)
126 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
127 descr
->register_offset
[i
] = offset
;
128 offset
+= descr
->sizeof_register
[i
];
129 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
131 /* Set the real size of the raw register cache buffer. */
132 descr
->sizeof_raw_registers
= offset
;
134 for (; i
< descr
->nr_cooked_registers
; i
++)
136 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
137 descr
->register_offset
[i
] = offset
;
138 offset
+= descr
->sizeof_register
[i
];
139 gdb_assert (MAX_REGISTER_SIZE
>= descr
->sizeof_register
[i
]);
141 /* Set the real size of the readonly register cache buffer. */
142 descr
->sizeof_cooked_registers
= offset
;
148 static struct regcache_descr
*
149 regcache_descr (struct gdbarch
*gdbarch
)
151 return (struct regcache_descr
*) gdbarch_data (gdbarch
,
152 regcache_descr_handle
);
155 /* Utility functions returning useful register attributes stored in
156 the regcache descr. */
159 register_type (struct gdbarch
*gdbarch
, int regnum
)
161 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
163 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
164 return descr
->register_type
[regnum
];
167 /* Utility functions returning useful register attributes stored in
168 the regcache descr. */
171 register_size (struct gdbarch
*gdbarch
, int regnum
)
173 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
176 gdb_assert (regnum
>= 0
177 && regnum
< (gdbarch_num_regs (gdbarch
)
178 + gdbarch_num_pseudo_regs (gdbarch
)));
179 size
= descr
->sizeof_register
[regnum
];
183 /* See common/common-regcache.h. */
186 regcache_register_size (const struct regcache
*regcache
, int n
)
188 return register_size (get_regcache_arch (regcache
), n
);
191 regcache::regcache (gdbarch
*gdbarch
, address_space
*aspace_
,
193 : m_aspace (aspace_
), m_readonly_p (readonly_p_
)
195 gdb_assert (gdbarch
!= NULL
);
196 m_descr
= regcache_descr (gdbarch
);
200 m_registers
= XCNEWVEC (gdb_byte
, m_descr
->sizeof_cooked_registers
);
201 m_register_status
= XCNEWVEC (signed char,
202 m_descr
->sizeof_cooked_register_status
);
206 m_registers
= XCNEWVEC (gdb_byte
, m_descr
->sizeof_raw_registers
);
207 m_register_status
= XCNEWVEC (signed char,
208 m_descr
->sizeof_raw_register_status
);
210 m_ptid
= minus_one_ptid
;
213 static enum register_status
214 do_cooked_read (void *src
, int regnum
, gdb_byte
*buf
)
216 struct regcache
*regcache
= (struct regcache
*) src
;
218 return regcache_cooked_read (regcache
, regnum
, buf
);
221 regcache::regcache (readonly_t
, const regcache
&src
)
222 : regcache (src
.arch (), src
.aspace (), true)
224 gdb_assert (!src
.m_readonly_p
);
225 save (do_cooked_read
, (void *) &src
);
229 regcache::arch () const
231 return m_descr
->gdbarch
;
234 /* See regcache.h. */
237 regcache_get_ptid (const struct regcache
*regcache
)
239 gdb_assert (!ptid_equal (regcache
->ptid (), minus_one_ptid
));
241 return regcache
->ptid ();
244 /* Cleanup class for invalidating a register. */
246 class regcache_invalidator
250 regcache_invalidator (struct regcache
*regcache
, int regnum
)
251 : m_regcache (regcache
),
256 ~regcache_invalidator ()
258 if (m_regcache
!= nullptr)
259 regcache_invalidate (m_regcache
, m_regnum
);
262 DISABLE_COPY_AND_ASSIGN (regcache_invalidator
);
266 m_regcache
= nullptr;
271 struct regcache
*m_regcache
;
275 /* Return REGCACHE's architecture. */
278 get_regcache_arch (const struct regcache
*regcache
)
280 return regcache
->arch ();
283 struct address_space
*
284 get_regcache_aspace (const struct regcache
*regcache
)
286 return regcache
->aspace ();
289 /* Return a pointer to register REGNUM's buffer cache. */
292 regcache::register_buffer (int regnum
) const
294 return m_registers
+ m_descr
->register_offset
[regnum
];
298 regcache_save (struct regcache
*regcache
,
299 regcache_cooked_read_ftype
*cooked_read
, void *src
)
301 regcache
->save (cooked_read
, src
);
305 regcache::save (regcache_cooked_read_ftype
*cooked_read
,
308 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
311 /* The DST should be `read-only', if it wasn't then the save would
312 end up trying to write the register values back out to the
314 gdb_assert (m_readonly_p
);
315 /* Clear the dest. */
316 memset (m_registers
, 0, m_descr
->sizeof_cooked_registers
);
317 memset (m_register_status
, 0, m_descr
->sizeof_cooked_register_status
);
318 /* Copy over any registers (identified by their membership in the
319 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
320 gdbarch_num_pseudo_regs) range is checked since some architectures need
321 to save/restore `cooked' registers that live in memory. */
322 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
324 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
326 gdb_byte
*dst_buf
= register_buffer (regnum
);
327 enum register_status status
= cooked_read (src
, regnum
, dst_buf
);
329 gdb_assert (status
!= REG_UNKNOWN
);
331 if (status
!= REG_VALID
)
332 memset (dst_buf
, 0, register_size (gdbarch
, regnum
));
334 m_register_status
[regnum
] = status
;
340 regcache::restore (struct regcache
*src
)
342 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
345 /* The dst had better not be read-only. If it is, the `restore'
346 doesn't make much sense. */
347 gdb_assert (!m_readonly_p
);
348 gdb_assert (src
->m_readonly_p
);
349 /* Copy over any registers, being careful to only restore those that
350 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
351 + gdbarch_num_pseudo_regs) range is checked since some architectures need
352 to save/restore `cooked' registers that live in memory. */
353 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
355 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
357 if (src
->m_register_status
[regnum
] == REG_VALID
)
358 cooked_write (regnum
, src
->register_buffer (regnum
));
364 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
366 gdb_assert (src
!= NULL
&& dst
!= NULL
);
367 gdb_assert (src
->m_descr
->gdbarch
== dst
->m_descr
->gdbarch
);
368 gdb_assert (src
!= dst
);
369 gdb_assert (src
->m_readonly_p
&& !dst
->m_readonly_p
);
375 regcache_dup (struct regcache
*src
)
377 return new regcache (regcache::readonly
, *src
);
381 regcache_register_status (const struct regcache
*regcache
, int regnum
)
383 gdb_assert (regcache
!= NULL
);
384 return regcache
->get_register_status (regnum
);
388 regcache::get_register_status (int regnum
) const
390 gdb_assert (regnum
>= 0);
392 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
394 gdb_assert (regnum
< m_descr
->nr_raw_registers
);
396 return (enum register_status
) m_register_status
[regnum
];
400 regcache_invalidate (struct regcache
*regcache
, int regnum
)
402 gdb_assert (regcache
!= NULL
);
403 regcache
->invalidate (regnum
);
407 regcache::invalidate (int regnum
)
409 gdb_assert (regnum
>= 0);
410 gdb_assert (!m_readonly_p
);
411 gdb_assert (regnum
< m_descr
->nr_raw_registers
);
412 m_register_status
[regnum
] = REG_UNKNOWN
;
415 /* Global structure containing the current regcache. */
417 /* NOTE: this is a write-through cache. There is no "dirty" bit for
418 recording if the register values have been changed (eg. by the
419 user). Therefore all registers must be written back to the
420 target when appropriate. */
421 std::forward_list
<regcache
*> regcache::current_regcache
;
424 get_thread_arch_aspace_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
,
425 struct address_space
*aspace
)
427 for (const auto ®cache
: regcache::current_regcache
)
428 if (ptid_equal (regcache
->ptid (), ptid
) && regcache
->arch () == gdbarch
)
431 regcache
*new_regcache
= new regcache (gdbarch
, aspace
, false);
433 regcache::current_regcache
.push_front (new_regcache
);
434 new_regcache
->set_ptid (ptid
);
440 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
442 struct address_space
*aspace
;
444 /* For the benefit of "maint print registers" & co when debugging an
445 executable, allow dumping the regcache even when there is no
446 thread selected (target_thread_address_space internal-errors if
447 no address space is found). Note that normal user commands will
448 fail higher up on the call stack due to no
449 target_has_registers. */
450 aspace
= (ptid_equal (null_ptid
, ptid
)
452 : target_thread_address_space (ptid
));
454 return get_thread_arch_aspace_regcache (ptid
, gdbarch
, aspace
);
457 static ptid_t current_thread_ptid
;
458 static struct gdbarch
*current_thread_arch
;
461 get_thread_regcache (ptid_t ptid
)
463 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
465 current_thread_ptid
= ptid
;
466 current_thread_arch
= target_thread_architecture (ptid
);
469 return get_thread_arch_regcache (ptid
, current_thread_arch
);
473 get_current_regcache (void)
475 return get_thread_regcache (inferior_ptid
);
478 /* See common/common-regcache.h. */
481 get_thread_regcache_for_ptid (ptid_t ptid
)
483 return get_thread_regcache (ptid
);
486 /* Observer for the target_changed event. */
489 regcache_observer_target_changed (struct target_ops
*target
)
491 registers_changed ();
494 /* Update global variables old ptids to hold NEW_PTID if they were
497 regcache::regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
499 for (auto ®cache
: regcache::current_regcache
)
501 if (ptid_equal (regcache
->ptid (), old_ptid
))
502 regcache
->set_ptid (new_ptid
);
506 /* Low level examining and depositing of registers.
508 The caller is responsible for making sure that the inferior is
509 stopped before calling the fetching routines, or it will get
510 garbage. (a change from GDB version 3, in which the caller got the
511 value from the last stop). */
513 /* REGISTERS_CHANGED ()
515 Indicate that registers may have changed, so invalidate the cache. */
518 registers_changed_ptid (ptid_t ptid
)
520 for (auto oit
= regcache::current_regcache
.before_begin (),
521 it
= std::next (oit
);
522 it
!= regcache::current_regcache
.end ();
525 if (ptid_match ((*it
)->ptid (), ptid
))
528 it
= regcache::current_regcache
.erase_after (oit
);
534 if (ptid_match (current_thread_ptid
, ptid
))
536 current_thread_ptid
= null_ptid
;
537 current_thread_arch
= NULL
;
540 if (ptid_match (inferior_ptid
, ptid
))
542 /* We just deleted the regcache of the current thread. Need to
543 forget about any frames we have cached, too. */
544 reinit_frame_cache ();
549 registers_changed (void)
551 registers_changed_ptid (minus_one_ptid
);
553 /* Force cleanup of any alloca areas if using C alloca instead of
554 a builtin alloca. This particular call is used to clean up
555 areas allocated by low level target code which may build up
556 during lengthy interactions between gdb and the target before
557 gdb gives control to the user (ie watchpoints). */
562 regcache_raw_update (struct regcache
*regcache
, int regnum
)
564 gdb_assert (regcache
!= NULL
);
566 regcache
->raw_update (regnum
);
570 regcache::raw_update (int regnum
)
572 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
574 /* Make certain that the register cache is up-to-date with respect
575 to the current thread. This switching shouldn't be necessary
576 only there is still only one target side register cache. Sigh!
577 On the bright side, at least there is a regcache object. */
579 if (!m_readonly_p
&& get_register_status (regnum
) == REG_UNKNOWN
)
581 target_fetch_registers (this, regnum
);
583 /* A number of targets can't access the whole set of raw
584 registers (because the debug API provides no means to get at
586 if (m_register_status
[regnum
] == REG_UNKNOWN
)
587 m_register_status
[regnum
] = REG_UNAVAILABLE
;
592 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
594 return regcache
->raw_read (regnum
, buf
);
598 regcache::raw_read (int regnum
, gdb_byte
*buf
)
600 gdb_assert (buf
!= NULL
);
603 if (m_register_status
[regnum
] != REG_VALID
)
604 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
606 memcpy (buf
, register_buffer (regnum
),
607 m_descr
->sizeof_register
[regnum
]);
609 return (enum register_status
) m_register_status
[regnum
];
613 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
615 gdb_assert (regcache
!= NULL
);
616 return regcache
->raw_read (regnum
, val
);
619 template<typename T
, typename
>
621 regcache::raw_read (int regnum
, T
*val
)
624 enum register_status status
;
626 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
627 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
628 status
= raw_read (regnum
, buf
);
629 if (status
== REG_VALID
)
630 *val
= extract_integer
<T
> (buf
,
631 m_descr
->sizeof_register
[regnum
],
632 gdbarch_byte_order (m_descr
->gdbarch
));
639 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
642 gdb_assert (regcache
!= NULL
);
643 return regcache
->raw_read (regnum
, val
);
647 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
649 gdb_assert (regcache
!= NULL
);
650 regcache
->raw_write (regnum
, val
);
653 template<typename T
, typename
>
655 regcache::raw_write (int regnum
, T val
)
659 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_raw_registers
);
660 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
661 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
662 gdbarch_byte_order (m_descr
->gdbarch
), val
);
663 raw_write (regnum
, buf
);
667 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
670 gdb_assert (regcache
!= NULL
);
671 regcache
->raw_write (regnum
, val
);
675 regcache_raw_get_signed (struct regcache
*regcache
, int regnum
)
678 enum register_status status
;
680 status
= regcache_raw_read_signed (regcache
, regnum
, &value
);
681 if (status
== REG_UNAVAILABLE
)
682 throw_error (NOT_AVAILABLE_ERROR
,
683 _("Register %d is not available"), regnum
);
688 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
690 return regcache
->cooked_read (regnum
, buf
);
694 regcache::cooked_read (int regnum
, gdb_byte
*buf
)
696 gdb_assert (regnum
>= 0);
697 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
698 if (regnum
< m_descr
->nr_raw_registers
)
699 return raw_read (regnum
, buf
);
700 else if (m_readonly_p
701 && m_register_status
[regnum
] != REG_UNKNOWN
)
703 /* Read-only register cache, perhaps the cooked value was
705 if (m_register_status
[regnum
] == REG_VALID
)
706 memcpy (buf
, register_buffer (regnum
),
707 m_descr
->sizeof_register
[regnum
]);
709 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
711 return (enum register_status
) m_register_status
[regnum
];
713 else if (gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
715 struct value
*mark
, *computed
;
716 enum register_status result
= REG_VALID
;
718 mark
= value_mark ();
720 computed
= gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
722 if (value_entirely_available (computed
))
723 memcpy (buf
, value_contents_raw (computed
),
724 m_descr
->sizeof_register
[regnum
]);
727 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
728 result
= REG_UNAVAILABLE
;
731 value_free_to_mark (mark
);
736 return gdbarch_pseudo_register_read (m_descr
->gdbarch
, this,
741 regcache_cooked_read_value (struct regcache
*regcache
, int regnum
)
743 return regcache
->cooked_read_value (regnum
);
747 regcache::cooked_read_value (int regnum
)
749 gdb_assert (regnum
>= 0);
750 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
752 if (regnum
< m_descr
->nr_raw_registers
753 || (m_readonly_p
&& m_register_status
[regnum
] != REG_UNKNOWN
)
754 || !gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
756 struct value
*result
;
758 result
= allocate_value (register_type (m_descr
->gdbarch
, regnum
));
759 VALUE_LVAL (result
) = lval_register
;
760 VALUE_REGNUM (result
) = regnum
;
762 /* It is more efficient in general to do this delegation in this
763 direction than in the other one, even though the value-based
765 if (cooked_read (regnum
,
766 value_contents_raw (result
)) == REG_UNAVAILABLE
)
767 mark_value_bytes_unavailable (result
, 0,
768 TYPE_LENGTH (value_type (result
)));
773 return gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
778 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
781 gdb_assert (regcache
!= NULL
);
782 return regcache
->cooked_read (regnum
, val
);
785 template<typename T
, typename
>
787 regcache::cooked_read (int regnum
, T
*val
)
789 enum register_status status
;
792 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
793 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
794 status
= cooked_read (regnum
, buf
);
795 if (status
== REG_VALID
)
796 *val
= extract_integer
<T
> (buf
, m_descr
->sizeof_register
[regnum
],
797 gdbarch_byte_order (m_descr
->gdbarch
));
804 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
807 gdb_assert (regcache
!= NULL
);
808 return regcache
->cooked_read (regnum
, val
);
812 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
815 gdb_assert (regcache
!= NULL
);
816 regcache
->cooked_write (regnum
, val
);
819 template<typename T
, typename
>
821 regcache::cooked_write (int regnum
, T val
)
825 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
826 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
827 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
828 gdbarch_byte_order (m_descr
->gdbarch
), val
);
829 cooked_write (regnum
, buf
);
833 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
836 gdb_assert (regcache
!= NULL
);
837 regcache
->cooked_write (regnum
, val
);
840 /* See regcache.h. */
843 regcache_raw_set_cached_value (struct regcache
*regcache
, int regnum
,
846 regcache
->raw_set_cached_value (regnum
, buf
);
850 regcache::raw_set_cached_value (int regnum
, const gdb_byte
*buf
)
852 memcpy (register_buffer (regnum
), buf
,
853 m_descr
->sizeof_register
[regnum
]);
854 m_register_status
[regnum
] = REG_VALID
;
858 regcache_raw_write (struct regcache
*regcache
, int regnum
,
861 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
862 regcache
->raw_write (regnum
, buf
);
866 regcache::raw_write (int regnum
, const gdb_byte
*buf
)
869 gdb_assert (buf
!= NULL
);
870 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
871 gdb_assert (!m_readonly_p
);
873 /* On the sparc, writing %g0 is a no-op, so we don't even want to
874 change the registers array if something writes to this register. */
875 if (gdbarch_cannot_store_register (arch (), regnum
))
878 /* If we have a valid copy of the register, and new value == old
879 value, then don't bother doing the actual store. */
880 if (get_register_status (regnum
) == REG_VALID
881 && (memcmp (register_buffer (regnum
), buf
,
882 m_descr
->sizeof_register
[regnum
]) == 0))
885 target_prepare_to_store (this);
886 raw_set_cached_value (regnum
, buf
);
888 /* Invalidate the register after it is written, in case of a
890 regcache_invalidator
invalidator (this, regnum
);
892 target_store_registers (this, regnum
);
894 /* The target did not throw an error so we can discard invalidating
896 invalidator
.release ();
900 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
903 regcache
->cooked_write (regnum
, buf
);
907 regcache::cooked_write (int regnum
, const gdb_byte
*buf
)
909 gdb_assert (regnum
>= 0);
910 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
911 if (regnum
< m_descr
->nr_raw_registers
)
912 raw_write (regnum
, buf
);
914 gdbarch_pseudo_register_write (m_descr
->gdbarch
, this,
918 /* Perform a partial register transfer using a read, modify, write
921 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
923 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
927 regcache::xfer_part (int regnum
, int offset
, int len
, void *in
,
929 enum register_status (*read
) (struct regcache
*regcache
,
932 void (*write
) (struct regcache
*regcache
, int regnum
,
933 const gdb_byte
*buf
))
935 struct gdbarch
*gdbarch
= arch ();
936 gdb_byte
*reg
= (gdb_byte
*) alloca (register_size (gdbarch
, regnum
));
938 gdb_assert (offset
>= 0 && offset
<= m_descr
->sizeof_register
[regnum
]);
939 gdb_assert (len
>= 0 && offset
+ len
<= m_descr
->sizeof_register
[regnum
]);
940 /* Something to do? */
941 if (offset
+ len
== 0)
943 /* Read (when needed) ... */
946 || offset
+ len
< m_descr
->sizeof_register
[regnum
])
948 enum register_status status
;
950 gdb_assert (read
!= NULL
);
951 status
= read (this, regnum
, reg
);
952 if (status
!= REG_VALID
)
957 memcpy (in
, reg
+ offset
, len
);
959 memcpy (reg
+ offset
, out
, len
);
960 /* ... write (when needed). */
963 gdb_assert (write
!= NULL
);
964 write (this, regnum
, reg
);
971 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
972 int offset
, int len
, gdb_byte
*buf
)
974 return regcache
->raw_read_part (regnum
, offset
, len
, buf
);
978 regcache::raw_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
980 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
981 return xfer_part (regnum
, offset
, len
, buf
, NULL
,
982 regcache_raw_read
, regcache_raw_write
);
986 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
987 int offset
, int len
, const gdb_byte
*buf
)
989 regcache
->raw_write_part (regnum
, offset
, len
, buf
);
993 regcache::raw_write_part (int regnum
, int offset
, int len
,
996 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
997 xfer_part (regnum
, offset
, len
, NULL
, buf
, regcache_raw_read
,
1001 enum register_status
1002 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
1003 int offset
, int len
, gdb_byte
*buf
)
1005 return regcache
->cooked_read_part (regnum
, offset
, len
, buf
);
1009 enum register_status
1010 regcache::cooked_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
1012 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1013 return xfer_part (regnum
, offset
, len
, buf
, NULL
,
1014 regcache_cooked_read
, regcache_cooked_write
);
1018 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
1019 int offset
, int len
, const gdb_byte
*buf
)
1021 regcache
->cooked_write_part (regnum
, offset
, len
, buf
);
1025 regcache::cooked_write_part (int regnum
, int offset
, int len
,
1026 const gdb_byte
*buf
)
1028 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1029 xfer_part (regnum
, offset
, len
, NULL
, buf
,
1030 regcache_cooked_read
, regcache_cooked_write
);
1033 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
1036 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
1038 gdb_assert (regcache
!= NULL
);
1039 regcache
->raw_supply (regnum
, buf
);
1043 regcache::raw_supply (int regnum
, const void *buf
)
1048 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1049 gdb_assert (!m_readonly_p
);
1051 regbuf
= register_buffer (regnum
);
1052 size
= m_descr
->sizeof_register
[regnum
];
1056 memcpy (regbuf
, buf
, size
);
1057 m_register_status
[regnum
] = REG_VALID
;
1061 /* This memset not strictly necessary, but better than garbage
1062 in case the register value manages to escape somewhere (due
1063 to a bug, no less). */
1064 memset (regbuf
, 0, size
);
1065 m_register_status
[regnum
] = REG_UNAVAILABLE
;
1069 /* Supply register REGNUM to REGCACHE. Value to supply is an integer stored at
1070 address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED. If
1071 the register size is greater than ADDR_LEN, then the integer will be sign or
1072 zero extended. If the register size is smaller than the integer, then the
1073 most significant bytes of the integer will be truncated. */
1076 regcache::raw_supply_integer (int regnum
, const gdb_byte
*addr
, int addr_len
,
1079 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1083 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1084 gdb_assert (!m_readonly_p
);
1086 regbuf
= register_buffer (regnum
);
1087 regsize
= m_descr
->sizeof_register
[regnum
];
1089 copy_integer_to_size (regbuf
, regsize
, addr
, addr_len
, is_signed
,
1091 m_register_status
[regnum
] = REG_VALID
;
1094 /* Supply register REGNUM with zeroed value to REGCACHE. This is not the same
1095 as calling raw_supply with NULL (which will set the state to
1099 regcache::raw_supply_zeroed (int regnum
)
1104 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1105 gdb_assert (!m_readonly_p
);
1107 regbuf
= register_buffer (regnum
);
1108 size
= m_descr
->sizeof_register
[regnum
];
1110 memset (regbuf
, 0, size
);
1111 m_register_status
[regnum
] = REG_VALID
;
1114 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1117 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
1119 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
1120 regcache
->raw_collect (regnum
, buf
);
1124 regcache::raw_collect (int regnum
, void *buf
) const
1129 gdb_assert (buf
!= NULL
);
1130 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1132 regbuf
= register_buffer (regnum
);
1133 size
= m_descr
->sizeof_register
[regnum
];
1134 memcpy (buf
, regbuf
, size
);
1137 /* Transfer a single or all registers belonging to a certain register
1138 set to or from a buffer. This is the main worker function for
1139 regcache_supply_regset and regcache_collect_regset. */
1141 /* Collect register REGNUM from REGCACHE. Store collected value as an integer
1142 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
1143 If ADDR_LEN is greater than the register size, then the integer will be sign
1144 or zero extended. If ADDR_LEN is smaller than the register size, then the
1145 most significant bytes of the integer will be truncated. */
1148 regcache::raw_collect_integer (int regnum
, gdb_byte
*addr
, int addr_len
,
1149 bool is_signed
) const
1151 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1152 const gdb_byte
*regbuf
;
1155 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1157 regbuf
= register_buffer (regnum
);
1158 regsize
= m_descr
->sizeof_register
[regnum
];
1160 copy_integer_to_size (addr
, addr_len
, regbuf
, regsize
, is_signed
,
1165 regcache::transfer_regset (const struct regset
*regset
,
1166 struct regcache
*out_regcache
,
1167 int regnum
, const void *in_buf
,
1168 void *out_buf
, size_t size
) const
1170 const struct regcache_map_entry
*map
;
1171 int offs
= 0, count
;
1173 for (map
= (const struct regcache_map_entry
*) regset
->regmap
;
1174 (count
= map
->count
) != 0;
1177 int regno
= map
->regno
;
1178 int slot_size
= map
->size
;
1180 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1181 slot_size
= m_descr
->sizeof_register
[regno
];
1183 if (regno
== REGCACHE_MAP_SKIP
1185 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1186 offs
+= count
* slot_size
;
1188 else if (regnum
== -1)
1189 for (; count
--; regno
++, offs
+= slot_size
)
1191 if (offs
+ slot_size
> size
)
1195 raw_collect (regno
, (gdb_byte
*) out_buf
+ offs
);
1197 out_regcache
->raw_supply (regno
, in_buf
1198 ? (const gdb_byte
*) in_buf
+ offs
1203 /* Transfer a single register and return. */
1204 offs
+= (regnum
- regno
) * slot_size
;
1205 if (offs
+ slot_size
> size
)
1209 raw_collect (regnum
, (gdb_byte
*) out_buf
+ offs
);
1211 out_regcache
->raw_supply (regnum
, in_buf
1212 ? (const gdb_byte
*) in_buf
+ offs
1219 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1220 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1221 If BUF is NULL, set the register(s) to "unavailable" status. */
1224 regcache_supply_regset (const struct regset
*regset
,
1225 struct regcache
*regcache
,
1226 int regnum
, const void *buf
, size_t size
)
1228 regcache
->supply_regset (regset
, regnum
, buf
, size
);
1232 regcache::supply_regset (const struct regset
*regset
,
1233 int regnum
, const void *buf
, size_t size
)
1235 transfer_regset (regset
, this, regnum
, buf
, NULL
, size
);
1238 /* Collect register REGNUM from REGCACHE to BUF, using the register
1239 map in REGSET. If REGNUM is -1, do this for all registers in
1243 regcache_collect_regset (const struct regset
*regset
,
1244 const struct regcache
*regcache
,
1245 int regnum
, void *buf
, size_t size
)
1247 regcache
->collect_regset (regset
, regnum
, buf
, size
);
1251 regcache::collect_regset (const struct regset
*regset
,
1252 int regnum
, void *buf
, size_t size
) const
1254 transfer_regset (regset
, NULL
, regnum
, NULL
, buf
, size
);
1258 /* Special handling for register PC. */
1261 regcache_read_pc (struct regcache
*regcache
)
1263 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1267 if (gdbarch_read_pc_p (gdbarch
))
1268 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1269 /* Else use per-frame method on get_current_frame. */
1270 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1274 if (regcache_cooked_read_unsigned (regcache
,
1275 gdbarch_pc_regnum (gdbarch
),
1276 &raw_val
) == REG_UNAVAILABLE
)
1277 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1279 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1282 internal_error (__FILE__
, __LINE__
,
1283 _("regcache_read_pc: Unable to find PC"));
1288 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1290 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1292 if (gdbarch_write_pc_p (gdbarch
))
1293 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1294 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1295 regcache_cooked_write_unsigned (regcache
,
1296 gdbarch_pc_regnum (gdbarch
), pc
);
1298 internal_error (__FILE__
, __LINE__
,
1299 _("regcache_write_pc: Unable to update PC"));
1301 /* Writing the PC (for instance, from "load") invalidates the
1303 reinit_frame_cache ();
1307 regcache::debug_print_register (const char *func
, int regno
)
1309 struct gdbarch
*gdbarch
= arch ();
1311 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1312 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
1313 && gdbarch_register_name (gdbarch
, regno
) != NULL
1314 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
1315 fprintf_unfiltered (gdb_stdlog
, "(%s)",
1316 gdbarch_register_name (gdbarch
, regno
));
1318 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1319 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
1321 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1322 int size
= register_size (gdbarch
, regno
);
1323 gdb_byte
*buf
= register_buffer (regno
);
1325 fprintf_unfiltered (gdb_stdlog
, " = ");
1326 for (int i
= 0; i
< size
; i
++)
1328 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1330 if (size
<= sizeof (LONGEST
))
1332 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
1334 fprintf_unfiltered (gdb_stdlog
, " %s %s",
1335 core_addr_to_string_nz (val
), plongest (val
));
1338 fprintf_unfiltered (gdb_stdlog
, "\n");
1342 reg_flush_command (char *command
, int from_tty
)
1344 /* Force-flush the register cache. */
1345 registers_changed ();
1347 printf_filtered (_("Register cache flushed.\n"));
1351 regcache::dump (ui_file
*file
, enum regcache_dump_what what_to_dump
)
1353 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
1355 int footnote_nr
= 0;
1356 int footnote_register_size
= 0;
1357 int footnote_register_offset
= 0;
1358 int footnote_register_type_name_null
= 0;
1359 long register_offset
= 0;
1362 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1363 m_descr
->nr_raw_registers
);
1364 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1365 m_descr
->nr_cooked_registers
);
1366 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1367 m_descr
->sizeof_raw_registers
);
1368 fprintf_unfiltered (file
, "sizeof_raw_register_status %ld\n",
1369 m_descr
->sizeof_raw_register_status
);
1370 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
1371 gdbarch_num_regs (gdbarch
));
1372 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
1373 gdbarch_num_pseudo_regs (gdbarch
));
1376 gdb_assert (m_descr
->nr_cooked_registers
1377 == (gdbarch_num_regs (gdbarch
)
1378 + gdbarch_num_pseudo_regs (gdbarch
)));
1380 for (regnum
= -1; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
1384 fprintf_unfiltered (file
, " %-10s", "Name");
1387 const char *p
= gdbarch_register_name (gdbarch
, regnum
);
1391 else if (p
[0] == '\0')
1393 fprintf_unfiltered (file
, " %-10s", p
);
1398 fprintf_unfiltered (file
, " %4s", "Nr");
1400 fprintf_unfiltered (file
, " %4d", regnum
);
1402 /* Relative number. */
1404 fprintf_unfiltered (file
, " %4s", "Rel");
1405 else if (regnum
< gdbarch_num_regs (gdbarch
))
1406 fprintf_unfiltered (file
, " %4d", regnum
);
1408 fprintf_unfiltered (file
, " %4d",
1409 (regnum
- gdbarch_num_regs (gdbarch
)));
1413 fprintf_unfiltered (file
, " %6s ", "Offset");
1416 fprintf_unfiltered (file
, " %6ld",
1417 m_descr
->register_offset
[regnum
]);
1418 if (register_offset
!= m_descr
->register_offset
[regnum
]
1420 && (m_descr
->register_offset
[regnum
]
1421 != (m_descr
->register_offset
[regnum
- 1]
1422 + m_descr
->sizeof_register
[regnum
- 1])))
1425 if (!footnote_register_offset
)
1426 footnote_register_offset
= ++footnote_nr
;
1427 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1430 fprintf_unfiltered (file
, " ");
1431 register_offset
= (m_descr
->register_offset
[regnum
]
1432 + m_descr
->sizeof_register
[regnum
]);
1437 fprintf_unfiltered (file
, " %5s ", "Size");
1439 fprintf_unfiltered (file
, " %5ld", m_descr
->sizeof_register
[regnum
]);
1444 std::string name_holder
;
1450 static const char blt
[] = "builtin_type";
1452 t
= TYPE_NAME (register_type (arch (), regnum
));
1455 if (!footnote_register_type_name_null
)
1456 footnote_register_type_name_null
= ++footnote_nr
;
1457 name_holder
= string_printf ("*%d",
1458 footnote_register_type_name_null
);
1459 t
= name_holder
.c_str ();
1461 /* Chop a leading builtin_type. */
1462 if (startswith (t
, blt
))
1465 fprintf_unfiltered (file
, " %-15s", t
);
1468 /* Leading space always present. */
1469 fprintf_unfiltered (file
, " ");
1472 if (what_to_dump
== regcache_dump_raw
)
1475 fprintf_unfiltered (file
, "Raw value");
1476 else if (regnum
>= m_descr
->nr_raw_registers
)
1477 fprintf_unfiltered (file
, "<cooked>");
1478 else if (get_register_status (regnum
) == REG_UNKNOWN
)
1479 fprintf_unfiltered (file
, "<invalid>");
1480 else if (get_register_status (regnum
) == REG_UNAVAILABLE
)
1481 fprintf_unfiltered (file
, "<unavailable>");
1484 raw_update (regnum
);
1485 print_hex_chars (file
, register_buffer (regnum
),
1486 m_descr
->sizeof_register
[regnum
],
1487 gdbarch_byte_order (gdbarch
), true);
1491 /* Value, cooked. */
1492 if (what_to_dump
== regcache_dump_cooked
)
1495 fprintf_unfiltered (file
, "Cooked value");
1498 const gdb_byte
*buf
= NULL
;
1499 enum register_status status
;
1500 struct value
*value
= NULL
;
1502 if (regnum
< m_descr
->nr_raw_registers
)
1504 raw_update (regnum
);
1505 status
= get_register_status (regnum
);
1506 buf
= register_buffer (regnum
);
1510 value
= cooked_read_value (regnum
);
1512 if (!value_optimized_out (value
)
1513 && value_entirely_available (value
))
1516 buf
= value_contents_all (value
);
1519 status
= REG_UNAVAILABLE
;
1522 if (status
== REG_UNKNOWN
)
1523 fprintf_unfiltered (file
, "<invalid>");
1524 else if (status
== REG_UNAVAILABLE
)
1525 fprintf_unfiltered (file
, "<unavailable>");
1527 print_hex_chars (file
, buf
,
1528 m_descr
->sizeof_register
[regnum
],
1529 gdbarch_byte_order (gdbarch
), true);
1533 release_value (value
);
1539 /* Group members. */
1540 if (what_to_dump
== regcache_dump_groups
)
1543 fprintf_unfiltered (file
, "Groups");
1546 const char *sep
= "";
1547 struct reggroup
*group
;
1549 for (group
= reggroup_next (gdbarch
, NULL
);
1551 group
= reggroup_next (gdbarch
, group
))
1553 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1555 fprintf_unfiltered (file
,
1556 "%s%s", sep
, reggroup_name (group
));
1563 /* Remote packet configuration. */
1564 if (what_to_dump
== regcache_dump_remote
)
1568 fprintf_unfiltered (file
, "Rmt Nr g/G Offset");
1570 else if (regnum
< m_descr
->nr_raw_registers
)
1574 if (remote_register_number_and_offset (arch (), regnum
,
1576 fprintf_unfiltered (file
, "%7d %11d", pnum
, poffset
);
1580 fprintf_unfiltered (file
, "\n");
1583 if (footnote_register_size
)
1584 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1585 footnote_register_size
);
1586 if (footnote_register_offset
)
1587 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1588 footnote_register_offset
);
1589 if (footnote_register_type_name_null
)
1590 fprintf_unfiltered (file
,
1591 "*%d: Register type's name NULL.\n",
1592 footnote_register_type_name_null
);
1596 regcache_print (const char *args
, enum regcache_dump_what what_to_dump
)
1599 get_current_regcache ()->dump (gdb_stdout
, what_to_dump
);
1604 if (!file
.open (args
, "w"))
1605 perror_with_name (_("maintenance print architecture"));
1606 get_current_regcache ()->dump (&file
, what_to_dump
);
1611 maintenance_print_registers (const char *args
, int from_tty
)
1613 regcache_print (args
, regcache_dump_none
);
1617 maintenance_print_raw_registers (const char *args
, int from_tty
)
1619 regcache_print (args
, regcache_dump_raw
);
1623 maintenance_print_cooked_registers (const char *args
, int from_tty
)
1625 regcache_print (args
, regcache_dump_cooked
);
1629 maintenance_print_register_groups (const char *args
, int from_tty
)
1631 regcache_print (args
, regcache_dump_groups
);
1635 maintenance_print_remote_registers (const char *args
, int from_tty
)
1637 regcache_print (args
, regcache_dump_remote
);
1641 #include "selftest.h"
1643 namespace selftests
{
1645 class regcache_access
: public regcache
1649 /* Return the number of elements in current_regcache. */
1652 current_regcache_size ()
1654 return std::distance (regcache::current_regcache
.begin (),
1655 regcache::current_regcache
.end ());
1660 current_regcache_test (void)
1662 /* It is empty at the start. */
1663 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1665 ptid_t
ptid1 (1), ptid2 (2), ptid3 (3);
1667 /* Get regcache from ptid1, a new regcache is added to
1668 current_regcache. */
1669 regcache
*regcache
= get_thread_arch_aspace_regcache (ptid1
,
1673 SELF_CHECK (regcache
!= NULL
);
1674 SELF_CHECK (regcache
->ptid () == ptid1
);
1675 SELF_CHECK (regcache_access::current_regcache_size () == 1);
1677 /* Get regcache from ptid2, a new regcache is added to
1678 current_regcache. */
1679 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1682 SELF_CHECK (regcache
!= NULL
);
1683 SELF_CHECK (regcache
->ptid () == ptid2
);
1684 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1686 /* Get regcache from ptid3, a new regcache is added to
1687 current_regcache. */
1688 regcache
= get_thread_arch_aspace_regcache (ptid3
,
1691 SELF_CHECK (regcache
!= NULL
);
1692 SELF_CHECK (regcache
->ptid () == ptid3
);
1693 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1695 /* Get regcache from ptid2 again, nothing is added to
1696 current_regcache. */
1697 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1700 SELF_CHECK (regcache
!= NULL
);
1701 SELF_CHECK (regcache
->ptid () == ptid2
);
1702 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1704 /* Mark ptid2 is changed, so regcache of ptid2 should be removed from
1705 current_regcache. */
1706 registers_changed_ptid (ptid2
);
1707 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1710 } // namespace selftests
1711 #endif /* GDB_SELF_TEST */
1714 _initialize_regcache (void)
1716 regcache_descr_handle
1717 = gdbarch_data_register_post_init (init_regcache_descr
);
1719 observer_attach_target_changed (regcache_observer_target_changed
);
1720 observer_attach_thread_ptid_changed (regcache::regcache_thread_ptid_changed
);
1722 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1723 _("Force gdb to flush its register cache (maintainer command)"));
1725 add_cmd ("registers", class_maintenance
, maintenance_print_registers
,
1726 _("Print the internal register configuration.\n"
1727 "Takes an optional file parameter."), &maintenanceprintlist
);
1728 add_cmd ("raw-registers", class_maintenance
,
1729 maintenance_print_raw_registers
,
1730 _("Print the internal register configuration "
1731 "including raw values.\n"
1732 "Takes an optional file parameter."), &maintenanceprintlist
);
1733 add_cmd ("cooked-registers", class_maintenance
,
1734 maintenance_print_cooked_registers
,
1735 _("Print the internal register configuration "
1736 "including cooked values.\n"
1737 "Takes an optional file parameter."), &maintenanceprintlist
);
1738 add_cmd ("register-groups", class_maintenance
,
1739 maintenance_print_register_groups
,
1740 _("Print the internal register configuration "
1741 "including each register's group.\n"
1742 "Takes an optional file parameter."),
1743 &maintenanceprintlist
);
1744 add_cmd ("remote-registers", class_maintenance
,
1745 maintenance_print_remote_registers
, _("\
1746 Print the internal register configuration including each register's\n\
1747 remote register number and buffer offset in the g/G packets.\n\
1748 Takes an optional file parameter."),
1749 &maintenanceprintlist
);
1752 selftests::register_test ("current_regcache", selftests::current_regcache_test
);