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
;
333 /* The DST should be `read-only', if it wasn't then the save would
334 end up trying to write the register values back out to the
336 gdb_assert (m_readonly_p
);
337 /* Clear the dest. */
338 memset (m_registers
, 0, m_descr
->sizeof_cooked_registers
);
339 memset (m_register_status
, 0, m_descr
->sizeof_cooked_register_status
);
340 /* Copy over any registers (identified by their membership in the
341 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
342 gdbarch_num_pseudo_regs) range is checked since some architectures need
343 to save/restore `cooked' registers that live in memory. */
344 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
346 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
348 gdb_byte
*dst_buf
= register_buffer (regnum
);
349 enum register_status status
= cooked_read (src
, regnum
, dst_buf
);
351 gdb_assert (status
!= REG_UNKNOWN
);
353 if (status
!= REG_VALID
)
354 memset (dst_buf
, 0, register_size (gdbarch
, regnum
));
356 m_register_status
[regnum
] = status
;
362 regcache::restore (struct regcache
*src
)
364 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
367 /* The dst had better not be read-only. If it is, the `restore'
368 doesn't make much sense. */
369 gdb_assert (!m_readonly_p
);
370 gdb_assert (src
->m_readonly_p
);
371 /* Copy over any registers, being careful to only restore those that
372 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
373 + gdbarch_num_pseudo_regs) range is checked since some architectures need
374 to save/restore `cooked' registers that live in memory. */
375 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
377 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
379 if (src
->m_register_status
[regnum
] == REG_VALID
)
380 cooked_write (regnum
, src
->register_buffer (regnum
));
386 regcache_cpy (struct regcache
*dst
, struct regcache
*src
)
388 gdb_assert (src
!= NULL
&& dst
!= NULL
);
389 gdb_assert (src
->m_descr
->gdbarch
== dst
->m_descr
->gdbarch
);
390 gdb_assert (src
!= dst
);
391 gdb_assert (src
->m_readonly_p
|| dst
->m_readonly_p
);
393 if (!src
->m_readonly_p
)
394 regcache_save (dst
, do_cooked_read
, src
);
395 else if (!dst
->m_readonly_p
)
398 dst
->cpy_no_passthrough (src
);
401 /* Copy/duplicate the contents of a register cache. Unlike regcache_cpy,
402 which is pass-through, this does not go through to the target.
403 Only values values already in the cache are transferred. The SRC and DST
404 buffers must not overlap. */
407 regcache::cpy_no_passthrough (struct regcache
*src
)
409 gdb_assert (src
!= NULL
);
410 gdb_assert (src
->m_descr
->gdbarch
== m_descr
->gdbarch
);
411 /* NOTE: cagney/2002-05-17: Don't let the caller do a no-passthrough
412 move of data into a thread's regcache. Doing this would be silly
413 - it would mean that regcache->register_status would be
414 completely invalid. */
415 gdb_assert (m_readonly_p
&& src
->m_readonly_p
);
417 memcpy (m_registers
, src
->m_registers
,
418 m_descr
->sizeof_cooked_registers
);
419 memcpy (m_register_status
, src
->m_register_status
,
420 m_descr
->sizeof_cooked_register_status
);
424 regcache_dup (struct regcache
*src
)
426 return new regcache (regcache::readonly
, *src
);
430 regcache_register_status (const struct regcache
*regcache
, int regnum
)
432 gdb_assert (regcache
!= NULL
);
433 return regcache
->get_register_status (regnum
);
437 regcache::get_register_status (int regnum
) const
439 gdb_assert (regnum
>= 0);
441 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
443 gdb_assert (regnum
< m_descr
->nr_raw_registers
);
445 return (enum register_status
) m_register_status
[regnum
];
449 regcache_invalidate (struct regcache
*regcache
, int regnum
)
451 gdb_assert (regcache
!= NULL
);
452 regcache
->invalidate (regnum
);
456 regcache::invalidate (int regnum
)
458 gdb_assert (regnum
>= 0);
459 gdb_assert (!m_readonly_p
);
460 gdb_assert (regnum
< m_descr
->nr_raw_registers
);
461 m_register_status
[regnum
] = REG_UNKNOWN
;
464 /* Global structure containing the current regcache. */
466 /* NOTE: this is a write-through cache. There is no "dirty" bit for
467 recording if the register values have been changed (eg. by the
468 user). Therefore all registers must be written back to the
469 target when appropriate. */
470 std::forward_list
<regcache
*> regcache::current_regcache
;
473 get_thread_arch_aspace_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
,
474 struct address_space
*aspace
)
476 for (const auto ®cache
: regcache::current_regcache
)
477 if (ptid_equal (regcache
->ptid (), ptid
) && regcache
->arch () == gdbarch
)
480 regcache
*new_regcache
= new regcache (gdbarch
, aspace
, false);
482 regcache::current_regcache
.push_front (new_regcache
);
483 new_regcache
->set_ptid (ptid
);
489 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
491 struct address_space
*aspace
;
493 /* For the benefit of "maint print registers" & co when debugging an
494 executable, allow dumping the regcache even when there is no
495 thread selected (target_thread_address_space internal-errors if
496 no address space is found). Note that normal user commands will
497 fail higher up on the call stack due to no
498 target_has_registers. */
499 aspace
= (ptid_equal (null_ptid
, ptid
)
501 : target_thread_address_space (ptid
));
503 return get_thread_arch_aspace_regcache (ptid
, gdbarch
, aspace
);
506 static ptid_t current_thread_ptid
;
507 static struct gdbarch
*current_thread_arch
;
510 get_thread_regcache (ptid_t ptid
)
512 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
514 current_thread_ptid
= ptid
;
515 current_thread_arch
= target_thread_architecture (ptid
);
518 return get_thread_arch_regcache (ptid
, current_thread_arch
);
522 get_current_regcache (void)
524 return get_thread_regcache (inferior_ptid
);
527 /* See common/common-regcache.h. */
530 get_thread_regcache_for_ptid (ptid_t ptid
)
532 return get_thread_regcache (ptid
);
535 /* Observer for the target_changed event. */
538 regcache_observer_target_changed (struct target_ops
*target
)
540 registers_changed ();
543 /* Update global variables old ptids to hold NEW_PTID if they were
546 regcache::regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
548 for (auto ®cache
: regcache::current_regcache
)
550 if (ptid_equal (regcache
->ptid (), old_ptid
))
551 regcache
->set_ptid (new_ptid
);
555 /* Low level examining and depositing of registers.
557 The caller is responsible for making sure that the inferior is
558 stopped before calling the fetching routines, or it will get
559 garbage. (a change from GDB version 3, in which the caller got the
560 value from the last stop). */
562 /* REGISTERS_CHANGED ()
564 Indicate that registers may have changed, so invalidate the cache. */
567 registers_changed_ptid (ptid_t ptid
)
569 for (auto oit
= regcache::current_regcache
.before_begin (),
570 it
= std::next (oit
);
571 it
!= regcache::current_regcache
.end ();
574 if (ptid_match ((*it
)->ptid (), ptid
))
577 it
= regcache::current_regcache
.erase_after (oit
);
583 if (ptid_match (current_thread_ptid
, ptid
))
585 current_thread_ptid
= null_ptid
;
586 current_thread_arch
= NULL
;
589 if (ptid_match (inferior_ptid
, ptid
))
591 /* We just deleted the regcache of the current thread. Need to
592 forget about any frames we have cached, too. */
593 reinit_frame_cache ();
598 registers_changed (void)
600 registers_changed_ptid (minus_one_ptid
);
602 /* Force cleanup of any alloca areas if using C alloca instead of
603 a builtin alloca. This particular call is used to clean up
604 areas allocated by low level target code which may build up
605 during lengthy interactions between gdb and the target before
606 gdb gives control to the user (ie watchpoints). */
611 regcache_raw_update (struct regcache
*regcache
, int regnum
)
613 gdb_assert (regcache
!= NULL
);
615 regcache
->raw_update (regnum
);
619 regcache::raw_update (int regnum
)
621 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
623 /* Make certain that the register cache is up-to-date with respect
624 to the current thread. This switching shouldn't be necessary
625 only there is still only one target side register cache. Sigh!
626 On the bright side, at least there is a regcache object. */
628 if (!m_readonly_p
&& get_register_status (regnum
) == REG_UNKNOWN
)
630 target_fetch_registers (this, regnum
);
632 /* A number of targets can't access the whole set of raw
633 registers (because the debug API provides no means to get at
635 if (m_register_status
[regnum
] == REG_UNKNOWN
)
636 m_register_status
[regnum
] = REG_UNAVAILABLE
;
641 regcache_raw_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
643 return regcache
->raw_read (regnum
, buf
);
647 regcache::raw_read (int regnum
, gdb_byte
*buf
)
649 gdb_assert (buf
!= NULL
);
652 if (m_register_status
[regnum
] != REG_VALID
)
653 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
655 memcpy (buf
, register_buffer (regnum
),
656 m_descr
->sizeof_register
[regnum
]);
658 return (enum register_status
) m_register_status
[regnum
];
662 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
664 gdb_assert (regcache
!= NULL
);
665 return regcache
->raw_read_signed (regnum
, val
);
669 regcache::raw_read_signed (int regnum
, LONGEST
*val
)
672 enum register_status status
;
674 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
675 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
676 status
= raw_read (regnum
, buf
);
677 if (status
== REG_VALID
)
678 *val
= extract_signed_integer
679 (buf
, m_descr
->sizeof_register
[regnum
],
680 gdbarch_byte_order (m_descr
->gdbarch
));
687 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
690 gdb_assert (regcache
!= NULL
);
691 return regcache
->raw_read_unsigned (regnum
, val
);
696 regcache::raw_read_unsigned (int regnum
, ULONGEST
*val
)
699 enum register_status status
;
701 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
702 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
703 status
= raw_read (regnum
, buf
);
704 if (status
== REG_VALID
)
705 *val
= extract_unsigned_integer
706 (buf
, m_descr
->sizeof_register
[regnum
],
707 gdbarch_byte_order (m_descr
->gdbarch
));
714 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
716 gdb_assert (regcache
!= NULL
);
717 regcache
->raw_write_signed (regnum
, val
);
721 regcache::raw_write_signed (int regnum
, LONGEST val
)
725 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_raw_registers
);
726 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
727 store_signed_integer (buf
, m_descr
->sizeof_register
[regnum
],
728 gdbarch_byte_order (m_descr
->gdbarch
), val
);
729 raw_write (regnum
, buf
);
733 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
736 gdb_assert (regcache
!= NULL
);
737 regcache
->raw_write_unsigned (regnum
, val
);
741 regcache::raw_write_unsigned (int regnum
, ULONGEST val
)
745 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_raw_registers
);
746 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
747 store_unsigned_integer (buf
, m_descr
->sizeof_register
[regnum
],
748 gdbarch_byte_order (m_descr
->gdbarch
), val
);
749 raw_write (regnum
, buf
);
753 regcache_raw_get_signed (struct regcache
*regcache
, int regnum
)
756 enum register_status status
;
758 status
= regcache_raw_read_signed (regcache
, regnum
, &value
);
759 if (status
== REG_UNAVAILABLE
)
760 throw_error (NOT_AVAILABLE_ERROR
,
761 _("Register %d is not available"), regnum
);
766 regcache_cooked_read (struct regcache
*regcache
, int regnum
, gdb_byte
*buf
)
768 return regcache
->cooked_read (regnum
, buf
);
772 regcache::cooked_read (int regnum
, gdb_byte
*buf
)
774 gdb_assert (regnum
>= 0);
775 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
776 if (regnum
< m_descr
->nr_raw_registers
)
777 return raw_read (regnum
, buf
);
778 else if (m_readonly_p
779 && m_register_status
[regnum
] != REG_UNKNOWN
)
781 /* Read-only register cache, perhaps the cooked value was
783 if (m_register_status
[regnum
] == REG_VALID
)
784 memcpy (buf
, register_buffer (regnum
),
785 m_descr
->sizeof_register
[regnum
]);
787 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
789 return (enum register_status
) m_register_status
[regnum
];
791 else if (gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
793 struct value
*mark
, *computed
;
794 enum register_status result
= REG_VALID
;
796 mark
= value_mark ();
798 computed
= gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
800 if (value_entirely_available (computed
))
801 memcpy (buf
, value_contents_raw (computed
),
802 m_descr
->sizeof_register
[regnum
]);
805 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
806 result
= REG_UNAVAILABLE
;
809 value_free_to_mark (mark
);
814 return gdbarch_pseudo_register_read (m_descr
->gdbarch
, this,
819 regcache_cooked_read_value (struct regcache
*regcache
, int regnum
)
821 return regcache
->cooked_read_value (regnum
);
825 regcache::cooked_read_value (int regnum
)
827 gdb_assert (regnum
>= 0);
828 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
830 if (regnum
< m_descr
->nr_raw_registers
831 || (m_readonly_p
&& m_register_status
[regnum
] != REG_UNKNOWN
)
832 || !gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
834 struct value
*result
;
836 result
= allocate_value (register_type (m_descr
->gdbarch
, regnum
));
837 VALUE_LVAL (result
) = lval_register
;
838 VALUE_REGNUM (result
) = regnum
;
840 /* It is more efficient in general to do this delegation in this
841 direction than in the other one, even though the value-based
843 if (cooked_read (regnum
,
844 value_contents_raw (result
)) == REG_UNAVAILABLE
)
845 mark_value_bytes_unavailable (result
, 0,
846 TYPE_LENGTH (value_type (result
)));
851 return gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
856 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
859 gdb_assert (regcache
!= NULL
);
860 return regcache
->cooked_read_signed (regnum
, val
);
864 regcache::cooked_read_signed (int regnum
, LONGEST
*val
)
866 enum register_status status
;
869 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
870 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
871 status
= cooked_read (regnum
, buf
);
872 if (status
== REG_VALID
)
873 *val
= extract_signed_integer
874 (buf
, m_descr
->sizeof_register
[regnum
],
875 gdbarch_byte_order (m_descr
->gdbarch
));
882 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
885 gdb_assert (regcache
!= NULL
);
886 return regcache
->cooked_read_unsigned (regnum
, val
);
890 regcache::cooked_read_unsigned (int regnum
, ULONGEST
*val
)
892 enum register_status status
;
895 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
896 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
897 status
= cooked_read (regnum
, buf
);
898 if (status
== REG_VALID
)
899 *val
= extract_unsigned_integer
900 (buf
, m_descr
->sizeof_register
[regnum
],
901 gdbarch_byte_order (m_descr
->gdbarch
));
908 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
911 gdb_assert (regcache
!= NULL
);
912 regcache
->cooked_write_signed (regnum
, val
);
916 regcache::cooked_write_signed (int regnum
, LONGEST val
)
920 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
921 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
922 store_signed_integer (buf
, m_descr
->sizeof_register
[regnum
],
923 gdbarch_byte_order (m_descr
->gdbarch
), val
);
924 cooked_write (regnum
, buf
);
928 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
931 gdb_assert (regcache
!= NULL
);
932 regcache
->cooked_write_unsigned (regnum
, val
);
936 regcache::cooked_write_unsigned (int regnum
, ULONGEST val
)
940 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
941 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
942 store_unsigned_integer (buf
, m_descr
->sizeof_register
[regnum
],
943 gdbarch_byte_order (m_descr
->gdbarch
), val
);
944 cooked_write (regnum
, buf
);
947 /* See regcache.h. */
950 regcache_raw_set_cached_value (struct regcache
*regcache
, int regnum
,
953 regcache
->raw_set_cached_value (regnum
, buf
);
957 regcache::raw_set_cached_value (int regnum
, const gdb_byte
*buf
)
959 memcpy (register_buffer (regnum
), buf
,
960 m_descr
->sizeof_register
[regnum
]);
961 m_register_status
[regnum
] = REG_VALID
;
965 regcache_raw_write (struct regcache
*regcache
, int regnum
,
968 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
969 regcache
->raw_write (regnum
, buf
);
973 regcache::raw_write (int regnum
, const gdb_byte
*buf
)
975 struct cleanup
*old_chain
;
977 gdb_assert (buf
!= NULL
);
978 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
979 gdb_assert (!m_readonly_p
);
981 /* On the sparc, writing %g0 is a no-op, so we don't even want to
982 change the registers array if something writes to this register. */
983 if (gdbarch_cannot_store_register (arch (), regnum
))
986 /* If we have a valid copy of the register, and new value == old
987 value, then don't bother doing the actual store. */
988 if (get_register_status (regnum
) == REG_VALID
989 && (memcmp (register_buffer (regnum
), buf
,
990 m_descr
->sizeof_register
[regnum
]) == 0))
993 target_prepare_to_store (this);
994 raw_set_cached_value (regnum
, buf
);
996 /* Register a cleanup function for invalidating the register after it is
997 written, in case of a failure. */
998 old_chain
= make_cleanup_regcache_invalidate (this, regnum
);
1000 target_store_registers (this, regnum
);
1002 /* The target did not throw an error so we can discard invalidating the
1003 register and restore the cleanup chain to what it was. */
1004 discard_cleanups (old_chain
);
1008 regcache_cooked_write (struct regcache
*regcache
, int regnum
,
1009 const gdb_byte
*buf
)
1011 regcache
->cooked_write (regnum
, buf
);
1015 regcache::cooked_write (int regnum
, const gdb_byte
*buf
)
1017 gdb_assert (regnum
>= 0);
1018 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
1019 if (regnum
< m_descr
->nr_raw_registers
)
1020 raw_write (regnum
, buf
);
1022 gdbarch_pseudo_register_write (m_descr
->gdbarch
, this,
1026 /* Perform a partial register transfer using a read, modify, write
1029 typedef void (regcache_read_ftype
) (struct regcache
*regcache
, int regnum
,
1031 typedef void (regcache_write_ftype
) (struct regcache
*regcache
, int regnum
,
1034 enum register_status
1035 regcache::xfer_part (int regnum
, int offset
, int len
, void *in
,
1037 enum register_status (*read
) (struct regcache
*regcache
,
1040 void (*write
) (struct regcache
*regcache
, int regnum
,
1041 const gdb_byte
*buf
))
1043 struct gdbarch
*gdbarch
= arch ();
1044 gdb_byte
*reg
= (gdb_byte
*) alloca (register_size (gdbarch
, regnum
));
1046 gdb_assert (offset
>= 0 && offset
<= m_descr
->sizeof_register
[regnum
]);
1047 gdb_assert (len
>= 0 && offset
+ len
<= m_descr
->sizeof_register
[regnum
]);
1048 /* Something to do? */
1049 if (offset
+ len
== 0)
1051 /* Read (when needed) ... */
1054 || offset
+ len
< m_descr
->sizeof_register
[regnum
])
1056 enum register_status status
;
1058 gdb_assert (read
!= NULL
);
1059 status
= read (this, regnum
, reg
);
1060 if (status
!= REG_VALID
)
1063 /* ... modify ... */
1065 memcpy (in
, reg
+ offset
, len
);
1067 memcpy (reg
+ offset
, out
, len
);
1068 /* ... write (when needed). */
1071 gdb_assert (write
!= NULL
);
1072 write (this, regnum
, reg
);
1078 enum register_status
1079 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
1080 int offset
, int len
, gdb_byte
*buf
)
1082 return regcache
->raw_read_part (regnum
, offset
, len
, buf
);
1085 enum register_status
1086 regcache::raw_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
1088 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1089 return xfer_part (regnum
, offset
, len
, buf
, NULL
,
1090 regcache_raw_read
, regcache_raw_write
);
1094 regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
1095 int offset
, int len
, const gdb_byte
*buf
)
1097 regcache
->raw_write_part (regnum
, offset
, len
, buf
);
1101 regcache::raw_write_part (int regnum
, int offset
, int len
,
1102 const gdb_byte
*buf
)
1104 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1105 xfer_part (regnum
, offset
, len
, NULL
, buf
, regcache_raw_read
,
1106 regcache_raw_write
);
1109 enum register_status
1110 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
1111 int offset
, int len
, gdb_byte
*buf
)
1113 return regcache
->cooked_read_part (regnum
, offset
, len
, buf
);
1117 enum register_status
1118 regcache::cooked_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
1120 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1121 return xfer_part (regnum
, offset
, len
, buf
, NULL
,
1122 regcache_cooked_read
, regcache_cooked_write
);
1126 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
1127 int offset
, int len
, const gdb_byte
*buf
)
1129 regcache
->cooked_write_part (regnum
, offset
, len
, buf
);
1133 regcache::cooked_write_part (int regnum
, int offset
, int len
,
1134 const gdb_byte
*buf
)
1136 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1137 xfer_part (regnum
, offset
, len
, NULL
, buf
,
1138 regcache_cooked_read
, regcache_cooked_write
);
1141 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
1144 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
1146 gdb_assert (regcache
!= NULL
);
1147 regcache
->raw_supply (regnum
, buf
);
1151 regcache::raw_supply (int regnum
, const void *buf
)
1156 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1157 gdb_assert (!m_readonly_p
);
1159 regbuf
= register_buffer (regnum
);
1160 size
= m_descr
->sizeof_register
[regnum
];
1164 memcpy (regbuf
, buf
, size
);
1165 m_register_status
[regnum
] = REG_VALID
;
1169 /* This memset not strictly necessary, but better than garbage
1170 in case the register value manages to escape somewhere (due
1171 to a bug, no less). */
1172 memset (regbuf
, 0, size
);
1173 m_register_status
[regnum
] = REG_UNAVAILABLE
;
1177 /* Supply register REGNUM to REGCACHE. Value to supply is an integer stored at
1178 address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED. If
1179 the register size is greater than ADDR_LEN, then the integer will be sign or
1180 zero extended. If the register size is smaller than the integer, then the
1181 most significant bytes of the integer will be truncated. */
1184 regcache::raw_supply_integer (int regnum
, const gdb_byte
*addr
, int addr_len
,
1187 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1191 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1192 gdb_assert (!m_readonly_p
);
1194 regbuf
= register_buffer (regnum
);
1195 regsize
= m_descr
->sizeof_register
[regnum
];
1197 copy_integer_to_size (regbuf
, regsize
, addr
, addr_len
, is_signed
,
1199 m_register_status
[regnum
] = REG_VALID
;
1202 /* Supply register REGNUM with zeroed value to REGCACHE. This is not the same
1203 as calling raw_supply with NULL (which will set the state to
1207 regcache::raw_supply_zeroed (int regnum
)
1212 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1213 gdb_assert (!m_readonly_p
);
1215 regbuf
= register_buffer (regnum
);
1216 size
= m_descr
->sizeof_register
[regnum
];
1218 memset (regbuf
, 0, size
);
1219 m_register_status
[regnum
] = REG_VALID
;
1222 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
1225 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
1227 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
1228 regcache
->raw_collect (regnum
, buf
);
1232 regcache::raw_collect (int regnum
, void *buf
) const
1237 gdb_assert (buf
!= NULL
);
1238 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1240 regbuf
= register_buffer (regnum
);
1241 size
= m_descr
->sizeof_register
[regnum
];
1242 memcpy (buf
, regbuf
, size
);
1245 /* Transfer a single or all registers belonging to a certain register
1246 set to or from a buffer. This is the main worker function for
1247 regcache_supply_regset and regcache_collect_regset. */
1249 /* Collect register REGNUM from REGCACHE. Store collected value as an integer
1250 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
1251 If ADDR_LEN is greater than the register size, then the integer will be sign
1252 or zero extended. If ADDR_LEN is smaller than the register size, then the
1253 most significant bytes of the integer will be truncated. */
1256 regcache::raw_collect_integer (int regnum
, gdb_byte
*addr
, int addr_len
,
1257 bool is_signed
) const
1259 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1260 const gdb_byte
*regbuf
;
1263 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_raw_registers
);
1265 regbuf
= register_buffer (regnum
);
1266 regsize
= m_descr
->sizeof_register
[regnum
];
1268 copy_integer_to_size (addr
, addr_len
, regbuf
, regsize
, is_signed
,
1273 regcache::transfer_regset (const struct regset
*regset
,
1274 struct regcache
*out_regcache
,
1275 int regnum
, const void *in_buf
,
1276 void *out_buf
, size_t size
) const
1278 const struct regcache_map_entry
*map
;
1279 int offs
= 0, count
;
1281 for (map
= (const struct regcache_map_entry
*) regset
->regmap
;
1282 (count
= map
->count
) != 0;
1285 int regno
= map
->regno
;
1286 int slot_size
= map
->size
;
1288 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1289 slot_size
= m_descr
->sizeof_register
[regno
];
1291 if (regno
== REGCACHE_MAP_SKIP
1293 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1294 offs
+= count
* slot_size
;
1296 else if (regnum
== -1)
1297 for (; count
--; regno
++, offs
+= slot_size
)
1299 if (offs
+ slot_size
> size
)
1303 raw_collect (regno
, (gdb_byte
*) out_buf
+ offs
);
1305 out_regcache
->raw_supply (regno
, in_buf
1306 ? (const gdb_byte
*) in_buf
+ offs
1311 /* Transfer a single register and return. */
1312 offs
+= (regnum
- regno
) * slot_size
;
1313 if (offs
+ slot_size
> size
)
1317 raw_collect (regnum
, (gdb_byte
*) out_buf
+ offs
);
1319 out_regcache
->raw_supply (regnum
, in_buf
1320 ? (const gdb_byte
*) in_buf
+ offs
1327 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1328 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1329 If BUF is NULL, set the register(s) to "unavailable" status. */
1332 regcache_supply_regset (const struct regset
*regset
,
1333 struct regcache
*regcache
,
1334 int regnum
, const void *buf
, size_t size
)
1336 regcache
->supply_regset (regset
, regnum
, buf
, size
);
1340 regcache::supply_regset (const struct regset
*regset
,
1341 int regnum
, const void *buf
, size_t size
)
1343 transfer_regset (regset
, this, regnum
, buf
, NULL
, size
);
1346 /* Collect register REGNUM from REGCACHE to BUF, using the register
1347 map in REGSET. If REGNUM is -1, do this for all registers in
1351 regcache_collect_regset (const struct regset
*regset
,
1352 const struct regcache
*regcache
,
1353 int regnum
, void *buf
, size_t size
)
1355 regcache
->collect_regset (regset
, regnum
, buf
, size
);
1359 regcache::collect_regset (const struct regset
*regset
,
1360 int regnum
, void *buf
, size_t size
) const
1362 transfer_regset (regset
, NULL
, regnum
, NULL
, buf
, size
);
1366 /* Special handling for register PC. */
1369 regcache_read_pc (struct regcache
*regcache
)
1371 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1375 if (gdbarch_read_pc_p (gdbarch
))
1376 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1377 /* Else use per-frame method on get_current_frame. */
1378 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1382 if (regcache_cooked_read_unsigned (regcache
,
1383 gdbarch_pc_regnum (gdbarch
),
1384 &raw_val
) == REG_UNAVAILABLE
)
1385 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1387 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1390 internal_error (__FILE__
, __LINE__
,
1391 _("regcache_read_pc: Unable to find PC"));
1396 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1398 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
1400 if (gdbarch_write_pc_p (gdbarch
))
1401 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1402 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1403 regcache_cooked_write_unsigned (regcache
,
1404 gdbarch_pc_regnum (gdbarch
), pc
);
1406 internal_error (__FILE__
, __LINE__
,
1407 _("regcache_write_pc: Unable to update PC"));
1409 /* Writing the PC (for instance, from "load") invalidates the
1411 reinit_frame_cache ();
1415 regcache::debug_print_register (const char *func
, int regno
)
1417 struct gdbarch
*gdbarch
= arch ();
1419 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1420 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
1421 && gdbarch_register_name (gdbarch
, regno
) != NULL
1422 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
1423 fprintf_unfiltered (gdb_stdlog
, "(%s)",
1424 gdbarch_register_name (gdbarch
, regno
));
1426 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1427 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
1429 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1430 int size
= register_size (gdbarch
, regno
);
1431 gdb_byte
*buf
= register_buffer (regno
);
1433 fprintf_unfiltered (gdb_stdlog
, " = ");
1434 for (int i
= 0; i
< size
; i
++)
1436 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1438 if (size
<= sizeof (LONGEST
))
1440 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
1442 fprintf_unfiltered (gdb_stdlog
, " %s %s",
1443 core_addr_to_string_nz (val
), plongest (val
));
1446 fprintf_unfiltered (gdb_stdlog
, "\n");
1450 reg_flush_command (char *command
, int from_tty
)
1452 /* Force-flush the register cache. */
1453 registers_changed ();
1455 printf_filtered (_("Register cache flushed.\n"));
1459 regcache::dump (ui_file
*file
, enum regcache_dump_what what_to_dump
)
1461 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1462 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
1464 int footnote_nr
= 0;
1465 int footnote_register_size
= 0;
1466 int footnote_register_offset
= 0;
1467 int footnote_register_type_name_null
= 0;
1468 long register_offset
= 0;
1471 fprintf_unfiltered (file
, "nr_raw_registers %d\n",
1472 m_descr
->nr_raw_registers
);
1473 fprintf_unfiltered (file
, "nr_cooked_registers %d\n",
1474 m_descr
->nr_cooked_registers
);
1475 fprintf_unfiltered (file
, "sizeof_raw_registers %ld\n",
1476 m_descr
->sizeof_raw_registers
);
1477 fprintf_unfiltered (file
, "sizeof_raw_register_status %ld\n",
1478 m_descr
->sizeof_raw_register_status
);
1479 fprintf_unfiltered (file
, "gdbarch_num_regs %d\n",
1480 gdbarch_num_regs (gdbarch
));
1481 fprintf_unfiltered (file
, "gdbarch_num_pseudo_regs %d\n",
1482 gdbarch_num_pseudo_regs (gdbarch
));
1485 gdb_assert (m_descr
->nr_cooked_registers
1486 == (gdbarch_num_regs (gdbarch
)
1487 + gdbarch_num_pseudo_regs (gdbarch
)));
1489 for (regnum
= -1; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
1493 fprintf_unfiltered (file
, " %-10s", "Name");
1496 const char *p
= gdbarch_register_name (gdbarch
, regnum
);
1500 else if (p
[0] == '\0')
1502 fprintf_unfiltered (file
, " %-10s", p
);
1507 fprintf_unfiltered (file
, " %4s", "Nr");
1509 fprintf_unfiltered (file
, " %4d", regnum
);
1511 /* Relative number. */
1513 fprintf_unfiltered (file
, " %4s", "Rel");
1514 else if (regnum
< gdbarch_num_regs (gdbarch
))
1515 fprintf_unfiltered (file
, " %4d", regnum
);
1517 fprintf_unfiltered (file
, " %4d",
1518 (regnum
- gdbarch_num_regs (gdbarch
)));
1522 fprintf_unfiltered (file
, " %6s ", "Offset");
1525 fprintf_unfiltered (file
, " %6ld",
1526 m_descr
->register_offset
[regnum
]);
1527 if (register_offset
!= m_descr
->register_offset
[regnum
]
1529 && (m_descr
->register_offset
[regnum
]
1530 != (m_descr
->register_offset
[regnum
- 1]
1531 + m_descr
->sizeof_register
[regnum
- 1])))
1534 if (!footnote_register_offset
)
1535 footnote_register_offset
= ++footnote_nr
;
1536 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1539 fprintf_unfiltered (file
, " ");
1540 register_offset
= (m_descr
->register_offset
[regnum
]
1541 + m_descr
->sizeof_register
[regnum
]);
1546 fprintf_unfiltered (file
, " %5s ", "Size");
1548 fprintf_unfiltered (file
, " %5ld", m_descr
->sizeof_register
[regnum
]);
1558 static const char blt
[] = "builtin_type";
1560 t
= TYPE_NAME (register_type (arch (), regnum
));
1565 if (!footnote_register_type_name_null
)
1566 footnote_register_type_name_null
= ++footnote_nr
;
1567 n
= xstrprintf ("*%d", footnote_register_type_name_null
);
1568 make_cleanup (xfree
, n
);
1571 /* Chop a leading builtin_type. */
1572 if (startswith (t
, blt
))
1575 fprintf_unfiltered (file
, " %-15s", t
);
1578 /* Leading space always present. */
1579 fprintf_unfiltered (file
, " ");
1582 if (what_to_dump
== regcache_dump_raw
)
1585 fprintf_unfiltered (file
, "Raw value");
1586 else if (regnum
>= m_descr
->nr_raw_registers
)
1587 fprintf_unfiltered (file
, "<cooked>");
1588 else if (get_register_status (regnum
) == REG_UNKNOWN
)
1589 fprintf_unfiltered (file
, "<invalid>");
1590 else if (get_register_status (regnum
) == REG_UNAVAILABLE
)
1591 fprintf_unfiltered (file
, "<unavailable>");
1594 raw_update (regnum
);
1595 print_hex_chars (file
, register_buffer (regnum
),
1596 m_descr
->sizeof_register
[regnum
],
1597 gdbarch_byte_order (gdbarch
));
1601 /* Value, cooked. */
1602 if (what_to_dump
== regcache_dump_cooked
)
1605 fprintf_unfiltered (file
, "Cooked value");
1608 const gdb_byte
*buf
= NULL
;
1609 enum register_status status
;
1610 struct value
*value
= NULL
;
1612 if (regnum
< m_descr
->nr_raw_registers
)
1614 raw_update (regnum
);
1615 status
= get_register_status (regnum
);
1616 buf
= register_buffer (regnum
);
1620 value
= cooked_read_value (regnum
);
1622 if (!value_optimized_out (value
)
1623 && value_entirely_available (value
))
1626 buf
= value_contents_all (value
);
1629 status
= REG_UNAVAILABLE
;
1632 if (status
== REG_UNKNOWN
)
1633 fprintf_unfiltered (file
, "<invalid>");
1634 else if (status
== REG_UNAVAILABLE
)
1635 fprintf_unfiltered (file
, "<unavailable>");
1637 print_hex_chars (file
, buf
,
1638 m_descr
->sizeof_register
[regnum
],
1639 gdbarch_byte_order (gdbarch
));
1643 release_value (value
);
1649 /* Group members. */
1650 if (what_to_dump
== regcache_dump_groups
)
1653 fprintf_unfiltered (file
, "Groups");
1656 const char *sep
= "";
1657 struct reggroup
*group
;
1659 for (group
= reggroup_next (gdbarch
, NULL
);
1661 group
= reggroup_next (gdbarch
, group
))
1663 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, group
))
1665 fprintf_unfiltered (file
,
1666 "%s%s", sep
, reggroup_name (group
));
1673 /* Remote packet configuration. */
1674 if (what_to_dump
== regcache_dump_remote
)
1678 fprintf_unfiltered (file
, "Rmt Nr g/G Offset");
1680 else if (regnum
< m_descr
->nr_raw_registers
)
1684 if (remote_register_number_and_offset (arch (), regnum
,
1686 fprintf_unfiltered (file
, "%7d %11d", pnum
, poffset
);
1690 fprintf_unfiltered (file
, "\n");
1693 if (footnote_register_size
)
1694 fprintf_unfiltered (file
, "*%d: Inconsistent register sizes.\n",
1695 footnote_register_size
);
1696 if (footnote_register_offset
)
1697 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1698 footnote_register_offset
);
1699 if (footnote_register_type_name_null
)
1700 fprintf_unfiltered (file
,
1701 "*%d: Register type's name NULL.\n",
1702 footnote_register_type_name_null
);
1703 do_cleanups (cleanups
);
1707 regcache_print (char *args
, enum regcache_dump_what what_to_dump
)
1710 get_current_regcache ()->dump (gdb_stdout
, what_to_dump
);
1715 if (!file
.open (args
, "w"))
1716 perror_with_name (_("maintenance print architecture"));
1717 get_current_regcache ()->dump (&file
, what_to_dump
);
1722 maintenance_print_registers (char *args
, int from_tty
)
1724 regcache_print (args
, regcache_dump_none
);
1728 maintenance_print_raw_registers (char *args
, int from_tty
)
1730 regcache_print (args
, regcache_dump_raw
);
1734 maintenance_print_cooked_registers (char *args
, int from_tty
)
1736 regcache_print (args
, regcache_dump_cooked
);
1740 maintenance_print_register_groups (char *args
, int from_tty
)
1742 regcache_print (args
, regcache_dump_groups
);
1746 maintenance_print_remote_registers (char *args
, int from_tty
)
1748 regcache_print (args
, regcache_dump_remote
);
1752 #include "selftest.h"
1754 namespace selftests
{
1756 class regcache_access
: public regcache
1760 /* Return the number of elements in current_regcache. */
1763 current_regcache_size ()
1765 return std::distance (regcache::current_regcache
.begin (),
1766 regcache::current_regcache
.end ());
1771 current_regcache_test (void)
1773 /* It is empty at the start. */
1774 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1776 ptid_t
ptid1 (1), ptid2 (2), ptid3 (3);
1778 /* Get regcache from ptid1, a new regcache is added to
1779 current_regcache. */
1780 regcache
*regcache
= get_thread_arch_aspace_regcache (ptid1
,
1784 SELF_CHECK (regcache
!= NULL
);
1785 SELF_CHECK (regcache
->ptid () == ptid1
);
1786 SELF_CHECK (regcache_access::current_regcache_size () == 1);
1788 /* Get regcache from ptid2, a new regcache is added to
1789 current_regcache. */
1790 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1793 SELF_CHECK (regcache
!= NULL
);
1794 SELF_CHECK (regcache
->ptid () == ptid2
);
1795 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1797 /* Get regcache from ptid3, a new regcache is added to
1798 current_regcache. */
1799 regcache
= get_thread_arch_aspace_regcache (ptid3
,
1802 SELF_CHECK (regcache
!= NULL
);
1803 SELF_CHECK (regcache
->ptid () == ptid3
);
1804 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1806 /* Get regcache from ptid2 again, nothing is added to
1807 current_regcache. */
1808 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1811 SELF_CHECK (regcache
!= NULL
);
1812 SELF_CHECK (regcache
->ptid () == ptid2
);
1813 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1815 /* Mark ptid2 is changed, so regcache of ptid2 should be removed from
1816 current_regcache. */
1817 registers_changed_ptid (ptid2
);
1818 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1821 } // namespace selftests
1822 #endif /* GDB_SELF_TEST */
1824 extern initialize_file_ftype _initialize_regcache
; /* -Wmissing-prototype */
1827 _initialize_regcache (void)
1829 regcache_descr_handle
1830 = gdbarch_data_register_post_init (init_regcache_descr
);
1832 observer_attach_target_changed (regcache_observer_target_changed
);
1833 observer_attach_thread_ptid_changed (regcache::regcache_thread_ptid_changed
);
1835 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1836 _("Force gdb to flush its register cache (maintainer command)"));
1838 add_cmd ("registers", class_maintenance
, maintenance_print_registers
,
1839 _("Print the internal register configuration.\n"
1840 "Takes an optional file parameter."), &maintenanceprintlist
);
1841 add_cmd ("raw-registers", class_maintenance
,
1842 maintenance_print_raw_registers
,
1843 _("Print the internal register configuration "
1844 "including raw values.\n"
1845 "Takes an optional file parameter."), &maintenanceprintlist
);
1846 add_cmd ("cooked-registers", class_maintenance
,
1847 maintenance_print_cooked_registers
,
1848 _("Print the internal register configuration "
1849 "including cooked values.\n"
1850 "Takes an optional file parameter."), &maintenanceprintlist
);
1851 add_cmd ("register-groups", class_maintenance
,
1852 maintenance_print_register_groups
,
1853 _("Print the internal register configuration "
1854 "including each register's group.\n"
1855 "Takes an optional file parameter."),
1856 &maintenanceprintlist
);
1857 add_cmd ("remote-registers", class_maintenance
,
1858 maintenance_print_remote_registers
, _("\
1859 Print the internal register configuration including each register's\n\
1860 remote register number and buffer offset in the g/G packets.\n\
1861 Takes an optional file parameter."),
1862 &maintenanceprintlist
);
1864 register_self_test (selftests::current_regcache_test
);