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 ();
245 do_regcache_xfree (void *data
)
247 delete (struct regcache
*) data
;
251 make_cleanup_regcache_xfree (struct regcache
*regcache
)
253 return make_cleanup (do_regcache_xfree
, regcache
);
256 /* Cleanup routines for invalidating a register. */
258 struct register_to_invalidate
260 struct regcache
*regcache
;
265 do_regcache_invalidate (void *data
)
267 struct register_to_invalidate
*reg
= (struct register_to_invalidate
*) data
;
269 regcache_invalidate (reg
->regcache
, reg
->regnum
);
272 static struct cleanup
*
273 make_cleanup_regcache_invalidate (struct regcache
*regcache
, int regnum
)
275 struct register_to_invalidate
* reg
= XNEW (struct register_to_invalidate
);
277 reg
->regcache
= regcache
;
278 reg
->regnum
= regnum
;
279 return make_cleanup_dtor (do_regcache_invalidate
, (void *) reg
, xfree
);
282 /* Return REGCACHE's architecture. */
285 get_regcache_arch (const struct regcache
*regcache
)
287 return regcache
->arch ();
290 struct address_space
*
291 get_regcache_aspace (const struct regcache
*regcache
)
293 return regcache
->aspace ();
296 /* Return a pointer to register REGNUM's buffer cache. */
299 regcache::register_buffer (int regnum
) const
301 return m_registers
+ m_descr
->register_offset
[regnum
];
305 regcache_save (struct regcache
*regcache
,
306 regcache_cooked_read_ftype
*cooked_read
, void *src
)
308 regcache
->save (cooked_read
, src
);
312 regcache::save (regcache_cooked_read_ftype
*cooked_read
,
315 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
318 /* The DST should be `read-only', if it wasn't then the save would
319 end up trying to write the register values back out to the
321 gdb_assert (m_readonly_p
);
322 /* Clear the dest. */
323 memset (m_registers
, 0, m_descr
->sizeof_cooked_registers
);
324 memset (m_register_status
, 0, m_descr
->sizeof_cooked_register_status
);
325 /* Copy over any registers (identified by their membership in the
326 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
327 gdbarch_num_pseudo_regs) range is checked since some architectures need
328 to save/restore `cooked' registers that live in memory. */
329 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
331 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
333 gdb_byte
*dst_buf
= register_buffer (regnum
);
334 enum register_status status
= cooked_read (src
, regnum
, dst_buf
);
336 gdb_assert (status
!= REG_UNKNOWN
);
338 if (status
!= REG_VALID
)
339 memset (dst_buf
, 0, register_size (gdbarch
, regnum
));
341 m_register_status
[regnum
] = status
;
347 regcache::restore (struct regcache
*src
)
349 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
352 /* The dst had better not be read-only. If it is, the `restore'
353 doesn't make much sense. */
354 gdb_assert (!m_readonly_p
);
355 gdb_assert (src
->m_readonly_p
);
356 /* Copy over any registers, being careful to only restore those that
357 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
358 + gdbarch_num_pseudo_regs) range is checked since some architectures need
359 to save/restore `cooked' registers that live in memory. */
360 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
362 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
364 if (src
->m_register_status
[regnum
] == REG_VALID
)
365 cooked_write (regnum
, src
->register_buffer (regnum
));
371 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
373 gdb_assert (src
!= NULL
&& dst
!= NULL
);
374 gdb_assert (src
->m_descr
->gdbarch
== dst
->m_descr
->gdbarch
);
375 gdb_assert (src
!= dst
);
376 gdb_assert (src
->m_readonly_p
&& !dst
->m_readonly_p
);
382 regcache_dup (struct regcache
*src
)
384 return new regcache (regcache::readonly
, *src
);
388 regcache_register_status (const struct regcache
*regcache
, int regnum
)
390 gdb_assert (regcache
!= NULL
);
391 return regcache
->get_register_status (regnum
);
395 regcache::get_register_status (int regnum
) const
397 gdb_assert (regnum
>= 0);
399 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
401 gdb_assert (regnum
< m_descr
->nr_raw_registers
);
403 return (enum register_status
) m_register_status
[regnum
];
407 regcache_invalidate (struct regcache
*regcache
, int regnum
)
409 gdb_assert (regcache
!= NULL
);
410 regcache
->invalidate (regnum
);
414 regcache::invalidate (int regnum
)
416 gdb_assert (regnum
>= 0);
417 gdb_assert (!m_readonly_p
);
418 gdb_assert (regnum
< m_descr
->nr_raw_registers
);
419 m_register_status
[regnum
] = REG_UNKNOWN
;
422 /* Global structure containing the current regcache. */
424 /* NOTE: this is a write-through cache. There is no "dirty" bit for
425 recording if the register values have been changed (eg. by the
426 user). Therefore all registers must be written back to the
427 target when appropriate. */
428 std::forward_list
<regcache
*> regcache::current_regcache
;
431 get_thread_arch_aspace_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
,
432 struct address_space
*aspace
)
434 for (const auto ®cache
: regcache::current_regcache
)
435 if (ptid_equal (regcache
->ptid (), ptid
) && regcache
->arch () == gdbarch
)
438 regcache
*new_regcache
= new regcache (gdbarch
, aspace
, false);
440 regcache::current_regcache
.push_front (new_regcache
);
441 new_regcache
->set_ptid (ptid
);
447 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
449 struct address_space
*aspace
;
451 /* For the benefit of "maint print registers" & co when debugging an
452 executable, allow dumping the regcache even when there is no
453 thread selected (target_thread_address_space internal-errors if
454 no address space is found). Note that normal user commands will
455 fail higher up on the call stack due to no
456 target_has_registers. */
457 aspace
= (ptid_equal (null_ptid
, ptid
)
459 : target_thread_address_space (ptid
));
461 return get_thread_arch_aspace_regcache (ptid
, gdbarch
, aspace
);
464 static ptid_t current_thread_ptid
;
465 static struct gdbarch
*current_thread_arch
;
468 get_thread_regcache (ptid_t ptid
)
470 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
472 current_thread_ptid
= ptid
;
473 current_thread_arch
= target_thread_architecture (ptid
);
476 return get_thread_arch_regcache (ptid
, current_thread_arch
);
480 get_current_regcache (void)
482 return get_thread_regcache (inferior_ptid
);
485 /* See common/common-regcache.h. */
488 get_thread_regcache_for_ptid (ptid_t ptid
)
490 return get_thread_regcache (ptid
);
493 /* Observer for the target_changed event. */
496 regcache_observer_target_changed (struct target_ops
*target
)
498 registers_changed ();
501 /* Update global variables old ptids to hold NEW_PTID if they were
504 regcache::regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
506 for (auto ®cache
: regcache::current_regcache
)
508 if (ptid_equal (regcache
->ptid (), old_ptid
))
509 regcache
->set_ptid (new_ptid
);
513 /* Low level examining and depositing of registers.
515 The caller is responsible for making sure that the inferior is
516 stopped before calling the fetching routines, or it will get
517 garbage. (a change from GDB version 3, in which the caller got the
518 value from the last stop). */
520 /* REGISTERS_CHANGED ()
522 Indicate that registers may have changed, so invalidate the cache. */
525 registers_changed_ptid (ptid_t ptid
)
527 for (auto oit
= regcache::current_regcache
.before_begin (),
528 it
= std::next (oit
);
529 it
!= regcache::current_regcache
.end ();
532 if (ptid_match ((*it
)->ptid (), ptid
))
535 it
= regcache::current_regcache
.erase_after (oit
);
541 if (ptid_match (current_thread_ptid
, ptid
))
543 current_thread_ptid
= null_ptid
;
544 current_thread_arch
= NULL
;
547 if (ptid_match (inferior_ptid
, ptid
))
549 /* We just deleted the regcache of the current thread. Need to
550 forget about any frames we have cached, too. */
551 reinit_frame_cache ();
556 registers_changed (void)
558 registers_changed_ptid (minus_one_ptid
);
560 /* Force cleanup of any alloca areas if using C alloca instead of
561 a builtin alloca. This particular call is used to clean up
562 areas allocated by low level target code which may build up
563 during lengthy interactions between gdb and the target before
564 gdb gives control to the user (ie watchpoints). */
569 regcache_raw_update (struct regcache
*regcache
, int regnum
)
571 gdb_assert (regcache
!= NULL
);
573 regcache
->raw_update (regnum
);
577 regcache::raw_update (int regnum
)
579 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
581 /* Make certain that the register cache is up-to-date with respect
582 to the current thread. This switching shouldn't be necessary
583 only there is still only one target side register cache. Sigh!
584 On the bright side, at least there is a regcache object. */
586 if (!m_readonly_p
&& get_register_status (regnum
) == REG_UNKNOWN
)
588 target_fetch_registers (this, regnum
);
590 /* A number of targets can't access the whole set of raw
591 registers (because the debug API provides no means to get at
593 if (m_register_status
[regnum
] == REG_UNKNOWN
)
594 m_register_status
[regnum
] = REG_UNAVAILABLE
;
599 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
601 return regcache
->raw_read (regnum
, buf
);
605 regcache::raw_read (int regnum
, gdb_byte
*buf
)
607 gdb_assert (buf
!= NULL
);
610 if (m_register_status
[regnum
] != REG_VALID
)
611 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
613 memcpy (buf
, register_buffer (regnum
),
614 m_descr
->sizeof_register
[regnum
]);
616 return (enum register_status
) m_register_status
[regnum
];
620 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
622 gdb_assert (regcache
!= NULL
);
623 return regcache
->raw_read (regnum
, val
);
626 template<typename T
, typename
>
628 regcache::raw_read (int regnum
, T
*val
)
631 enum register_status status
;
633 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
634 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
635 status
= raw_read (regnum
, buf
);
636 if (status
== REG_VALID
)
637 *val
= extract_integer
<T
> (buf
,
638 m_descr
->sizeof_register
[regnum
],
639 gdbarch_byte_order (m_descr
->gdbarch
));
646 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
649 gdb_assert (regcache
!= NULL
);
650 return regcache
->raw_read (regnum
, val
);
654 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
656 gdb_assert (regcache
!= NULL
);
657 regcache
->raw_write (regnum
, val
);
660 template<typename T
, typename
>
662 regcache::raw_write (int regnum
, T val
)
666 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_raw_registers
);
667 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
668 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
669 gdbarch_byte_order (m_descr
->gdbarch
), val
);
670 raw_write (regnum
, buf
);
674 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
677 gdb_assert (regcache
!= NULL
);
678 regcache
->raw_write (regnum
, val
);
682 regcache_raw_get_signed (struct regcache
*regcache
, int regnum
)
685 enum register_status status
;
687 status
= regcache_raw_read_signed (regcache
, regnum
, &value
);
688 if (status
== REG_UNAVAILABLE
)
689 throw_error (NOT_AVAILABLE_ERROR
,
690 _("Register %d is not available"), regnum
);
695 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
697 return regcache
->cooked_read (regnum
, buf
);
701 regcache::cooked_read (int regnum
, gdb_byte
*buf
)
703 gdb_assert (regnum
>= 0);
704 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
705 if (regnum
< m_descr
->nr_raw_registers
)
706 return raw_read (regnum
, buf
);
707 else if (m_readonly_p
708 && m_register_status
[regnum
] != REG_UNKNOWN
)
710 /* Read-only register cache, perhaps the cooked value was
712 if (m_register_status
[regnum
] == REG_VALID
)
713 memcpy (buf
, register_buffer (regnum
),
714 m_descr
->sizeof_register
[regnum
]);
716 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
718 return (enum register_status
) m_register_status
[regnum
];
720 else if (gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
722 struct value
*mark
, *computed
;
723 enum register_status result
= REG_VALID
;
725 mark
= value_mark ();
727 computed
= gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
729 if (value_entirely_available (computed
))
730 memcpy (buf
, value_contents_raw (computed
),
731 m_descr
->sizeof_register
[regnum
]);
734 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
735 result
= REG_UNAVAILABLE
;
738 value_free_to_mark (mark
);
743 return gdbarch_pseudo_register_read (m_descr
->gdbarch
, this,
748 regcache_cooked_read_value (struct regcache
*regcache
, int regnum
)
750 return regcache
->cooked_read_value (regnum
);
754 regcache::cooked_read_value (int regnum
)
756 gdb_assert (regnum
>= 0);
757 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
759 if (regnum
< m_descr
->nr_raw_registers
760 || (m_readonly_p
&& m_register_status
[regnum
] != REG_UNKNOWN
)
761 || !gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
763 struct value
*result
;
765 result
= allocate_value (register_type (m_descr
->gdbarch
, regnum
));
766 VALUE_LVAL (result
) = lval_register
;
767 VALUE_REGNUM (result
) = regnum
;
769 /* It is more efficient in general to do this delegation in this
770 direction than in the other one, even though the value-based
772 if (cooked_read (regnum
,
773 value_contents_raw (result
)) == REG_UNAVAILABLE
)
774 mark_value_bytes_unavailable (result
, 0,
775 TYPE_LENGTH (value_type (result
)));
780 return gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
785 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
788 gdb_assert (regcache
!= NULL
);
789 return regcache
->cooked_read (regnum
, val
);
792 template<typename T
, typename
>
794 regcache::cooked_read (int regnum
, T
*val
)
796 enum register_status status
;
799 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
800 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
801 status
= cooked_read (regnum
, buf
);
802 if (status
== REG_VALID
)
803 *val
= extract_integer
<T
> (buf
, m_descr
->sizeof_register
[regnum
],
804 gdbarch_byte_order (m_descr
->gdbarch
));
811 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
814 gdb_assert (regcache
!= NULL
);
815 return regcache
->cooked_read (regnum
, val
);
819 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
822 gdb_assert (regcache
!= NULL
);
823 regcache
->cooked_write (regnum
, val
);
826 template<typename T
, typename
>
828 regcache::cooked_write (int regnum
, T val
)
832 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
833 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
834 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
835 gdbarch_byte_order (m_descr
->gdbarch
), val
);
836 cooked_write (regnum
, buf
);
840 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
843 gdb_assert (regcache
!= NULL
);
844 regcache
->cooked_write (regnum
, val
);
847 /* See regcache.h. */
850 regcache_raw_set_cached_value (struct regcache
*regcache
, int regnum
,
853 regcache
->raw_set_cached_value (regnum
, buf
);
857 regcache::raw_set_cached_value (int regnum
, const gdb_byte
*buf
)
859 memcpy (register_buffer (regnum
), buf
,
860 m_descr
->sizeof_register
[regnum
]);
861 m_register_status
[regnum
] = REG_VALID
;
865 regcache_raw_write (struct regcache
*regcache
, int regnum
,
868 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
869 regcache
->raw_write (regnum
, buf
);
873 regcache::raw_write (int regnum
, const gdb_byte
*buf
)
875 struct cleanup
*old_chain
;
877 gdb_assert (buf
!= NULL
);
878 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
879 gdb_assert (!m_readonly_p
);
881 /* On the sparc, writing %g0 is a no-op, so we don't even want to
882 change the registers array if something writes to this register. */
883 if (gdbarch_cannot_store_register (arch (), regnum
))
886 /* If we have a valid copy of the register, and new value == old
887 value, then don't bother doing the actual store. */
888 if (get_register_status (regnum
) == REG_VALID
889 && (memcmp (register_buffer (regnum
), buf
,
890 m_descr
->sizeof_register
[regnum
]) == 0))
893 target_prepare_to_store (this);
894 raw_set_cached_value (regnum
, buf
);
896 /* Register a cleanup function for invalidating the register after it is
897 written, in case of a failure. */
898 old_chain
= make_cleanup_regcache_invalidate (this, regnum
);
900 target_store_registers (this, regnum
);
902 /* The target did not throw an error so we can discard invalidating the
903 register and restore the cleanup chain to what it was. */
904 discard_cleanups (old_chain
);
908 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
911 regcache
->cooked_write (regnum
, buf
);
915 regcache::cooked_write (int regnum
, const gdb_byte
*buf
)
917 gdb_assert (regnum
>= 0);
918 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
919 if (regnum
< m_descr
->nr_raw_registers
)
920 raw_write (regnum
, buf
);
922 gdbarch_pseudo_register_write (m_descr
->gdbarch
, this,
926 /* Perform a partial register transfer using a read, modify, write
929 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
931 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
935 regcache::xfer_part (int regnum
, int offset
, int len
, void *in
,
937 enum register_status (*read
) (struct regcache
*regcache
,
940 void (*write
) (struct regcache
*regcache
, int regnum
,
941 const gdb_byte
*buf
))
943 struct gdbarch
*gdbarch
= arch ();
944 gdb_byte
*reg
= (gdb_byte
*) alloca (register_size (gdbarch
, regnum
));
946 gdb_assert (offset
>= 0 && offset
<= m_descr
->sizeof_register
[regnum
]);
947 gdb_assert (len
>= 0 && offset
+ len
<= m_descr
->sizeof_register
[regnum
]);
948 /* Something to do? */
949 if (offset
+ len
== 0)
951 /* Read (when needed) ... */
954 || offset
+ len
< m_descr
->sizeof_register
[regnum
])
956 enum register_status status
;
958 gdb_assert (read
!= NULL
);
959 status
= read (this, regnum
, reg
);
960 if (status
!= REG_VALID
)
965 memcpy (in
, reg
+ offset
, len
);
967 memcpy (reg
+ offset
, out
, len
);
968 /* ... write (when needed). */
971 gdb_assert (write
!= NULL
);
972 write (this, regnum
, reg
);
979 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
980 int offset
, int len
, gdb_byte
*buf
)
982 return regcache
->raw_read_part (regnum
, offset
, len
, buf
);
986 regcache::raw_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
988 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
989 return xfer_part (regnum
, offset
, len
, buf
, NULL
,
990 regcache_raw_read
, regcache_raw_write
);
994 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
995 int offset
, int len
, const gdb_byte
*buf
)
997 regcache
->raw_write_part (regnum
, offset
, len
, buf
);
1001 regcache::raw_write_part (int regnum
, int offset
, int len
,
1002 const gdb_byte
*buf
)
1004 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1005 xfer_part (regnum
, offset
, len
, NULL
, buf
, regcache_raw_read
,
1006 regcache_raw_write
);
1009 enum register_status
1010 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
1011 int offset
, int len
, gdb_byte
*buf
)
1013 return regcache
->cooked_read_part (regnum
, offset
, len
, buf
);
1017 enum register_status
1018 regcache::cooked_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
1020 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1021 return xfer_part (regnum
, offset
, len
, buf
, NULL
,
1022 regcache_cooked_read
, regcache_cooked_write
);
1026 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
1027 int offset
, int len
, const gdb_byte
*buf
)
1029 regcache
->cooked_write_part (regnum
, offset
, len
, buf
);
1033 regcache::cooked_write_part (int regnum
, int offset
, int len
,
1034 const gdb_byte
*buf
)
1036 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1037 xfer_part (regnum
, offset
, len
, NULL
, buf
,
1038 regcache_cooked_read
, regcache_cooked_write
);
1041 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
1044 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
1046 gdb_assert (regcache
!= NULL
);
1047 regcache
->raw_supply (regnum
, buf
);
1051 regcache::raw_supply (int regnum
, const void *buf
)
1056 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1057 gdb_assert (!m_readonly_p
);
1059 regbuf
= register_buffer (regnum
);
1060 size
= m_descr
->sizeof_register
[regnum
];
1064 memcpy (regbuf
, buf
, size
);
1065 m_register_status
[regnum
] = REG_VALID
;
1069 /* This memset not strictly necessary, but better than garbage
1070 in case the register value manages to escape somewhere (due
1071 to a bug, no less). */
1072 memset (regbuf
, 0, size
);
1073 m_register_status
[regnum
] = REG_UNAVAILABLE
;
1077 /* Supply register REGNUM to REGCACHE. Value to supply is an integer stored at
1078 address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED. If
1079 the register size is greater than ADDR_LEN, then the integer will be sign or
1080 zero extended. If the register size is smaller than the integer, then the
1081 most significant bytes of the integer will be truncated. */
1084 regcache::raw_supply_integer (int regnum
, const gdb_byte
*addr
, int addr_len
,
1087 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1091 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1092 gdb_assert (!m_readonly_p
);
1094 regbuf
= register_buffer (regnum
);
1095 regsize
= m_descr
->sizeof_register
[regnum
];
1097 copy_integer_to_size (regbuf
, regsize
, addr
, addr_len
, is_signed
,
1099 m_register_status
[regnum
] = REG_VALID
;
1102 /* Supply register REGNUM with zeroed value to REGCACHE. This is not the same
1103 as calling raw_supply with NULL (which will set the state to
1107 regcache::raw_supply_zeroed (int regnum
)
1112 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1113 gdb_assert (!m_readonly_p
);
1115 regbuf
= register_buffer (regnum
);
1116 size
= m_descr
->sizeof_register
[regnum
];
1118 memset (regbuf
, 0, size
);
1119 m_register_status
[regnum
] = REG_VALID
;
1122 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1125 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
1127 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
1128 regcache
->raw_collect (regnum
, buf
);
1132 regcache::raw_collect (int regnum
, void *buf
) const
1137 gdb_assert (buf
!= NULL
);
1138 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1140 regbuf
= register_buffer (regnum
);
1141 size
= m_descr
->sizeof_register
[regnum
];
1142 memcpy (buf
, regbuf
, size
);
1145 /* Transfer a single or all registers belonging to a certain register
1146 set to or from a buffer. This is the main worker function for
1147 regcache_supply_regset and regcache_collect_regset. */
1149 /* Collect register REGNUM from REGCACHE. Store collected value as an integer
1150 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
1151 If ADDR_LEN is greater than the register size, then the integer will be sign
1152 or zero extended. If ADDR_LEN is smaller than the register size, then the
1153 most significant bytes of the integer will be truncated. */
1156 regcache::raw_collect_integer (int regnum
, gdb_byte
*addr
, int addr_len
,
1157 bool is_signed
) const
1159 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1160 const gdb_byte
*regbuf
;
1163 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1165 regbuf
= register_buffer (regnum
);
1166 regsize
= m_descr
->sizeof_register
[regnum
];
1168 copy_integer_to_size (addr
, addr_len
, regbuf
, regsize
, is_signed
,
1173 regcache::transfer_regset (const struct regset
*regset
,
1174 struct regcache
*out_regcache
,
1175 int regnum
, const void *in_buf
,
1176 void *out_buf
, size_t size
) const
1178 const struct regcache_map_entry
*map
;
1179 int offs
= 0, count
;
1181 for (map
= (const struct regcache_map_entry
*) regset
->regmap
;
1182 (count
= map
->count
) != 0;
1185 int regno
= map
->regno
;
1186 int slot_size
= map
->size
;
1188 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1189 slot_size
= m_descr
->sizeof_register
[regno
];
1191 if (regno
== REGCACHE_MAP_SKIP
1193 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1194 offs
+= count
* slot_size
;
1196 else if (regnum
== -1)
1197 for (; count
--; regno
++, offs
+= slot_size
)
1199 if (offs
+ slot_size
> size
)
1203 raw_collect (regno
, (gdb_byte
*) out_buf
+ offs
);
1205 out_regcache
->raw_supply (regno
, in_buf
1206 ? (const gdb_byte
*) in_buf
+ offs
1211 /* Transfer a single register and return. */
1212 offs
+= (regnum
- regno
) * slot_size
;
1213 if (offs
+ slot_size
> size
)
1217 raw_collect (regnum
, (gdb_byte
*) out_buf
+ offs
);
1219 out_regcache
->raw_supply (regnum
, in_buf
1220 ? (const gdb_byte
*) in_buf
+ offs
1227 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1228 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1229 If BUF is NULL, set the register(s) to "unavailable" status. */
1232 regcache_supply_regset (const struct regset
*regset
,
1233 struct regcache
*regcache
,
1234 int regnum
, const void *buf
, size_t size
)
1236 regcache
->supply_regset (regset
, regnum
, buf
, size
);
1240 regcache::supply_regset (const struct regset
*regset
,
1241 int regnum
, const void *buf
, size_t size
)
1243 transfer_regset (regset
, this, regnum
, buf
, NULL
, size
);
1246 /* Collect register REGNUM from REGCACHE to BUF, using the register
1247 map in REGSET. If REGNUM is -1, do this for all registers in
1251 regcache_collect_regset (const struct regset
*regset
,
1252 const struct regcache
*regcache
,
1253 int regnum
, void *buf
, size_t size
)
1255 regcache
->collect_regset (regset
, regnum
, buf
, size
);
1259 regcache::collect_regset (const struct regset
*regset
,
1260 int regnum
, void *buf
, size_t size
) const
1262 transfer_regset (regset
, NULL
, regnum
, NULL
, buf
, size
);
1266 /* Special handling for register PC. */
1269 regcache_read_pc (struct regcache
*regcache
)
1271 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1275 if (gdbarch_read_pc_p (gdbarch
))
1276 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1277 /* Else use per-frame method on get_current_frame. */
1278 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1282 if (regcache_cooked_read_unsigned (regcache
,
1283 gdbarch_pc_regnum (gdbarch
),
1284 &raw_val
) == REG_UNAVAILABLE
)
1285 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1287 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1290 internal_error (__FILE__
, __LINE__
,
1291 _("regcache_read_pc: Unable to find PC"));
1296 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1298 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1300 if (gdbarch_write_pc_p (gdbarch
))
1301 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1302 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1303 regcache_cooked_write_unsigned (regcache
,
1304 gdbarch_pc_regnum (gdbarch
), pc
);
1306 internal_error (__FILE__
, __LINE__
,
1307 _("regcache_write_pc: Unable to update PC"));
1309 /* Writing the PC (for instance, from "load") invalidates the
1311 reinit_frame_cache ();
1315 regcache::debug_print_register (const char *func
, int regno
)
1317 struct gdbarch
*gdbarch
= arch ();
1319 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1320 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
1321 && gdbarch_register_name (gdbarch
, regno
) != NULL
1322 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
1323 fprintf_unfiltered (gdb_stdlog
, "(%s)",
1324 gdbarch_register_name (gdbarch
, regno
));
1326 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1327 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
1329 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1330 int size
= register_size (gdbarch
, regno
);
1331 gdb_byte
*buf
= register_buffer (regno
);
1333 fprintf_unfiltered (gdb_stdlog
, " = ");
1334 for (int i
= 0; i
< size
; i
++)
1336 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1338 if (size
<= sizeof (LONGEST
))
1340 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
1342 fprintf_unfiltered (gdb_stdlog
, " %s %s",
1343 core_addr_to_string_nz (val
), plongest (val
));
1346 fprintf_unfiltered (gdb_stdlog
, "\n");
1350 reg_flush_command (char *command
, int from_tty
)
1352 /* Force-flush the register cache. */
1353 registers_changed ();
1355 printf_filtered (_("Register cache flushed.\n"));
1359 regcache::dump (ui_file
*file
, enum regcache_dump_what what_to_dump
)
1361 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1362 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
1364 int footnote_nr
= 0;
1365 int footnote_register_size
= 0;
1366 int footnote_register_offset
= 0;
1367 int footnote_register_type_name_null
= 0;
1368 long register_offset
= 0;
1371 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1372 m_descr
->nr_raw_registers
);
1373 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1374 m_descr
->nr_cooked_registers
);
1375 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1376 m_descr
->sizeof_raw_registers
);
1377 fprintf_unfiltered (file
, "sizeof_raw_register_status %ld\n",
1378 m_descr
->sizeof_raw_register_status
);
1379 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
1380 gdbarch_num_regs (gdbarch
));
1381 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
1382 gdbarch_num_pseudo_regs (gdbarch
));
1385 gdb_assert (m_descr
->nr_cooked_registers
1386 == (gdbarch_num_regs (gdbarch
)
1387 + gdbarch_num_pseudo_regs (gdbarch
)));
1389 for (regnum
= -1; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
1393 fprintf_unfiltered (file
, " %-10s", "Name");
1396 const char *p
= gdbarch_register_name (gdbarch
, regnum
);
1400 else if (p
[0] == '\0')
1402 fprintf_unfiltered (file
, " %-10s", p
);
1407 fprintf_unfiltered (file
, " %4s", "Nr");
1409 fprintf_unfiltered (file
, " %4d", regnum
);
1411 /* Relative number. */
1413 fprintf_unfiltered (file
, " %4s", "Rel");
1414 else if (regnum
< gdbarch_num_regs (gdbarch
))
1415 fprintf_unfiltered (file
, " %4d", regnum
);
1417 fprintf_unfiltered (file
, " %4d",
1418 (regnum
- gdbarch_num_regs (gdbarch
)));
1422 fprintf_unfiltered (file
, " %6s ", "Offset");
1425 fprintf_unfiltered (file
, " %6ld",
1426 m_descr
->register_offset
[regnum
]);
1427 if (register_offset
!= m_descr
->register_offset
[regnum
]
1429 && (m_descr
->register_offset
[regnum
]
1430 != (m_descr
->register_offset
[regnum
- 1]
1431 + m_descr
->sizeof_register
[regnum
- 1])))
1434 if (!footnote_register_offset
)
1435 footnote_register_offset
= ++footnote_nr
;
1436 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1439 fprintf_unfiltered (file
, " ");
1440 register_offset
= (m_descr
->register_offset
[regnum
]
1441 + m_descr
->sizeof_register
[regnum
]);
1446 fprintf_unfiltered (file
, " %5s ", "Size");
1448 fprintf_unfiltered (file
, " %5ld", m_descr
->sizeof_register
[regnum
]);
1458 static const char blt
[] = "builtin_type";
1460 t
= TYPE_NAME (register_type (arch (), regnum
));
1465 if (!footnote_register_type_name_null
)
1466 footnote_register_type_name_null
= ++footnote_nr
;
1467 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1468 make_cleanup (xfree
, n
);
1471 /* Chop a leading builtin_type. */
1472 if (startswith (t
, blt
))
1475 fprintf_unfiltered (file
, " %-15s", t
);
1478 /* Leading space always present. */
1479 fprintf_unfiltered (file
, " ");
1482 if (what_to_dump
== regcache_dump_raw
)
1485 fprintf_unfiltered (file
, "Raw value");
1486 else if (regnum
>= m_descr
->nr_raw_registers
)
1487 fprintf_unfiltered (file
, "<cooked>");
1488 else if (get_register_status (regnum
) == REG_UNKNOWN
)
1489 fprintf_unfiltered (file
, "<invalid>");
1490 else if (get_register_status (regnum
) == REG_UNAVAILABLE
)
1491 fprintf_unfiltered (file
, "<unavailable>");
1494 raw_update (regnum
);
1495 print_hex_chars (file
, register_buffer (regnum
),
1496 m_descr
->sizeof_register
[regnum
],
1497 gdbarch_byte_order (gdbarch
), true);
1501 /* Value, cooked. */
1502 if (what_to_dump
== regcache_dump_cooked
)
1505 fprintf_unfiltered (file
, "Cooked value");
1508 const gdb_byte
*buf
= NULL
;
1509 enum register_status status
;
1510 struct value
*value
= NULL
;
1512 if (regnum
< m_descr
->nr_raw_registers
)
1514 raw_update (regnum
);
1515 status
= get_register_status (regnum
);
1516 buf
= register_buffer (regnum
);
1520 value
= cooked_read_value (regnum
);
1522 if (!value_optimized_out (value
)
1523 && value_entirely_available (value
))
1526 buf
= value_contents_all (value
);
1529 status
= REG_UNAVAILABLE
;
1532 if (status
== REG_UNKNOWN
)
1533 fprintf_unfiltered (file
, "<invalid>");
1534 else if (status
== REG_UNAVAILABLE
)
1535 fprintf_unfiltered (file
, "<unavailable>");
1537 print_hex_chars (file
, buf
,
1538 m_descr
->sizeof_register
[regnum
],
1539 gdbarch_byte_order (gdbarch
), true);
1543 release_value (value
);
1549 /* Group members. */
1550 if (what_to_dump
== regcache_dump_groups
)
1553 fprintf_unfiltered (file
, "Groups");
1556 const char *sep
= "";
1557 struct reggroup
*group
;
1559 for (group
= reggroup_next (gdbarch
, NULL
);
1561 group
= reggroup_next (gdbarch
, group
))
1563 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1565 fprintf_unfiltered (file
,
1566 "%s%s", sep
, reggroup_name (group
));
1573 /* Remote packet configuration. */
1574 if (what_to_dump
== regcache_dump_remote
)
1578 fprintf_unfiltered (file
, "Rmt Nr g/G Offset");
1580 else if (regnum
< m_descr
->nr_raw_registers
)
1584 if (remote_register_number_and_offset (arch (), regnum
,
1586 fprintf_unfiltered (file
, "%7d %11d", pnum
, poffset
);
1590 fprintf_unfiltered (file
, "\n");
1593 if (footnote_register_size
)
1594 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1595 footnote_register_size
);
1596 if (footnote_register_offset
)
1597 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1598 footnote_register_offset
);
1599 if (footnote_register_type_name_null
)
1600 fprintf_unfiltered (file
,
1601 "*%d: Register type's name NULL.\n",
1602 footnote_register_type_name_null
);
1603 do_cleanups (cleanups
);
1607 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1610 get_current_regcache ()->dump (gdb_stdout
, what_to_dump
);
1615 if (!file
.open (args
, "w"))
1616 perror_with_name (_("maintenance print architecture"));
1617 get_current_regcache ()->dump (&file
, what_to_dump
);
1622 maintenance_print_registers (char *args
, int from_tty
)
1624 regcache_print (args
, regcache_dump_none
);
1628 maintenance_print_raw_registers (char *args
, int from_tty
)
1630 regcache_print (args
, regcache_dump_raw
);
1634 maintenance_print_cooked_registers (char *args
, int from_tty
)
1636 regcache_print (args
, regcache_dump_cooked
);
1640 maintenance_print_register_groups (char *args
, int from_tty
)
1642 regcache_print (args
, regcache_dump_groups
);
1646 maintenance_print_remote_registers (char *args
, int from_tty
)
1648 regcache_print (args
, regcache_dump_remote
);
1652 #include "selftest.h"
1654 namespace selftests
{
1656 class regcache_access
: public regcache
1660 /* Return the number of elements in current_regcache. */
1663 current_regcache_size ()
1665 return std::distance (regcache::current_regcache
.begin (),
1666 regcache::current_regcache
.end ());
1671 current_regcache_test (void)
1673 /* It is empty at the start. */
1674 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1676 ptid_t
ptid1 (1), ptid2 (2), ptid3 (3);
1678 /* Get regcache from ptid1, a new regcache is added to
1679 current_regcache. */
1680 regcache
*regcache
= get_thread_arch_aspace_regcache (ptid1
,
1684 SELF_CHECK (regcache
!= NULL
);
1685 SELF_CHECK (regcache
->ptid () == ptid1
);
1686 SELF_CHECK (regcache_access::current_regcache_size () == 1);
1688 /* Get regcache from ptid2, a new regcache is added to
1689 current_regcache. */
1690 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1693 SELF_CHECK (regcache
!= NULL
);
1694 SELF_CHECK (regcache
->ptid () == ptid2
);
1695 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1697 /* Get regcache from ptid3, a new regcache is added to
1698 current_regcache. */
1699 regcache
= get_thread_arch_aspace_regcache (ptid3
,
1702 SELF_CHECK (regcache
!= NULL
);
1703 SELF_CHECK (regcache
->ptid () == ptid3
);
1704 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1706 /* Get regcache from ptid2 again, nothing is added to
1707 current_regcache. */
1708 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1711 SELF_CHECK (regcache
!= NULL
);
1712 SELF_CHECK (regcache
->ptid () == ptid2
);
1713 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1715 /* Mark ptid2 is changed, so regcache of ptid2 should be removed from
1716 current_regcache. */
1717 registers_changed_ptid (ptid2
);
1718 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1721 } // namespace selftests
1722 #endif /* GDB_SELF_TEST */
1725 _initialize_regcache (void)
1727 regcache_descr_handle
1728 = gdbarch_data_register_post_init (init_regcache_descr
);
1730 observer_attach_target_changed (regcache_observer_target_changed
);
1731 observer_attach_thread_ptid_changed (regcache::regcache_thread_ptid_changed
);
1733 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1734 _("Force gdb to flush its register cache (maintainer command)"));
1736 add_cmd ("registers", class_maintenance
, maintenance_print_registers
,
1737 _("Print the internal register configuration.\n"
1738 "Takes an optional file parameter."), &maintenanceprintlist
);
1739 add_cmd ("raw-registers", class_maintenance
,
1740 maintenance_print_raw_registers
,
1741 _("Print the internal register configuration "
1742 "including raw values.\n"
1743 "Takes an optional file parameter."), &maintenanceprintlist
);
1744 add_cmd ("cooked-registers", class_maintenance
,
1745 maintenance_print_cooked_registers
,
1746 _("Print the internal register configuration "
1747 "including cooked values.\n"
1748 "Takes an optional file parameter."), &maintenanceprintlist
);
1749 add_cmd ("register-groups", class_maintenance
,
1750 maintenance_print_register_groups
,
1751 _("Print the internal register configuration "
1752 "including each register's group.\n"
1753 "Takes an optional file parameter."),
1754 &maintenanceprintlist
);
1755 add_cmd ("remote-registers", class_maintenance
,
1756 maintenance_print_remote_registers
, _("\
1757 Print the internal register configuration including each register's\n\
1758 remote register number and buffer offset in the g/G packets.\n\
1759 Takes an optional file parameter."),
1760 &maintenanceprintlist
);
1763 selftests::register_test ("current_regcache", selftests::current_regcache_test
);