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 regcache_xfree (struct regcache
*regcache
)
247 if (regcache
== NULL
)
254 do_regcache_xfree (void *data
)
256 regcache_xfree ((struct regcache
*) data
);
260 make_cleanup_regcache_xfree (struct regcache
*regcache
)
262 return make_cleanup (do_regcache_xfree
, regcache
);
265 /* Cleanup routines for invalidating a register. */
267 struct register_to_invalidate
269 struct regcache
*regcache
;
274 do_regcache_invalidate (void *data
)
276 struct register_to_invalidate
*reg
= (struct register_to_invalidate
*) data
;
278 regcache_invalidate (reg
->regcache
, reg
->regnum
);
281 static struct cleanup
*
282 make_cleanup_regcache_invalidate (struct regcache
*regcache
, int regnum
)
284 struct register_to_invalidate
* reg
= XNEW (struct register_to_invalidate
);
286 reg
->regcache
= regcache
;
287 reg
->regnum
= regnum
;
288 return make_cleanup_dtor (do_regcache_invalidate
, (void *) reg
, xfree
);
291 /* Return REGCACHE's architecture. */
294 get_regcache_arch (const struct regcache
*regcache
)
296 return regcache
->arch ();
299 struct address_space
*
300 get_regcache_aspace (const struct regcache
*regcache
)
302 return regcache
->aspace ();
305 /* Return a pointer to register REGNUM's buffer cache. */
308 regcache::register_buffer (int regnum
) const
310 return m_registers
+ m_descr
->register_offset
[regnum
];
314 regcache_save (struct regcache
*regcache
,
315 regcache_cooked_read_ftype
*cooked_read
, void *src
)
317 regcache
->save (cooked_read
, src
);
321 regcache::save (regcache_cooked_read_ftype
*cooked_read
,
324 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
327 /* The DST should be `read-only', if it wasn't then the save would
328 end up trying to write the register values back out to the
330 gdb_assert (m_readonly_p
);
331 /* Clear the dest. */
332 memset (m_registers
, 0, m_descr
->sizeof_cooked_registers
);
333 memset (m_register_status
, 0, m_descr
->sizeof_cooked_register_status
);
334 /* Copy over any registers (identified by their membership in the
335 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
336 gdbarch_num_pseudo_regs) range is checked since some architectures need
337 to save/restore `cooked' registers that live in memory. */
338 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
340 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
342 gdb_byte
*dst_buf
= register_buffer (regnum
);
343 enum register_status status
= cooked_read (src
, regnum
, dst_buf
);
345 gdb_assert (status
!= REG_UNKNOWN
);
347 if (status
!= REG_VALID
)
348 memset (dst_buf
, 0, register_size (gdbarch
, regnum
));
350 m_register_status
[regnum
] = status
;
356 regcache::restore (struct regcache
*src
)
358 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
361 /* The dst had better not be read-only. If it is, the `restore'
362 doesn't make much sense. */
363 gdb_assert (!m_readonly_p
);
364 gdb_assert (src
->m_readonly_p
);
365 /* Copy over any registers, being careful to only restore those that
366 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
367 + gdbarch_num_pseudo_regs) range is checked since some architectures need
368 to save/restore `cooked' registers that live in memory. */
369 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
371 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
373 if (src
->m_register_status
[regnum
] == REG_VALID
)
374 cooked_write (regnum
, src
->register_buffer (regnum
));
380 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
382 gdb_assert (src
!= NULL
&& dst
!= NULL
);
383 gdb_assert (src
->m_descr
->gdbarch
== dst
->m_descr
->gdbarch
);
384 gdb_assert (src
!= dst
);
385 gdb_assert (src
->m_readonly_p
&& !dst
->m_readonly_p
);
391 regcache_dup (struct regcache
*src
)
393 return new regcache (regcache::readonly
, *src
);
397 regcache_register_status (const struct regcache
*regcache
, int regnum
)
399 gdb_assert (regcache
!= NULL
);
400 return regcache
->get_register_status (regnum
);
404 regcache::get_register_status (int regnum
) const
406 gdb_assert (regnum
>= 0);
408 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
410 gdb_assert (regnum
< m_descr
->nr_raw_registers
);
412 return (enum register_status
) m_register_status
[regnum
];
416 regcache_invalidate (struct regcache
*regcache
, int regnum
)
418 gdb_assert (regcache
!= NULL
);
419 regcache
->invalidate (regnum
);
423 regcache::invalidate (int regnum
)
425 gdb_assert (regnum
>= 0);
426 gdb_assert (!m_readonly_p
);
427 gdb_assert (regnum
< m_descr
->nr_raw_registers
);
428 m_register_status
[regnum
] = REG_UNKNOWN
;
431 /* Global structure containing the current regcache. */
433 /* NOTE: this is a write-through cache. There is no "dirty" bit for
434 recording if the register values have been changed (eg. by the
435 user). Therefore all registers must be written back to the
436 target when appropriate. */
437 std::forward_list
<regcache
*> regcache::current_regcache
;
440 get_thread_arch_aspace_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
,
441 struct address_space
*aspace
)
443 for (const auto ®cache
: regcache::current_regcache
)
444 if (ptid_equal (regcache
->ptid (), ptid
) && regcache
->arch () == gdbarch
)
447 regcache
*new_regcache
= new regcache (gdbarch
, aspace
, false);
449 regcache::current_regcache
.push_front (new_regcache
);
450 new_regcache
->set_ptid (ptid
);
456 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
458 struct address_space
*aspace
;
460 /* For the benefit of "maint print registers" & co when debugging an
461 executable, allow dumping the regcache even when there is no
462 thread selected (target_thread_address_space internal-errors if
463 no address space is found). Note that normal user commands will
464 fail higher up on the call stack due to no
465 target_has_registers. */
466 aspace
= (ptid_equal (null_ptid
, ptid
)
468 : target_thread_address_space (ptid
));
470 return get_thread_arch_aspace_regcache (ptid
, gdbarch
, aspace
);
473 static ptid_t current_thread_ptid
;
474 static struct gdbarch
*current_thread_arch
;
477 get_thread_regcache (ptid_t ptid
)
479 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
481 current_thread_ptid
= ptid
;
482 current_thread_arch
= target_thread_architecture (ptid
);
485 return get_thread_arch_regcache (ptid
, current_thread_arch
);
489 get_current_regcache (void)
491 return get_thread_regcache (inferior_ptid
);
494 /* See common/common-regcache.h. */
497 get_thread_regcache_for_ptid (ptid_t ptid
)
499 return get_thread_regcache (ptid
);
502 /* Observer for the target_changed event. */
505 regcache_observer_target_changed (struct target_ops
*target
)
507 registers_changed ();
510 /* Update global variables old ptids to hold NEW_PTID if they were
513 regcache::regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
515 for (auto ®cache
: regcache::current_regcache
)
517 if (ptid_equal (regcache
->ptid (), old_ptid
))
518 regcache
->set_ptid (new_ptid
);
522 /* Low level examining and depositing of registers.
524 The caller is responsible for making sure that the inferior is
525 stopped before calling the fetching routines, or it will get
526 garbage. (a change from GDB version 3, in which the caller got the
527 value from the last stop). */
529 /* REGISTERS_CHANGED ()
531 Indicate that registers may have changed, so invalidate the cache. */
534 registers_changed_ptid (ptid_t ptid
)
536 for (auto oit
= regcache::current_regcache
.before_begin (),
537 it
= std::next (oit
);
538 it
!= regcache::current_regcache
.end ();
541 if (ptid_match ((*it
)->ptid (), ptid
))
544 it
= regcache::current_regcache
.erase_after (oit
);
550 if (ptid_match (current_thread_ptid
, ptid
))
552 current_thread_ptid
= null_ptid
;
553 current_thread_arch
= NULL
;
556 if (ptid_match (inferior_ptid
, ptid
))
558 /* We just deleted the regcache of the current thread. Need to
559 forget about any frames we have cached, too. */
560 reinit_frame_cache ();
565 registers_changed (void)
567 registers_changed_ptid (minus_one_ptid
);
569 /* Force cleanup of any alloca areas if using C alloca instead of
570 a builtin alloca. This particular call is used to clean up
571 areas allocated by low level target code which may build up
572 during lengthy interactions between gdb and the target before
573 gdb gives control to the user (ie watchpoints). */
578 regcache_raw_update (struct regcache
*regcache
, int regnum
)
580 gdb_assert (regcache
!= NULL
);
582 regcache
->raw_update (regnum
);
586 regcache::raw_update (int regnum
)
588 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
590 /* Make certain that the register cache is up-to-date with respect
591 to the current thread. This switching shouldn't be necessary
592 only there is still only one target side register cache. Sigh!
593 On the bright side, at least there is a regcache object. */
595 if (!m_readonly_p
&& get_register_status (regnum
) == REG_UNKNOWN
)
597 target_fetch_registers (this, regnum
);
599 /* A number of targets can't access the whole set of raw
600 registers (because the debug API provides no means to get at
602 if (m_register_status
[regnum
] == REG_UNKNOWN
)
603 m_register_status
[regnum
] = REG_UNAVAILABLE
;
608 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
610 return regcache
->raw_read (regnum
, buf
);
614 regcache::raw_read (int regnum
, gdb_byte
*buf
)
616 gdb_assert (buf
!= NULL
);
619 if (m_register_status
[regnum
] != REG_VALID
)
620 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
622 memcpy (buf
, register_buffer (regnum
),
623 m_descr
->sizeof_register
[regnum
]);
625 return (enum register_status
) m_register_status
[regnum
];
629 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
631 gdb_assert (regcache
!= NULL
);
632 return regcache
->raw_read (regnum
, val
);
635 template<typename T
, typename
>
637 regcache::raw_read (int regnum
, T
*val
)
640 enum register_status status
;
642 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
643 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
644 status
= raw_read (regnum
, buf
);
645 if (status
== REG_VALID
)
646 *val
= extract_integer
<T
> (buf
,
647 m_descr
->sizeof_register
[regnum
],
648 gdbarch_byte_order (m_descr
->gdbarch
));
655 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
658 gdb_assert (regcache
!= NULL
);
659 return regcache
->raw_read (regnum
, val
);
663 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
665 gdb_assert (regcache
!= NULL
);
666 regcache
->raw_write (regnum
, val
);
669 template<typename T
, typename
>
671 regcache::raw_write (int regnum
, T val
)
675 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_raw_registers
);
676 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
677 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
678 gdbarch_byte_order (m_descr
->gdbarch
), val
);
679 raw_write (regnum
, buf
);
683 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
686 gdb_assert (regcache
!= NULL
);
687 regcache
->raw_write (regnum
, val
);
691 regcache_raw_get_signed (struct regcache
*regcache
, int regnum
)
694 enum register_status status
;
696 status
= regcache_raw_read_signed (regcache
, regnum
, &value
);
697 if (status
== REG_UNAVAILABLE
)
698 throw_error (NOT_AVAILABLE_ERROR
,
699 _("Register %d is not available"), regnum
);
704 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
706 return regcache
->cooked_read (regnum
, buf
);
710 regcache::cooked_read (int regnum
, gdb_byte
*buf
)
712 gdb_assert (regnum
>= 0);
713 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
714 if (regnum
< m_descr
->nr_raw_registers
)
715 return raw_read (regnum
, buf
);
716 else if (m_readonly_p
717 && m_register_status
[regnum
] != REG_UNKNOWN
)
719 /* Read-only register cache, perhaps the cooked value was
721 if (m_register_status
[regnum
] == REG_VALID
)
722 memcpy (buf
, register_buffer (regnum
),
723 m_descr
->sizeof_register
[regnum
]);
725 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
727 return (enum register_status
) m_register_status
[regnum
];
729 else if (gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
731 struct value
*mark
, *computed
;
732 enum register_status result
= REG_VALID
;
734 mark
= value_mark ();
736 computed
= gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
738 if (value_entirely_available (computed
))
739 memcpy (buf
, value_contents_raw (computed
),
740 m_descr
->sizeof_register
[regnum
]);
743 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
744 result
= REG_UNAVAILABLE
;
747 value_free_to_mark (mark
);
752 return gdbarch_pseudo_register_read (m_descr
->gdbarch
, this,
757 regcache_cooked_read_value (struct regcache
*regcache
, int regnum
)
759 return regcache
->cooked_read_value (regnum
);
763 regcache::cooked_read_value (int regnum
)
765 gdb_assert (regnum
>= 0);
766 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
768 if (regnum
< m_descr
->nr_raw_registers
769 || (m_readonly_p
&& m_register_status
[regnum
] != REG_UNKNOWN
)
770 || !gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
772 struct value
*result
;
774 result
= allocate_value (register_type (m_descr
->gdbarch
, regnum
));
775 VALUE_LVAL (result
) = lval_register
;
776 VALUE_REGNUM (result
) = regnum
;
778 /* It is more efficient in general to do this delegation in this
779 direction than in the other one, even though the value-based
781 if (cooked_read (regnum
,
782 value_contents_raw (result
)) == REG_UNAVAILABLE
)
783 mark_value_bytes_unavailable (result
, 0,
784 TYPE_LENGTH (value_type (result
)));
789 return gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
794 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
797 gdb_assert (regcache
!= NULL
);
798 return regcache
->cooked_read (regnum
, val
);
801 template<typename T
, typename
>
803 regcache::cooked_read (int regnum
, T
*val
)
805 enum register_status status
;
808 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
809 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
810 status
= cooked_read (regnum
, buf
);
811 if (status
== REG_VALID
)
812 *val
= extract_integer
<T
> (buf
, m_descr
->sizeof_register
[regnum
],
813 gdbarch_byte_order (m_descr
->gdbarch
));
820 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
823 gdb_assert (regcache
!= NULL
);
824 return regcache
->cooked_read (regnum
, val
);
828 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
831 gdb_assert (regcache
!= NULL
);
832 regcache
->cooked_write (regnum
, val
);
835 template<typename T
, typename
>
837 regcache::cooked_write (int regnum
, T val
)
841 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
842 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
843 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
844 gdbarch_byte_order (m_descr
->gdbarch
), val
);
845 cooked_write (regnum
, buf
);
849 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
852 gdb_assert (regcache
!= NULL
);
853 regcache
->cooked_write (regnum
, val
);
856 /* See regcache.h. */
859 regcache_raw_set_cached_value (struct regcache
*regcache
, int regnum
,
862 regcache
->raw_set_cached_value (regnum
, buf
);
866 regcache::raw_set_cached_value (int regnum
, const gdb_byte
*buf
)
868 memcpy (register_buffer (regnum
), buf
,
869 m_descr
->sizeof_register
[regnum
]);
870 m_register_status
[regnum
] = REG_VALID
;
874 regcache_raw_write (struct regcache
*regcache
, int regnum
,
877 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
878 regcache
->raw_write (regnum
, buf
);
882 regcache::raw_write (int regnum
, const gdb_byte
*buf
)
884 struct cleanup
*old_chain
;
886 gdb_assert (buf
!= NULL
);
887 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
888 gdb_assert (!m_readonly_p
);
890 /* On the sparc, writing %g0 is a no-op, so we don't even want to
891 change the registers array if something writes to this register. */
892 if (gdbarch_cannot_store_register (arch (), regnum
))
895 /* If we have a valid copy of the register, and new value == old
896 value, then don't bother doing the actual store. */
897 if (get_register_status (regnum
) == REG_VALID
898 && (memcmp (register_buffer (regnum
), buf
,
899 m_descr
->sizeof_register
[regnum
]) == 0))
902 target_prepare_to_store (this);
903 raw_set_cached_value (regnum
, buf
);
905 /* Register a cleanup function for invalidating the register after it is
906 written, in case of a failure. */
907 old_chain
= make_cleanup_regcache_invalidate (this, regnum
);
909 target_store_registers (this, regnum
);
911 /* The target did not throw an error so we can discard invalidating the
912 register and restore the cleanup chain to what it was. */
913 discard_cleanups (old_chain
);
917 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
920 regcache
->cooked_write (regnum
, buf
);
924 regcache::cooked_write (int regnum
, const gdb_byte
*buf
)
926 gdb_assert (regnum
>= 0);
927 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
928 if (regnum
< m_descr
->nr_raw_registers
)
929 raw_write (regnum
, buf
);
931 gdbarch_pseudo_register_write (m_descr
->gdbarch
, this,
935 /* Perform a partial register transfer using a read, modify, write
938 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
940 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
944 regcache::xfer_part (int regnum
, int offset
, int len
, void *in
,
946 enum register_status (*read
) (struct regcache
*regcache
,
949 void (*write
) (struct regcache
*regcache
, int regnum
,
950 const gdb_byte
*buf
))
952 struct gdbarch
*gdbarch
= arch ();
953 gdb_byte
*reg
= (gdb_byte
*) alloca (register_size (gdbarch
, regnum
));
955 gdb_assert (offset
>= 0 && offset
<= m_descr
->sizeof_register
[regnum
]);
956 gdb_assert (len
>= 0 && offset
+ len
<= m_descr
->sizeof_register
[regnum
]);
957 /* Something to do? */
958 if (offset
+ len
== 0)
960 /* Read (when needed) ... */
963 || offset
+ len
< m_descr
->sizeof_register
[regnum
])
965 enum register_status status
;
967 gdb_assert (read
!= NULL
);
968 status
= read (this, regnum
, reg
);
969 if (status
!= REG_VALID
)
974 memcpy (in
, reg
+ offset
, len
);
976 memcpy (reg
+ offset
, out
, len
);
977 /* ... write (when needed). */
980 gdb_assert (write
!= NULL
);
981 write (this, regnum
, reg
);
988 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
989 int offset
, int len
, gdb_byte
*buf
)
991 return regcache
->raw_read_part (regnum
, offset
, len
, buf
);
995 regcache::raw_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
997 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
998 return xfer_part (regnum
, offset
, len
, buf
, NULL
,
999 regcache_raw_read
, regcache_raw_write
);
1003 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
1004 int offset
, int len
, const gdb_byte
*buf
)
1006 regcache
->raw_write_part (regnum
, offset
, len
, buf
);
1010 regcache::raw_write_part (int regnum
, int offset
, int len
,
1011 const gdb_byte
*buf
)
1013 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1014 xfer_part (regnum
, offset
, len
, NULL
, buf
, regcache_raw_read
,
1015 regcache_raw_write
);
1018 enum register_status
1019 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
1020 int offset
, int len
, gdb_byte
*buf
)
1022 return regcache
->cooked_read_part (regnum
, offset
, len
, buf
);
1026 enum register_status
1027 regcache::cooked_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
1029 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1030 return xfer_part (regnum
, offset
, len
, buf
, NULL
,
1031 regcache_cooked_read
, regcache_cooked_write
);
1035 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
1036 int offset
, int len
, const gdb_byte
*buf
)
1038 regcache
->cooked_write_part (regnum
, offset
, len
, buf
);
1042 regcache::cooked_write_part (int regnum
, int offset
, int len
,
1043 const gdb_byte
*buf
)
1045 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1046 xfer_part (regnum
, offset
, len
, NULL
, buf
,
1047 regcache_cooked_read
, regcache_cooked_write
);
1050 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
1053 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
1055 gdb_assert (regcache
!= NULL
);
1056 regcache
->raw_supply (regnum
, buf
);
1060 regcache::raw_supply (int regnum
, const void *buf
)
1065 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1066 gdb_assert (!m_readonly_p
);
1068 regbuf
= register_buffer (regnum
);
1069 size
= m_descr
->sizeof_register
[regnum
];
1073 memcpy (regbuf
, buf
, size
);
1074 m_register_status
[regnum
] = REG_VALID
;
1078 /* This memset not strictly necessary, but better than garbage
1079 in case the register value manages to escape somewhere (due
1080 to a bug, no less). */
1081 memset (regbuf
, 0, size
);
1082 m_register_status
[regnum
] = REG_UNAVAILABLE
;
1086 /* Supply register REGNUM to REGCACHE. Value to supply is an integer stored at
1087 address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED. If
1088 the register size is greater than ADDR_LEN, then the integer will be sign or
1089 zero extended. If the register size is smaller than the integer, then the
1090 most significant bytes of the integer will be truncated. */
1093 regcache::raw_supply_integer (int regnum
, const gdb_byte
*addr
, int addr_len
,
1096 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1100 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1101 gdb_assert (!m_readonly_p
);
1103 regbuf
= register_buffer (regnum
);
1104 regsize
= m_descr
->sizeof_register
[regnum
];
1106 copy_integer_to_size (regbuf
, regsize
, addr
, addr_len
, is_signed
,
1108 m_register_status
[regnum
] = REG_VALID
;
1111 /* Supply register REGNUM with zeroed value to REGCACHE. This is not the same
1112 as calling raw_supply with NULL (which will set the state to
1116 regcache::raw_supply_zeroed (int regnum
)
1121 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1122 gdb_assert (!m_readonly_p
);
1124 regbuf
= register_buffer (regnum
);
1125 size
= m_descr
->sizeof_register
[regnum
];
1127 memset (regbuf
, 0, size
);
1128 m_register_status
[regnum
] = REG_VALID
;
1131 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1134 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
1136 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
1137 regcache
->raw_collect (regnum
, buf
);
1141 regcache::raw_collect (int regnum
, void *buf
) const
1146 gdb_assert (buf
!= NULL
);
1147 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1149 regbuf
= register_buffer (regnum
);
1150 size
= m_descr
->sizeof_register
[regnum
];
1151 memcpy (buf
, regbuf
, size
);
1154 /* Transfer a single or all registers belonging to a certain register
1155 set to or from a buffer. This is the main worker function for
1156 regcache_supply_regset and regcache_collect_regset. */
1158 /* Collect register REGNUM from REGCACHE. Store collected value as an integer
1159 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
1160 If ADDR_LEN is greater than the register size, then the integer will be sign
1161 or zero extended. If ADDR_LEN is smaller than the register size, then the
1162 most significant bytes of the integer will be truncated. */
1165 regcache::raw_collect_integer (int regnum
, gdb_byte
*addr
, int addr_len
,
1166 bool is_signed
) const
1168 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1169 const gdb_byte
*regbuf
;
1172 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1174 regbuf
= register_buffer (regnum
);
1175 regsize
= m_descr
->sizeof_register
[regnum
];
1177 copy_integer_to_size (addr
, addr_len
, regbuf
, regsize
, is_signed
,
1182 regcache::transfer_regset (const struct regset
*regset
,
1183 struct regcache
*out_regcache
,
1184 int regnum
, const void *in_buf
,
1185 void *out_buf
, size_t size
) const
1187 const struct regcache_map_entry
*map
;
1188 int offs
= 0, count
;
1190 for (map
= (const struct regcache_map_entry
*) regset
->regmap
;
1191 (count
= map
->count
) != 0;
1194 int regno
= map
->regno
;
1195 int slot_size
= map
->size
;
1197 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1198 slot_size
= m_descr
->sizeof_register
[regno
];
1200 if (regno
== REGCACHE_MAP_SKIP
1202 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1203 offs
+= count
* slot_size
;
1205 else if (regnum
== -1)
1206 for (; count
--; regno
++, offs
+= slot_size
)
1208 if (offs
+ slot_size
> size
)
1212 raw_collect (regno
, (gdb_byte
*) out_buf
+ offs
);
1214 out_regcache
->raw_supply (regno
, in_buf
1215 ? (const gdb_byte
*) in_buf
+ offs
1220 /* Transfer a single register and return. */
1221 offs
+= (regnum
- regno
) * slot_size
;
1222 if (offs
+ slot_size
> size
)
1226 raw_collect (regnum
, (gdb_byte
*) out_buf
+ offs
);
1228 out_regcache
->raw_supply (regnum
, in_buf
1229 ? (const gdb_byte
*) in_buf
+ offs
1236 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1237 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1238 If BUF is NULL, set the register(s) to "unavailable" status. */
1241 regcache_supply_regset (const struct regset
*regset
,
1242 struct regcache
*regcache
,
1243 int regnum
, const void *buf
, size_t size
)
1245 regcache
->supply_regset (regset
, regnum
, buf
, size
);
1249 regcache::supply_regset (const struct regset
*regset
,
1250 int regnum
, const void *buf
, size_t size
)
1252 transfer_regset (regset
, this, regnum
, buf
, NULL
, size
);
1255 /* Collect register REGNUM from REGCACHE to BUF, using the register
1256 map in REGSET. If REGNUM is -1, do this for all registers in
1260 regcache_collect_regset (const struct regset
*regset
,
1261 const struct regcache
*regcache
,
1262 int regnum
, void *buf
, size_t size
)
1264 regcache
->collect_regset (regset
, regnum
, buf
, size
);
1268 regcache::collect_regset (const struct regset
*regset
,
1269 int regnum
, void *buf
, size_t size
) const
1271 transfer_regset (regset
, NULL
, regnum
, NULL
, buf
, size
);
1275 /* Special handling for register PC. */
1278 regcache_read_pc (struct regcache
*regcache
)
1280 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1284 if (gdbarch_read_pc_p (gdbarch
))
1285 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1286 /* Else use per-frame method on get_current_frame. */
1287 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1291 if (regcache_cooked_read_unsigned (regcache
,
1292 gdbarch_pc_regnum (gdbarch
),
1293 &raw_val
) == REG_UNAVAILABLE
)
1294 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1296 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1299 internal_error (__FILE__
, __LINE__
,
1300 _("regcache_read_pc: Unable to find PC"));
1305 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1307 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1309 if (gdbarch_write_pc_p (gdbarch
))
1310 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1311 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1312 regcache_cooked_write_unsigned (regcache
,
1313 gdbarch_pc_regnum (gdbarch
), pc
);
1315 internal_error (__FILE__
, __LINE__
,
1316 _("regcache_write_pc: Unable to update PC"));
1318 /* Writing the PC (for instance, from "load") invalidates the
1320 reinit_frame_cache ();
1324 regcache::debug_print_register (const char *func
, int regno
)
1326 struct gdbarch
*gdbarch
= arch ();
1328 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1329 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
1330 && gdbarch_register_name (gdbarch
, regno
) != NULL
1331 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
1332 fprintf_unfiltered (gdb_stdlog
, "(%s)",
1333 gdbarch_register_name (gdbarch
, regno
));
1335 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1336 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
1338 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1339 int size
= register_size (gdbarch
, regno
);
1340 gdb_byte
*buf
= register_buffer (regno
);
1342 fprintf_unfiltered (gdb_stdlog
, " = ");
1343 for (int i
= 0; i
< size
; i
++)
1345 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1347 if (size
<= sizeof (LONGEST
))
1349 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
1351 fprintf_unfiltered (gdb_stdlog
, " %s %s",
1352 core_addr_to_string_nz (val
), plongest (val
));
1355 fprintf_unfiltered (gdb_stdlog
, "\n");
1359 reg_flush_command (char *command
, int from_tty
)
1361 /* Force-flush the register cache. */
1362 registers_changed ();
1364 printf_filtered (_("Register cache flushed.\n"));
1368 regcache::dump (ui_file
*file
, enum regcache_dump_what what_to_dump
)
1370 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1371 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
1373 int footnote_nr
= 0;
1374 int footnote_register_size
= 0;
1375 int footnote_register_offset
= 0;
1376 int footnote_register_type_name_null
= 0;
1377 long register_offset
= 0;
1380 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1381 m_descr
->nr_raw_registers
);
1382 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1383 m_descr
->nr_cooked_registers
);
1384 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1385 m_descr
->sizeof_raw_registers
);
1386 fprintf_unfiltered (file
, "sizeof_raw_register_status %ld\n",
1387 m_descr
->sizeof_raw_register_status
);
1388 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
1389 gdbarch_num_regs (gdbarch
));
1390 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
1391 gdbarch_num_pseudo_regs (gdbarch
));
1394 gdb_assert (m_descr
->nr_cooked_registers
1395 == (gdbarch_num_regs (gdbarch
)
1396 + gdbarch_num_pseudo_regs (gdbarch
)));
1398 for (regnum
= -1; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
1402 fprintf_unfiltered (file
, " %-10s", "Name");
1405 const char *p
= gdbarch_register_name (gdbarch
, regnum
);
1409 else if (p
[0] == '\0')
1411 fprintf_unfiltered (file
, " %-10s", p
);
1416 fprintf_unfiltered (file
, " %4s", "Nr");
1418 fprintf_unfiltered (file
, " %4d", regnum
);
1420 /* Relative number. */
1422 fprintf_unfiltered (file
, " %4s", "Rel");
1423 else if (regnum
< gdbarch_num_regs (gdbarch
))
1424 fprintf_unfiltered (file
, " %4d", regnum
);
1426 fprintf_unfiltered (file
, " %4d",
1427 (regnum
- gdbarch_num_regs (gdbarch
)));
1431 fprintf_unfiltered (file
, " %6s ", "Offset");
1434 fprintf_unfiltered (file
, " %6ld",
1435 m_descr
->register_offset
[regnum
]);
1436 if (register_offset
!= m_descr
->register_offset
[regnum
]
1438 && (m_descr
->register_offset
[regnum
]
1439 != (m_descr
->register_offset
[regnum
- 1]
1440 + m_descr
->sizeof_register
[regnum
- 1])))
1443 if (!footnote_register_offset
)
1444 footnote_register_offset
= ++footnote_nr
;
1445 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1448 fprintf_unfiltered (file
, " ");
1449 register_offset
= (m_descr
->register_offset
[regnum
]
1450 + m_descr
->sizeof_register
[regnum
]);
1455 fprintf_unfiltered (file
, " %5s ", "Size");
1457 fprintf_unfiltered (file
, " %5ld", m_descr
->sizeof_register
[regnum
]);
1467 static const char blt
[] = "builtin_type";
1469 t
= TYPE_NAME (register_type (arch (), regnum
));
1474 if (!footnote_register_type_name_null
)
1475 footnote_register_type_name_null
= ++footnote_nr
;
1476 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1477 make_cleanup (xfree
, n
);
1480 /* Chop a leading builtin_type. */
1481 if (startswith (t
, blt
))
1484 fprintf_unfiltered (file
, " %-15s", t
);
1487 /* Leading space always present. */
1488 fprintf_unfiltered (file
, " ");
1491 if (what_to_dump
== regcache_dump_raw
)
1494 fprintf_unfiltered (file
, "Raw value");
1495 else if (regnum
>= m_descr
->nr_raw_registers
)
1496 fprintf_unfiltered (file
, "<cooked>");
1497 else if (get_register_status (regnum
) == REG_UNKNOWN
)
1498 fprintf_unfiltered (file
, "<invalid>");
1499 else if (get_register_status (regnum
) == REG_UNAVAILABLE
)
1500 fprintf_unfiltered (file
, "<unavailable>");
1503 raw_update (regnum
);
1504 print_hex_chars (file
, register_buffer (regnum
),
1505 m_descr
->sizeof_register
[regnum
],
1506 gdbarch_byte_order (gdbarch
), true);
1510 /* Value, cooked. */
1511 if (what_to_dump
== regcache_dump_cooked
)
1514 fprintf_unfiltered (file
, "Cooked value");
1517 const gdb_byte
*buf
= NULL
;
1518 enum register_status status
;
1519 struct value
*value
= NULL
;
1521 if (regnum
< m_descr
->nr_raw_registers
)
1523 raw_update (regnum
);
1524 status
= get_register_status (regnum
);
1525 buf
= register_buffer (regnum
);
1529 value
= cooked_read_value (regnum
);
1531 if (!value_optimized_out (value
)
1532 && value_entirely_available (value
))
1535 buf
= value_contents_all (value
);
1538 status
= REG_UNAVAILABLE
;
1541 if (status
== REG_UNKNOWN
)
1542 fprintf_unfiltered (file
, "<invalid>");
1543 else if (status
== REG_UNAVAILABLE
)
1544 fprintf_unfiltered (file
, "<unavailable>");
1546 print_hex_chars (file
, buf
,
1547 m_descr
->sizeof_register
[regnum
],
1548 gdbarch_byte_order (gdbarch
), true);
1552 release_value (value
);
1558 /* Group members. */
1559 if (what_to_dump
== regcache_dump_groups
)
1562 fprintf_unfiltered (file
, "Groups");
1565 const char *sep
= "";
1566 struct reggroup
*group
;
1568 for (group
= reggroup_next (gdbarch
, NULL
);
1570 group
= reggroup_next (gdbarch
, group
))
1572 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1574 fprintf_unfiltered (file
,
1575 "%s%s", sep
, reggroup_name (group
));
1582 /* Remote packet configuration. */
1583 if (what_to_dump
== regcache_dump_remote
)
1587 fprintf_unfiltered (file
, "Rmt Nr g/G Offset");
1589 else if (regnum
< m_descr
->nr_raw_registers
)
1593 if (remote_register_number_and_offset (arch (), regnum
,
1595 fprintf_unfiltered (file
, "%7d %11d", pnum
, poffset
);
1599 fprintf_unfiltered (file
, "\n");
1602 if (footnote_register_size
)
1603 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1604 footnote_register_size
);
1605 if (footnote_register_offset
)
1606 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1607 footnote_register_offset
);
1608 if (footnote_register_type_name_null
)
1609 fprintf_unfiltered (file
,
1610 "*%d: Register type's name NULL.\n",
1611 footnote_register_type_name_null
);
1612 do_cleanups (cleanups
);
1616 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1619 get_current_regcache ()->dump (gdb_stdout
, what_to_dump
);
1624 if (!file
.open (args
, "w"))
1625 perror_with_name (_("maintenance print architecture"));
1626 get_current_regcache ()->dump (&file
, what_to_dump
);
1631 maintenance_print_registers (char *args
, int from_tty
)
1633 regcache_print (args
, regcache_dump_none
);
1637 maintenance_print_raw_registers (char *args
, int from_tty
)
1639 regcache_print (args
, regcache_dump_raw
);
1643 maintenance_print_cooked_registers (char *args
, int from_tty
)
1645 regcache_print (args
, regcache_dump_cooked
);
1649 maintenance_print_register_groups (char *args
, int from_tty
)
1651 regcache_print (args
, regcache_dump_groups
);
1655 maintenance_print_remote_registers (char *args
, int from_tty
)
1657 regcache_print (args
, regcache_dump_remote
);
1661 #include "selftest.h"
1663 namespace selftests
{
1665 class regcache_access
: public regcache
1669 /* Return the number of elements in current_regcache. */
1672 current_regcache_size ()
1674 return std::distance (regcache::current_regcache
.begin (),
1675 regcache::current_regcache
.end ());
1680 current_regcache_test (void)
1682 /* It is empty at the start. */
1683 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1685 ptid_t
ptid1 (1), ptid2 (2), ptid3 (3);
1687 /* Get regcache from ptid1, a new regcache is added to
1688 current_regcache. */
1689 regcache
*regcache
= get_thread_arch_aspace_regcache (ptid1
,
1693 SELF_CHECK (regcache
!= NULL
);
1694 SELF_CHECK (regcache
->ptid () == ptid1
);
1695 SELF_CHECK (regcache_access::current_regcache_size () == 1);
1697 /* Get regcache from ptid2, a new regcache is added to
1698 current_regcache. */
1699 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1702 SELF_CHECK (regcache
!= NULL
);
1703 SELF_CHECK (regcache
->ptid () == ptid2
);
1704 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1706 /* Get regcache from ptid3, a new regcache is added to
1707 current_regcache. */
1708 regcache
= get_thread_arch_aspace_regcache (ptid3
,
1711 SELF_CHECK (regcache
!= NULL
);
1712 SELF_CHECK (regcache
->ptid () == ptid3
);
1713 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1715 /* Get regcache from ptid2 again, nothing is added to
1716 current_regcache. */
1717 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1720 SELF_CHECK (regcache
!= NULL
);
1721 SELF_CHECK (regcache
->ptid () == ptid2
);
1722 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1724 /* Mark ptid2 is changed, so regcache of ptid2 should be removed from
1725 current_regcache. */
1726 registers_changed_ptid (ptid2
);
1727 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1730 } // namespace selftests
1731 #endif /* GDB_SELF_TEST */
1734 _initialize_regcache (void)
1736 regcache_descr_handle
1737 = gdbarch_data_register_post_init (init_regcache_descr
);
1739 observer_attach_target_changed (regcache_observer_target_changed
);
1740 observer_attach_thread_ptid_changed (regcache::regcache_thread_ptid_changed
);
1742 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1743 _("Force gdb to flush its register cache (maintainer command)"));
1745 add_cmd ("registers", class_maintenance
, maintenance_print_registers
,
1746 _("Print the internal register configuration.\n"
1747 "Takes an optional file parameter."), &maintenanceprintlist
);
1748 add_cmd ("raw-registers", class_maintenance
,
1749 maintenance_print_raw_registers
,
1750 _("Print the internal register configuration "
1751 "including raw values.\n"
1752 "Takes an optional file parameter."), &maintenanceprintlist
);
1753 add_cmd ("cooked-registers", class_maintenance
,
1754 maintenance_print_cooked_registers
,
1755 _("Print the internal register configuration "
1756 "including cooked values.\n"
1757 "Takes an optional file parameter."), &maintenanceprintlist
);
1758 add_cmd ("register-groups", class_maintenance
,
1759 maintenance_print_register_groups
,
1760 _("Print the internal register configuration "
1761 "including each register's group.\n"
1762 "Takes an optional file parameter."),
1763 &maintenanceprintlist
);
1764 add_cmd ("remote-registers", class_maintenance
,
1765 maintenance_print_remote_registers
, _("\
1766 Print the internal register configuration including each register's\n\
1767 remote register number and buffer offset in the g/G packets.\n\
1768 Takes an optional file parameter."),
1769 &maintenanceprintlist
);
1772 selftests::register_test ("current_regcache", selftests::current_regcache_test
);