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
.reset (new gdb_byte
[m_descr
->sizeof_cooked_registers
] ());
189 m_register_status
.reset
190 (new register_status
[m_descr
->nr_cooked_registers
] ());
194 m_registers
.reset (new gdb_byte
[m_descr
->sizeof_raw_registers
] ());
195 m_register_status
.reset
196 (new register_status
[gdbarch_num_regs (gdbarch
)] ());
200 regcache::regcache (gdbarch
*gdbarch
, const address_space
*aspace_
)
201 /* The register buffers. A read/write register cache can only hold
202 [0 .. gdbarch_num_regs). */
203 : detached_regcache (gdbarch
, false), m_aspace (aspace_
)
205 m_ptid
= minus_one_ptid
;
208 readonly_detached_regcache::readonly_detached_regcache (regcache
&src
)
209 : readonly_detached_regcache (src
.arch (),
210 [&src
] (int regnum
, gdb_byte
*buf
)
212 return src
.cooked_read (regnum
, buf
);
218 reg_buffer::arch () const
220 return m_descr
->gdbarch
;
223 /* Cleanup class for invalidating a register. */
225 class regcache_invalidator
229 regcache_invalidator (struct regcache
*regcache
, int regnum
)
230 : m_regcache (regcache
),
235 ~regcache_invalidator ()
237 if (m_regcache
!= nullptr)
238 m_regcache
->invalidate (m_regnum
);
241 DISABLE_COPY_AND_ASSIGN (regcache_invalidator
);
245 m_regcache
= nullptr;
250 struct regcache
*m_regcache
;
254 /* Return a pointer to register REGNUM's buffer cache. */
257 reg_buffer::register_buffer (int regnum
) const
259 return m_registers
.get () + m_descr
->register_offset
[regnum
];
263 reg_buffer::save (register_read_ftype cooked_read
)
265 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
268 /* It should have pseudo registers. */
269 gdb_assert (m_has_pseudo
);
270 /* Clear the dest. */
271 memset (m_registers
.get (), 0, m_descr
->sizeof_cooked_registers
);
272 memset (m_register_status
.get (), REG_UNKNOWN
, m_descr
->nr_cooked_registers
);
273 /* Copy over any registers (identified by their membership in the
274 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
275 gdbarch_num_pseudo_regs) range is checked since some architectures need
276 to save/restore `cooked' registers that live in memory. */
277 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
279 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
281 gdb_byte
*dst_buf
= register_buffer (regnum
);
282 enum register_status status
= cooked_read (regnum
, dst_buf
);
284 gdb_assert (status
!= REG_UNKNOWN
);
286 if (status
!= REG_VALID
)
287 memset (dst_buf
, 0, register_size (gdbarch
, regnum
));
289 m_register_status
[regnum
] = status
;
295 regcache::restore (readonly_detached_regcache
*src
)
297 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
300 gdb_assert (src
!= NULL
);
301 gdb_assert (src
->m_has_pseudo
);
303 gdb_assert (gdbarch
== src
->arch ());
305 /* Copy over any registers, being careful to only restore those that
306 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
307 + gdbarch_num_pseudo_regs) range is checked since some architectures need
308 to save/restore `cooked' registers that live in memory. */
309 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
311 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
313 if (src
->m_register_status
[regnum
] == REG_VALID
)
314 cooked_write (regnum
, src
->register_buffer (regnum
));
319 /* See common/common-regcache.h. */
322 reg_buffer::get_register_status (int regnum
) const
324 assert_regnum (regnum
);
326 return m_register_status
[regnum
];
330 reg_buffer::invalidate (int regnum
)
332 assert_regnum (regnum
);
333 m_register_status
[regnum
] = REG_UNKNOWN
;
337 reg_buffer::assert_regnum (int regnum
) const
339 gdb_assert (regnum
>= 0);
341 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
343 gdb_assert (regnum
< gdbarch_num_regs (arch ()));
346 /* Global structure containing the current regcache. */
348 /* NOTE: this is a write-through cache. There is no "dirty" bit for
349 recording if the register values have been changed (eg. by the
350 user). Therefore all registers must be written back to the
351 target when appropriate. */
352 std::forward_list
<regcache
*> regcache::current_regcache
;
355 get_thread_arch_aspace_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
,
356 struct address_space
*aspace
)
358 for (const auto ®cache
: regcache::current_regcache
)
359 if (ptid_equal (regcache
->ptid (), ptid
) && regcache
->arch () == gdbarch
)
362 regcache
*new_regcache
= new regcache (gdbarch
, aspace
);
364 regcache::current_regcache
.push_front (new_regcache
);
365 new_regcache
->set_ptid (ptid
);
371 get_thread_arch_regcache (ptid_t ptid
, struct gdbarch
*gdbarch
)
373 address_space
*aspace
= target_thread_address_space (ptid
);
375 return get_thread_arch_aspace_regcache (ptid
, gdbarch
, aspace
);
378 static ptid_t current_thread_ptid
;
379 static struct gdbarch
*current_thread_arch
;
382 get_thread_regcache (ptid_t ptid
)
384 if (!current_thread_arch
|| !ptid_equal (current_thread_ptid
, ptid
))
386 current_thread_ptid
= ptid
;
387 current_thread_arch
= target_thread_architecture (ptid
);
390 return get_thread_arch_regcache (ptid
, current_thread_arch
);
394 get_current_regcache (void)
396 return get_thread_regcache (inferior_ptid
);
399 /* See common/common-regcache.h. */
402 get_thread_regcache_for_ptid (ptid_t ptid
)
404 return get_thread_regcache (ptid
);
407 /* Observer for the target_changed event. */
410 regcache_observer_target_changed (struct target_ops
*target
)
412 registers_changed ();
415 /* Update global variables old ptids to hold NEW_PTID if they were
418 regcache::regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
)
420 for (auto ®cache
: regcache::current_regcache
)
422 if (ptid_equal (regcache
->ptid (), old_ptid
))
423 regcache
->set_ptid (new_ptid
);
427 /* Low level examining and depositing of registers.
429 The caller is responsible for making sure that the inferior is
430 stopped before calling the fetching routines, or it will get
431 garbage. (a change from GDB version 3, in which the caller got the
432 value from the last stop). */
434 /* REGISTERS_CHANGED ()
436 Indicate that registers may have changed, so invalidate the cache. */
439 registers_changed_ptid (ptid_t ptid
)
441 for (auto oit
= regcache::current_regcache
.before_begin (),
442 it
= std::next (oit
);
443 it
!= regcache::current_regcache
.end ();
446 if (ptid_match ((*it
)->ptid (), ptid
))
449 it
= regcache::current_regcache
.erase_after (oit
);
455 if (ptid_match (current_thread_ptid
, ptid
))
457 current_thread_ptid
= null_ptid
;
458 current_thread_arch
= NULL
;
461 if (ptid_match (inferior_ptid
, ptid
))
463 /* We just deleted the regcache of the current thread. Need to
464 forget about any frames we have cached, too. */
465 reinit_frame_cache ();
470 registers_changed (void)
472 registers_changed_ptid (minus_one_ptid
);
474 /* Force cleanup of any alloca areas if using C alloca instead of
475 a builtin alloca. This particular call is used to clean up
476 areas allocated by low level target code which may build up
477 during lengthy interactions between gdb and the target before
478 gdb gives control to the user (ie watchpoints). */
483 regcache::raw_update (int regnum
)
485 assert_regnum (regnum
);
487 /* Make certain that the register cache is up-to-date with respect
488 to the current thread. This switching shouldn't be necessary
489 only there is still only one target side register cache. Sigh!
490 On the bright side, at least there is a regcache object. */
492 if (get_register_status (regnum
) == REG_UNKNOWN
)
494 target_fetch_registers (this, regnum
);
496 /* A number of targets can't access the whole set of raw
497 registers (because the debug API provides no means to get at
499 if (m_register_status
[regnum
] == REG_UNKNOWN
)
500 m_register_status
[regnum
] = REG_UNAVAILABLE
;
505 readable_regcache::raw_read (int regnum
, gdb_byte
*buf
)
507 gdb_assert (buf
!= NULL
);
510 if (m_register_status
[regnum
] != REG_VALID
)
511 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
513 memcpy (buf
, register_buffer (regnum
),
514 m_descr
->sizeof_register
[regnum
]);
516 return m_register_status
[regnum
];
520 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
522 gdb_assert (regcache
!= NULL
);
523 return regcache
->raw_read (regnum
, val
);
526 template<typename T
, typename
>
528 readable_regcache::raw_read (int regnum
, T
*val
)
531 enum register_status status
;
533 assert_regnum (regnum
);
534 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
535 status
= raw_read (regnum
, buf
);
536 if (status
== REG_VALID
)
537 *val
= extract_integer
<T
> (buf
,
538 m_descr
->sizeof_register
[regnum
],
539 gdbarch_byte_order (m_descr
->gdbarch
));
546 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
549 gdb_assert (regcache
!= NULL
);
550 return regcache
->raw_read (regnum
, val
);
554 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
556 gdb_assert (regcache
!= NULL
);
557 regcache
->raw_write (regnum
, val
);
560 template<typename T
, typename
>
562 regcache::raw_write (int regnum
, T val
)
566 assert_regnum (regnum
);
567 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
568 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
569 gdbarch_byte_order (m_descr
->gdbarch
), val
);
570 raw_write (regnum
, buf
);
574 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
577 gdb_assert (regcache
!= NULL
);
578 regcache
->raw_write (regnum
, val
);
582 regcache_raw_get_signed (struct regcache
*regcache
, int regnum
)
585 enum register_status status
;
587 status
= regcache_raw_read_signed (regcache
, regnum
, &value
);
588 if (status
== REG_UNAVAILABLE
)
589 throw_error (NOT_AVAILABLE_ERROR
,
590 _("Register %d is not available"), regnum
);
595 readable_regcache::cooked_read (int regnum
, gdb_byte
*buf
)
597 gdb_assert (regnum
>= 0);
598 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
599 if (regnum
< num_raw_registers ())
600 return raw_read (regnum
, buf
);
601 else if (m_has_pseudo
602 && m_register_status
[regnum
] != REG_UNKNOWN
)
604 if (m_register_status
[regnum
] == REG_VALID
)
605 memcpy (buf
, register_buffer (regnum
),
606 m_descr
->sizeof_register
[regnum
]);
608 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
610 return m_register_status
[regnum
];
612 else if (gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
614 struct value
*mark
, *computed
;
615 enum register_status result
= REG_VALID
;
617 mark
= value_mark ();
619 computed
= gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
621 if (value_entirely_available (computed
))
622 memcpy (buf
, value_contents_raw (computed
),
623 m_descr
->sizeof_register
[regnum
]);
626 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
627 result
= REG_UNAVAILABLE
;
630 value_free_to_mark (mark
);
635 return gdbarch_pseudo_register_read (m_descr
->gdbarch
, this,
640 readable_regcache::cooked_read_value (int regnum
)
642 gdb_assert (regnum
>= 0);
643 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
645 if (regnum
< num_raw_registers ()
646 || (m_has_pseudo
&& m_register_status
[regnum
] != REG_UNKNOWN
)
647 || !gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
649 struct value
*result
;
651 result
= allocate_value (register_type (m_descr
->gdbarch
, regnum
));
652 VALUE_LVAL (result
) = lval_register
;
653 VALUE_REGNUM (result
) = regnum
;
655 /* It is more efficient in general to do this delegation in this
656 direction than in the other one, even though the value-based
658 if (cooked_read (regnum
,
659 value_contents_raw (result
)) == REG_UNAVAILABLE
)
660 mark_value_bytes_unavailable (result
, 0,
661 TYPE_LENGTH (value_type (result
)));
666 return gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
671 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
674 gdb_assert (regcache
!= NULL
);
675 return regcache
->cooked_read (regnum
, val
);
678 template<typename T
, typename
>
680 readable_regcache::cooked_read (int regnum
, T
*val
)
682 enum register_status status
;
685 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
686 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
687 status
= cooked_read (regnum
, buf
);
688 if (status
== REG_VALID
)
689 *val
= extract_integer
<T
> (buf
, m_descr
->sizeof_register
[regnum
],
690 gdbarch_byte_order (m_descr
->gdbarch
));
697 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
700 gdb_assert (regcache
!= NULL
);
701 return regcache
->cooked_read (regnum
, val
);
705 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
708 gdb_assert (regcache
!= NULL
);
709 regcache
->cooked_write (regnum
, val
);
712 template<typename T
, typename
>
714 regcache::cooked_write (int regnum
, T val
)
718 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
719 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
720 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
721 gdbarch_byte_order (m_descr
->gdbarch
), val
);
722 cooked_write (regnum
, buf
);
726 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
729 gdb_assert (regcache
!= NULL
);
730 regcache
->cooked_write (regnum
, val
);
734 regcache::raw_write (int regnum
, const gdb_byte
*buf
)
737 gdb_assert (buf
!= NULL
);
738 assert_regnum (regnum
);
740 /* On the sparc, writing %g0 is a no-op, so we don't even want to
741 change the registers array if something writes to this register. */
742 if (gdbarch_cannot_store_register (arch (), regnum
))
745 /* If we have a valid copy of the register, and new value == old
746 value, then don't bother doing the actual store. */
747 if (get_register_status (regnum
) == REG_VALID
748 && (memcmp (register_buffer (regnum
), buf
,
749 m_descr
->sizeof_register
[regnum
]) == 0))
752 target_prepare_to_store (this);
753 raw_supply (regnum
, buf
);
755 /* Invalidate the register after it is written, in case of a
757 regcache_invalidator
invalidator (this, regnum
);
759 target_store_registers (this, regnum
);
761 /* The target did not throw an error so we can discard invalidating
763 invalidator
.release ();
767 regcache::cooked_write (int regnum
, const gdb_byte
*buf
)
769 gdb_assert (regnum
>= 0);
770 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
771 if (regnum
< num_raw_registers ())
772 raw_write (regnum
, buf
);
774 gdbarch_pseudo_register_write (m_descr
->gdbarch
, this,
778 /* Perform a partial register transfer using a read, modify, write
782 readable_regcache::read_part (int regnum
, int offset
, int len
, void *in
,
785 struct gdbarch
*gdbarch
= arch ();
786 gdb_byte
*reg
= (gdb_byte
*) alloca (register_size (gdbarch
, regnum
));
788 gdb_assert (in
!= NULL
);
789 gdb_assert (offset
>= 0 && offset
<= m_descr
->sizeof_register
[regnum
]);
790 gdb_assert (len
>= 0 && offset
+ len
<= m_descr
->sizeof_register
[regnum
]);
791 /* Something to do? */
792 if (offset
+ len
== 0)
794 /* Read (when needed) ... */
795 enum register_status status
;
798 status
= raw_read (regnum
, reg
);
800 status
= cooked_read (regnum
, reg
);
801 if (status
!= REG_VALID
)
805 memcpy (in
, reg
+ offset
, len
);
811 regcache::write_part (int regnum
, int offset
, int len
,
812 const void *out
, bool is_raw
)
814 struct gdbarch
*gdbarch
= arch ();
815 gdb_byte
*reg
= (gdb_byte
*) alloca (register_size (gdbarch
, regnum
));
817 gdb_assert (out
!= NULL
);
818 gdb_assert (offset
>= 0 && offset
<= m_descr
->sizeof_register
[regnum
]);
819 gdb_assert (len
>= 0 && offset
+ len
<= m_descr
->sizeof_register
[regnum
]);
820 /* Something to do? */
821 if (offset
+ len
== 0)
823 /* Read (when needed) ... */
825 || offset
+ len
< m_descr
->sizeof_register
[regnum
])
827 enum register_status status
;
830 status
= raw_read (regnum
, reg
);
832 status
= cooked_read (regnum
, reg
);
833 if (status
!= REG_VALID
)
837 memcpy (reg
+ offset
, out
, len
);
838 /* ... write (when needed). */
840 raw_write (regnum
, reg
);
842 cooked_write (regnum
, reg
);
848 readable_regcache::raw_read_part (int regnum
, int offset
, int len
, gdb_byte
*buf
)
850 assert_regnum (regnum
);
851 return read_part (regnum
, offset
, len
, buf
, true);
854 /* See regcache.h. */
857 regcache::raw_write_part (int regnum
, int offset
, int len
,
860 assert_regnum (regnum
);
861 write_part (regnum
, offset
, len
, buf
, true);
865 readable_regcache::cooked_read_part (int regnum
, int offset
, int len
,
868 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
869 return read_part (regnum
, offset
, len
, buf
, false);
873 regcache::cooked_write_part (int regnum
, int offset
, int len
,
876 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
877 write_part (regnum
, offset
, len
, buf
, false);
880 /* See common/common-regcache.h. */
883 reg_buffer::raw_supply (int regnum
, const void *buf
)
888 assert_regnum (regnum
);
890 regbuf
= register_buffer (regnum
);
891 size
= m_descr
->sizeof_register
[regnum
];
895 memcpy (regbuf
, buf
, size
);
896 m_register_status
[regnum
] = REG_VALID
;
900 /* This memset not strictly necessary, but better than garbage
901 in case the register value manages to escape somewhere (due
902 to a bug, no less). */
903 memset (regbuf
, 0, size
);
904 m_register_status
[regnum
] = REG_UNAVAILABLE
;
908 /* See regcache.h. */
911 reg_buffer::raw_supply_integer (int regnum
, const gdb_byte
*addr
,
912 int addr_len
, bool is_signed
)
914 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
918 assert_regnum (regnum
);
920 regbuf
= register_buffer (regnum
);
921 regsize
= m_descr
->sizeof_register
[regnum
];
923 copy_integer_to_size (regbuf
, regsize
, addr
, addr_len
, is_signed
,
925 m_register_status
[regnum
] = REG_VALID
;
928 /* See regcache.h. */
931 reg_buffer::raw_supply_zeroed (int regnum
)
936 assert_regnum (regnum
);
938 regbuf
= register_buffer (regnum
);
939 size
= m_descr
->sizeof_register
[regnum
];
941 memset (regbuf
, 0, size
);
942 m_register_status
[regnum
] = REG_VALID
;
945 /* See common/common-regcache.h. */
948 reg_buffer::raw_collect (int regnum
, void *buf
) const
953 gdb_assert (buf
!= NULL
);
954 assert_regnum (regnum
);
956 regbuf
= register_buffer (regnum
);
957 size
= m_descr
->sizeof_register
[regnum
];
958 memcpy (buf
, regbuf
, size
);
961 /* See regcache.h. */
964 reg_buffer::raw_collect_integer (int regnum
, gdb_byte
*addr
, int addr_len
,
965 bool is_signed
) const
967 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
968 const gdb_byte
*regbuf
;
971 assert_regnum (regnum
);
973 regbuf
= register_buffer (regnum
);
974 regsize
= m_descr
->sizeof_register
[regnum
];
976 copy_integer_to_size (addr
, addr_len
, regbuf
, regsize
, is_signed
,
980 /* Transfer a single or all registers belonging to a certain register
981 set to or from a buffer. This is the main worker function for
982 regcache_supply_regset and regcache_collect_regset. */
985 regcache::transfer_regset (const struct regset
*regset
,
986 struct regcache
*out_regcache
,
987 int regnum
, const void *in_buf
,
988 void *out_buf
, size_t size
) const
990 const struct regcache_map_entry
*map
;
993 for (map
= (const struct regcache_map_entry
*) regset
->regmap
;
994 (count
= map
->count
) != 0;
997 int regno
= map
->regno
;
998 int slot_size
= map
->size
;
1000 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1001 slot_size
= m_descr
->sizeof_register
[regno
];
1003 if (regno
== REGCACHE_MAP_SKIP
1005 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1006 offs
+= count
* slot_size
;
1008 else if (regnum
== -1)
1009 for (; count
--; regno
++, offs
+= slot_size
)
1011 if (offs
+ slot_size
> size
)
1015 raw_collect (regno
, (gdb_byte
*) out_buf
+ offs
);
1017 out_regcache
->raw_supply (regno
, in_buf
1018 ? (const gdb_byte
*) in_buf
+ offs
1023 /* Transfer a single register and return. */
1024 offs
+= (regnum
- regno
) * slot_size
;
1025 if (offs
+ slot_size
> size
)
1029 raw_collect (regnum
, (gdb_byte
*) out_buf
+ offs
);
1031 out_regcache
->raw_supply (regnum
, in_buf
1032 ? (const gdb_byte
*) in_buf
+ offs
1039 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1040 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1041 If BUF is NULL, set the register(s) to "unavailable" status. */
1044 regcache_supply_regset (const struct regset
*regset
,
1045 struct regcache
*regcache
,
1046 int regnum
, const void *buf
, size_t size
)
1048 regcache
->supply_regset (regset
, regnum
, buf
, size
);
1052 regcache::supply_regset (const struct regset
*regset
,
1053 int regnum
, const void *buf
, size_t size
)
1055 transfer_regset (regset
, this, regnum
, buf
, NULL
, size
);
1058 /* Collect register REGNUM from REGCACHE to BUF, using the register
1059 map in REGSET. If REGNUM is -1, do this for all registers in
1063 regcache_collect_regset (const struct regset
*regset
,
1064 const struct regcache
*regcache
,
1065 int regnum
, void *buf
, size_t size
)
1067 regcache
->collect_regset (regset
, regnum
, buf
, size
);
1071 regcache::collect_regset (const struct regset
*regset
,
1072 int regnum
, void *buf
, size_t size
) const
1074 transfer_regset (regset
, NULL
, regnum
, NULL
, buf
, size
);
1077 /* See common/common-regcache.h. */
1080 reg_buffer::raw_compare (int regnum
, const void *buf
, int offset
) const
1082 gdb_assert (buf
!= NULL
);
1083 assert_regnum (regnum
);
1085 const char *regbuf
= (const char *) register_buffer (regnum
);
1086 size_t size
= m_descr
->sizeof_register
[regnum
];
1087 gdb_assert (size
>= offset
);
1089 return (memcmp (buf
, regbuf
+ offset
, size
- offset
) == 0);
1092 /* Special handling for register PC. */
1095 regcache_read_pc (struct regcache
*regcache
)
1097 struct gdbarch
*gdbarch
= regcache
->arch ();
1101 if (gdbarch_read_pc_p (gdbarch
))
1102 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1103 /* Else use per-frame method on get_current_frame. */
1104 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1108 if (regcache_cooked_read_unsigned (regcache
,
1109 gdbarch_pc_regnum (gdbarch
),
1110 &raw_val
) == REG_UNAVAILABLE
)
1111 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1113 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1116 internal_error (__FILE__
, __LINE__
,
1117 _("regcache_read_pc: Unable to find PC"));
1122 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1124 struct gdbarch
*gdbarch
= regcache
->arch ();
1126 if (gdbarch_write_pc_p (gdbarch
))
1127 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1128 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1129 regcache_cooked_write_unsigned (regcache
,
1130 gdbarch_pc_regnum (gdbarch
), pc
);
1132 internal_error (__FILE__
, __LINE__
,
1133 _("regcache_write_pc: Unable to update PC"));
1135 /* Writing the PC (for instance, from "load") invalidates the
1137 reinit_frame_cache ();
1141 reg_buffer::num_raw_registers () const
1143 return gdbarch_num_regs (arch ());
1147 regcache::debug_print_register (const char *func
, int regno
)
1149 struct gdbarch
*gdbarch
= arch ();
1151 fprintf_unfiltered (gdb_stdlog
, "%s ", func
);
1152 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
1153 && gdbarch_register_name (gdbarch
, regno
) != NULL
1154 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
1155 fprintf_unfiltered (gdb_stdlog
, "(%s)",
1156 gdbarch_register_name (gdbarch
, regno
));
1158 fprintf_unfiltered (gdb_stdlog
, "(%d)", regno
);
1159 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
1161 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1162 int size
= register_size (gdbarch
, regno
);
1163 gdb_byte
*buf
= register_buffer (regno
);
1165 fprintf_unfiltered (gdb_stdlog
, " = ");
1166 for (int i
= 0; i
< size
; i
++)
1168 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
1170 if (size
<= sizeof (LONGEST
))
1172 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
1174 fprintf_unfiltered (gdb_stdlog
, " %s %s",
1175 core_addr_to_string_nz (val
), plongest (val
));
1178 fprintf_unfiltered (gdb_stdlog
, "\n");
1182 reg_flush_command (const char *command
, int from_tty
)
1184 /* Force-flush the register cache. */
1185 registers_changed ();
1187 printf_filtered (_("Register cache flushed.\n"));
1191 register_dump::dump (ui_file
*file
)
1193 auto descr
= regcache_descr (m_gdbarch
);
1195 int footnote_nr
= 0;
1196 int footnote_register_offset
= 0;
1197 int footnote_register_type_name_null
= 0;
1198 long register_offset
= 0;
1200 gdb_assert (descr
->nr_cooked_registers
1201 == (gdbarch_num_regs (m_gdbarch
)
1202 + gdbarch_num_pseudo_regs (m_gdbarch
)));
1204 for (regnum
= -1; regnum
< descr
->nr_cooked_registers
; regnum
++)
1208 fprintf_unfiltered (file
, " %-10s", "Name");
1211 const char *p
= gdbarch_register_name (m_gdbarch
, regnum
);
1215 else if (p
[0] == '\0')
1217 fprintf_unfiltered (file
, " %-10s", p
);
1222 fprintf_unfiltered (file
, " %4s", "Nr");
1224 fprintf_unfiltered (file
, " %4d", regnum
);
1226 /* Relative number. */
1228 fprintf_unfiltered (file
, " %4s", "Rel");
1229 else if (regnum
< gdbarch_num_regs (m_gdbarch
))
1230 fprintf_unfiltered (file
, " %4d", regnum
);
1232 fprintf_unfiltered (file
, " %4d",
1233 (regnum
- gdbarch_num_regs (m_gdbarch
)));
1237 fprintf_unfiltered (file
, " %6s ", "Offset");
1240 fprintf_unfiltered (file
, " %6ld",
1241 descr
->register_offset
[regnum
]);
1242 if (register_offset
!= descr
->register_offset
[regnum
]
1244 && (descr
->register_offset
[regnum
]
1245 != (descr
->register_offset
[regnum
- 1]
1246 + descr
->sizeof_register
[regnum
- 1])))
1249 if (!footnote_register_offset
)
1250 footnote_register_offset
= ++footnote_nr
;
1251 fprintf_unfiltered (file
, "*%d", footnote_register_offset
);
1254 fprintf_unfiltered (file
, " ");
1255 register_offset
= (descr
->register_offset
[regnum
]
1256 + descr
->sizeof_register
[regnum
]);
1261 fprintf_unfiltered (file
, " %5s ", "Size");
1263 fprintf_unfiltered (file
, " %5ld", descr
->sizeof_register
[regnum
]);
1268 std::string name_holder
;
1274 static const char blt
[] = "builtin_type";
1276 t
= TYPE_NAME (register_type (m_gdbarch
, regnum
));
1279 if (!footnote_register_type_name_null
)
1280 footnote_register_type_name_null
= ++footnote_nr
;
1281 name_holder
= string_printf ("*%d",
1282 footnote_register_type_name_null
);
1283 t
= name_holder
.c_str ();
1285 /* Chop a leading builtin_type. */
1286 if (startswith (t
, blt
))
1289 fprintf_unfiltered (file
, " %-15s", t
);
1292 /* Leading space always present. */
1293 fprintf_unfiltered (file
, " ");
1295 dump_reg (file
, regnum
);
1297 fprintf_unfiltered (file
, "\n");
1300 if (footnote_register_offset
)
1301 fprintf_unfiltered (file
, "*%d: Inconsistent register offsets.\n",
1302 footnote_register_offset
);
1303 if (footnote_register_type_name_null
)
1304 fprintf_unfiltered (file
,
1305 "*%d: Register type's name NULL.\n",
1306 footnote_register_type_name_null
);
1310 #include "selftest.h"
1311 #include "selftest-arch.h"
1312 #include "gdbthread.h"
1313 #include "target-float.h"
1315 namespace selftests
{
1317 class regcache_access
: public regcache
1321 /* Return the number of elements in current_regcache. */
1324 current_regcache_size ()
1326 return std::distance (regcache::current_regcache
.begin (),
1327 regcache::current_regcache
.end ());
1332 current_regcache_test (void)
1334 /* It is empty at the start. */
1335 SELF_CHECK (regcache_access::current_regcache_size () == 0);
1337 ptid_t
ptid1 (1), ptid2 (2), ptid3 (3);
1339 /* Get regcache from ptid1, a new regcache is added to
1340 current_regcache. */
1341 regcache
*regcache
= get_thread_arch_aspace_regcache (ptid1
,
1345 SELF_CHECK (regcache
!= NULL
);
1346 SELF_CHECK (regcache
->ptid () == ptid1
);
1347 SELF_CHECK (regcache_access::current_regcache_size () == 1);
1349 /* Get regcache from ptid2, a new regcache is added to
1350 current_regcache. */
1351 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1354 SELF_CHECK (regcache
!= NULL
);
1355 SELF_CHECK (regcache
->ptid () == ptid2
);
1356 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1358 /* Get regcache from ptid3, a new regcache is added to
1359 current_regcache. */
1360 regcache
= get_thread_arch_aspace_regcache (ptid3
,
1363 SELF_CHECK (regcache
!= NULL
);
1364 SELF_CHECK (regcache
->ptid () == ptid3
);
1365 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1367 /* Get regcache from ptid2 again, nothing is added to
1368 current_regcache. */
1369 regcache
= get_thread_arch_aspace_regcache (ptid2
,
1372 SELF_CHECK (regcache
!= NULL
);
1373 SELF_CHECK (regcache
->ptid () == ptid2
);
1374 SELF_CHECK (regcache_access::current_regcache_size () == 3);
1376 /* Mark ptid2 is changed, so regcache of ptid2 should be removed from
1377 current_regcache. */
1378 registers_changed_ptid (ptid2
);
1379 SELF_CHECK (regcache_access::current_regcache_size () == 2);
1382 class target_ops_no_register
: public test_target_ops
1385 target_ops_no_register ()
1386 : test_target_ops
{}
1391 fetch_registers_called
= 0;
1392 store_registers_called
= 0;
1393 xfer_partial_called
= 0;
1396 void fetch_registers (regcache
*regs
, int regno
) override
;
1397 void store_registers (regcache
*regs
, int regno
) override
;
1399 enum target_xfer_status
xfer_partial (enum target_object object
,
1400 const char *annex
, gdb_byte
*readbuf
,
1401 const gdb_byte
*writebuf
,
1402 ULONGEST offset
, ULONGEST len
,
1403 ULONGEST
*xfered_len
) override
;
1405 unsigned int fetch_registers_called
= 0;
1406 unsigned int store_registers_called
= 0;
1407 unsigned int xfer_partial_called
= 0;
1411 target_ops_no_register::fetch_registers (regcache
*regs
, int regno
)
1413 /* Mark register available. */
1414 regs
->raw_supply_zeroed (regno
);
1415 this->fetch_registers_called
++;
1419 target_ops_no_register::store_registers (regcache
*regs
, int regno
)
1421 this->store_registers_called
++;
1424 enum target_xfer_status
1425 target_ops_no_register::xfer_partial (enum target_object object
,
1426 const char *annex
, gdb_byte
*readbuf
,
1427 const gdb_byte
*writebuf
,
1428 ULONGEST offset
, ULONGEST len
,
1429 ULONGEST
*xfered_len
)
1431 this->xfer_partial_called
++;
1434 return TARGET_XFER_OK
;
1437 class readwrite_regcache
: public regcache
1440 readwrite_regcache (struct gdbarch
*gdbarch
)
1441 : regcache (gdbarch
, nullptr)
1445 /* Test regcache::cooked_read gets registers from raw registers and
1446 memory instead of target to_{fetch,store}_registers. */
1449 cooked_read_test (struct gdbarch
*gdbarch
)
1451 /* Error out if debugging something, because we're going to push the
1452 test target, which would pop any existing target. */
1453 if (current_top_target ()->to_stratum
>= process_stratum
)
1454 error (_("target already pushed"));
1456 /* Create a mock environment. An inferior with a thread, with a
1457 process_stratum target pushed. */
1459 target_ops_no_register mock_target
;
1460 ptid_t
mock_ptid (1, 1);
1461 inferior
mock_inferior (mock_ptid
.pid ());
1462 address_space mock_aspace
{};
1463 mock_inferior
.gdbarch
= gdbarch
;
1464 mock_inferior
.aspace
= &mock_aspace
;
1465 thread_info
mock_thread (&mock_inferior
, mock_ptid
);
1467 scoped_restore restore_thread_list
1468 = make_scoped_restore (&thread_list
, &mock_thread
);
1470 /* Add the mock inferior to the inferior list so that look ups by
1471 target+ptid can find it. */
1472 scoped_restore restore_inferior_list
1473 = make_scoped_restore (&inferior_list
);
1474 inferior_list
= &mock_inferior
;
1476 /* Switch to the mock inferior. */
1477 scoped_restore_current_inferior restore_current_inferior
;
1478 set_current_inferior (&mock_inferior
);
1480 /* Push the process_stratum target so we can mock accessing
1482 push_target (&mock_target
);
1484 /* Pop it again on exit (return/exception). */
1489 pop_all_targets_at_and_above (process_stratum
);
1493 /* Switch to the mock thread. */
1494 scoped_restore restore_inferior_ptid
1495 = make_scoped_restore (&inferior_ptid
, mock_ptid
);
1497 /* Test that read one raw register from regcache_no_target will go
1498 to the target layer. */
1501 /* Find a raw register which size isn't zero. */
1502 for (regnum
= 0; regnum
< gdbarch_num_regs (gdbarch
); regnum
++)
1504 if (register_size (gdbarch
, regnum
) != 0)
1508 readwrite_regcache
readwrite (gdbarch
);
1509 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
));
1511 readwrite
.raw_read (regnum
, buf
.data ());
1513 /* raw_read calls target_fetch_registers. */
1514 SELF_CHECK (mock_target
.fetch_registers_called
> 0);
1515 mock_target
.reset ();
1517 /* Mark all raw registers valid, so the following raw registers
1518 accesses won't go to target. */
1519 for (auto i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1520 readwrite
.raw_update (i
);
1522 mock_target
.reset ();
1523 /* Then, read all raw and pseudo registers, and don't expect calling
1524 to_{fetch,store}_registers. */
1525 for (int regnum
= 0;
1526 regnum
< gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1529 if (register_size (gdbarch
, regnum
) == 0)
1532 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
));
1534 SELF_CHECK (REG_VALID
== readwrite
.cooked_read (regnum
, buf
.data ()));
1536 SELF_CHECK (mock_target
.fetch_registers_called
== 0);
1537 SELF_CHECK (mock_target
.store_registers_called
== 0);
1539 /* Some SPU pseudo registers are got via TARGET_OBJECT_SPU. */
1540 if (gdbarch_bfd_arch_info (gdbarch
)->arch
!= bfd_arch_spu
)
1541 SELF_CHECK (mock_target
.xfer_partial_called
== 0);
1543 mock_target
.reset ();
1546 readonly_detached_regcache
readonly (readwrite
);
1548 /* GDB may go to target layer to fetch all registers and memory for
1549 readonly regcache. */
1550 mock_target
.reset ();
1552 for (int regnum
= 0;
1553 regnum
< gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1556 if (register_size (gdbarch
, regnum
) == 0)
1559 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
));
1560 enum register_status status
= readonly
.cooked_read (regnum
,
1563 if (regnum
< gdbarch_num_regs (gdbarch
))
1565 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1567 if (bfd_arch
== bfd_arch_frv
|| bfd_arch
== bfd_arch_h8300
1568 || bfd_arch
== bfd_arch_m32c
|| bfd_arch
== bfd_arch_sh
1569 || bfd_arch
== bfd_arch_alpha
|| bfd_arch
== bfd_arch_v850
1570 || bfd_arch
== bfd_arch_msp430
|| bfd_arch
== bfd_arch_mep
1571 || bfd_arch
== bfd_arch_mips
|| bfd_arch
== bfd_arch_v850_rh850
1572 || bfd_arch
== bfd_arch_tic6x
|| bfd_arch
== bfd_arch_mn10300
1573 || bfd_arch
== bfd_arch_rl78
|| bfd_arch
== bfd_arch_score
1574 || bfd_arch
== bfd_arch_riscv
)
1576 /* Raw registers. If raw registers are not in save_reggroup,
1577 their status are unknown. */
1578 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1579 SELF_CHECK (status
== REG_VALID
);
1581 SELF_CHECK (status
== REG_UNKNOWN
);
1584 SELF_CHECK (status
== REG_VALID
);
1588 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1589 SELF_CHECK (status
== REG_VALID
);
1592 /* If pseudo registers are not in save_reggroup, some of
1593 them can be computed from saved raw registers, but some
1594 of them are unknown. */
1595 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1597 if (bfd_arch
== bfd_arch_frv
1598 || bfd_arch
== bfd_arch_m32c
1599 || bfd_arch
== bfd_arch_mep
1600 || bfd_arch
== bfd_arch_sh
)
1601 SELF_CHECK (status
== REG_VALID
|| status
== REG_UNKNOWN
);
1602 else if (bfd_arch
== bfd_arch_mips
1603 || bfd_arch
== bfd_arch_h8300
)
1604 SELF_CHECK (status
== REG_UNKNOWN
);
1606 SELF_CHECK (status
== REG_VALID
);
1610 SELF_CHECK (mock_target
.fetch_registers_called
== 0);
1611 SELF_CHECK (mock_target
.store_registers_called
== 0);
1612 SELF_CHECK (mock_target
.xfer_partial_called
== 0);
1614 mock_target
.reset ();
1618 /* Test regcache::cooked_write by writing some expected contents to
1619 registers, and checking that contents read from registers and the
1620 expected contents are the same. */
1623 cooked_write_test (struct gdbarch
*gdbarch
)
1625 /* Error out if debugging something, because we're going to push the
1626 test target, which would pop any existing target. */
1627 if (current_top_target ()->to_stratum
>= process_stratum
)
1628 error (_("target already pushed"));
1630 /* Create a mock environment. A process_stratum target pushed. */
1632 target_ops_no_register mock_target
;
1634 /* Push the process_stratum target so we can mock accessing
1636 push_target (&mock_target
);
1638 /* Pop it again on exit (return/exception). */
1643 pop_all_targets_at_and_above (process_stratum
);
1647 readwrite_regcache
readwrite (gdbarch
);
1649 const int num_regs
= (gdbarch_num_regs (gdbarch
)
1650 + gdbarch_num_pseudo_regs (gdbarch
));
1652 for (auto regnum
= 0; regnum
< num_regs
; regnum
++)
1654 if (register_size (gdbarch
, regnum
) == 0
1655 || gdbarch_cannot_store_register (gdbarch
, regnum
))
1658 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1660 if ((bfd_arch
== bfd_arch_sparc
1661 /* SPARC64_CWP_REGNUM, SPARC64_PSTATE_REGNUM,
1662 SPARC64_ASI_REGNUM and SPARC64_CCR_REGNUM are hard to test. */
1663 && gdbarch_ptr_bit (gdbarch
) == 64
1664 && (regnum
>= gdbarch_num_regs (gdbarch
)
1665 && regnum
<= gdbarch_num_regs (gdbarch
) + 4))
1666 || (bfd_arch
== bfd_arch_spu
1667 /* SPU pseudo registers except SPU_SP_REGNUM are got by
1668 TARGET_OBJECT_SPU. */
1669 && regnum
>= gdbarch_num_regs (gdbarch
) && regnum
!= 130))
1672 std::vector
<gdb_byte
> expected (register_size (gdbarch
, regnum
), 0);
1673 std::vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
), 0);
1674 const auto type
= register_type (gdbarch
, regnum
);
1676 if (TYPE_CODE (type
) == TYPE_CODE_FLT
1677 || TYPE_CODE (type
) == TYPE_CODE_DECFLOAT
)
1679 /* Generate valid float format. */
1680 target_float_from_string (expected
.data (), type
, "1.25");
1682 else if (TYPE_CODE (type
) == TYPE_CODE_INT
1683 || TYPE_CODE (type
) == TYPE_CODE_ARRAY
1684 || TYPE_CODE (type
) == TYPE_CODE_PTR
1685 || TYPE_CODE (type
) == TYPE_CODE_UNION
1686 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1688 if (bfd_arch
== bfd_arch_ia64
1689 || (regnum
>= gdbarch_num_regs (gdbarch
)
1690 && (bfd_arch
== bfd_arch_xtensa
1691 || bfd_arch
== bfd_arch_bfin
1692 || bfd_arch
== bfd_arch_m32c
1693 /* m68hc11 pseudo registers are in memory. */
1694 || bfd_arch
== bfd_arch_m68hc11
1695 || bfd_arch
== bfd_arch_m68hc12
1696 || bfd_arch
== bfd_arch_s390
))
1697 || (bfd_arch
== bfd_arch_frv
1698 /* FRV pseudo registers except iacc0. */
1699 && regnum
> gdbarch_num_regs (gdbarch
)))
1701 /* Skip setting the expected values for some architecture
1704 else if (bfd_arch
== bfd_arch_rl78
&& regnum
== 40)
1706 /* RL78_PC_REGNUM */
1707 for (auto j
= 0; j
< register_size (gdbarch
, regnum
) - 1; j
++)
1712 for (auto j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1716 else if (TYPE_CODE (type
) == TYPE_CODE_FLAGS
)
1718 /* No idea how to test flags. */
1723 /* If we don't know how to create the expected value for the
1724 this type, make it fail. */
1728 readwrite
.cooked_write (regnum
, expected
.data ());
1730 SELF_CHECK (readwrite
.cooked_read (regnum
, buf
.data ()) == REG_VALID
);
1731 SELF_CHECK (expected
== buf
);
1735 } // namespace selftests
1736 #endif /* GDB_SELF_TEST */
1739 _initialize_regcache (void)
1741 regcache_descr_handle
1742 = gdbarch_data_register_post_init (init_regcache_descr
);
1744 gdb::observers::target_changed
.attach (regcache_observer_target_changed
);
1745 gdb::observers::thread_ptid_changed
.attach
1746 (regcache::regcache_thread_ptid_changed
);
1748 add_com ("flushregs", class_maintenance
, reg_flush_command
,
1749 _("Force gdb to flush its register cache (maintainer command)"));
1752 selftests::register_test ("current_regcache", selftests::current_regcache_test
);
1754 selftests::register_test_foreach_arch ("regcache::cooked_read_test",
1755 selftests::cooked_read_test
);
1756 selftests::register_test_foreach_arch ("regcache::cooked_write_test",
1757 selftests::cooked_write_test
);