1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986-2022 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/>. */
22 #include "gdbthread.h"
24 #include "test-target.h"
25 #include "scoped-mock-context.h"
29 #include "reggroups.h"
30 #include "observable.h"
32 #include <unordered_map>
33 #include "cli/cli-cmds.h"
38 * Here is the actual register cache.
41 /* Per-architecture object describing the layout of a register cache.
42 Computed once when the architecture is created. */
46 /* The architecture this descriptor belongs to. */
47 struct gdbarch
*gdbarch
= nullptr;
49 /* The raw register cache. Each raw (or hard) register is supplied
50 by the target interface. The raw cache should not contain
51 redundant information - if the PC is constructed from two
52 registers then those registers and not the PC lives in the raw
54 long sizeof_raw_registers
= 0;
56 /* The cooked register space. Each cooked register in the range
57 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
58 register. The remaining [NR_RAW_REGISTERS
59 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
60 both raw registers and memory by the architecture methods
61 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
62 int nr_cooked_registers
= 0;
63 long sizeof_cooked_registers
= 0;
65 /* Offset and size (in 8 bit bytes), of each register in the
66 register cache. All registers (including those in the range
67 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
69 long *register_offset
= nullptr;
70 long *sizeof_register
= nullptr;
72 /* Cached table containing the type of each register. */
73 struct type
**register_type
= nullptr;
76 static const registry
<gdbarch
>::key
<struct regcache_descr
>
77 regcache_descr_handle
;
79 static struct regcache_descr
*
80 init_regcache_descr (struct gdbarch
*gdbarch
)
83 struct regcache_descr
*descr
;
84 gdb_assert (gdbarch
!= NULL
);
86 /* Create an initial, zero filled, table. */
87 descr
= new struct regcache_descr
;
88 descr
->gdbarch
= gdbarch
;
90 /* Total size of the register space. The raw registers are mapped
91 directly onto the raw register cache while the pseudo's are
92 either mapped onto raw-registers or memory. */
93 descr
->nr_cooked_registers
= gdbarch_num_cooked_regs (gdbarch
);
95 /* Fill in a table of register types. */
97 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
,
99 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
100 descr
->register_type
[i
] = gdbarch_register_type (gdbarch
, i
);
102 /* Construct a strictly RAW register cache. Don't allow pseudo's
103 into the register cache. */
105 /* Lay out the register cache.
107 NOTE: cagney/2002-05-22: Only register_type () is used when
108 constructing the register cache. It is assumed that the
109 register's raw size, virtual size and type length are all the
115 descr
->sizeof_register
116 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
117 descr
->register_offset
118 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
119 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
121 descr
->sizeof_register
[i
] = descr
->register_type
[i
]->length ();
122 descr
->register_offset
[i
] = offset
;
123 offset
+= descr
->sizeof_register
[i
];
125 /* Set the real size of the raw register cache buffer. */
126 descr
->sizeof_raw_registers
= offset
;
128 for (; i
< descr
->nr_cooked_registers
; i
++)
130 descr
->sizeof_register
[i
] = descr
->register_type
[i
]->length ();
131 descr
->register_offset
[i
] = offset
;
132 offset
+= descr
->sizeof_register
[i
];
134 /* Set the real size of the readonly register cache buffer. */
135 descr
->sizeof_cooked_registers
= offset
;
141 static struct regcache_descr
*
142 regcache_descr (struct gdbarch
*gdbarch
)
144 struct regcache_descr
*result
= regcache_descr_handle
.get (gdbarch
);
145 if (result
== nullptr)
147 result
= init_regcache_descr (gdbarch
);
148 regcache_descr_handle
.set (gdbarch
, result
);
154 /* Utility functions returning useful register attributes stored in
155 the regcache descr. */
158 register_type (struct gdbarch
*gdbarch
, int regnum
)
160 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
162 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
163 return descr
->register_type
[regnum
];
166 /* Utility functions returning useful register attributes stored in
167 the regcache descr. */
170 register_size (struct gdbarch
*gdbarch
, int regnum
)
172 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
175 gdb_assert (regnum
>= 0 && regnum
< gdbarch_num_cooked_regs (gdbarch
));
176 size
= descr
->sizeof_register
[regnum
];
180 /* See gdbsupport/common-regcache.h. */
183 regcache_register_size (const struct regcache
*regcache
, int n
)
185 return register_size (regcache
->arch (), n
);
188 reg_buffer::reg_buffer (gdbarch
*gdbarch
, bool has_pseudo
)
189 : m_has_pseudo (has_pseudo
)
191 gdb_assert (gdbarch
!= NULL
);
192 m_descr
= regcache_descr (gdbarch
);
194 /* We don't zero-initialize the M_REGISTERS array, as the bytes it contains
195 aren't meaningful as long as the corresponding register status is not
199 m_registers
.reset (new gdb_byte
[m_descr
->sizeof_cooked_registers
]);
200 m_register_status
.reset
201 (new register_status
[m_descr
->nr_cooked_registers
] ());
205 m_registers
.reset (new gdb_byte
[m_descr
->sizeof_raw_registers
]);
206 m_register_status
.reset
207 (new register_status
[gdbarch_num_regs (gdbarch
)] ());
211 regcache::regcache (process_stratum_target
*target
, gdbarch
*gdbarch
,
212 const address_space
*aspace_
)
213 /* The register buffers. A read/write register cache can only hold
214 [0 .. gdbarch_num_regs). */
215 : detached_regcache (gdbarch
, false), m_aspace (aspace_
), m_target (target
)
217 m_ptid
= minus_one_ptid
;
220 readonly_detached_regcache::readonly_detached_regcache (regcache
&src
)
221 : readonly_detached_regcache (src
.arch (),
222 [&src
] (int regnum
, gdb_byte
*buf
)
224 return src
.cooked_read (regnum
, buf
);
230 reg_buffer::arch () const
232 return m_descr
->gdbarch
;
235 /* Return a pointer to register REGNUM's buffer cache. */
238 reg_buffer::register_buffer (int regnum
) const
240 return m_registers
.get () + m_descr
->register_offset
[regnum
];
244 reg_buffer::save (register_read_ftype cooked_read
)
246 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
249 /* It should have pseudo registers. */
250 gdb_assert (m_has_pseudo
);
251 /* Clear the dest. */
252 memset (m_registers
.get (), 0, m_descr
->sizeof_cooked_registers
);
253 memset (m_register_status
.get (), REG_UNKNOWN
, m_descr
->nr_cooked_registers
);
254 /* Copy over any registers (identified by their membership in the
255 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
256 gdbarch_num_pseudo_regs) range is checked since some architectures need
257 to save/restore `cooked' registers that live in memory. */
258 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
260 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
262 gdb_byte
*dst_buf
= register_buffer (regnum
);
263 enum register_status status
= cooked_read (regnum
, dst_buf
);
265 gdb_assert (status
!= REG_UNKNOWN
);
267 if (status
!= REG_VALID
)
268 memset (dst_buf
, 0, register_size (gdbarch
, regnum
));
270 m_register_status
[regnum
] = status
;
276 regcache::restore (readonly_detached_regcache
*src
)
278 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
281 gdb_assert (src
!= NULL
);
282 gdb_assert (src
->m_has_pseudo
);
284 gdb_assert (gdbarch
== src
->arch ());
286 /* Copy over any registers, being careful to only restore those that
287 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
288 + gdbarch_num_pseudo_regs) range is checked since some architectures need
289 to save/restore `cooked' registers that live in memory. */
290 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
292 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
294 if (src
->m_register_status
[regnum
] == REG_VALID
)
295 cooked_write (regnum
, src
->register_buffer (regnum
));
300 /* See gdbsupport/common-regcache.h. */
303 reg_buffer::get_register_status (int regnum
) const
305 assert_regnum (regnum
);
307 return m_register_status
[regnum
];
311 reg_buffer::invalidate (int regnum
)
313 assert_regnum (regnum
);
314 m_register_status
[regnum
] = REG_UNKNOWN
;
318 reg_buffer::assert_regnum (int regnum
) const
320 gdb_assert (regnum
>= 0);
322 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
324 gdb_assert (regnum
< gdbarch_num_regs (arch ()));
327 /* Type to map a ptid to a list of regcaches (one thread may have multiple
328 regcaches, associated to different gdbarches). */
330 using ptid_regcache_map
331 = std::unordered_multimap
<ptid_t
, regcache_up
, hash_ptid
>;
333 /* Type holding regcaches for a given pid. */
335 using pid_ptid_regcache_map
= std::unordered_map
<int, ptid_regcache_map
>;
337 /* Type holding regcaches for a given target. */
339 using target_pid_ptid_regcache_map
340 = std::unordered_map
<process_stratum_target
*, pid_ptid_regcache_map
>;
342 /* Global structure containing the existing regcaches. */
344 /* NOTE: this is a write-through cache. There is no "dirty" bit for
345 recording if the register values have been changed (eg. by the
346 user). Therefore all registers must be written back to the
347 target when appropriate. */
348 static target_pid_ptid_regcache_map regcaches
;
351 get_thread_arch_aspace_regcache (process_stratum_target
*target
,
352 ptid_t ptid
, gdbarch
*arch
,
353 struct address_space
*aspace
)
355 gdb_assert (target
!= nullptr);
357 /* Find the map for this target. */
358 pid_ptid_regcache_map
&pid_ptid_regc_map
= regcaches
[target
];
360 /* Find the map for this pid. */
361 ptid_regcache_map
&ptid_regc_map
= pid_ptid_regc_map
[ptid
.pid ()];
363 /* Check first if a regcache for this arch already exists. */
364 auto range
= ptid_regc_map
.equal_range (ptid
);
365 for (auto it
= range
.first
; it
!= range
.second
; ++it
)
367 if (it
->second
->arch () == arch
)
368 return it
->second
.get ();
371 /* It does not exist, create it. */
372 regcache
*new_regcache
= new regcache (target
, arch
, aspace
);
373 new_regcache
->set_ptid (ptid
);
374 /* Work around a problem with g++ 4.8 (PR96537): Call the regcache_up
375 constructor explictly instead of implicitly. */
376 ptid_regc_map
.insert (std::make_pair (ptid
, regcache_up (new_regcache
)));
382 get_thread_arch_regcache (process_stratum_target
*target
, ptid_t ptid
,
383 struct gdbarch
*gdbarch
)
385 scoped_restore_current_inferior restore_current_inferior
;
386 set_current_inferior (find_inferior_ptid (target
, ptid
));
387 address_space
*aspace
= target_thread_address_space (ptid
);
389 return get_thread_arch_aspace_regcache (target
, ptid
, gdbarch
, aspace
);
392 static process_stratum_target
*current_thread_target
;
393 static ptid_t current_thread_ptid
;
394 static struct gdbarch
*current_thread_arch
;
397 get_thread_regcache (process_stratum_target
*target
, ptid_t ptid
)
399 if (!current_thread_arch
400 || target
!= current_thread_target
401 || current_thread_ptid
!= ptid
)
403 gdb_assert (ptid
!= null_ptid
);
405 current_thread_ptid
= ptid
;
406 current_thread_target
= target
;
408 scoped_restore_current_inferior restore_current_inferior
;
409 set_current_inferior (find_inferior_ptid (target
, ptid
));
410 current_thread_arch
= target_thread_architecture (ptid
);
413 return get_thread_arch_regcache (target
, ptid
, current_thread_arch
);
416 /* See regcache.h. */
419 get_thread_regcache (thread_info
*thread
)
421 return get_thread_regcache (thread
->inf
->process_target (),
426 get_current_regcache (void)
428 return get_thread_regcache (inferior_thread ());
431 /* See gdbsupport/common-regcache.h. */
434 get_thread_regcache_for_ptid (ptid_t ptid
)
436 /* This function doesn't take a process_stratum_target parameter
437 because it's a gdbsupport/ routine implemented by both gdb and
438 gdbserver. It always refers to a ptid of the current target. */
439 process_stratum_target
*proc_target
= current_inferior ()->process_target ();
440 return get_thread_regcache (proc_target
, ptid
);
443 /* Observer for the target_changed event. */
446 regcache_observer_target_changed (struct target_ops
*target
)
448 registers_changed ();
451 /* Update regcaches related to OLD_PTID to now use NEW_PTID. */
453 regcache_thread_ptid_changed (process_stratum_target
*target
,
454 ptid_t old_ptid
, ptid_t new_ptid
)
456 /* Look up map for target. */
457 auto pid_ptid_regc_map_it
= regcaches
.find (target
);
458 if (pid_ptid_regc_map_it
== regcaches
.end ())
461 /* Look up map for pid. */
462 pid_ptid_regcache_map
&pid_ptid_regc_map
= pid_ptid_regc_map_it
->second
;
463 auto ptid_regc_map_it
= pid_ptid_regc_map
.find (old_ptid
.pid ());
464 if (ptid_regc_map_it
== pid_ptid_regc_map
.end ())
467 /* Update all regcaches belonging to old_ptid. */
468 ptid_regcache_map
&ptid_regc_map
= ptid_regc_map_it
->second
;
469 auto range
= ptid_regc_map
.equal_range (old_ptid
);
470 for (auto it
= range
.first
; it
!= range
.second
;)
472 regcache_up rc
= std::move (it
->second
);
473 rc
->set_ptid (new_ptid
);
475 /* Remove old before inserting new, to avoid rehashing,
476 which would invalidate iterators. */
477 it
= ptid_regc_map
.erase (it
);
478 ptid_regc_map
.insert (std::make_pair (new_ptid
, std::move (rc
)));
482 /* Low level examining and depositing of registers.
484 The caller is responsible for making sure that the inferior is
485 stopped before calling the fetching routines, or it will get
486 garbage. (a change from GDB version 3, in which the caller got the
487 value from the last stop). */
489 /* REGISTERS_CHANGED ()
491 Indicate that registers may have changed, so invalidate the cache. */
494 registers_changed_ptid (process_stratum_target
*target
, ptid_t ptid
)
496 if (target
== nullptr)
498 /* Since there can be ptid clashes between targets, it's not valid to
499 pass a ptid without saying to which target it belongs. */
500 gdb_assert (ptid
== minus_one_ptid
);
502 /* Delete all the regcaches of all targets. */
505 else if (ptid
.is_pid ())
507 /* Non-NULL target and pid ptid, delete all regcaches belonging
508 to this (TARGET, PID). */
510 /* Look up map for target. */
511 auto pid_ptid_regc_map_it
= regcaches
.find (target
);
512 if (pid_ptid_regc_map_it
!= regcaches
.end ())
514 pid_ptid_regcache_map
&pid_ptid_regc_map
515 = pid_ptid_regc_map_it
->second
;
517 pid_ptid_regc_map
.erase (ptid
.pid ());
520 else if (ptid
!= minus_one_ptid
)
522 /* Non-NULL target and non-minus_one_ptid, delete all regcaches belonging
523 to this (TARGET, PTID). */
525 /* Look up map for target. */
526 auto pid_ptid_regc_map_it
= regcaches
.find (target
);
527 if (pid_ptid_regc_map_it
!= regcaches
.end ())
529 pid_ptid_regcache_map
&pid_ptid_regc_map
530 = pid_ptid_regc_map_it
->second
;
532 /* Look up map for pid. */
533 auto ptid_regc_map_it
534 = pid_ptid_regc_map
.find (ptid
.pid ());
535 if (ptid_regc_map_it
!= pid_ptid_regc_map
.end ())
537 ptid_regcache_map
&ptid_regc_map
538 = ptid_regc_map_it
->second
;
540 ptid_regc_map
.erase (ptid
);
546 /* Non-NULL target and minus_one_ptid, delete all regcaches
547 associated to this target. */
548 regcaches
.erase (target
);
551 if ((target
== nullptr || current_thread_target
== target
)
552 && current_thread_ptid
.matches (ptid
))
554 current_thread_target
= NULL
;
555 current_thread_ptid
= null_ptid
;
556 current_thread_arch
= NULL
;
559 if ((target
== nullptr || current_inferior ()->process_target () == target
)
560 && inferior_ptid
.matches (ptid
))
562 /* We just deleted the regcache of the current thread. Need to
563 forget about any frames we have cached, too. */
564 reinit_frame_cache ();
568 /* See regcache.h. */
571 registers_changed_thread (thread_info
*thread
)
573 registers_changed_ptid (thread
->inf
->process_target (), thread
->ptid
);
577 registers_changed (void)
579 registers_changed_ptid (nullptr, minus_one_ptid
);
583 regcache::raw_update (int regnum
)
585 assert_regnum (regnum
);
587 /* Make certain that the register cache is up-to-date with respect
588 to the current thread. This switching shouldn't be necessary
589 only there is still only one target side register cache. Sigh!
590 On the bright side, at least there is a regcache object. */
592 if (get_register_status (regnum
) == REG_UNKNOWN
)
594 target_fetch_registers (this, regnum
);
596 /* A number of targets can't access the whole set of raw
597 registers (because the debug API provides no means to get at
599 if (m_register_status
[regnum
] == REG_UNKNOWN
)
600 m_register_status
[regnum
] = REG_UNAVAILABLE
;
605 readable_regcache::raw_read (int regnum
, gdb_byte
*buf
)
607 gdb_assert (buf
!= NULL
);
610 if (m_register_status
[regnum
] != REG_VALID
)
611 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
613 memcpy (buf
, register_buffer (regnum
),
614 m_descr
->sizeof_register
[regnum
]);
616 return m_register_status
[regnum
];
620 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
622 gdb_assert (regcache
!= NULL
);
623 return regcache
->raw_read (regnum
, val
);
626 template<typename T
, typename
>
628 readable_regcache::raw_read (int regnum
, T
*val
)
630 assert_regnum (regnum
);
631 size_t len
= m_descr
->sizeof_register
[regnum
];
632 gdb_byte
*buf
= (gdb_byte
*) alloca (len
);
633 register_status status
= raw_read (regnum
, buf
);
634 if (status
== REG_VALID
)
635 *val
= extract_integer
<T
> ({buf
, len
},
636 gdbarch_byte_order (m_descr
->gdbarch
));
643 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
646 gdb_assert (regcache
!= NULL
);
647 return regcache
->raw_read (regnum
, val
);
651 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
653 gdb_assert (regcache
!= NULL
);
654 regcache
->raw_write (regnum
, val
);
657 template<typename T
, typename
>
659 regcache::raw_write (int regnum
, T val
)
663 assert_regnum (regnum
);
664 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
665 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
666 gdbarch_byte_order (m_descr
->gdbarch
), val
);
667 raw_write (regnum
, buf
);
671 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
674 gdb_assert (regcache
!= NULL
);
675 regcache
->raw_write (regnum
, val
);
679 regcache_raw_get_signed (struct regcache
*regcache
, int regnum
)
682 enum register_status status
;
684 status
= regcache_raw_read_signed (regcache
, regnum
, &value
);
685 if (status
== REG_UNAVAILABLE
)
686 throw_error (NOT_AVAILABLE_ERROR
,
687 _("Register %d is not available"), regnum
);
692 readable_regcache::cooked_read (int regnum
, gdb_byte
*buf
)
694 gdb_assert (regnum
>= 0);
695 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
696 if (regnum
< num_raw_registers ())
697 return raw_read (regnum
, buf
);
698 else if (m_has_pseudo
699 && m_register_status
[regnum
] != REG_UNKNOWN
)
701 if (m_register_status
[regnum
] == REG_VALID
)
702 memcpy (buf
, register_buffer (regnum
),
703 m_descr
->sizeof_register
[regnum
]);
705 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
707 return m_register_status
[regnum
];
709 else if (gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
711 struct value
*computed
;
712 enum register_status result
= REG_VALID
;
714 scoped_value_mark mark
;
716 computed
= gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
718 if (value_entirely_available (computed
))
719 memcpy (buf
, value_contents_raw (computed
).data (),
720 m_descr
->sizeof_register
[regnum
]);
723 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
724 result
= REG_UNAVAILABLE
;
730 return gdbarch_pseudo_register_read (m_descr
->gdbarch
, this,
735 readable_regcache::cooked_read_value (int regnum
)
737 gdb_assert (regnum
>= 0);
738 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
740 if (regnum
< num_raw_registers ()
741 || (m_has_pseudo
&& m_register_status
[regnum
] != REG_UNKNOWN
)
742 || !gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
744 struct value
*result
;
746 result
= allocate_value (register_type (m_descr
->gdbarch
, regnum
));
747 VALUE_LVAL (result
) = lval_register
;
748 VALUE_REGNUM (result
) = regnum
;
750 /* It is more efficient in general to do this delegation in this
751 direction than in the other one, even though the value-based
753 if (cooked_read (regnum
,
754 value_contents_raw (result
).data ()) == REG_UNAVAILABLE
)
755 mark_value_bytes_unavailable (result
, 0,
756 value_type (result
)->length ());
761 return gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
766 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
769 gdb_assert (regcache
!= NULL
);
770 return regcache
->cooked_read (regnum
, val
);
773 template<typename T
, typename
>
775 readable_regcache::cooked_read (int regnum
, T
*val
)
777 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
778 size_t len
= m_descr
->sizeof_register
[regnum
];
779 gdb_byte
*buf
= (gdb_byte
*) alloca (len
);
780 register_status status
= cooked_read (regnum
, buf
);
781 if (status
== REG_VALID
)
782 *val
= extract_integer
<T
> ({buf
, len
},
783 gdbarch_byte_order (m_descr
->gdbarch
));
790 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
793 gdb_assert (regcache
!= NULL
);
794 return regcache
->cooked_read (regnum
, val
);
798 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
801 gdb_assert (regcache
!= NULL
);
802 regcache
->cooked_write (regnum
, val
);
805 template<typename T
, typename
>
807 regcache::cooked_write (int regnum
, T val
)
811 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
812 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
813 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
814 gdbarch_byte_order (m_descr
->gdbarch
), val
);
815 cooked_write (regnum
, buf
);
819 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
822 gdb_assert (regcache
!= NULL
);
823 regcache
->cooked_write (regnum
, val
);
827 regcache::raw_write (int regnum
, const gdb_byte
*buf
)
830 gdb_assert (buf
!= NULL
);
831 assert_regnum (regnum
);
833 /* On the sparc, writing %g0 is a no-op, so we don't even want to
834 change the registers array if something writes to this register. */
835 if (gdbarch_cannot_store_register (arch (), regnum
))
838 /* If we have a valid copy of the register, and new value == old
839 value, then don't bother doing the actual store. */
840 if (get_register_status (regnum
) == REG_VALID
841 && (memcmp (register_buffer (regnum
), buf
,
842 m_descr
->sizeof_register
[regnum
]) == 0))
845 target_prepare_to_store (this);
846 raw_supply (regnum
, buf
);
848 /* Invalidate the register after it is written, in case of a
851 = make_scope_exit ([&] { this->invalidate (regnum
); });
853 target_store_registers (this, regnum
);
855 /* The target did not throw an error so we can discard invalidating
857 invalidator
.release ();
861 regcache::cooked_write (int regnum
, const gdb_byte
*buf
)
863 gdb_assert (regnum
>= 0);
864 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
865 if (regnum
< num_raw_registers ())
866 raw_write (regnum
, buf
);
868 gdbarch_pseudo_register_write (m_descr
->gdbarch
, this,
872 /* See regcache.h. */
875 readable_regcache::read_part (int regnum
, int offset
, int len
,
876 gdb_byte
*out
, bool is_raw
)
878 int reg_size
= register_size (arch (), regnum
);
880 gdb_assert (out
!= NULL
);
881 gdb_assert (offset
>= 0 && offset
<= reg_size
);
882 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
884 if (offset
== 0 && len
== 0)
890 if (offset
== 0 && len
== reg_size
)
892 /* Read the full register. */
893 return (is_raw
) ? raw_read (regnum
, out
) : cooked_read (regnum
, out
);
896 enum register_status status
;
897 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
899 /* Read full register to buffer. */
900 status
= (is_raw
) ? raw_read (regnum
, reg
) : cooked_read (regnum
, reg
);
901 if (status
!= REG_VALID
)
905 memcpy (out
, reg
+ offset
, len
);
909 /* See regcache.h. */
912 reg_buffer::raw_collect_part (int regnum
, int offset
, int len
,
915 int reg_size
= register_size (arch (), regnum
);
917 gdb_assert (out
!= nullptr);
918 gdb_assert (offset
>= 0 && offset
<= reg_size
);
919 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
921 if (offset
== 0 && len
== 0)
927 if (offset
== 0 && len
== reg_size
)
929 /* Collect the full register. */
930 return raw_collect (regnum
, out
);
933 /* Read to buffer, then write out. */
934 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
935 raw_collect (regnum
, reg
);
936 memcpy (out
, reg
+ offset
, len
);
939 /* See regcache.h. */
942 regcache::write_part (int regnum
, int offset
, int len
,
943 const gdb_byte
*in
, bool is_raw
)
945 int reg_size
= register_size (arch (), regnum
);
947 gdb_assert (in
!= NULL
);
948 gdb_assert (offset
>= 0 && offset
<= reg_size
);
949 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
951 if (offset
== 0 && len
== 0)
957 if (offset
== 0 && len
== reg_size
)
959 /* Write the full register. */
960 (is_raw
) ? raw_write (regnum
, in
) : cooked_write (regnum
, in
);
964 enum register_status status
;
965 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
967 /* Read existing register to buffer. */
968 status
= (is_raw
) ? raw_read (regnum
, reg
) : cooked_read (regnum
, reg
);
969 if (status
!= REG_VALID
)
972 /* Update buffer, then write back to regcache. */
973 memcpy (reg
+ offset
, in
, len
);
974 is_raw
? raw_write (regnum
, reg
) : cooked_write (regnum
, reg
);
978 /* See regcache.h. */
981 reg_buffer::raw_supply_part (int regnum
, int offset
, int len
,
984 int reg_size
= register_size (arch (), regnum
);
986 gdb_assert (in
!= nullptr);
987 gdb_assert (offset
>= 0 && offset
<= reg_size
);
988 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
990 if (offset
== 0 && len
== 0)
996 if (offset
== 0 && len
== reg_size
)
998 /* Supply the full register. */
999 return raw_supply (regnum
, in
);
1002 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
1004 /* Read existing value to buffer. */
1005 raw_collect (regnum
, reg
);
1007 /* Write to buffer, then write out. */
1008 memcpy (reg
+ offset
, in
, len
);
1009 raw_supply (regnum
, reg
);
1012 enum register_status
1013 readable_regcache::raw_read_part (int regnum
, int offset
, int len
,
1016 assert_regnum (regnum
);
1017 return read_part (regnum
, offset
, len
, buf
, true);
1020 /* See regcache.h. */
1023 regcache::raw_write_part (int regnum
, int offset
, int len
,
1024 const gdb_byte
*buf
)
1026 assert_regnum (regnum
);
1027 write_part (regnum
, offset
, len
, buf
, true);
1030 /* See regcache.h. */
1032 enum register_status
1033 readable_regcache::cooked_read_part (int regnum
, int offset
, int len
,
1036 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1037 return read_part (regnum
, offset
, len
, buf
, false);
1040 /* See regcache.h. */
1043 regcache::cooked_write_part (int regnum
, int offset
, int len
,
1044 const gdb_byte
*buf
)
1046 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1047 write_part (regnum
, offset
, len
, buf
, false);
1050 /* See gdbsupport/common-regcache.h. */
1053 reg_buffer::raw_supply (int regnum
, const void *buf
)
1058 assert_regnum (regnum
);
1060 regbuf
= register_buffer (regnum
);
1061 size
= m_descr
->sizeof_register
[regnum
];
1065 memcpy (regbuf
, buf
, size
);
1066 m_register_status
[regnum
] = REG_VALID
;
1070 /* This memset not strictly necessary, but better than garbage
1071 in case the register value manages to escape somewhere (due
1072 to a bug, no less). */
1073 memset (regbuf
, 0, size
);
1074 m_register_status
[regnum
] = REG_UNAVAILABLE
;
1078 /* See regcache.h. */
1081 reg_buffer::raw_supply_integer (int regnum
, const gdb_byte
*addr
,
1082 int addr_len
, bool is_signed
)
1084 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1088 assert_regnum (regnum
);
1090 regbuf
= register_buffer (regnum
);
1091 regsize
= m_descr
->sizeof_register
[regnum
];
1093 copy_integer_to_size (regbuf
, regsize
, addr
, addr_len
, is_signed
,
1095 m_register_status
[regnum
] = REG_VALID
;
1098 /* See regcache.h. */
1101 reg_buffer::raw_supply_zeroed (int regnum
)
1106 assert_regnum (regnum
);
1108 regbuf
= register_buffer (regnum
);
1109 size
= m_descr
->sizeof_register
[regnum
];
1111 memset (regbuf
, 0, size
);
1112 m_register_status
[regnum
] = REG_VALID
;
1115 /* See gdbsupport/common-regcache.h. */
1118 reg_buffer::raw_collect (int regnum
, void *buf
) const
1123 gdb_assert (buf
!= NULL
);
1124 assert_regnum (regnum
);
1126 regbuf
= register_buffer (regnum
);
1127 size
= m_descr
->sizeof_register
[regnum
];
1128 memcpy (buf
, regbuf
, size
);
1131 /* See regcache.h. */
1134 reg_buffer::raw_collect_integer (int regnum
, gdb_byte
*addr
, int addr_len
,
1135 bool is_signed
) const
1137 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1138 const gdb_byte
*regbuf
;
1141 assert_regnum (regnum
);
1143 regbuf
= register_buffer (regnum
);
1144 regsize
= m_descr
->sizeof_register
[regnum
];
1146 copy_integer_to_size (addr
, addr_len
, regbuf
, regsize
, is_signed
,
1150 /* See regcache.h. */
1153 regcache::transfer_regset_register (struct regcache
*out_regcache
, int regnum
,
1154 const gdb_byte
*in_buf
, gdb_byte
*out_buf
,
1155 int slot_size
, int offs
) const
1157 struct gdbarch
*gdbarch
= arch ();
1158 int reg_size
= std::min (register_size (gdbarch
, regnum
), slot_size
);
1160 /* Use part versions and reg_size to prevent possible buffer overflows when
1161 accessing the regcache. */
1163 if (out_buf
!= nullptr)
1165 raw_collect_part (regnum
, 0, reg_size
, out_buf
+ offs
);
1167 /* Ensure any additional space is cleared. */
1168 if (slot_size
> reg_size
)
1169 memset (out_buf
+ offs
+ reg_size
, 0, slot_size
- reg_size
);
1171 else if (in_buf
!= nullptr)
1173 /* Zero-extend the register value if the slot is smaller than the register. */
1174 if (slot_size
< register_size (gdbarch
, regnum
))
1175 out_regcache
->raw_supply_zeroed (regnum
);
1176 out_regcache
->raw_supply_part (regnum
, 0, reg_size
, in_buf
+ offs
);
1180 /* Invalidate the register. */
1181 out_regcache
->raw_supply (regnum
, nullptr);
1185 /* See regcache.h. */
1188 regcache::transfer_regset (const struct regset
*regset
, int regbase
,
1189 struct regcache
*out_regcache
,
1190 int regnum
, const gdb_byte
*in_buf
,
1191 gdb_byte
*out_buf
, size_t size
) const
1193 const struct regcache_map_entry
*map
;
1194 int offs
= 0, count
;
1196 for (map
= (const struct regcache_map_entry
*) regset
->regmap
;
1197 (count
= map
->count
) != 0;
1200 int regno
= map
->regno
;
1201 int slot_size
= map
->size
;
1203 if (regno
!= REGCACHE_MAP_SKIP
)
1206 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1207 slot_size
= m_descr
->sizeof_register
[regno
];
1209 if (regno
== REGCACHE_MAP_SKIP
1211 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1212 offs
+= count
* slot_size
;
1214 else if (regnum
== -1)
1215 for (; count
--; regno
++, offs
+= slot_size
)
1217 if (offs
+ slot_size
> size
)
1220 transfer_regset_register (out_regcache
, regno
, in_buf
, out_buf
,
1225 /* Transfer a single register and return. */
1226 offs
+= (regnum
- regno
) * slot_size
;
1227 if (offs
+ slot_size
> size
)
1230 transfer_regset_register (out_regcache
, regnum
, in_buf
, out_buf
,
1237 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1238 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1239 If BUF is NULL, set the register(s) to "unavailable" status. */
1242 regcache_supply_regset (const struct regset
*regset
,
1243 struct regcache
*regcache
,
1244 int regnum
, const void *buf
, size_t size
)
1246 regcache
->supply_regset (regset
, regnum
, (const gdb_byte
*) buf
, size
);
1249 /* See regcache.h. */
1252 regcache::supply_regset (const struct regset
*regset
, int regbase
,
1253 int regnum
, const void *buf
, size_t size
)
1255 transfer_regset (regset
, regbase
, this, regnum
, (const gdb_byte
*) buf
,
1259 /* Collect register REGNUM from REGCACHE to BUF, using the register
1260 map in REGSET. If REGNUM is -1, do this for all registers in
1264 regcache_collect_regset (const struct regset
*regset
,
1265 const struct regcache
*regcache
,
1266 int regnum
, void *buf
, size_t size
)
1268 regcache
->collect_regset (regset
, regnum
, (gdb_byte
*) buf
, size
);
1271 /* See regcache.h */
1274 regcache::collect_regset (const struct regset
*regset
, int regbase
,
1275 int regnum
, void *buf
, size_t size
) const
1277 transfer_regset (regset
, regbase
, nullptr, regnum
, nullptr, (gdb_byte
*) buf
,
1282 regcache_map_supplies (const struct regcache_map_entry
*map
, int regnum
,
1283 struct gdbarch
*gdbarch
, size_t size
)
1285 int offs
= 0, count
;
1287 for (; (count
= map
->count
) != 0; map
++)
1289 int regno
= map
->regno
;
1290 int slot_size
= map
->size
;
1292 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1293 slot_size
= register_size (gdbarch
, regno
);
1295 if (regno
!= REGCACHE_MAP_SKIP
&& regnum
>= regno
1296 && regnum
< regno
+ count
)
1297 return offs
+ (regnum
- regno
+ 1) * slot_size
<= size
;
1299 offs
+= count
* slot_size
;
1306 /* See gdbsupport/common-regcache.h. */
1309 reg_buffer::raw_compare (int regnum
, const void *buf
, int offset
) const
1311 gdb_assert (buf
!= NULL
);
1312 assert_regnum (regnum
);
1314 const char *regbuf
= (const char *) register_buffer (regnum
);
1315 size_t size
= m_descr
->sizeof_register
[regnum
];
1316 gdb_assert (size
>= offset
);
1318 return (memcmp (buf
, regbuf
+ offset
, size
- offset
) == 0);
1321 /* Special handling for register PC. */
1324 regcache_read_pc (struct regcache
*regcache
)
1326 struct gdbarch
*gdbarch
= regcache
->arch ();
1330 if (gdbarch_read_pc_p (gdbarch
))
1331 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1332 /* Else use per-frame method on get_current_frame. */
1333 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1337 if (regcache_cooked_read_unsigned (regcache
,
1338 gdbarch_pc_regnum (gdbarch
),
1339 &raw_val
) == REG_UNAVAILABLE
)
1340 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1342 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1345 internal_error (_("regcache_read_pc: Unable to find PC"));
1349 /* See gdbsupport/common-regcache.h. */
1352 regcache_read_pc_protected (regcache
*regcache
)
1357 pc
= regcache_read_pc (regcache
);
1359 catch (const gdb_exception_error
&ex
)
1368 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1370 struct gdbarch
*gdbarch
= regcache
->arch ();
1372 if (gdbarch_write_pc_p (gdbarch
))
1373 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1374 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1375 regcache_cooked_write_unsigned (regcache
,
1376 gdbarch_pc_regnum (gdbarch
), pc
);
1378 internal_error (_("regcache_write_pc: Unable to update PC"));
1380 /* Writing the PC (for instance, from "load") invalidates the
1382 reinit_frame_cache ();
1386 reg_buffer::num_raw_registers () const
1388 return gdbarch_num_regs (arch ());
1392 regcache::debug_print_register (const char *func
, int regno
)
1394 struct gdbarch
*gdbarch
= arch ();
1396 gdb_printf (gdb_stdlog
, "%s ", func
);
1397 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
1398 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
1399 gdb_printf (gdb_stdlog
, "(%s)",
1400 gdbarch_register_name (gdbarch
, regno
));
1402 gdb_printf (gdb_stdlog
, "(%d)", regno
);
1403 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
1405 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1406 int size
= register_size (gdbarch
, regno
);
1407 gdb_byte
*buf
= register_buffer (regno
);
1409 gdb_printf (gdb_stdlog
, " = ");
1410 for (int i
= 0; i
< size
; i
++)
1412 gdb_printf (gdb_stdlog
, "%02x", buf
[i
]);
1414 if (size
<= sizeof (LONGEST
))
1416 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
1418 gdb_printf (gdb_stdlog
, " %s %s",
1419 core_addr_to_string_nz (val
), plongest (val
));
1422 gdb_printf (gdb_stdlog
, "\n");
1425 /* Implement 'maint flush register-cache' command. */
1428 reg_flush_command (const char *command
, int from_tty
)
1430 /* Force-flush the register cache. */
1431 registers_changed ();
1433 gdb_printf (_("Register cache flushed.\n"));
1437 register_dump::dump (ui_file
*file
)
1439 auto descr
= regcache_descr (m_gdbarch
);
1441 int footnote_nr
= 0;
1442 int footnote_register_offset
= 0;
1443 int footnote_register_type_name_null
= 0;
1444 long register_offset
= 0;
1446 gdb_assert (descr
->nr_cooked_registers
1447 == gdbarch_num_cooked_regs (m_gdbarch
));
1449 for (regnum
= -1; regnum
< descr
->nr_cooked_registers
; regnum
++)
1453 gdb_printf (file
, " %-10s", "Name");
1456 const char *p
= gdbarch_register_name (m_gdbarch
, regnum
);
1460 gdb_printf (file
, " %-10s", p
);
1465 gdb_printf (file
, " %4s", "Nr");
1467 gdb_printf (file
, " %4d", regnum
);
1469 /* Relative number. */
1471 gdb_printf (file
, " %4s", "Rel");
1472 else if (regnum
< gdbarch_num_regs (m_gdbarch
))
1473 gdb_printf (file
, " %4d", regnum
);
1475 gdb_printf (file
, " %4d",
1476 (regnum
- gdbarch_num_regs (m_gdbarch
)));
1480 gdb_printf (file
, " %6s ", "Offset");
1483 gdb_printf (file
, " %6ld",
1484 descr
->register_offset
[regnum
]);
1485 if (register_offset
!= descr
->register_offset
[regnum
]
1487 && (descr
->register_offset
[regnum
]
1488 != (descr
->register_offset
[regnum
- 1]
1489 + descr
->sizeof_register
[regnum
- 1])))
1492 if (!footnote_register_offset
)
1493 footnote_register_offset
= ++footnote_nr
;
1494 gdb_printf (file
, "*%d", footnote_register_offset
);
1497 gdb_printf (file
, " ");
1498 register_offset
= (descr
->register_offset
[regnum
]
1499 + descr
->sizeof_register
[regnum
]);
1504 gdb_printf (file
, " %5s ", "Size");
1506 gdb_printf (file
, " %5ld", descr
->sizeof_register
[regnum
]);
1511 std::string name_holder
;
1517 static const char blt
[] = "builtin_type";
1519 t
= register_type (m_gdbarch
, regnum
)->name ();
1522 if (!footnote_register_type_name_null
)
1523 footnote_register_type_name_null
= ++footnote_nr
;
1524 name_holder
= string_printf ("*%d",
1525 footnote_register_type_name_null
);
1526 t
= name_holder
.c_str ();
1528 /* Chop a leading builtin_type. */
1529 if (startswith (t
, blt
))
1532 gdb_printf (file
, " %-15s", t
);
1535 /* Leading space always present. */
1536 gdb_printf (file
, " ");
1538 dump_reg (file
, regnum
);
1540 gdb_printf (file
, "\n");
1543 if (footnote_register_offset
)
1544 gdb_printf (file
, "*%d: Inconsistent register offsets.\n",
1545 footnote_register_offset
);
1546 if (footnote_register_type_name_null
)
1548 "*%d: Register type's name NULL.\n",
1549 footnote_register_type_name_null
);
1553 #include "gdbsupport/selftest.h"
1554 #include "selftest-arch.h"
1555 #include "target-float.h"
1557 namespace selftests
{
1564 for (auto pid_ptid_regc_map_it
= regcaches
.cbegin ();
1565 pid_ptid_regc_map_it
!= regcaches
.cend ();
1566 ++pid_ptid_regc_map_it
)
1568 const pid_ptid_regcache_map
&pid_ptid_regc_map
1569 = pid_ptid_regc_map_it
->second
;
1571 for (auto ptid_regc_map_it
= pid_ptid_regc_map
.cbegin ();
1572 ptid_regc_map_it
!= pid_ptid_regc_map
.cend ();
1575 const ptid_regcache_map
&ptid_regc_map
1576 = ptid_regc_map_it
->second
;
1578 size
+= ptid_regc_map
.size ();
1585 /* Return the count of regcaches for (TARGET, PTID) in REGCACHES. */
1588 regcache_count (process_stratum_target
*target
, ptid_t ptid
)
1590 /* Look up map for target. */
1591 auto pid_ptid_regc_map_it
= regcaches
.find (target
);
1592 if (pid_ptid_regc_map_it
!= regcaches
.end ())
1594 pid_ptid_regcache_map
&pid_ptid_regc_map
= pid_ptid_regc_map_it
->second
;
1596 /* Look map for pid. */
1597 auto ptid_regc_map_it
= pid_ptid_regc_map
.find (ptid
.pid ());
1598 if (ptid_regc_map_it
!= pid_ptid_regc_map
.end ())
1600 ptid_regcache_map
&ptid_regc_map
= ptid_regc_map_it
->second
;
1601 auto range
= ptid_regc_map
.equal_range (ptid
);
1603 return std::distance (range
.first
, range
.second
);
1610 /* Wrapper around get_thread_arch_aspace_regcache that does some self checks. */
1613 get_thread_arch_aspace_regcache_and_check (process_stratum_target
*target
,
1616 /* We currently only test with a single gdbarch. Any gdbarch will do, so use
1617 the current inferior's gdbarch. Also use the current inferior's address
1619 gdbarch
*arch
= current_inferior ()->gdbarch
;
1620 address_space
*aspace
= current_inferior ()->aspace
;
1622 = get_thread_arch_aspace_regcache (target
, ptid
, arch
, aspace
);
1624 SELF_CHECK (regcache
!= NULL
);
1625 SELF_CHECK (regcache
->target () == target
);
1626 SELF_CHECK (regcache
->ptid () == ptid
);
1627 SELF_CHECK (regcache
->arch () == arch
);
1628 SELF_CHECK (regcache
->aspace () == aspace
);
1631 /* The data that the regcaches selftests must hold onto for the duration of the
1634 struct regcache_test_data
1636 regcache_test_data ()
1638 /* Ensure the regcaches container is empty at the start. */
1639 registers_changed ();
1642 ~regcache_test_data ()
1644 /* Make sure to leave the global regcaches container empty. */
1645 registers_changed ();
1648 test_target_ops test_target1
;
1649 test_target_ops test_target2
;
1652 using regcache_test_data_up
= std::unique_ptr
<regcache_test_data
>;
1654 /* Set up a few regcaches from two different targets, for use in
1655 regcache-management tests.
1657 Return a pointer, because the `regcache_test_data` type is not moveable. */
1659 static regcache_test_data_up
1660 populate_regcaches_for_test ()
1662 regcache_test_data_up
data (new regcache_test_data
);
1663 size_t expected_regcache_size
= 0;
1665 SELF_CHECK (regcaches_size () == 0);
1667 /* Populate the regcache container with a few regcaches for the two test
1669 for (int pid
: { 1, 2 })
1671 for (long lwp
: { 1, 2, 3 })
1673 get_thread_arch_aspace_regcache_and_check
1674 (&data
->test_target1
, ptid_t (pid
, lwp
));
1675 expected_regcache_size
++;
1676 SELF_CHECK (regcaches_size () == expected_regcache_size
);
1678 get_thread_arch_aspace_regcache_and_check
1679 (&data
->test_target2
, ptid_t (pid
, lwp
));
1680 expected_regcache_size
++;
1681 SELF_CHECK (regcaches_size () == expected_regcache_size
);
1689 get_thread_arch_aspace_regcache_test ()
1691 /* populate_regcaches_for_test already tests most of the
1692 get_thread_arch_aspace_regcache functionality. */
1693 regcache_test_data_up data
= populate_regcaches_for_test ();
1694 size_t regcaches_size_before
= regcaches_size ();
1696 /* Test that getting an existing regcache doesn't create a new one. */
1697 get_thread_arch_aspace_regcache_and_check (&data
->test_target1
, ptid_t (2, 2));
1698 SELF_CHECK (regcaches_size () == regcaches_size_before
);
1701 /* Test marking all regcaches of all targets as changed. */
1704 registers_changed_ptid_all_test ()
1706 regcache_test_data_up data
= populate_regcaches_for_test ();
1708 registers_changed_ptid (nullptr, minus_one_ptid
);
1709 SELF_CHECK (regcaches_size () == 0);
1712 /* Test marking regcaches of a specific target as changed. */
1715 registers_changed_ptid_target_test ()
1717 regcache_test_data_up data
= populate_regcaches_for_test ();
1719 registers_changed_ptid (&data
->test_target1
, minus_one_ptid
);
1720 SELF_CHECK (regcaches_size () == 6);
1722 /* Check that we deleted the regcache for the right target. */
1723 SELF_CHECK (regcache_count (&data
->test_target1
, ptid_t (2, 2)) == 0);
1724 SELF_CHECK (regcache_count (&data
->test_target2
, ptid_t (2, 2)) == 1);
1727 /* Test marking regcaches of a specific (target, pid) as changed. */
1730 registers_changed_ptid_target_pid_test ()
1732 regcache_test_data_up data
= populate_regcaches_for_test ();
1734 registers_changed_ptid (&data
->test_target1
, ptid_t (2));
1735 SELF_CHECK (regcaches_size () == 9);
1737 /* Regcaches from target1 should not exist, while regcaches from target2
1739 SELF_CHECK (regcache_count (&data
->test_target1
, ptid_t (2, 2)) == 0);
1740 SELF_CHECK (regcache_count (&data
->test_target2
, ptid_t (2, 2)) == 1);
1743 /* Test marking regcaches of a specific (target, ptid) as changed. */
1746 registers_changed_ptid_target_ptid_test ()
1748 regcache_test_data_up data
= populate_regcaches_for_test ();
1750 registers_changed_ptid (&data
->test_target1
, ptid_t (2, 2));
1751 SELF_CHECK (regcaches_size () == 11);
1753 /* Check that we deleted the regcache for the right target. */
1754 SELF_CHECK (regcache_count (&data
->test_target1
, ptid_t (2, 2)) == 0);
1755 SELF_CHECK (regcache_count (&data
->test_target2
, ptid_t (2, 2)) == 1);
1758 class target_ops_no_register
: public test_target_ops
1761 target_ops_no_register ()
1762 : test_target_ops
{}
1767 fetch_registers_called
= 0;
1768 store_registers_called
= 0;
1769 xfer_partial_called
= 0;
1772 void fetch_registers (regcache
*regs
, int regno
) override
;
1773 void store_registers (regcache
*regs
, int regno
) override
;
1775 enum target_xfer_status
xfer_partial (enum target_object object
,
1776 const char *annex
, gdb_byte
*readbuf
,
1777 const gdb_byte
*writebuf
,
1778 ULONGEST offset
, ULONGEST len
,
1779 ULONGEST
*xfered_len
) override
;
1781 unsigned int fetch_registers_called
= 0;
1782 unsigned int store_registers_called
= 0;
1783 unsigned int xfer_partial_called
= 0;
1787 target_ops_no_register::fetch_registers (regcache
*regs
, int regno
)
1789 /* Mark register available. */
1790 regs
->raw_supply_zeroed (regno
);
1791 this->fetch_registers_called
++;
1795 target_ops_no_register::store_registers (regcache
*regs
, int regno
)
1797 this->store_registers_called
++;
1800 enum target_xfer_status
1801 target_ops_no_register::xfer_partial (enum target_object object
,
1802 const char *annex
, gdb_byte
*readbuf
,
1803 const gdb_byte
*writebuf
,
1804 ULONGEST offset
, ULONGEST len
,
1805 ULONGEST
*xfered_len
)
1807 this->xfer_partial_called
++;
1810 return TARGET_XFER_OK
;
1813 class readwrite_regcache
: public regcache
1816 readwrite_regcache (process_stratum_target
*target
,
1817 struct gdbarch
*gdbarch
)
1818 : regcache (target
, gdbarch
, nullptr)
1822 /* Return true if regcache::cooked_{read,write}_test should be skipped for
1826 selftest_skiparch (struct gdbarch
*gdbarch
)
1828 const char *name
= gdbarch_bfd_arch_info (gdbarch
)->printable_name
;
1831 Running selftest regcache::cooked_{read,write}_test::m68hc11.
1832 warning: No frame soft register found in the symbol table.
1833 Stack backtrace will not work.
1834 We could instead capture the output and then filter out the warning, but
1835 that seems more trouble than it's worth. */
1836 return (strcmp (name
, "m68hc11") == 0
1837 || strcmp (name
, "m68hc12") == 0
1838 || strcmp (name
, "m68hc12:HCS12") == 0);
1841 /* Test regcache::cooked_read gets registers from raw registers and
1842 memory instead of target to_{fetch,store}_registers. */
1845 cooked_read_test (struct gdbarch
*gdbarch
)
1847 if (selftest_skiparch (gdbarch
))
1850 scoped_mock_context
<target_ops_no_register
> mockctx (gdbarch
);
1852 /* Test that read one raw register from regcache_no_target will go
1853 to the target layer. */
1855 /* Find a raw register which size isn't zero. */
1857 for (nonzero_regnum
= 0;
1858 nonzero_regnum
< gdbarch_num_regs (gdbarch
);
1861 if (register_size (gdbarch
, nonzero_regnum
) != 0)
1865 readwrite_regcache
readwrite (&mockctx
.mock_target
, gdbarch
);
1866 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, nonzero_regnum
));
1868 readwrite
.raw_read (nonzero_regnum
, buf
.data ());
1870 /* raw_read calls target_fetch_registers. */
1871 SELF_CHECK (mockctx
.mock_target
.fetch_registers_called
> 0);
1872 mockctx
.mock_target
.reset ();
1874 /* Mark all raw registers valid, so the following raw registers
1875 accesses won't go to target. */
1876 for (auto i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1877 readwrite
.raw_update (i
);
1879 mockctx
.mock_target
.reset ();
1880 /* Then, read all raw and pseudo registers, and don't expect calling
1881 to_{fetch,store}_registers. */
1882 for (int regnum
= 0; regnum
< gdbarch_num_cooked_regs (gdbarch
); regnum
++)
1884 if (register_size (gdbarch
, regnum
) == 0)
1887 gdb::def_vector
<gdb_byte
> inner_buf (register_size (gdbarch
, regnum
));
1889 SELF_CHECK (REG_VALID
== readwrite
.cooked_read (regnum
,
1890 inner_buf
.data ()));
1892 SELF_CHECK (mockctx
.mock_target
.fetch_registers_called
== 0);
1893 SELF_CHECK (mockctx
.mock_target
.store_registers_called
== 0);
1894 SELF_CHECK (mockctx
.mock_target
.xfer_partial_called
== 0);
1896 mockctx
.mock_target
.reset ();
1899 readonly_detached_regcache
readonly (readwrite
);
1901 /* GDB may go to target layer to fetch all registers and memory for
1902 readonly regcache. */
1903 mockctx
.mock_target
.reset ();
1905 for (int regnum
= 0; regnum
< gdbarch_num_cooked_regs (gdbarch
); regnum
++)
1907 if (register_size (gdbarch
, regnum
) == 0)
1910 gdb::def_vector
<gdb_byte
> inner_buf (register_size (gdbarch
, regnum
));
1911 enum register_status status
= readonly
.cooked_read (regnum
,
1914 if (regnum
< gdbarch_num_regs (gdbarch
))
1916 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1918 if (bfd_arch
== bfd_arch_frv
|| bfd_arch
== bfd_arch_h8300
1919 || bfd_arch
== bfd_arch_m32c
|| bfd_arch
== bfd_arch_sh
1920 || bfd_arch
== bfd_arch_alpha
|| bfd_arch
== bfd_arch_v850
1921 || bfd_arch
== bfd_arch_msp430
|| bfd_arch
== bfd_arch_mep
1922 || bfd_arch
== bfd_arch_mips
|| bfd_arch
== bfd_arch_v850_rh850
1923 || bfd_arch
== bfd_arch_tic6x
|| bfd_arch
== bfd_arch_mn10300
1924 || bfd_arch
== bfd_arch_rl78
|| bfd_arch
== bfd_arch_score
1925 || bfd_arch
== bfd_arch_riscv
|| bfd_arch
== bfd_arch_csky
)
1927 /* Raw registers. If raw registers are not in save_reggroup,
1928 their status are unknown. */
1929 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1930 SELF_CHECK (status
== REG_VALID
);
1932 SELF_CHECK (status
== REG_UNKNOWN
);
1935 SELF_CHECK (status
== REG_VALID
);
1939 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1940 SELF_CHECK (status
== REG_VALID
);
1943 /* If pseudo registers are not in save_reggroup, some of
1944 them can be computed from saved raw registers, but some
1945 of them are unknown. */
1946 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1948 if (bfd_arch
== bfd_arch_frv
1949 || bfd_arch
== bfd_arch_m32c
1950 || bfd_arch
== bfd_arch_mep
1951 || bfd_arch
== bfd_arch_sh
)
1952 SELF_CHECK (status
== REG_VALID
|| status
== REG_UNKNOWN
);
1953 else if (bfd_arch
== bfd_arch_mips
1954 || bfd_arch
== bfd_arch_h8300
)
1955 SELF_CHECK (status
== REG_UNKNOWN
);
1957 SELF_CHECK (status
== REG_VALID
);
1961 SELF_CHECK (mockctx
.mock_target
.fetch_registers_called
== 0);
1962 SELF_CHECK (mockctx
.mock_target
.store_registers_called
== 0);
1963 SELF_CHECK (mockctx
.mock_target
.xfer_partial_called
== 0);
1965 mockctx
.mock_target
.reset ();
1969 /* Test regcache::cooked_write by writing some expected contents to
1970 registers, and checking that contents read from registers and the
1971 expected contents are the same. */
1974 cooked_write_test (struct gdbarch
*gdbarch
)
1976 if (selftest_skiparch (gdbarch
))
1979 /* Create a mock environment. A process_stratum target pushed. */
1980 scoped_mock_context
<target_ops_no_register
> ctx (gdbarch
);
1981 readwrite_regcache
readwrite (&ctx
.mock_target
, gdbarch
);
1982 const int num_regs
= gdbarch_num_cooked_regs (gdbarch
);
1984 for (auto regnum
= 0; regnum
< num_regs
; regnum
++)
1986 if (register_size (gdbarch
, regnum
) == 0
1987 || gdbarch_cannot_store_register (gdbarch
, regnum
))
1990 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1992 if (bfd_arch
== bfd_arch_sparc
1993 /* SPARC64_CWP_REGNUM, SPARC64_PSTATE_REGNUM,
1994 SPARC64_ASI_REGNUM and SPARC64_CCR_REGNUM are hard to test. */
1995 && gdbarch_ptr_bit (gdbarch
) == 64
1996 && (regnum
>= gdbarch_num_regs (gdbarch
)
1997 && regnum
<= gdbarch_num_regs (gdbarch
) + 4))
2000 std::vector
<gdb_byte
> expected (register_size (gdbarch
, regnum
), 0);
2001 std::vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
), 0);
2002 const auto type
= register_type (gdbarch
, regnum
);
2004 if (type
->code () == TYPE_CODE_FLT
2005 || type
->code () == TYPE_CODE_DECFLOAT
)
2007 /* Generate valid float format. */
2008 target_float_from_string (expected
.data (), type
, "1.25");
2010 else if (type
->code () == TYPE_CODE_INT
2011 || type
->code () == TYPE_CODE_ARRAY
2012 || type
->code () == TYPE_CODE_PTR
2013 || type
->code () == TYPE_CODE_UNION
2014 || type
->code () == TYPE_CODE_STRUCT
)
2016 if (bfd_arch
== bfd_arch_ia64
2017 || (regnum
>= gdbarch_num_regs (gdbarch
)
2018 && (bfd_arch
== bfd_arch_xtensa
2019 || bfd_arch
== bfd_arch_bfin
2020 || bfd_arch
== bfd_arch_m32c
2021 /* m68hc11 pseudo registers are in memory. */
2022 || bfd_arch
== bfd_arch_m68hc11
2023 || bfd_arch
== bfd_arch_m68hc12
2024 || bfd_arch
== bfd_arch_s390
))
2025 || (bfd_arch
== bfd_arch_frv
2026 /* FRV pseudo registers except iacc0. */
2027 && regnum
> gdbarch_num_regs (gdbarch
)))
2029 /* Skip setting the expected values for some architecture
2032 else if (bfd_arch
== bfd_arch_rl78
&& regnum
== 40)
2034 /* RL78_PC_REGNUM */
2035 for (auto j
= 0; j
< register_size (gdbarch
, regnum
) - 1; j
++)
2040 for (auto j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
2044 else if (type
->code () == TYPE_CODE_FLAGS
)
2046 /* No idea how to test flags. */
2051 /* If we don't know how to create the expected value for the
2052 this type, make it fail. */
2056 readwrite
.cooked_write (regnum
, expected
.data ());
2058 SELF_CHECK (readwrite
.cooked_read (regnum
, buf
.data ()) == REG_VALID
);
2059 SELF_CHECK (expected
== buf
);
2063 /* Verify that when two threads with the same ptid exist (from two different
2064 targets) and one of them changes ptid, we only update the appropriate
2068 regcache_thread_ptid_changed ()
2070 /* This test relies on the global regcache list to initially be empty. */
2071 registers_changed ();
2073 /* Any arch will do. */
2074 gdbarch
*arch
= current_inferior ()->gdbarch
;
2076 /* Prepare two targets with one thread each, with the same ptid. */
2077 scoped_mock_context
<test_target_ops
> target1 (arch
);
2078 scoped_mock_context
<test_target_ops
> target2 (arch
);
2080 ptid_t
old_ptid (111, 222);
2081 ptid_t
new_ptid (111, 333);
2083 target1
.mock_inferior
.pid
= old_ptid
.pid ();
2084 target1
.mock_thread
.ptid
= old_ptid
;
2085 target1
.mock_inferior
.ptid_thread_map
.clear ();
2086 target1
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target1
.mock_thread
;
2088 target2
.mock_inferior
.pid
= old_ptid
.pid ();
2089 target2
.mock_thread
.ptid
= old_ptid
;
2090 target2
.mock_inferior
.ptid_thread_map
.clear ();
2091 target2
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target2
.mock_thread
;
2093 gdb_assert (regcaches
.empty ());
2095 /* Populate the regcaches container. */
2096 get_thread_arch_aspace_regcache (&target1
.mock_target
, old_ptid
, arch
,
2098 get_thread_arch_aspace_regcache (&target2
.mock_target
, old_ptid
, arch
,
2101 gdb_assert (regcaches
.size () == 2);
2102 gdb_assert (regcache_count (&target1
.mock_target
, old_ptid
) == 1);
2103 gdb_assert (regcache_count (&target1
.mock_target
, new_ptid
) == 0);
2104 gdb_assert (regcache_count (&target2
.mock_target
, old_ptid
) == 1);
2105 gdb_assert (regcache_count (&target2
.mock_target
, new_ptid
) == 0);
2107 thread_change_ptid (&target1
.mock_target
, old_ptid
, new_ptid
);
2109 gdb_assert (regcaches
.size () == 2);
2110 gdb_assert (regcache_count (&target1
.mock_target
, old_ptid
) == 0);
2111 gdb_assert (regcache_count (&target1
.mock_target
, new_ptid
) == 1);
2112 gdb_assert (regcache_count (&target2
.mock_target
, old_ptid
) == 1);
2113 gdb_assert (regcache_count (&target2
.mock_target
, new_ptid
) == 0);
2115 /* Leave the regcache list empty. */
2116 registers_changed ();
2117 gdb_assert (regcaches
.empty ());
2120 } // namespace selftests
2121 #endif /* GDB_SELF_TEST */
2123 void _initialize_regcache ();
2125 _initialize_regcache ()
2127 struct cmd_list_element
*c
;
2129 gdb::observers::target_changed
.attach (regcache_observer_target_changed
,
2131 gdb::observers::thread_ptid_changed
.attach (regcache_thread_ptid_changed
,
2134 cmd_list_element
*maintenance_flush_register_cache_cmd
2135 = add_cmd ("register-cache", class_maintenance
, reg_flush_command
,
2136 _("Force gdb to flush its register and frame cache."),
2137 &maintenanceflushlist
);
2138 c
= add_com_alias ("flushregs", maintenance_flush_register_cache_cmd
,
2139 class_maintenance
, 0);
2140 deprecate_cmd (c
, "maintenance flush register-cache");
2143 selftests::register_test ("get_thread_arch_aspace_regcache",
2144 selftests::get_thread_arch_aspace_regcache_test
);
2145 selftests::register_test ("registers_changed_ptid_all",
2146 selftests::registers_changed_ptid_all_test
);
2147 selftests::register_test ("registers_changed_ptid_target",
2148 selftests::registers_changed_ptid_target_test
);
2149 selftests::register_test ("registers_changed_ptid_target_pid",
2150 selftests::registers_changed_ptid_target_pid_test
);
2151 selftests::register_test ("registers_changed_ptid_target_ptid",
2152 selftests::registers_changed_ptid_target_ptid_test
);
2154 selftests::register_test_foreach_arch ("regcache::cooked_read_test",
2155 selftests::cooked_read_test
);
2156 selftests::register_test_foreach_arch ("regcache::cooked_write_test",
2157 selftests::cooked_write_test
);
2158 selftests::register_test ("regcache_thread_ptid_changed",
2159 selftests::regcache_thread_ptid_changed
);