1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986-2018 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"
27 #include "observable.h"
29 #include <forward_list>
34 * Here is the actual register cache.
37 /* Per-architecture object describing the layout of a register cache.
38 Computed once when the architecture is created. */
40 struct gdbarch_data
*regcache_descr_handle
;
44 /* The architecture this descriptor belongs to. */
45 struct gdbarch
*gdbarch
;
47 /* The raw register cache. Each raw (or hard) register is supplied
48 by the target interface. The raw cache should not contain
49 redundant information - if the PC is constructed from two
50 registers then those registers and not the PC lives in the raw
52 long sizeof_raw_registers
;
54 /* The cooked register space. Each cooked register in the range
55 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
56 register. The remaining [NR_RAW_REGISTERS
57 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
58 both raw registers and memory by the architecture methods
59 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
60 int nr_cooked_registers
;
61 long sizeof_cooked_registers
;
63 /* Offset and size (in 8 bit bytes), of each register in the
64 register cache. All registers (including those in the range
65 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
67 long *register_offset
;
68 long *sizeof_register
;
70 /* Cached table containing the type of each register. */
71 struct type
**register_type
;
75 init_regcache_descr (struct gdbarch
*gdbarch
)
78 struct regcache_descr
*descr
;
79 gdb_assert (gdbarch
!= NULL
);
81 /* Create an initial, zero filled, table. */
82 descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct regcache_descr
);
83 descr
->gdbarch
= gdbarch
;
85 /* Total size of the register space. The raw registers are mapped
86 directly onto the raw register cache while the pseudo's are
87 either mapped onto raw-registers or memory. */
88 descr
->nr_cooked_registers
= gdbarch_num_regs (gdbarch
)
89 + gdbarch_num_pseudo_regs (gdbarch
);
91 /* Fill in a table of register types. */
93 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
,
95 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
96 descr
->register_type
[i
] = gdbarch_register_type (gdbarch
, i
);
98 /* Construct a strictly RAW register cache. Don't allow pseudo's
99 into the register cache. */
101 /* Lay out the register cache.
103 NOTE: cagney/2002-05-22: Only register_type() is used when
104 constructing the register cache. It is assumed that the
105 register's raw size, virtual size and type length are all the
111 descr
->sizeof_register
112 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
113 descr
->register_offset
114 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
115 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
117 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
118 descr
->register_offset
[i
] = offset
;
119 offset
+= descr
->sizeof_register
[i
];
121 /* Set the real size of the raw register cache buffer. */
122 descr
->sizeof_raw_registers
= offset
;
124 for (; i
< descr
->nr_cooked_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
];
130 /* Set the real size of the readonly register cache buffer. */
131 descr
->sizeof_cooked_registers
= offset
;
137 static struct regcache_descr
*
138 regcache_descr (struct gdbarch
*gdbarch
)
140 return (struct regcache_descr
*) gdbarch_data (gdbarch
,
141 regcache_descr_handle
);
144 /* Utility functions returning useful register attributes stored in
145 the regcache descr. */
148 register_type (struct gdbarch
*gdbarch
, int regnum
)
150 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
152 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
153 return descr
->register_type
[regnum
];
156 /* Utility functions returning useful register attributes stored in
157 the regcache descr. */
160 register_size (struct gdbarch
*gdbarch
, int regnum
)
162 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
165 gdb_assert (regnum
>= 0
166 && regnum
< (gdbarch_num_regs (gdbarch
)
167 + gdbarch_num_pseudo_regs (gdbarch
)));
168 size
= descr
->sizeof_register
[regnum
];
172 /* See common/common-regcache.h. */
175 regcache_register_size (const struct regcache
*regcache
, int n
)
177 return register_size (regcache
->arch (), n
);
180 reg_buffer::reg_buffer (gdbarch
*gdbarch
, bool has_pseudo
)
181 : m_has_pseudo (has_pseudo
)
183 gdb_assert (gdbarch
!= NULL
);
184 m_descr
= regcache_descr (gdbarch
);
188 m_registers
= XCNEWVEC (gdb_byte
, m_descr
->sizeof_cooked_registers
);
189 m_register_status
= XCNEWVEC (signed char,
190 m_descr
->nr_cooked_registers
);
194 m_registers
= XCNEWVEC (gdb_byte
, m_descr
->sizeof_raw_registers
);
195 m_register_status
= XCNEWVEC (signed char, gdbarch_num_regs (gdbarch
));
199 regcache::regcache (gdbarch
*gdbarch
, const address_space
*aspace_
)
200 /* The register buffers. A read/write register cache can only hold
201 [0 .. gdbarch_num_regs). */
202 : detached_regcache (gdbarch
, false), m_aspace (aspace_
)
204 m_ptid
= minus_one_ptid
;
207 static enum register_status
208 do_cooked_read (void *src
, int regnum
, gdb_byte
*buf
)
210 struct regcache
*regcache
= (struct regcache
*) src
;
212 return regcache
->cooked_read (regnum
, buf
);
215 readonly_detached_regcache::readonly_detached_regcache (const regcache
&src
)
216 : readonly_detached_regcache (src
.arch (), do_cooked_read
, (void *) &src
)
221 reg_buffer::arch () const
223 return m_descr
->gdbarch
;
226 /* Cleanup class for invalidating a register. */
228 class regcache_invalidator
232 regcache_invalidator (struct regcache
*regcache
, int regnum
)
233 : m_regcache (regcache
),
238 ~regcache_invalidator ()
240 if (m_regcache
!= nullptr)
241 m_regcache
->invalidate (m_regnum
);
244 DISABLE_COPY_AND_ASSIGN (regcache_invalidator
);
248 m_regcache
= nullptr;
253 struct regcache
*m_regcache
;
257 /* Return a pointer to register REGNUM's buffer cache. */
260 reg_buffer::register_buffer (int regnum
) const
262 return m_registers
+ m_descr
->register_offset
[regnum
];
266 reg_buffer::save (regcache_cooked_read_ftype
*cooked_read
,
269 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
272 /* It should have pseudo registers. */
273 gdb_assert (m_has_pseudo
);
274 /* Clear the dest. */
275 memset (m_registers
, 0, m_descr
->sizeof_cooked_registers
);
276 memset (m_register_status
, 0, m_descr
->nr_cooked_registers
);
277 /* Copy over any registers (identified by their membership in the
278 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
279 gdbarch_num_pseudo_regs) range is checked since some architectures need
280 to save/restore `cooked' registers that live in memory. */
281 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
283 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
285 gdb_byte
*dst_buf
= register_buffer (regnum
);
286 enum register_status status
= cooked_read (src
, regnum
, dst_buf
);
288 gdb_assert (status
!= REG_UNKNOWN
);
290 if (status
!= REG_VALID
)
291 memset (dst_buf
, 0, register_size (gdbarch
, regnum
));
293 m_register_status
[regnum
] = status
;
299 regcache::restore (readonly_detached_regcache
*src
)
301 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
304 gdb_assert (src
!= NULL
);
305 gdb_assert (src
->m_has_pseudo
);
307 gdb_assert (gdbarch
== src
->arch ());
309 /* Copy over any registers, being careful to only restore those that
310 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
311 + gdbarch_num_pseudo_regs) range is checked since some architectures need
312 to save/restore `cooked' registers that live in memory. */
313 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
315 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
317 if (src
->m_register_status
[regnum
] == REG_VALID
)
318 cooked_write (regnum
, src
->register_buffer (regnum
));
324 reg_buffer::get_register_status (int regnum
) const
326 assert_regnum (regnum
);
328 return (enum register_status
) m_register_status
[regnum
];
332 detached_regcache::invalidate (int regnum
)
334 assert_regnum (regnum
);
335 m_register_status
[regnum
] = REG_UNKNOWN
;
339 reg_buffer::assert_regnum (int regnum
) const
341 gdb_assert (regnum
>= 0);
343 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
345 gdb_assert (regnum
< gdbarch_num_regs (arch ()));
348 /* Global structure containing the current regcache. */
350 /* NOTE: this is a write-through cache. There is no "dirty" bit for
351 recording if the register values have been changed (eg. by the
352 user). Therefore all registers must be written back to the
353 target when appropriate. */
354 std::forward_list
<regcache
*> regcache::current_regcache
;
357 get_thread_arch_aspace_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
,
358 struct address_space
*aspace
)
360 for (const auto ®cache
: regcache::current_regcache
)
361 if (ptid_equal (regcache
->ptid (), ptid
) && regcache
->arch () == gdbarch
)
364 regcache
*new_regcache
= new regcache (gdbarch
, aspace
);
366 regcache::current_regcache
.push_front (new_regcache
);
367 new_regcache
->set_ptid (ptid
);
373 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
375 address_space
*aspace
= target_thread_address_space (ptid
);
377 return get_thread_arch_aspace_regcache (ptid
, gdbarch
, aspace
);
380 static ptid_t current_thread_ptid
;
381 static struct gdbarch
*current_thread_arch
;
384 get_thread_regcache (ptid_t ptid
)
386 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
388 current_thread_ptid
= ptid
;
389 current_thread_arch
= target_thread_architecture (ptid
);
392 return get_thread_arch_regcache (ptid
, current_thread_arch
);
396 get_current_regcache (void)
398 return get_thread_regcache (inferior_ptid
);
401 /* See common/common-regcache.h. */
404 get_thread_regcache_for_ptid (ptid_t ptid
)
406 return get_thread_regcache (ptid
);
409 /* Observer for the target_changed event. */
412 regcache_observer_target_changed (struct target_ops
*target
)
414 registers_changed ();
417 /* Update global variables old ptids to hold NEW_PTID if they were
420 regcache::regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
422 for (auto ®cache
: regcache::current_regcache
)
424 if (ptid_equal (regcache
->ptid (), old_ptid
))
425 regcache
->set_ptid (new_ptid
);
429 /* Low level examining and depositing of registers.
431 The caller is responsible for making sure that the inferior is
432 stopped before calling the fetching routines, or it will get
433 garbage. (a change from GDB version 3, in which the caller got the
434 value from the last stop). */
436 /* REGISTERS_CHANGED ()
438 Indicate that registers may have changed, so invalidate the cache. */
441 registers_changed_ptid (ptid_t ptid
)
443 for (auto oit
= regcache::current_regcache
.before_begin (),
444 it
= std::next (oit
);
445 it
!= regcache::current_regcache
.end ();
448 if (ptid_match ((*it
)->ptid (), ptid
))
451 it
= regcache::current_regcache
.erase_after (oit
);
457 if (ptid_match (current_thread_ptid
, ptid
))
459 current_thread_ptid
= null_ptid
;
460 current_thread_arch
= NULL
;
463 if (ptid_match (inferior_ptid
, ptid
))
465 /* We just deleted the regcache of the current thread. Need to
466 forget about any frames we have cached, too. */
467 reinit_frame_cache ();
472 registers_changed (void)
474 registers_changed_ptid (minus_one_ptid
);
476 /* Force cleanup of any alloca areas if using C alloca instead of
477 a builtin alloca. This particular call is used to clean up
478 areas allocated by low level target code which may build up
479 during lengthy interactions between gdb and the target before
480 gdb gives control to the user (ie watchpoints). */
485 regcache::raw_update (int regnum
)
487 assert_regnum (regnum
);
489 /* Make certain that the register cache is up-to-date with respect
490 to the current thread. This switching shouldn't be necessary
491 only there is still only one target side register cache. Sigh!
492 On the bright side, at least there is a regcache object. */
494 if (get_register_status (regnum
) == REG_UNKNOWN
)
496 target_fetch_registers (this, regnum
);
498 /* A number of targets can't access the whole set of raw
499 registers (because the debug API provides no means to get at
501 if (m_register_status
[regnum
] == REG_UNKNOWN
)
502 m_register_status
[regnum
] = REG_UNAVAILABLE
;
507 readable_regcache::raw_read (int regnum
, gdb_byte
*buf
)
509 gdb_assert (buf
!= NULL
);
512 if (m_register_status
[regnum
] != REG_VALID
)
513 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
515 memcpy (buf
, register_buffer (regnum
),
516 m_descr
->sizeof_register
[regnum
]);
518 return (enum register_status
) m_register_status
[regnum
];
522 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
524 gdb_assert (regcache
!= NULL
);
525 return regcache
->raw_read (regnum
, val
);
528 template<typename T
, typename
>
530 readable_regcache::raw_read (int regnum
, T
*val
)
533 enum register_status status
;
535 assert_regnum (regnum
);
536 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
537 status
= raw_read (regnum
, buf
);
538 if (status
== REG_VALID
)
539 *val
= extract_integer
<T
> (buf
,
540 m_descr
->sizeof_register
[regnum
],
541 gdbarch_byte_order (m_descr
->gdbarch
));
548 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
551 gdb_assert (regcache
!= NULL
);
552 return regcache
->raw_read (regnum
, val
);
556 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
558 gdb_assert (regcache
!= NULL
);
559 regcache
->raw_write (regnum
, val
);
562 template<typename T
, typename
>
564 regcache::raw_write (int regnum
, T val
)
568 assert_regnum (regnum
);
569 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
570 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
571 gdbarch_byte_order (m_descr
->gdbarch
), val
);
572 raw_write (regnum
, buf
);
576 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
579 gdb_assert (regcache
!= NULL
);
580 regcache
->raw_write (regnum
, val
);
584 regcache_raw_get_signed (struct regcache
*regcache
, int regnum
)
587 enum register_status status
;
589 status
= regcache_raw_read_signed (regcache
, regnum
, &value
);
590 if (status
== REG_UNAVAILABLE
)
591 throw_error (NOT_AVAILABLE_ERROR
,
592 _("Register %d is not available"), regnum
);
597 readable_regcache::cooked_read (int regnum
, gdb_byte
*buf
)
599 gdb_assert (regnum
>= 0);
600 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
601 if (regnum
< num_raw_registers ())
602 return raw_read (regnum
, buf
);
603 else if (m_has_pseudo
604 && m_register_status
[regnum
] != REG_UNKNOWN
)
606 if (m_register_status
[regnum
] == REG_VALID
)
607 memcpy (buf
, register_buffer (regnum
),
608 m_descr
->sizeof_register
[regnum
]);
610 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
612 return (enum register_status
) m_register_status
[regnum
];
614 else if (gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
616 struct value
*mark
, *computed
;
617 enum register_status result
= REG_VALID
;
619 mark
= value_mark ();
621 computed
= gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
623 if (value_entirely_available (computed
))
624 memcpy (buf
, value_contents_raw (computed
),
625 m_descr
->sizeof_register
[regnum
]);
628 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
629 result
= REG_UNAVAILABLE
;
632 value_free_to_mark (mark
);
637 return gdbarch_pseudo_register_read (m_descr
->gdbarch
, this,
642 regcache_cooked_read_value (struct regcache
*regcache
, int regnum
)
644 return regcache
->cooked_read_value (regnum
);
648 readable_regcache::cooked_read_value (int regnum
)
650 gdb_assert (regnum
>= 0);
651 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
653 if (regnum
< num_raw_registers ()
654 || (m_has_pseudo
&& m_register_status
[regnum
] != REG_UNKNOWN
)
655 || !gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
657 struct value
*result
;
659 result
= allocate_value (register_type (m_descr
->gdbarch
, regnum
));
660 VALUE_LVAL (result
) = lval_register
;
661 VALUE_REGNUM (result
) = regnum
;
663 /* It is more efficient in general to do this delegation in this
664 direction than in the other one, even though the value-based
666 if (cooked_read (regnum
,
667 value_contents_raw (result
)) == REG_UNAVAILABLE
)
668 mark_value_bytes_unavailable (result
, 0,
669 TYPE_LENGTH (value_type (result
)));
674 return gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
679 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
682 gdb_assert (regcache
!= NULL
);
683 return regcache
->cooked_read (regnum
, val
);
686 template<typename T
, typename
>
688 readable_regcache::cooked_read (int regnum
, T
*val
)
690 enum register_status status
;
693 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
694 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
695 status
= cooked_read (regnum
, buf
);
696 if (status
== REG_VALID
)
697 *val
= extract_integer
<T
> (buf
, m_descr
->sizeof_register
[regnum
],
698 gdbarch_byte_order (m_descr
->gdbarch
));
705 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
708 gdb_assert (regcache
!= NULL
);
709 return regcache
->cooked_read (regnum
, val
);
713 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
716 gdb_assert (regcache
!= NULL
);
717 regcache
->cooked_write (regnum
, val
);
720 template<typename T
, typename
>
722 regcache::cooked_write (int regnum
, T val
)
726 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
727 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
728 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
729 gdbarch_byte_order (m_descr
->gdbarch
), val
);
730 cooked_write (regnum
, buf
);
734 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
737 gdb_assert (regcache
!= NULL
);
738 regcache
->cooked_write (regnum
, val
);
742 regcache::raw_write (int regnum
, const gdb_byte
*buf
)
745 gdb_assert (buf
!= NULL
);
746 assert_regnum (regnum
);
748 /* On the sparc, writing %g0 is a no-op, so we don't even want to
749 change the registers array if something writes to this register. */
750 if (gdbarch_cannot_store_register (arch (), regnum
))
753 /* If we have a valid copy of the register, and new value == old
754 value, then don't bother doing the actual store. */
755 if (get_register_status (regnum
) == REG_VALID
756 && (memcmp (register_buffer (regnum
), buf
,
757 m_descr
->sizeof_register
[regnum
]) == 0))
760 target_prepare_to_store (this);
761 raw_supply (regnum
, buf
);
763 /* Invalidate the register after it is written, in case of a
765 regcache_invalidator
invalidator (this, regnum
);
767 target_store_registers (this, regnum
);
769 /* The target did not throw an error so we can discard invalidating
771 invalidator
.release ();
775 regcache::cooked_write (int regnum
, const gdb_byte
*buf
)
777 gdb_assert (regnum
>= 0);
778 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
779 if (regnum
< num_raw_registers ())
780 raw_write (regnum
, buf
);
782 gdbarch_pseudo_register_write (m_descr
->gdbarch
, this,
786 /* Perform a partial register transfer using a read, modify, write
790 readable_regcache::read_part (int regnum
, int offset
, int len
, void *in
,
793 struct gdbarch
*gdbarch
= arch ();
794 gdb_byte
*reg
= (gdb_byte
*) alloca (register_size (gdbarch
, regnum
));
796 gdb_assert (in
!= NULL
);
797 gdb_assert (offset
>= 0 && offset
<= m_descr
->sizeof_register
[regnum
]);
798 gdb_assert (len
>= 0 && offset
+ len
<= m_descr
->sizeof_register
[regnum
]);
799 /* Something to do? */
800 if (offset
+ len
== 0)
802 /* Read (when needed) ... */
803 enum register_status status
;
806 status
= raw_read (regnum
, reg
);
808 status
= cooked_read (regnum
, reg
);
809 if (status
!= REG_VALID
)
813 memcpy (in
, reg
+ offset
, len
);
819 regcache::write_part (int regnum
, int offset
, int len
,
820 const void *out
, bool is_raw
)
822 struct gdbarch
*gdbarch
= arch ();
823 gdb_byte
*reg
= (gdb_byte
*) alloca (register_size (gdbarch
, regnum
));
825 gdb_assert (out
!= NULL
);
826 gdb_assert (offset
>= 0 && offset
<= m_descr
->sizeof_register
[regnum
]);
827 gdb_assert (len
>= 0 && offset
+ len
<= m_descr
->sizeof_register
[regnum
]);
828 /* Something to do? */
829 if (offset
+ len
== 0)
831 /* Read (when needed) ... */
833 || offset
+ len
< m_descr
->sizeof_register
[regnum
])
835 enum register_status status
;
838 status
= raw_read (regnum
, reg
);
840 status
= cooked_read (regnum
, reg
);
841 if (status
!= REG_VALID
)
845 memcpy (reg
+ offset
, out
, len
);
846 /* ... write (when needed). */
848 raw_write (regnum
, reg
);
850 cooked_write (regnum
, reg
);
856 readable_regcache::raw_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
858 assert_regnum (regnum
);
859 return read_part (regnum
, offset
, len
, buf
, true);
862 /* See regcache.h. */
865 regcache::raw_write_part (int regnum
, int offset
, int len
,
868 assert_regnum (regnum
);
869 write_part (regnum
, offset
, len
, buf
, true);
873 regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
874 int offset
, int len
, gdb_byte
*buf
)
876 return regcache
->cooked_read_part (regnum
, offset
, len
, buf
);
881 readable_regcache::cooked_read_part (int regnum
, int offset
, int len
,
884 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
885 return read_part (regnum
, offset
, len
, buf
, false);
889 regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
890 int offset
, int len
, const gdb_byte
*buf
)
892 regcache
->cooked_write_part (regnum
, offset
, len
, buf
);
896 regcache::cooked_write_part (int regnum
, int offset
, int len
,
899 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
900 write_part (regnum
, offset
, len
, buf
, false);
903 /* Supply register REGNUM, whose contents are stored in BUF, to REGCACHE. */
906 regcache_raw_supply (struct regcache
*regcache
, int regnum
, const void *buf
)
908 gdb_assert (regcache
!= NULL
);
909 regcache
->raw_supply (regnum
, buf
);
913 detached_regcache::raw_supply (int regnum
, const void *buf
)
918 assert_regnum (regnum
);
920 regbuf
= register_buffer (regnum
);
921 size
= m_descr
->sizeof_register
[regnum
];
925 memcpy (regbuf
, buf
, size
);
926 m_register_status
[regnum
] = REG_VALID
;
930 /* This memset not strictly necessary, but better than garbage
931 in case the register value manages to escape somewhere (due
932 to a bug, no less). */
933 memset (regbuf
, 0, size
);
934 m_register_status
[regnum
] = REG_UNAVAILABLE
;
938 /* Supply register REGNUM to REGCACHE. Value to supply is an integer stored at
939 address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED. If
940 the register size is greater than ADDR_LEN, then the integer will be sign or
941 zero extended. If the register size is smaller than the integer, then the
942 most significant bytes of the integer will be truncated. */
945 detached_regcache::raw_supply_integer (int regnum
, const gdb_byte
*addr
,
946 int addr_len
, bool is_signed
)
948 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
952 assert_regnum (regnum
);
954 regbuf
= register_buffer (regnum
);
955 regsize
= m_descr
->sizeof_register
[regnum
];
957 copy_integer_to_size (regbuf
, regsize
, addr
, addr_len
, is_signed
,
959 m_register_status
[regnum
] = REG_VALID
;
962 /* Supply register REGNUM with zeroed value to REGCACHE. This is not the same
963 as calling raw_supply with NULL (which will set the state to
967 detached_regcache::raw_supply_zeroed (int regnum
)
972 assert_regnum (regnum
);
974 regbuf
= register_buffer (regnum
);
975 size
= m_descr
->sizeof_register
[regnum
];
977 memset (regbuf
, 0, size
);
978 m_register_status
[regnum
] = REG_VALID
;
981 /* Collect register REGNUM from REGCACHE and store its contents in BUF. */
984 regcache_raw_collect (const struct regcache
*regcache
, int regnum
, void *buf
)
986 gdb_assert (regcache
!= NULL
&& buf
!= NULL
);
987 regcache
->raw_collect (regnum
, buf
);
991 regcache::raw_collect (int regnum
, void *buf
) const
996 gdb_assert (buf
!= NULL
);
997 assert_regnum (regnum
);
999 regbuf
= register_buffer (regnum
);
1000 size
= m_descr
->sizeof_register
[regnum
];
1001 memcpy (buf
, regbuf
, size
);
1004 /* Transfer a single or all registers belonging to a certain register
1005 set to or from a buffer. This is the main worker function for
1006 regcache_supply_regset and regcache_collect_regset. */
1008 /* Collect register REGNUM from REGCACHE. Store collected value as an integer
1009 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
1010 If ADDR_LEN is greater than the register size, then the integer will be sign
1011 or zero extended. If ADDR_LEN is smaller than the register size, then the
1012 most significant bytes of the integer will be truncated. */
1015 regcache::raw_collect_integer (int regnum
, gdb_byte
*addr
, int addr_len
,
1016 bool is_signed
) const
1018 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1019 const gdb_byte
*regbuf
;
1022 assert_regnum (regnum
);
1024 regbuf
= register_buffer (regnum
);
1025 regsize
= m_descr
->sizeof_register
[regnum
];
1027 copy_integer_to_size (addr
, addr_len
, regbuf
, regsize
, is_signed
,
1032 regcache::transfer_regset (const struct regset
*regset
,
1033 struct regcache
*out_regcache
,
1034 int regnum
, const void *in_buf
,
1035 void *out_buf
, size_t size
) const
1037 const struct regcache_map_entry
*map
;
1038 int offs
= 0, count
;
1040 for (map
= (const struct regcache_map_entry
*) regset
->regmap
;
1041 (count
= map
->count
) != 0;
1044 int regno
= map
->regno
;
1045 int slot_size
= map
->size
;
1047 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1048 slot_size
= m_descr
->sizeof_register
[regno
];
1050 if (regno
== REGCACHE_MAP_SKIP
1052 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1053 offs
+= count
* slot_size
;
1055 else if (regnum
== -1)
1056 for (; count
--; regno
++, offs
+= slot_size
)
1058 if (offs
+ slot_size
> size
)
1062 raw_collect (regno
, (gdb_byte
*) out_buf
+ offs
);
1064 out_regcache
->raw_supply (regno
, in_buf
1065 ? (const gdb_byte
*) in_buf
+ offs
1070 /* Transfer a single register and return. */
1071 offs
+= (regnum
- regno
) * slot_size
;
1072 if (offs
+ slot_size
> size
)
1076 raw_collect (regnum
, (gdb_byte
*) out_buf
+ offs
);
1078 out_regcache
->raw_supply (regnum
, in_buf
1079 ? (const gdb_byte
*) in_buf
+ offs
1086 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1087 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1088 If BUF is NULL, set the register(s) to "unavailable" status. */
1091 regcache_supply_regset (const struct regset
*regset
,
1092 struct regcache
*regcache
,
1093 int regnum
, const void *buf
, size_t size
)
1095 regcache
->supply_regset (regset
, regnum
, buf
, size
);
1099 regcache::supply_regset (const struct regset
*regset
,
1100 int regnum
, const void *buf
, size_t size
)
1102 transfer_regset (regset
, this, regnum
, buf
, NULL
, size
);
1105 /* Collect register REGNUM from REGCACHE to BUF, using the register
1106 map in REGSET. If REGNUM is -1, do this for all registers in
1110 regcache_collect_regset (const struct regset
*regset
,
1111 const struct regcache
*regcache
,
1112 int regnum
, void *buf
, size_t size
)
1114 regcache
->collect_regset (regset
, regnum
, buf
, size
);
1118 regcache::collect_regset (const struct regset
*regset
,
1119 int regnum
, void *buf
, size_t size
) const
1121 transfer_regset (regset
, NULL
, regnum
, NULL
, buf
, size
);
1125 /* Special handling for register PC. */
1128 regcache_read_pc (struct regcache
*regcache
)
1130 struct gdbarch
*gdbarch
= regcache
->arch ();
1134 if (gdbarch_read_pc_p (gdbarch
))
1135 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1136 /* Else use per-frame method on get_current_frame. */
1137 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1141 if (regcache_cooked_read_unsigned (regcache
,
1142 gdbarch_pc_regnum (gdbarch
),
1143 &raw_val
) == REG_UNAVAILABLE
)
1144 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1146 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1149 internal_error (__FILE__
, __LINE__
,
1150 _("regcache_read_pc: Unable to find PC"));
1155 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1157 struct gdbarch
*gdbarch
= regcache
->arch ();
1159 if (gdbarch_write_pc_p (gdbarch
))
1160 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1161 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1162 regcache_cooked_write_unsigned (regcache
,
1163 gdbarch_pc_regnum (gdbarch
), pc
);
1165 internal_error (__FILE__
, __LINE__
,
1166 _("regcache_write_pc: Unable to update PC"));
1168 /* Writing the PC (for instance, from "load") invalidates the
1170 reinit_frame_cache ();
1174 reg_buffer::num_raw_registers () const
1176 return gdbarch_num_regs (arch ());
1180 regcache::debug_print_register (const char *func
, int regno
)
1182 struct gdbarch
*gdbarch
= arch ();
1184 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1185 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
1186 && gdbarch_register_name (gdbarch
, regno
) != NULL
1187 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
1188 fprintf_unfiltered (gdb_stdlog
, "(%s)",
1189 gdbarch_register_name (gdbarch
, regno
));
1191 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1192 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
1194 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1195 int size
= register_size (gdbarch
, regno
);
1196 gdb_byte
*buf
= register_buffer (regno
);
1198 fprintf_unfiltered (gdb_stdlog
, " = ");
1199 for (int i
= 0; i
< size
; i
++)
1201 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1203 if (size
<= sizeof (LONGEST
))
1205 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
1207 fprintf_unfiltered (gdb_stdlog
, " %s %s",
1208 core_addr_to_string_nz (val
), plongest (val
));
1211 fprintf_unfiltered (gdb_stdlog
, "\n");
1215 reg_flush_command (const char *command
, int from_tty
)
1217 /* Force-flush the register cache. */
1218 registers_changed ();
1220 printf_filtered (_("Register cache flushed.\n"));
1224 register_dump::dump (ui_file
*file
)
1226 auto descr
= regcache_descr (m_gdbarch
);
1228 int footnote_nr
= 0;
1229 int footnote_register_offset
= 0;
1230 int footnote_register_type_name_null
= 0;
1231 long register_offset
= 0;
1233 gdb_assert (descr
->nr_cooked_registers
1234 == (gdbarch_num_regs (m_gdbarch
)
1235 + gdbarch_num_pseudo_regs (m_gdbarch
)));
1237 for (regnum
= -1; regnum
< descr
->nr_cooked_registers
; regnum
++)
1241 fprintf_unfiltered (file
, " %-10s", "Name");
1244 const char *p
= gdbarch_register_name (m_gdbarch
, regnum
);
1248 else if (p
[0] == '\0')
1250 fprintf_unfiltered (file
, " %-10s", p
);
1255 fprintf_unfiltered (file
, " %4s", "Nr");
1257 fprintf_unfiltered (file
, " %4d", regnum
);
1259 /* Relative number. */
1261 fprintf_unfiltered (file
, " %4s", "Rel");
1262 else if (regnum
< gdbarch_num_regs (m_gdbarch
))
1263 fprintf_unfiltered (file
, " %4d", regnum
);
1265 fprintf_unfiltered (file
, " %4d",
1266 (regnum
- gdbarch_num_regs (m_gdbarch
)));
1270 fprintf_unfiltered (file
, " %6s ", "Offset");
1273 fprintf_unfiltered (file
, " %6ld",
1274 descr
->register_offset
[regnum
]);
1275 if (register_offset
!= descr
->register_offset
[regnum
]
1277 && (descr
->register_offset
[regnum
]
1278 != (descr
->register_offset
[regnum
- 1]
1279 + descr
->sizeof_register
[regnum
- 1])))
1282 if (!footnote_register_offset
)
1283 footnote_register_offset
= ++footnote_nr
;
1284 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1287 fprintf_unfiltered (file
, " ");
1288 register_offset
= (descr
->register_offset
[regnum
]
1289 + descr
->sizeof_register
[regnum
]);
1294 fprintf_unfiltered (file
, " %5s ", "Size");
1296 fprintf_unfiltered (file
, " %5ld", descr
->sizeof_register
[regnum
]);
1301 std::string name_holder
;
1307 static const char blt
[] = "builtin_type";
1309 t
= TYPE_NAME (register_type (m_gdbarch
, regnum
));
1312 if (!footnote_register_type_name_null
)
1313 footnote_register_type_name_null
= ++footnote_nr
;
1314 name_holder
= string_printf ("*%d",
1315 footnote_register_type_name_null
);
1316 t
= name_holder
.c_str ();
1318 /* Chop a leading builtin_type. */
1319 if (startswith (t
, blt
))
1322 fprintf_unfiltered (file
, " %-15s", t
);
1325 /* Leading space always present. */
1326 fprintf_unfiltered (file
, " ");
1328 dump_reg (file
, regnum
);
1330 fprintf_unfiltered (file
, "\n");
1333 if (footnote_register_offset
)
1334 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1335 footnote_register_offset
);
1336 if (footnote_register_type_name_null
)
1337 fprintf_unfiltered (file
,
1338 "*%d: Register type's name NULL.\n",
1339 footnote_register_type_name_null
);
1343 #include "selftest.h"
1344 #include "selftest-arch.h"
1345 #include "gdbthread.h"
1346 #include "target-float.h"
1348 namespace selftests
{
1350 class regcache_access
: public regcache
1354 /* Return the number of elements in current_regcache. */
1357 current_regcache_size ()
1359 return std::distance (regcache::current_regcache
.begin (),
1360 regcache::current_regcache
.end ());
1365 current_regcache_test (void)
1367 /* It is empty at the start. */
1368 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1370 ptid_t
ptid1 (1), ptid2 (2), ptid3 (3);
1372 /* Get regcache from ptid1, a new regcache is added to
1373 current_regcache. */
1374 regcache
*regcache
= get_thread_arch_aspace_regcache (ptid1
,
1378 SELF_CHECK (regcache
!= NULL
);
1379 SELF_CHECK (regcache
->ptid () == ptid1
);
1380 SELF_CHECK (regcache_access::current_regcache_size () == 1);
1382 /* Get regcache from ptid2, a new regcache is added to
1383 current_regcache. */
1384 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1387 SELF_CHECK (regcache
!= NULL
);
1388 SELF_CHECK (regcache
->ptid () == ptid2
);
1389 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1391 /* Get regcache from ptid3, a new regcache is added to
1392 current_regcache. */
1393 regcache
= get_thread_arch_aspace_regcache (ptid3
,
1396 SELF_CHECK (regcache
!= NULL
);
1397 SELF_CHECK (regcache
->ptid () == ptid3
);
1398 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1400 /* Get regcache from ptid2 again, nothing is added to
1401 current_regcache. */
1402 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1405 SELF_CHECK (regcache
!= NULL
);
1406 SELF_CHECK (regcache
->ptid () == ptid2
);
1407 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1409 /* Mark ptid2 is changed, so regcache of ptid2 should be removed from
1410 current_regcache. */
1411 registers_changed_ptid (ptid2
);
1412 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1415 class target_ops_no_register
: public test_target_ops
1418 target_ops_no_register ()
1419 : test_target_ops
{}
1424 fetch_registers_called
= 0;
1425 store_registers_called
= 0;
1426 xfer_partial_called
= 0;
1429 void fetch_registers (regcache
*regs
, int regno
) override
;
1430 void store_registers (regcache
*regs
, int regno
) override
;
1432 enum target_xfer_status
xfer_partial (enum target_object object
,
1433 const char *annex
, gdb_byte
*readbuf
,
1434 const gdb_byte
*writebuf
,
1435 ULONGEST offset
, ULONGEST len
,
1436 ULONGEST
*xfered_len
) override
;
1438 unsigned int fetch_registers_called
= 0;
1439 unsigned int store_registers_called
= 0;
1440 unsigned int xfer_partial_called
= 0;
1444 target_ops_no_register::fetch_registers (regcache
*regs
, int regno
)
1446 /* Mark register available. */
1447 regs
->raw_supply_zeroed (regno
);
1448 this->fetch_registers_called
++;
1452 target_ops_no_register::store_registers (regcache
*regs
, int regno
)
1454 this->store_registers_called
++;
1457 enum target_xfer_status
1458 target_ops_no_register::xfer_partial (enum target_object object
,
1459 const char *annex
, gdb_byte
*readbuf
,
1460 const gdb_byte
*writebuf
,
1461 ULONGEST offset
, ULONGEST len
,
1462 ULONGEST
*xfered_len
)
1464 this->xfer_partial_called
++;
1467 return TARGET_XFER_OK
;
1470 class readwrite_regcache
: public regcache
1473 readwrite_regcache (struct gdbarch
*gdbarch
)
1474 : regcache (gdbarch
, nullptr)
1478 /* Test regcache::cooked_read gets registers from raw registers and
1479 memory instead of target to_{fetch,store}_registers. */
1482 cooked_read_test (struct gdbarch
*gdbarch
)
1484 /* Error out if debugging something, because we're going to push the
1485 test target, which would pop any existing target. */
1486 if (target_stack
->to_stratum
>= process_stratum
)
1487 error (_("target already pushed"));
1489 /* Create a mock environment. An inferior with a thread, with a
1490 process_stratum target pushed. */
1492 target_ops_no_register mock_target
;
1493 ptid_t
mock_ptid (1, 1);
1494 inferior
mock_inferior (mock_ptid
.pid ());
1495 address_space mock_aspace
{};
1496 mock_inferior
.gdbarch
= gdbarch
;
1497 mock_inferior
.aspace
= &mock_aspace
;
1498 thread_info
mock_thread (&mock_inferior
, mock_ptid
);
1500 scoped_restore restore_thread_list
1501 = make_scoped_restore (&thread_list
, &mock_thread
);
1503 /* Add the mock inferior to the inferior list so that look ups by
1504 target+ptid can find it. */
1505 scoped_restore restore_inferior_list
1506 = make_scoped_restore (&inferior_list
);
1507 inferior_list
= &mock_inferior
;
1509 /* Switch to the mock inferior. */
1510 scoped_restore_current_inferior restore_current_inferior
;
1511 set_current_inferior (&mock_inferior
);
1513 /* Push the process_stratum target so we can mock accessing
1515 push_target (&mock_target
);
1517 /* Pop it again on exit (return/exception). */
1522 pop_all_targets_at_and_above (process_stratum
);
1526 /* Switch to the mock thread. */
1527 scoped_restore restore_inferior_ptid
1528 = make_scoped_restore (&inferior_ptid
, mock_ptid
);
1530 /* Test that read one raw register from regcache_no_target will go
1531 to the target layer. */
1534 /* Find a raw register which size isn't zero. */
1535 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1537 if (register_size (gdbarch
, regnum
) != 0)
1541 readwrite_regcache
readwrite (gdbarch
);
1542 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
));
1544 readwrite
.raw_read (regnum
, buf
.data ());
1546 /* raw_read calls target_fetch_registers. */
1547 SELF_CHECK (mock_target
.fetch_registers_called
> 0);
1548 mock_target
.reset ();
1550 /* Mark all raw registers valid, so the following raw registers
1551 accesses won't go to target. */
1552 for (auto i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1553 readwrite
.raw_update (i
);
1555 mock_target
.reset ();
1556 /* Then, read all raw and pseudo registers, and don't expect calling
1557 to_{fetch,store}_registers. */
1558 for (int regnum
= 0;
1559 regnum
< gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1562 if (register_size (gdbarch
, regnum
) == 0)
1565 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
));
1567 SELF_CHECK (REG_VALID
== readwrite
.cooked_read (regnum
, buf
.data ()));
1569 SELF_CHECK (mock_target
.fetch_registers_called
== 0);
1570 SELF_CHECK (mock_target
.store_registers_called
== 0);
1572 /* Some SPU pseudo registers are got via TARGET_OBJECT_SPU. */
1573 if (gdbarch_bfd_arch_info (gdbarch
)->arch
!= bfd_arch_spu
)
1574 SELF_CHECK (mock_target
.xfer_partial_called
== 0);
1576 mock_target
.reset ();
1579 readonly_detached_regcache
readonly (readwrite
);
1581 /* GDB may go to target layer to fetch all registers and memory for
1582 readonly regcache. */
1583 mock_target
.reset ();
1585 for (int regnum
= 0;
1586 regnum
< gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1589 if (register_size (gdbarch
, regnum
) == 0)
1592 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
));
1593 enum register_status status
= readonly
.cooked_read (regnum
,
1596 if (regnum
< gdbarch_num_regs (gdbarch
))
1598 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1600 if (bfd_arch
== bfd_arch_frv
|| bfd_arch
== bfd_arch_h8300
1601 || bfd_arch
== bfd_arch_m32c
|| bfd_arch
== bfd_arch_sh
1602 || bfd_arch
== bfd_arch_alpha
|| bfd_arch
== bfd_arch_v850
1603 || bfd_arch
== bfd_arch_msp430
|| bfd_arch
== bfd_arch_mep
1604 || bfd_arch
== bfd_arch_mips
|| bfd_arch
== bfd_arch_v850_rh850
1605 || bfd_arch
== bfd_arch_tic6x
|| bfd_arch
== bfd_arch_mn10300
1606 || bfd_arch
== bfd_arch_rl78
|| bfd_arch
== bfd_arch_score
1607 || bfd_arch
== bfd_arch_riscv
)
1609 /* Raw registers. If raw registers are not in save_reggroup,
1610 their status are unknown. */
1611 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1612 SELF_CHECK (status
== REG_VALID
);
1614 SELF_CHECK (status
== REG_UNKNOWN
);
1617 SELF_CHECK (status
== REG_VALID
);
1621 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1622 SELF_CHECK (status
== REG_VALID
);
1625 /* If pseudo registers are not in save_reggroup, some of
1626 them can be computed from saved raw registers, but some
1627 of them are unknown. */
1628 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1630 if (bfd_arch
== bfd_arch_frv
1631 || bfd_arch
== bfd_arch_m32c
1632 || bfd_arch
== bfd_arch_mep
1633 || bfd_arch
== bfd_arch_sh
)
1634 SELF_CHECK (status
== REG_VALID
|| status
== REG_UNKNOWN
);
1635 else if (bfd_arch
== bfd_arch_mips
1636 || bfd_arch
== bfd_arch_h8300
)
1637 SELF_CHECK (status
== REG_UNKNOWN
);
1639 SELF_CHECK (status
== REG_VALID
);
1643 SELF_CHECK (mock_target
.fetch_registers_called
== 0);
1644 SELF_CHECK (mock_target
.store_registers_called
== 0);
1645 SELF_CHECK (mock_target
.xfer_partial_called
== 0);
1647 mock_target
.reset ();
1651 /* Test regcache::cooked_write by writing some expected contents to
1652 registers, and checking that contents read from registers and the
1653 expected contents are the same. */
1656 cooked_write_test (struct gdbarch
*gdbarch
)
1658 /* Error out if debugging something, because we're going to push the
1659 test target, which would pop any existing target. */
1660 if (target_stack
->to_stratum
>= process_stratum
)
1661 error (_("target already pushed"));
1663 /* Create a mock environment. A process_stratum target pushed. */
1665 target_ops_no_register mock_target
;
1667 /* Push the process_stratum target so we can mock accessing
1669 push_target (&mock_target
);
1671 /* Pop it again on exit (return/exception). */
1676 pop_all_targets_at_and_above (process_stratum
);
1680 readwrite_regcache
readwrite (gdbarch
);
1682 const int num_regs
= (gdbarch_num_regs (gdbarch
)
1683 + gdbarch_num_pseudo_regs (gdbarch
));
1685 for (auto regnum
= 0; regnum
< num_regs
; regnum
++)
1687 if (register_size (gdbarch
, regnum
) == 0
1688 || gdbarch_cannot_store_register (gdbarch
, regnum
))
1691 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1693 if ((bfd_arch
== bfd_arch_sparc
1694 /* SPARC64_CWP_REGNUM, SPARC64_PSTATE_REGNUM,
1695 SPARC64_ASI_REGNUM and SPARC64_CCR_REGNUM are hard to test. */
1696 && gdbarch_ptr_bit (gdbarch
) == 64
1697 && (regnum
>= gdbarch_num_regs (gdbarch
)
1698 && regnum
<= gdbarch_num_regs (gdbarch
) + 4))
1699 || (bfd_arch
== bfd_arch_spu
1700 /* SPU pseudo registers except SPU_SP_REGNUM are got by
1701 TARGET_OBJECT_SPU. */
1702 && regnum
>= gdbarch_num_regs (gdbarch
) && regnum
!= 130))
1705 std::vector
<gdb_byte
> expected (register_size (gdbarch
, regnum
), 0);
1706 std::vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
), 0);
1707 const auto type
= register_type (gdbarch
, regnum
);
1709 if (TYPE_CODE (type
) == TYPE_CODE_FLT
1710 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1712 /* Generate valid float format. */
1713 target_float_from_string (expected
.data (), type
, "1.25");
1715 else if (TYPE_CODE (type
) == TYPE_CODE_INT
1716 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1717 || TYPE_CODE (type
) == TYPE_CODE_PTR
1718 || TYPE_CODE (type
) == TYPE_CODE_UNION
1719 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1721 if (bfd_arch
== bfd_arch_ia64
1722 || (regnum
>= gdbarch_num_regs (gdbarch
)
1723 && (bfd_arch
== bfd_arch_xtensa
1724 || bfd_arch
== bfd_arch_bfin
1725 || bfd_arch
== bfd_arch_m32c
1726 /* m68hc11 pseudo registers are in memory. */
1727 || bfd_arch
== bfd_arch_m68hc11
1728 || bfd_arch
== bfd_arch_m68hc12
1729 || bfd_arch
== bfd_arch_s390
))
1730 || (bfd_arch
== bfd_arch_frv
1731 /* FRV pseudo registers except iacc0. */
1732 && regnum
> gdbarch_num_regs (gdbarch
)))
1734 /* Skip setting the expected values for some architecture
1737 else if (bfd_arch
== bfd_arch_rl78
&& regnum
== 40)
1739 /* RL78_PC_REGNUM */
1740 for (auto j
= 0; j
< register_size (gdbarch
, regnum
) - 1; j
++)
1745 for (auto j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1749 else if (TYPE_CODE (type
) == TYPE_CODE_FLAGS
)
1751 /* No idea how to test flags. */
1756 /* If we don't know how to create the expected value for the
1757 this type, make it fail. */
1761 readwrite
.cooked_write (regnum
, expected
.data ());
1763 SELF_CHECK (readwrite
.cooked_read (regnum
, buf
.data ()) == REG_VALID
);
1764 SELF_CHECK (expected
== buf
);
1768 } // namespace selftests
1769 #endif /* GDB_SELF_TEST */
1772 _initialize_regcache (void)
1774 regcache_descr_handle
1775 = gdbarch_data_register_post_init (init_regcache_descr
);
1777 gdb::observers::target_changed
.attach (regcache_observer_target_changed
);
1778 gdb::observers::thread_ptid_changed
.attach
1779 (regcache::regcache_thread_ptid_changed
);
1781 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1782 _("Force gdb to flush its register cache (maintainer command)"));
1785 selftests::register_test ("current_regcache", selftests::current_regcache_test
);
1787 selftests::register_test_foreach_arch ("regcache::cooked_read_test",
1788 selftests::cooked_read_test
);
1789 selftests::register_test_foreach_arch ("regcache::cooked_write_test",
1790 selftests::cooked_write_test
);