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_xmalloc (struct gdbarch
*gdbarch
, struct address_space
*aspace
)
247 return new regcache (gdbarch
, aspace
);
251 regcache_xfree (struct regcache
*regcache
)
253 if (regcache
== NULL
)
260 do_regcache_xfree (void *data
)
262 regcache_xfree ((struct regcache
*) data
);
266 make_cleanup_regcache_xfree (struct regcache
*regcache
)
268 return make_cleanup (do_regcache_xfree
, regcache
);
271 /* Cleanup routines for invalidating a register. */
273 struct register_to_invalidate
275 struct regcache
*regcache
;
280 do_regcache_invalidate (void *data
)
282 struct register_to_invalidate
*reg
= (struct register_to_invalidate
*) data
;
284 regcache_invalidate (reg
->regcache
, reg
->regnum
);
287 static struct cleanup
*
288 make_cleanup_regcache_invalidate (struct regcache
*regcache
, int regnum
)
290 struct register_to_invalidate
* reg
= XNEW (struct register_to_invalidate
);
292 reg
->regcache
= regcache
;
293 reg
->regnum
= regnum
;
294 return make_cleanup_dtor (do_regcache_invalidate
, (void *) reg
, xfree
);
297 /* Return REGCACHE's architecture. */
300 get_regcache_arch (const struct regcache
*regcache
)
302 return regcache
->arch ();
305 struct address_space
*
306 get_regcache_aspace (const struct regcache
*regcache
)
308 return regcache
->aspace ();
311 /* Return a pointer to register REGNUM's buffer cache. */
314 regcache::register_buffer (int regnum
) const
316 return m_registers
+ m_descr
->register_offset
[regnum
];
320 regcache_save (struct regcache
*regcache
,
321 regcache_cooked_read_ftype
*cooked_read
, void *src
)
323 regcache
->save (cooked_read
, src
);
327 regcache::save (regcache_cooked_read_ftype
*cooked_read
,
330 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
331 gdb_byte buf
[MAX_REGISTER_SIZE
];
334 /* The DST should be `read-only', if it wasn't then the save would
335 end up trying to write the register values back out to the
337 gdb_assert (m_readonly_p
);
338 /* Clear the dest. */
339 memset (m_registers
, 0, m_descr
->sizeof_cooked_registers
);
340 memset (m_register_status
, 0, m_descr
->sizeof_cooked_register_status
);
341 /* Copy over any registers (identified by their membership in the
342 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
343 gdbarch_num_pseudo_regs) range is checked since some architectures need
344 to save/restore `cooked' registers that live in memory. */
345 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
347 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
349 enum register_status status
= cooked_read (src
, regnum
, buf
);
351 if (status
== REG_VALID
)
352 memcpy (register_buffer (regnum
), buf
,
353 register_size (gdbarch
, regnum
));
356 gdb_assert (status
!= REG_UNKNOWN
);
358 memset (register_buffer (regnum
), 0,
359 register_size (gdbarch
, regnum
));
361 m_register_status
[regnum
] = status
;
367 regcache::restore (struct regcache
*src
)
369 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
372 /* The dst had better not be read-only. If it is, the `restore'
373 doesn't make much sense. */
374 gdb_assert (!m_readonly_p
);
375 gdb_assert (src
->m_readonly_p
);
376 /* Copy over any registers, being careful to only restore those that
377 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
378 + gdbarch_num_pseudo_regs) range is checked since some architectures need
379 to save/restore `cooked' registers that live in memory. */
380 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
382 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
384 if (src
->m_register_status
[regnum
] == REG_VALID
)
385 cooked_write (regnum
, src
->register_buffer (regnum
));
391 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
393 gdb_assert (src
!= NULL
&& dst
!= NULL
);
394 gdb_assert (src
->m_descr
->gdbarch
== dst
->m_descr
->gdbarch
);
395 gdb_assert (src
!= dst
);
396 gdb_assert (src
->m_readonly_p
|| dst
->m_readonly_p
);
398 if (!src
->m_readonly_p
)
399 regcache_save (dst
, do_cooked_read
, src
);
400 else if (!dst
->m_readonly_p
)
403 dst
->cpy_no_passthrough (src
);
406 /* Copy/duplicate the contents of a register cache. Unlike regcache_cpy,
407 which is pass-through, this does not go through to the target.
408 Only values values already in the cache are transferred. The SRC and DST
409 buffers must not overlap. */
412 regcache::cpy_no_passthrough (struct regcache
*src
)
414 gdb_assert (src
!= NULL
);
415 gdb_assert (src
->m_descr
->gdbarch
== m_descr
->gdbarch
);
416 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
417 move of data into a thread's regcache. Doing this would be silly
418 - it would mean that regcache->register_status would be
419 completely invalid. */
420 gdb_assert (m_readonly_p
&& src
->m_readonly_p
);
422 memcpy (m_registers
, src
->m_registers
,
423 m_descr
->sizeof_cooked_registers
);
424 memcpy (m_register_status
, src
->m_register_status
,
425 m_descr
->sizeof_cooked_register_status
);
429 regcache_dup (struct regcache
*src
)
431 return new regcache (regcache::readonly
, *src
);
435 regcache_register_status (const struct regcache
*regcache
, int regnum
)
437 gdb_assert (regcache
!= NULL
);
438 return regcache
->get_register_status (regnum
);
442 regcache::get_register_status (int regnum
) const
444 gdb_assert (regnum
>= 0);
446 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
448 gdb_assert (regnum
< m_descr
->nr_raw_registers
);
450 return (enum register_status
) m_register_status
[regnum
];
454 regcache_invalidate (struct regcache
*regcache
, int regnum
)
456 gdb_assert (regcache
!= NULL
);
457 regcache
->invalidate (regnum
);
461 regcache::invalidate (int regnum
)
463 gdb_assert (regnum
>= 0);
464 gdb_assert (!m_readonly_p
);
465 gdb_assert (regnum
< m_descr
->nr_raw_registers
);
466 m_register_status
[regnum
] = REG_UNKNOWN
;
469 /* Global structure containing the current regcache. */
471 /* NOTE: this is a write-through cache. There is no "dirty" bit for
472 recording if the register values have been changed (eg. by the
473 user). Therefore all registers must be written back to the
474 target when appropriate. */
475 std::forward_list
<regcache
*> regcache::current_regcache
;
478 get_thread_arch_aspace_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
,
479 struct address_space
*aspace
)
481 for (const auto ®cache
: regcache::current_regcache
)
482 if (ptid_equal (regcache
->ptid (), ptid
) && regcache
->arch () == gdbarch
)
485 regcache
*new_regcache
= new regcache (gdbarch
, aspace
, false);
487 regcache::current_regcache
.push_front (new_regcache
);
488 new_regcache
->set_ptid (ptid
);
494 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
496 struct address_space
*aspace
;
498 /* For the benefit of "maint print registers" & co when debugging an
499 executable, allow dumping the regcache even when there is no
500 thread selected (target_thread_address_space internal-errors if
501 no address space is found). Note that normal user commands will
502 fail higher up on the call stack due to no
503 target_has_registers. */
504 aspace
= (ptid_equal (null_ptid
, ptid
)
506 : target_thread_address_space (ptid
));
508 return get_thread_arch_aspace_regcache (ptid
, gdbarch
, aspace
);
511 static ptid_t current_thread_ptid
;
512 static struct gdbarch
*current_thread_arch
;
515 get_thread_regcache (ptid_t ptid
)
517 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
519 current_thread_ptid
= ptid
;
520 current_thread_arch
= target_thread_architecture (ptid
);
523 return get_thread_arch_regcache (ptid
, current_thread_arch
);
527 get_current_regcache (void)
529 return get_thread_regcache (inferior_ptid
);
532 /* See common/common-regcache.h. */
535 get_thread_regcache_for_ptid (ptid_t ptid
)
537 return get_thread_regcache (ptid
);
540 /* Observer for the target_changed event. */
543 regcache_observer_target_changed (struct target_ops
*target
)
545 registers_changed ();
548 /* Update global variables old ptids to hold NEW_PTID if they were
551 regcache::regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
553 for (auto ®cache
: regcache::current_regcache
)
555 if (ptid_equal (regcache
->ptid (), old_ptid
))
556 regcache
->set_ptid (new_ptid
);
560 /* Low level examining and depositing of registers.
562 The caller is responsible for making sure that the inferior is
563 stopped before calling the fetching routines, or it will get
564 garbage. (a change from GDB version 3, in which the caller got the
565 value from the last stop). */
567 /* REGISTERS_CHANGED ()
569 Indicate that registers may have changed, so invalidate the cache. */
572 registers_changed_ptid (ptid_t ptid
)
574 for (auto oit
= regcache::current_regcache
.before_begin (),
575 it
= std::next (oit
);
576 it
!= regcache::current_regcache
.end ();
579 if (ptid_match ((*it
)->ptid (), ptid
))
582 it
= regcache::current_regcache
.erase_after (oit
);
588 if (ptid_match (current_thread_ptid
, ptid
))
590 current_thread_ptid
= null_ptid
;
591 current_thread_arch
= NULL
;
594 if (ptid_match (inferior_ptid
, ptid
))
596 /* We just deleted the regcache of the current thread. Need to
597 forget about any frames we have cached, too. */
598 reinit_frame_cache ();
603 registers_changed (void)
605 registers_changed_ptid (minus_one_ptid
);
607 /* Force cleanup of any alloca areas if using C alloca instead of
608 a builtin alloca. This particular call is used to clean up
609 areas allocated by low level target code which may build up
610 during lengthy interactions between gdb and the target before
611 gdb gives control to the user (ie watchpoints). */
616 regcache_raw_update (struct regcache
*regcache
, int regnum
)
618 gdb_assert (regcache
!= NULL
);
620 regcache
->raw_update (regnum
);
624 regcache::raw_update (int regnum
)
626 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
628 /* Make certain that the register cache is up-to-date with respect
629 to the current thread. This switching shouldn't be necessary
630 only there is still only one target side register cache. Sigh!
631 On the bright side, at least there is a regcache object. */
633 if (!m_readonly_p
&& get_register_status (regnum
) == REG_UNKNOWN
)
635 target_fetch_registers (this, regnum
);
637 /* A number of targets can't access the whole set of raw
638 registers (because the debug API provides no means to get at
640 if (m_register_status
[regnum
] == REG_UNKNOWN
)
641 m_register_status
[regnum
] = REG_UNAVAILABLE
;
646 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
648 return regcache
->raw_read (regnum
, buf
);
652 regcache::raw_read (int regnum
, gdb_byte
*buf
)
654 gdb_assert (buf
!= NULL
);
657 if (m_register_status
[regnum
] != REG_VALID
)
658 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
660 memcpy (buf
, register_buffer (regnum
),
661 m_descr
->sizeof_register
[regnum
]);
663 return (enum register_status
) m_register_status
[regnum
];
667 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
669 gdb_assert (regcache
!= NULL
);
670 return regcache
->raw_read_signed (regnum
, val
);
674 regcache::raw_read_signed (int regnum
, LONGEST
*val
)
677 enum register_status status
;
679 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
680 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
681 status
= raw_read (regnum
, buf
);
682 if (status
== REG_VALID
)
683 *val
= extract_signed_integer
684 (buf
, m_descr
->sizeof_register
[regnum
],
685 gdbarch_byte_order (m_descr
->gdbarch
));
692 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
695 gdb_assert (regcache
!= NULL
);
696 return regcache
->raw_read_unsigned (regnum
, val
);
701 regcache::raw_read_unsigned (int regnum
, ULONGEST
*val
)
704 enum register_status status
;
706 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
707 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
708 status
= raw_read (regnum
, buf
);
709 if (status
== REG_VALID
)
710 *val
= extract_unsigned_integer
711 (buf
, m_descr
->sizeof_register
[regnum
],
712 gdbarch_byte_order (m_descr
->gdbarch
));
719 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
721 gdb_assert (regcache
!= NULL
);
722 regcache
->raw_write_signed (regnum
, val
);
726 regcache::raw_write_signed (int regnum
, LONGEST val
)
730 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_raw_registers
);
731 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
732 store_signed_integer (buf
, m_descr
->sizeof_register
[regnum
],
733 gdbarch_byte_order (m_descr
->gdbarch
), val
);
734 raw_write (regnum
, buf
);
738 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
741 gdb_assert (regcache
!= NULL
);
742 regcache
->raw_write_unsigned (regnum
, val
);
746 regcache::raw_write_unsigned (int regnum
, ULONGEST val
)
750 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_raw_registers
);
751 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
752 store_unsigned_integer (buf
, m_descr
->sizeof_register
[regnum
],
753 gdbarch_byte_order (m_descr
->gdbarch
), val
);
754 raw_write (regnum
, buf
);
758 regcache_raw_get_signed (struct regcache
*regcache
, int regnum
)
761 enum register_status status
;
763 status
= regcache_raw_read_signed (regcache
, regnum
, &value
);
764 if (status
== REG_UNAVAILABLE
)
765 throw_error (NOT_AVAILABLE_ERROR
,
766 _("Register %d is not available"), regnum
);
771 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
773 return regcache
->cooked_read (regnum
, buf
);
777 regcache::cooked_read (int regnum
, gdb_byte
*buf
)
779 gdb_assert (regnum
>= 0);
780 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
781 if (regnum
< m_descr
->nr_raw_registers
)
782 return raw_read (regnum
, buf
);
783 else if (m_readonly_p
784 && m_register_status
[regnum
] != REG_UNKNOWN
)
786 /* Read-only register cache, perhaps the cooked value was
788 if (m_register_status
[regnum
] == REG_VALID
)
789 memcpy (buf
, register_buffer (regnum
),
790 m_descr
->sizeof_register
[regnum
]);
792 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
794 return (enum register_status
) m_register_status
[regnum
];
796 else if (gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
798 struct value
*mark
, *computed
;
799 enum register_status result
= REG_VALID
;
801 mark
= value_mark ();
803 computed
= gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
805 if (value_entirely_available (computed
))
806 memcpy (buf
, value_contents_raw (computed
),
807 m_descr
->sizeof_register
[regnum
]);
810 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
811 result
= REG_UNAVAILABLE
;
814 value_free_to_mark (mark
);
819 return gdbarch_pseudo_register_read (m_descr
->gdbarch
, this,
824 regcache_cooked_read_value (struct regcache
*regcache
, int regnum
)
826 return regcache
->cooked_read_value (regnum
);
830 regcache::cooked_read_value (int regnum
)
832 gdb_assert (regnum
>= 0);
833 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
835 if (regnum
< m_descr
->nr_raw_registers
836 || (m_readonly_p
&& m_register_status
[regnum
] != REG_UNKNOWN
)
837 || !gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
839 struct value
*result
;
841 result
= allocate_value (register_type (m_descr
->gdbarch
, regnum
));
842 VALUE_LVAL (result
) = lval_register
;
843 VALUE_REGNUM (result
) = regnum
;
845 /* It is more efficient in general to do this delegation in this
846 direction than in the other one, even though the value-based
848 if (cooked_read (regnum
,
849 value_contents_raw (result
)) == REG_UNAVAILABLE
)
850 mark_value_bytes_unavailable (result
, 0,
851 TYPE_LENGTH (value_type (result
)));
856 return gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
861 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
864 gdb_assert (regcache
!= NULL
);
865 return regcache
->cooked_read_signed (regnum
, val
);
869 regcache::cooked_read_signed (int regnum
, LONGEST
*val
)
871 enum register_status status
;
874 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
875 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
876 status
= cooked_read (regnum
, buf
);
877 if (status
== REG_VALID
)
878 *val
= extract_signed_integer
879 (buf
, m_descr
->sizeof_register
[regnum
],
880 gdbarch_byte_order (m_descr
->gdbarch
));
887 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
890 gdb_assert (regcache
!= NULL
);
891 return regcache
->cooked_read_unsigned (regnum
, val
);
895 regcache::cooked_read_unsigned (int regnum
, ULONGEST
*val
)
897 enum register_status status
;
900 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
901 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
902 status
= cooked_read (regnum
, buf
);
903 if (status
== REG_VALID
)
904 *val
= extract_unsigned_integer
905 (buf
, m_descr
->sizeof_register
[regnum
],
906 gdbarch_byte_order (m_descr
->gdbarch
));
913 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
916 gdb_assert (regcache
!= NULL
);
917 regcache
->cooked_write_signed (regnum
, val
);
921 regcache::cooked_write_signed (int regnum
, LONGEST val
)
925 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
926 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
927 store_signed_integer (buf
, m_descr
->sizeof_register
[regnum
],
928 gdbarch_byte_order (m_descr
->gdbarch
), val
);
929 cooked_write (regnum
, buf
);
933 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
936 gdb_assert (regcache
!= NULL
);
937 regcache
->cooked_write_unsigned (regnum
, val
);
941 regcache::cooked_write_unsigned (int regnum
, ULONGEST val
)
945 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
946 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
947 store_unsigned_integer (buf
, m_descr
->sizeof_register
[regnum
],
948 gdbarch_byte_order (m_descr
->gdbarch
), val
);
949 cooked_write (regnum
, buf
);
952 /* See regcache.h. */
955 regcache_raw_set_cached_value (struct regcache
*regcache
, int regnum
,
958 regcache
->raw_set_cached_value (regnum
, buf
);
962 regcache::raw_set_cached_value (int regnum
, const gdb_byte
*buf
)
964 memcpy (register_buffer (regnum
), buf
,
965 m_descr
->sizeof_register
[regnum
]);
966 m_register_status
[regnum
] = REG_VALID
;
970 regcache_raw_write (struct regcache
*regcache
, int regnum
,
973 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
974 regcache
->raw_write (regnum
, buf
);
978 regcache::raw_write (int regnum
, const gdb_byte
*buf
)
980 struct cleanup
*old_chain
;
982 gdb_assert (buf
!= NULL
);
983 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
984 gdb_assert (!m_readonly_p
);
986 /* On the sparc, writing %g0 is a no-op, so we don't even want to
987 change the registers array if something writes to this register. */
988 if (gdbarch_cannot_store_register (arch (), regnum
))
991 /* If we have a valid copy of the register, and new value == old
992 value, then don't bother doing the actual store. */
993 if (get_register_status (regnum
) == REG_VALID
994 && (memcmp (register_buffer (regnum
), buf
,
995 m_descr
->sizeof_register
[regnum
]) == 0))
998 target_prepare_to_store (this);
999 raw_set_cached_value (regnum
, buf
);
1001 /* Register a cleanup function for invalidating the register after it is
1002 written, in case of a failure. */
1003 old_chain
= make_cleanup_regcache_invalidate (this, regnum
);
1005 target_store_registers (this, regnum
);
1007 /* The target did not throw an error so we can discard invalidating the
1008 register and restore the cleanup chain to what it was. */
1009 discard_cleanups (old_chain
);
1013 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
1014 const gdb_byte
*buf
)
1016 regcache
->cooked_write (regnum
, buf
);
1020 regcache::cooked_write (int regnum
, const gdb_byte
*buf
)
1022 gdb_assert (regnum
>= 0);
1023 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
1024 if (regnum
< m_descr
->nr_raw_registers
)
1025 raw_write (regnum
, buf
);
1027 gdbarch_pseudo_register_write (m_descr
->gdbarch
, this,
1031 /* Perform a partial register transfer using a read, modify, write
1034 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
1036 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
1039 enum register_status
1040 regcache::xfer_part (int regnum
, int offset
, int len
, void *in
,
1042 enum register_status (*read
) (struct regcache
*regcache
,
1045 void (*write
) (struct regcache
*regcache
, int regnum
,
1046 const gdb_byte
*buf
))
1048 struct gdbarch
*gdbarch
= arch ();
1049 gdb_byte
*reg
= (gdb_byte
*) alloca (register_size (gdbarch
, regnum
));
1051 gdb_assert (offset
>= 0 && offset
<= m_descr
->sizeof_register
[regnum
]);
1052 gdb_assert (len
>= 0 && offset
+ len
<= m_descr
->sizeof_register
[regnum
]);
1053 /* Something to do? */
1054 if (offset
+ len
== 0)
1056 /* Read (when needed) ... */
1059 || offset
+ len
< m_descr
->sizeof_register
[regnum
])
1061 enum register_status status
;
1063 gdb_assert (read
!= NULL
);
1064 status
= read (this, regnum
, reg
);
1065 if (status
!= REG_VALID
)
1068 /* ... modify ... */
1070 memcpy (in
, reg
+ offset
, len
);
1072 memcpy (reg
+ offset
, out
, len
);
1073 /* ... write (when needed). */
1076 gdb_assert (write
!= NULL
);
1077 write (this, regnum
, reg
);
1083 enum register_status
1084 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
1085 int offset
, int len
, gdb_byte
*buf
)
1087 return regcache
->raw_read_part (regnum
, offset
, len
, buf
);
1090 enum register_status
1091 regcache::raw_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
1093 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1094 return xfer_part (regnum
, offset
, len
, buf
, NULL
,
1095 regcache_raw_read
, regcache_raw_write
);
1099 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
1100 int offset
, int len
, const gdb_byte
*buf
)
1102 regcache
->raw_write_part (regnum
, offset
, len
, buf
);
1106 regcache::raw_write_part (int regnum
, int offset
, int len
,
1107 const gdb_byte
*buf
)
1109 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1110 xfer_part (regnum
, offset
, len
, NULL
, buf
, regcache_raw_read
,
1111 regcache_raw_write
);
1114 enum register_status
1115 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
1116 int offset
, int len
, gdb_byte
*buf
)
1118 return regcache
->cooked_read_part (regnum
, offset
, len
, buf
);
1122 enum register_status
1123 regcache::cooked_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
1125 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1126 return xfer_part (regnum
, offset
, len
, buf
, NULL
,
1127 regcache_cooked_read
, regcache_cooked_write
);
1131 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
1132 int offset
, int len
, const gdb_byte
*buf
)
1134 regcache
->cooked_write_part (regnum
, offset
, len
, buf
);
1138 regcache::cooked_write_part (int regnum
, int offset
, int len
,
1139 const gdb_byte
*buf
)
1141 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1142 xfer_part (regnum
, offset
, len
, NULL
, buf
,
1143 regcache_cooked_read
, regcache_cooked_write
);
1146 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
1149 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
1151 gdb_assert (regcache
!= NULL
);
1152 regcache
->raw_supply (regnum
, buf
);
1156 regcache::raw_supply (int regnum
, const void *buf
)
1161 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1162 gdb_assert (!m_readonly_p
);
1164 regbuf
= register_buffer (regnum
);
1165 size
= m_descr
->sizeof_register
[regnum
];
1169 memcpy (regbuf
, buf
, size
);
1170 m_register_status
[regnum
] = REG_VALID
;
1174 /* This memset not strictly necessary, but better than garbage
1175 in case the register value manages to escape somewhere (due
1176 to a bug, no less). */
1177 memset (regbuf
, 0, size
);
1178 m_register_status
[regnum
] = REG_UNAVAILABLE
;
1182 /* Supply register REGNUM with zeroed value to REGCACHE. This is not the same
1183 as calling raw_supply with NULL (which will set the state to
1187 regcache::raw_supply_zeroed (int regnum
)
1192 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1193 gdb_assert (!m_readonly_p
);
1195 regbuf
= register_buffer (regnum
);
1196 size
= m_descr
->sizeof_register
[regnum
];
1198 memset (regbuf
, 0, size
);
1199 m_register_status
[regnum
] = REG_VALID
;
1202 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1205 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
1207 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
1208 regcache
->raw_collect (regnum
, buf
);
1212 regcache::raw_collect (int regnum
, void *buf
) const
1217 gdb_assert (buf
!= NULL
);
1218 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1220 regbuf
= register_buffer (regnum
);
1221 size
= m_descr
->sizeof_register
[regnum
];
1222 memcpy (buf
, regbuf
, size
);
1225 /* Transfer a single or all registers belonging to a certain register
1226 set to or from a buffer. This is the main worker function for
1227 regcache_supply_regset and regcache_collect_regset. */
1230 regcache::transfer_regset (const struct regset
*regset
,
1231 struct regcache
*out_regcache
,
1232 int regnum
, const void *in_buf
,
1233 void *out_buf
, size_t size
) const
1235 const struct regcache_map_entry
*map
;
1236 int offs
= 0, count
;
1238 for (map
= (const struct regcache_map_entry
*) regset
->regmap
;
1239 (count
= map
->count
) != 0;
1242 int regno
= map
->regno
;
1243 int slot_size
= map
->size
;
1245 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1246 slot_size
= m_descr
->sizeof_register
[regno
];
1248 if (regno
== REGCACHE_MAP_SKIP
1250 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1251 offs
+= count
* slot_size
;
1253 else if (regnum
== -1)
1254 for (; count
--; regno
++, offs
+= slot_size
)
1256 if (offs
+ slot_size
> size
)
1260 raw_collect (regno
, (gdb_byte
*) out_buf
+ offs
);
1262 out_regcache
->raw_supply (regno
, in_buf
1263 ? (const gdb_byte
*) in_buf
+ offs
1268 /* Transfer a single register and return. */
1269 offs
+= (regnum
- regno
) * slot_size
;
1270 if (offs
+ slot_size
> size
)
1274 raw_collect (regnum
, (gdb_byte
*) out_buf
+ offs
);
1276 out_regcache
->raw_supply (regnum
, in_buf
1277 ? (const gdb_byte
*) in_buf
+ offs
1284 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1285 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1286 If BUF is NULL, set the register(s) to "unavailable" status. */
1289 regcache_supply_regset (const struct regset
*regset
,
1290 struct regcache
*regcache
,
1291 int regnum
, const void *buf
, size_t size
)
1293 regcache
->supply_regset (regset
, regnum
, buf
, size
);
1297 regcache::supply_regset (const struct regset
*regset
,
1298 int regnum
, const void *buf
, size_t size
)
1300 transfer_regset (regset
, this, regnum
, buf
, NULL
, size
);
1303 /* Collect register REGNUM from REGCACHE to BUF, using the register
1304 map in REGSET. If REGNUM is -1, do this for all registers in
1308 regcache_collect_regset (const struct regset
*regset
,
1309 const struct regcache
*regcache
,
1310 int regnum
, void *buf
, size_t size
)
1312 regcache
->collect_regset (regset
, regnum
, buf
, size
);
1316 regcache::collect_regset (const struct regset
*regset
,
1317 int regnum
, void *buf
, size_t size
) const
1319 transfer_regset (regset
, NULL
, regnum
, NULL
, buf
, size
);
1323 /* Special handling for register PC. */
1326 regcache_read_pc (struct regcache
*regcache
)
1328 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1332 if (gdbarch_read_pc_p (gdbarch
))
1333 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1334 /* Else use per-frame method on get_current_frame. */
1335 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1339 if (regcache_cooked_read_unsigned (regcache
,
1340 gdbarch_pc_regnum (gdbarch
),
1341 &raw_val
) == REG_UNAVAILABLE
)
1342 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1344 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1347 internal_error (__FILE__
, __LINE__
,
1348 _("regcache_read_pc: Unable to find PC"));
1353 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1355 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1357 if (gdbarch_write_pc_p (gdbarch
))
1358 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1359 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1360 regcache_cooked_write_unsigned (regcache
,
1361 gdbarch_pc_regnum (gdbarch
), pc
);
1363 internal_error (__FILE__
, __LINE__
,
1364 _("regcache_write_pc: Unable to update PC"));
1366 /* Writing the PC (for instance, from "load") invalidates the
1368 reinit_frame_cache ();
1372 regcache::debug_print_register (const char *func
, int regno
)
1374 struct gdbarch
*gdbarch
= arch ();
1376 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1377 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
1378 && gdbarch_register_name (gdbarch
, regno
) != NULL
1379 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
1380 fprintf_unfiltered (gdb_stdlog
, "(%s)",
1381 gdbarch_register_name (gdbarch
, regno
));
1383 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1384 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
1386 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1387 int size
= register_size (gdbarch
, regno
);
1388 gdb_byte
*buf
= register_buffer (regno
);
1390 fprintf_unfiltered (gdb_stdlog
, " = ");
1391 for (int i
= 0; i
< size
; i
++)
1393 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1395 if (size
<= sizeof (LONGEST
))
1397 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
1399 fprintf_unfiltered (gdb_stdlog
, " %s %s",
1400 core_addr_to_string_nz (val
), plongest (val
));
1403 fprintf_unfiltered (gdb_stdlog
, "\n");
1407 reg_flush_command (char *command
, int from_tty
)
1409 /* Force-flush the register cache. */
1410 registers_changed ();
1412 printf_filtered (_("Register cache flushed.\n"));
1416 regcache::dump (ui_file
*file
, enum regcache_dump_what what_to_dump
)
1418 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1419 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
1421 int footnote_nr
= 0;
1422 int footnote_register_size
= 0;
1423 int footnote_register_offset
= 0;
1424 int footnote_register_type_name_null
= 0;
1425 long register_offset
= 0;
1426 gdb_byte buf
[MAX_REGISTER_SIZE
];
1429 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1430 m_descr
->nr_raw_registers
);
1431 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1432 m_descr
->nr_cooked_registers
);
1433 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1434 m_descr
->sizeof_raw_registers
);
1435 fprintf_unfiltered (file
, "sizeof_raw_register_status %ld\n",
1436 m_descr
->sizeof_raw_register_status
);
1437 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
1438 gdbarch_num_regs (gdbarch
));
1439 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
1440 gdbarch_num_pseudo_regs (gdbarch
));
1443 gdb_assert (m_descr
->nr_cooked_registers
1444 == (gdbarch_num_regs (gdbarch
)
1445 + gdbarch_num_pseudo_regs (gdbarch
)));
1447 for (regnum
= -1; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
1451 fprintf_unfiltered (file
, " %-10s", "Name");
1454 const char *p
= gdbarch_register_name (gdbarch
, regnum
);
1458 else if (p
[0] == '\0')
1460 fprintf_unfiltered (file
, " %-10s", p
);
1465 fprintf_unfiltered (file
, " %4s", "Nr");
1467 fprintf_unfiltered (file
, " %4d", regnum
);
1469 /* Relative number. */
1471 fprintf_unfiltered (file
, " %4s", "Rel");
1472 else if (regnum
< gdbarch_num_regs (gdbarch
))
1473 fprintf_unfiltered (file
, " %4d", regnum
);
1475 fprintf_unfiltered (file
, " %4d",
1476 (regnum
- gdbarch_num_regs (gdbarch
)));
1480 fprintf_unfiltered (file
, " %6s ", "Offset");
1483 fprintf_unfiltered (file
, " %6ld",
1484 m_descr
->register_offset
[regnum
]);
1485 if (register_offset
!= m_descr
->register_offset
[regnum
]
1487 && (m_descr
->register_offset
[regnum
]
1488 != (m_descr
->register_offset
[regnum
- 1]
1489 + m_descr
->sizeof_register
[regnum
- 1])))
1492 if (!footnote_register_offset
)
1493 footnote_register_offset
= ++footnote_nr
;
1494 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1497 fprintf_unfiltered (file
, " ");
1498 register_offset
= (m_descr
->register_offset
[regnum
]
1499 + m_descr
->sizeof_register
[regnum
]);
1504 fprintf_unfiltered (file
, " %5s ", "Size");
1506 fprintf_unfiltered (file
, " %5ld", m_descr
->sizeof_register
[regnum
]);
1516 static const char blt
[] = "builtin_type";
1518 t
= TYPE_NAME (register_type (arch (), regnum
));
1523 if (!footnote_register_type_name_null
)
1524 footnote_register_type_name_null
= ++footnote_nr
;
1525 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1526 make_cleanup (xfree
, n
);
1529 /* Chop a leading builtin_type. */
1530 if (startswith (t
, blt
))
1533 fprintf_unfiltered (file
, " %-15s", t
);
1536 /* Leading space always present. */
1537 fprintf_unfiltered (file
, " ");
1540 if (what_to_dump
== regcache_dump_raw
)
1543 fprintf_unfiltered (file
, "Raw value");
1544 else if (regnum
>= m_descr
->nr_raw_registers
)
1545 fprintf_unfiltered (file
, "<cooked>");
1546 else if (get_register_status (regnum
) == REG_UNKNOWN
)
1547 fprintf_unfiltered (file
, "<invalid>");
1548 else if (get_register_status (regnum
) == REG_UNAVAILABLE
)
1549 fprintf_unfiltered (file
, "<unavailable>");
1552 raw_read (regnum
, buf
);
1553 print_hex_chars (file
, buf
,
1554 m_descr
->sizeof_register
[regnum
],
1555 gdbarch_byte_order (gdbarch
));
1559 /* Value, cooked. */
1560 if (what_to_dump
== regcache_dump_cooked
)
1563 fprintf_unfiltered (file
, "Cooked value");
1566 enum register_status status
;
1568 status
= cooked_read (regnum
, buf
);
1569 if (status
== REG_UNKNOWN
)
1570 fprintf_unfiltered (file
, "<invalid>");
1571 else if (status
== REG_UNAVAILABLE
)
1572 fprintf_unfiltered (file
, "<unavailable>");
1574 print_hex_chars (file
, buf
,
1575 m_descr
->sizeof_register
[regnum
],
1576 gdbarch_byte_order (gdbarch
));
1580 /* Group members. */
1581 if (what_to_dump
== regcache_dump_groups
)
1584 fprintf_unfiltered (file
, "Groups");
1587 const char *sep
= "";
1588 struct reggroup
*group
;
1590 for (group
= reggroup_next (gdbarch
, NULL
);
1592 group
= reggroup_next (gdbarch
, group
))
1594 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1596 fprintf_unfiltered (file
,
1597 "%s%s", sep
, reggroup_name (group
));
1604 /* Remote packet configuration. */
1605 if (what_to_dump
== regcache_dump_remote
)
1609 fprintf_unfiltered (file
, "Rmt Nr g/G Offset");
1611 else if (regnum
< m_descr
->nr_raw_registers
)
1615 if (remote_register_number_and_offset (arch (), regnum
,
1617 fprintf_unfiltered (file
, "%7d %11d", pnum
, poffset
);
1621 fprintf_unfiltered (file
, "\n");
1624 if (footnote_register_size
)
1625 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1626 footnote_register_size
);
1627 if (footnote_register_offset
)
1628 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1629 footnote_register_offset
);
1630 if (footnote_register_type_name_null
)
1631 fprintf_unfiltered (file
,
1632 "*%d: Register type's name NULL.\n",
1633 footnote_register_type_name_null
);
1634 do_cleanups (cleanups
);
1638 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1641 get_current_regcache ()->dump (gdb_stdout
, what_to_dump
);
1646 if (!file
.open (args
, "w"))
1647 perror_with_name (_("maintenance print architecture"));
1648 get_current_regcache ()->dump (&file
, what_to_dump
);
1653 maintenance_print_registers (char *args
, int from_tty
)
1655 regcache_print (args
, regcache_dump_none
);
1659 maintenance_print_raw_registers (char *args
, int from_tty
)
1661 regcache_print (args
, regcache_dump_raw
);
1665 maintenance_print_cooked_registers (char *args
, int from_tty
)
1667 regcache_print (args
, regcache_dump_cooked
);
1671 maintenance_print_register_groups (char *args
, int from_tty
)
1673 regcache_print (args
, regcache_dump_groups
);
1677 maintenance_print_remote_registers (char *args
, int from_tty
)
1679 regcache_print (args
, regcache_dump_remote
);
1683 #include "selftest.h"
1685 namespace selftests
{
1687 class regcache_access
: public regcache
1691 /* Return the number of elements in current_regcache. */
1694 current_regcache_size ()
1696 return std::distance (regcache::current_regcache
.begin (),
1697 regcache::current_regcache
.end ());
1702 current_regcache_test (void)
1704 /* It is empty at the start. */
1705 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1707 ptid_t
ptid1 (1), ptid2 (2), ptid3 (3);
1709 /* Get regcache from ptid1, a new regcache is added to
1710 current_regcache. */
1711 regcache
*regcache
= get_thread_arch_aspace_regcache (ptid1
,
1715 SELF_CHECK (regcache
!= NULL
);
1716 SELF_CHECK (regcache
->ptid () == ptid1
);
1717 SELF_CHECK (regcache_access::current_regcache_size () == 1);
1719 /* Get regcache from ptid2, a new regcache is added to
1720 current_regcache. */
1721 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1724 SELF_CHECK (regcache
!= NULL
);
1725 SELF_CHECK (regcache
->ptid () == ptid2
);
1726 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1728 /* Get regcache from ptid3, a new regcache is added to
1729 current_regcache. */
1730 regcache
= get_thread_arch_aspace_regcache (ptid3
,
1733 SELF_CHECK (regcache
!= NULL
);
1734 SELF_CHECK (regcache
->ptid () == ptid3
);
1735 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1737 /* Get regcache from ptid2 again, nothing is added to
1738 current_regcache. */
1739 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1742 SELF_CHECK (regcache
!= NULL
);
1743 SELF_CHECK (regcache
->ptid () == ptid2
);
1744 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1746 /* Mark ptid2 is changed, so regcache of ptid2 should be removed from
1747 current_regcache. */
1748 registers_changed_ptid (ptid2
);
1749 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1752 } // namespace selftests
1753 #endif /* GDB_SELF_TEST */
1755 extern initialize_file_ftype _initialize_regcache
; /* -Wmissing-prototype */
1758 _initialize_regcache (void)
1760 regcache_descr_handle
1761 = gdbarch_data_register_post_init (init_regcache_descr
);
1763 observer_attach_target_changed (regcache_observer_target_changed
);
1764 observer_attach_thread_ptid_changed (regcache::regcache_thread_ptid_changed
);
1766 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1767 _("Force gdb to flush its register cache (maintainer command)"));
1769 add_cmd ("registers", class_maintenance
, maintenance_print_registers
,
1770 _("Print the internal register configuration.\n"
1771 "Takes an optional file parameter."), &maintenanceprintlist
);
1772 add_cmd ("raw-registers", class_maintenance
,
1773 maintenance_print_raw_registers
,
1774 _("Print the internal register configuration "
1775 "including raw values.\n"
1776 "Takes an optional file parameter."), &maintenanceprintlist
);
1777 add_cmd ("cooked-registers", class_maintenance
,
1778 maintenance_print_cooked_registers
,
1779 _("Print the internal register configuration "
1780 "including cooked values.\n"
1781 "Takes an optional file parameter."), &maintenanceprintlist
);
1782 add_cmd ("register-groups", class_maintenance
,
1783 maintenance_print_register_groups
,
1784 _("Print the internal register configuration "
1785 "including each register's group.\n"
1786 "Takes an optional file parameter."),
1787 &maintenanceprintlist
);
1788 add_cmd ("remote-registers", class_maintenance
,
1789 maintenance_print_remote_registers
, _("\
1790 Print the internal register configuration including each register's\n\
1791 remote register number and buffer offset in the g/G packets.\n\
1792 Takes an optional file parameter."),
1793 &maintenanceprintlist
);
1795 register_self_test (selftests::current_regcache_test
);