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. */
44 static struct gdbarch_data
*regcache_descr_handle
;
48 /* The architecture this descriptor belongs to. */
49 struct gdbarch
*gdbarch
;
51 /* The raw register cache. Each raw (or hard) register is supplied
52 by the target interface. The raw cache should not contain
53 redundant information - if the PC is constructed from two
54 registers then those registers and not the PC lives in the raw
56 long sizeof_raw_registers
;
58 /* The cooked register space. Each cooked register in the range
59 [0..NR_RAW_REGISTERS) is direct-mapped onto the corresponding raw
60 register. The remaining [NR_RAW_REGISTERS
61 .. NR_COOKED_REGISTERS) (a.k.a. pseudo registers) are mapped onto
62 both raw registers and memory by the architecture methods
63 gdbarch_pseudo_register_read and gdbarch_pseudo_register_write. */
64 int nr_cooked_registers
;
65 long sizeof_cooked_registers
;
67 /* Offset and size (in 8 bit bytes), of each register in the
68 register cache. All registers (including those in the range
69 [NR_RAW_REGISTERS .. NR_COOKED_REGISTERS) are given an
71 long *register_offset
;
72 long *sizeof_register
;
74 /* Cached table containing the type of each register. */
75 struct type
**register_type
;
79 init_regcache_descr (struct gdbarch
*gdbarch
)
82 struct regcache_descr
*descr
;
83 gdb_assert (gdbarch
!= NULL
);
85 /* Create an initial, zero filled, table. */
86 descr
= GDBARCH_OBSTACK_ZALLOC (gdbarch
, struct regcache_descr
);
87 descr
->gdbarch
= gdbarch
;
89 /* Total size of the register space. The raw registers are mapped
90 directly onto the raw register cache while the pseudo's are
91 either mapped onto raw-registers or memory. */
92 descr
->nr_cooked_registers
= gdbarch_num_cooked_regs (gdbarch
);
94 /* Fill in a table of register types. */
96 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
,
98 for (i
= 0; i
< descr
->nr_cooked_registers
; i
++)
99 descr
->register_type
[i
] = gdbarch_register_type (gdbarch
, i
);
101 /* Construct a strictly RAW register cache. Don't allow pseudo's
102 into the register cache. */
104 /* Lay out the register cache.
106 NOTE: cagney/2002-05-22: Only register_type () is used when
107 constructing the register cache. It is assumed that the
108 register's raw size, virtual size and type length are all the
114 descr
->sizeof_register
115 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
116 descr
->register_offset
117 = GDBARCH_OBSTACK_CALLOC (gdbarch
, descr
->nr_cooked_registers
, long);
118 for (i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
120 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
121 descr
->register_offset
[i
] = offset
;
122 offset
+= descr
->sizeof_register
[i
];
124 /* Set the real size of the raw register cache buffer. */
125 descr
->sizeof_raw_registers
= offset
;
127 for (; i
< descr
->nr_cooked_registers
; i
++)
129 descr
->sizeof_register
[i
] = TYPE_LENGTH (descr
->register_type
[i
]);
130 descr
->register_offset
[i
] = offset
;
131 offset
+= descr
->sizeof_register
[i
];
133 /* Set the real size of the readonly register cache buffer. */
134 descr
->sizeof_cooked_registers
= offset
;
140 static struct regcache_descr
*
141 regcache_descr (struct gdbarch
*gdbarch
)
143 return (struct regcache_descr
*) gdbarch_data (gdbarch
,
144 regcache_descr_handle
);
147 /* Utility functions returning useful register attributes stored in
148 the regcache descr. */
151 register_type (struct gdbarch
*gdbarch
, int regnum
)
153 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
155 gdb_assert (regnum
>= 0 && regnum
< descr
->nr_cooked_registers
);
156 return descr
->register_type
[regnum
];
159 /* Utility functions returning useful register attributes stored in
160 the regcache descr. */
163 register_size (struct gdbarch
*gdbarch
, int regnum
)
165 struct regcache_descr
*descr
= regcache_descr (gdbarch
);
168 gdb_assert (regnum
>= 0 && regnum
< gdbarch_num_cooked_regs (gdbarch
));
169 size
= descr
->sizeof_register
[regnum
];
173 /* See gdbsupport/common-regcache.h. */
176 regcache_register_size (const struct regcache
*regcache
, int n
)
178 return register_size (regcache
->arch (), n
);
181 reg_buffer::reg_buffer (gdbarch
*gdbarch
, bool has_pseudo
)
182 : m_has_pseudo (has_pseudo
)
184 gdb_assert (gdbarch
!= NULL
);
185 m_descr
= regcache_descr (gdbarch
);
187 /* We don't zero-initialize the M_REGISTERS array, as the bytes it contains
188 aren't meaningful as long as the corresponding register status is not
192 m_registers
.reset (new gdb_byte
[m_descr
->sizeof_cooked_registers
]);
193 m_register_status
.reset
194 (new register_status
[m_descr
->nr_cooked_registers
] ());
198 m_registers
.reset (new gdb_byte
[m_descr
->sizeof_raw_registers
]);
199 m_register_status
.reset
200 (new register_status
[gdbarch_num_regs (gdbarch
)] ());
204 regcache::regcache (process_stratum_target
*target
, gdbarch
*gdbarch
,
205 const address_space
*aspace_
)
206 /* The register buffers. A read/write register cache can only hold
207 [0 .. gdbarch_num_regs). */
208 : detached_regcache (gdbarch
, false), m_aspace (aspace_
), m_target (target
)
210 m_ptid
= minus_one_ptid
;
213 readonly_detached_regcache::readonly_detached_regcache (regcache
&src
)
214 : readonly_detached_regcache (src
.arch (),
215 [&src
] (int regnum
, gdb_byte
*buf
)
217 return src
.cooked_read (regnum
, buf
);
223 reg_buffer::arch () const
225 return m_descr
->gdbarch
;
228 /* Return a pointer to register REGNUM's buffer cache. */
231 reg_buffer::register_buffer (int regnum
) const
233 return m_registers
.get () + m_descr
->register_offset
[regnum
];
237 reg_buffer::save (register_read_ftype cooked_read
)
239 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
242 /* It should have pseudo registers. */
243 gdb_assert (m_has_pseudo
);
244 /* Clear the dest. */
245 memset (m_registers
.get (), 0, m_descr
->sizeof_cooked_registers
);
246 memset (m_register_status
.get (), REG_UNKNOWN
, m_descr
->nr_cooked_registers
);
247 /* Copy over any registers (identified by their membership in the
248 save_reggroup) and mark them as valid. The full [0 .. gdbarch_num_regs +
249 gdbarch_num_pseudo_regs) range is checked since some architectures need
250 to save/restore `cooked' registers that live in memory. */
251 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
253 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
255 gdb_byte
*dst_buf
= register_buffer (regnum
);
256 enum register_status status
= cooked_read (regnum
, dst_buf
);
258 gdb_assert (status
!= REG_UNKNOWN
);
260 if (status
!= REG_VALID
)
261 memset (dst_buf
, 0, register_size (gdbarch
, regnum
));
263 m_register_status
[regnum
] = status
;
269 regcache::restore (readonly_detached_regcache
*src
)
271 struct gdbarch
*gdbarch
= m_descr
->gdbarch
;
274 gdb_assert (src
!= NULL
);
275 gdb_assert (src
->m_has_pseudo
);
277 gdb_assert (gdbarch
== src
->arch ());
279 /* Copy over any registers, being careful to only restore those that
280 were both saved and need to be restored. The full [0 .. gdbarch_num_regs
281 + gdbarch_num_pseudo_regs) range is checked since some architectures need
282 to save/restore `cooked' registers that live in memory. */
283 for (regnum
= 0; regnum
< m_descr
->nr_cooked_registers
; regnum
++)
285 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, restore_reggroup
))
287 if (src
->m_register_status
[regnum
] == REG_VALID
)
288 cooked_write (regnum
, src
->register_buffer (regnum
));
293 /* See gdbsupport/common-regcache.h. */
296 reg_buffer::get_register_status (int regnum
) const
298 assert_regnum (regnum
);
300 return m_register_status
[regnum
];
304 reg_buffer::invalidate (int regnum
)
306 assert_regnum (regnum
);
307 m_register_status
[regnum
] = REG_UNKNOWN
;
311 reg_buffer::assert_regnum (int regnum
) const
313 gdb_assert (regnum
>= 0);
315 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
317 gdb_assert (regnum
< gdbarch_num_regs (arch ()));
320 /* Type to map a ptid to a list of regcaches (one thread may have multiple
321 regcaches, associated to different gdbarches). */
323 using ptid_regcache_map
324 = std::unordered_multimap
<ptid_t
, regcache_up
, hash_ptid
>;
326 /* Type holding regcaches for a given pid. */
328 using pid_ptid_regcache_map
= std::unordered_map
<int, ptid_regcache_map
>;
330 /* Type holding regcaches for a given target. */
332 using target_pid_ptid_regcache_map
333 = std::unordered_map
<process_stratum_target
*, pid_ptid_regcache_map
>;
335 /* Global structure containing the existing regcaches. */
337 /* NOTE: this is a write-through cache. There is no "dirty" bit for
338 recording if the register values have been changed (eg. by the
339 user). Therefore all registers must be written back to the
340 target when appropriate. */
341 static target_pid_ptid_regcache_map regcaches
;
344 get_thread_arch_aspace_regcache (process_stratum_target
*target
,
345 ptid_t ptid
, gdbarch
*arch
,
346 struct address_space
*aspace
)
348 gdb_assert (target
!= nullptr);
350 /* Find the map for this target. */
351 pid_ptid_regcache_map
&pid_ptid_regc_map
= regcaches
[target
];
353 /* Find the map for this pid. */
354 ptid_regcache_map
&ptid_regc_map
= pid_ptid_regc_map
[ptid
.pid ()];
356 /* Check first if a regcache for this arch already exists. */
357 auto range
= ptid_regc_map
.equal_range (ptid
);
358 for (auto it
= range
.first
; it
!= range
.second
; ++it
)
360 if (it
->second
->arch () == arch
)
361 return it
->second
.get ();
364 /* It does not exist, create it. */
365 regcache
*new_regcache
= new regcache (target
, arch
, aspace
);
366 new_regcache
->set_ptid (ptid
);
367 /* Work around a problem with g++ 4.8 (PR96537): Call the regcache_up
368 constructor explictly instead of implicitly. */
369 ptid_regc_map
.insert (std::make_pair (ptid
, regcache_up (new_regcache
)));
375 get_thread_arch_regcache (process_stratum_target
*target
, ptid_t ptid
,
376 struct gdbarch
*gdbarch
)
378 scoped_restore_current_inferior restore_current_inferior
;
379 set_current_inferior (find_inferior_ptid (target
, ptid
));
380 address_space
*aspace
= target_thread_address_space (ptid
);
382 return get_thread_arch_aspace_regcache (target
, ptid
, gdbarch
, aspace
);
385 static process_stratum_target
*current_thread_target
;
386 static ptid_t current_thread_ptid
;
387 static struct gdbarch
*current_thread_arch
;
390 get_thread_regcache (process_stratum_target
*target
, ptid_t ptid
)
392 if (!current_thread_arch
393 || target
!= current_thread_target
394 || current_thread_ptid
!= ptid
)
396 gdb_assert (ptid
!= null_ptid
);
398 current_thread_ptid
= ptid
;
399 current_thread_target
= target
;
401 scoped_restore_current_inferior restore_current_inferior
;
402 set_current_inferior (find_inferior_ptid (target
, ptid
));
403 current_thread_arch
= target_thread_architecture (ptid
);
406 return get_thread_arch_regcache (target
, ptid
, current_thread_arch
);
409 /* See regcache.h. */
412 get_thread_regcache (thread_info
*thread
)
414 return get_thread_regcache (thread
->inf
->process_target (),
419 get_current_regcache (void)
421 return get_thread_regcache (inferior_thread ());
424 /* See gdbsupport/common-regcache.h. */
427 get_thread_regcache_for_ptid (ptid_t ptid
)
429 /* This function doesn't take a process_stratum_target parameter
430 because it's a gdbsupport/ routine implemented by both gdb and
431 gdbserver. It always refers to a ptid of the current target. */
432 process_stratum_target
*proc_target
= current_inferior ()->process_target ();
433 return get_thread_regcache (proc_target
, ptid
);
436 /* Observer for the target_changed event. */
439 regcache_observer_target_changed (struct target_ops
*target
)
441 registers_changed ();
444 /* Update regcaches related to OLD_PTID to now use NEW_PTID. */
446 regcache_thread_ptid_changed (process_stratum_target
*target
,
447 ptid_t old_ptid
, ptid_t new_ptid
)
449 /* Look up map for target. */
450 auto pid_ptid_regc_map_it
= regcaches
.find (target
);
451 if (pid_ptid_regc_map_it
== regcaches
.end ())
454 /* Look up map for pid. */
455 pid_ptid_regcache_map
&pid_ptid_regc_map
= pid_ptid_regc_map_it
->second
;
456 auto ptid_regc_map_it
= pid_ptid_regc_map
.find (old_ptid
.pid ());
457 if (ptid_regc_map_it
== pid_ptid_regc_map
.end ())
460 /* Update all regcaches belonging to old_ptid. */
461 ptid_regcache_map
&ptid_regc_map
= ptid_regc_map_it
->second
;
462 auto range
= ptid_regc_map
.equal_range (old_ptid
);
463 for (auto it
= range
.first
; it
!= range
.second
;)
465 regcache_up rc
= std::move (it
->second
);
466 rc
->set_ptid (new_ptid
);
468 /* Remove old before inserting new, to avoid rehashing,
469 which would invalidate iterators. */
470 it
= ptid_regc_map
.erase (it
);
471 ptid_regc_map
.insert (std::make_pair (new_ptid
, std::move (rc
)));
475 /* Low level examining and depositing of registers.
477 The caller is responsible for making sure that the inferior is
478 stopped before calling the fetching routines, or it will get
479 garbage. (a change from GDB version 3, in which the caller got the
480 value from the last stop). */
482 /* REGISTERS_CHANGED ()
484 Indicate that registers may have changed, so invalidate the cache. */
487 registers_changed_ptid (process_stratum_target
*target
, ptid_t ptid
)
489 if (target
== nullptr)
491 /* Since there can be ptid clashes between targets, it's not valid to
492 pass a ptid without saying to which target it belongs. */
493 gdb_assert (ptid
== minus_one_ptid
);
495 /* Delete all the regcaches of all targets. */
498 else if (ptid
.is_pid ())
500 /* Non-NULL target and pid ptid, delete all regcaches belonging
501 to this (TARGET, PID). */
503 /* Look up map for target. */
504 auto pid_ptid_regc_map_it
= regcaches
.find (target
);
505 if (pid_ptid_regc_map_it
!= regcaches
.end ())
507 pid_ptid_regcache_map
&pid_ptid_regc_map
508 = pid_ptid_regc_map_it
->second
;
510 pid_ptid_regc_map
.erase (ptid
.pid ());
513 else if (ptid
!= minus_one_ptid
)
515 /* Non-NULL target and non-minus_one_ptid, delete all regcaches belonging
516 to this (TARGET, PTID). */
518 /* Look up map for target. */
519 auto pid_ptid_regc_map_it
= regcaches
.find (target
);
520 if (pid_ptid_regc_map_it
!= regcaches
.end ())
522 pid_ptid_regcache_map
&pid_ptid_regc_map
523 = pid_ptid_regc_map_it
->second
;
525 /* Look up map for pid. */
526 auto ptid_regc_map_it
527 = pid_ptid_regc_map
.find (ptid
.pid ());
528 if (ptid_regc_map_it
!= pid_ptid_regc_map
.end ())
530 ptid_regcache_map
&ptid_regc_map
531 = ptid_regc_map_it
->second
;
533 ptid_regc_map
.erase (ptid
);
539 /* Non-NULL target and minus_one_ptid, delete all regcaches
540 associated to this target. */
541 regcaches
.erase (target
);
544 if ((target
== nullptr || current_thread_target
== target
)
545 && current_thread_ptid
.matches (ptid
))
547 current_thread_target
= NULL
;
548 current_thread_ptid
= null_ptid
;
549 current_thread_arch
= NULL
;
552 if ((target
== nullptr || current_inferior ()->process_target () == target
)
553 && inferior_ptid
.matches (ptid
))
555 /* We just deleted the regcache of the current thread. Need to
556 forget about any frames we have cached, too. */
557 reinit_frame_cache ();
561 /* See regcache.h. */
564 registers_changed_thread (thread_info
*thread
)
566 registers_changed_ptid (thread
->inf
->process_target (), thread
->ptid
);
570 registers_changed (void)
572 registers_changed_ptid (nullptr, minus_one_ptid
);
576 regcache::raw_update (int regnum
)
578 assert_regnum (regnum
);
580 /* Make certain that the register cache is up-to-date with respect
581 to the current thread. This switching shouldn't be necessary
582 only there is still only one target side register cache. Sigh!
583 On the bright side, at least there is a regcache object. */
585 if (get_register_status (regnum
) == REG_UNKNOWN
)
587 target_fetch_registers (this, regnum
);
589 /* A number of targets can't access the whole set of raw
590 registers (because the debug API provides no means to get at
592 if (m_register_status
[regnum
] == REG_UNKNOWN
)
593 m_register_status
[regnum
] = REG_UNAVAILABLE
;
598 readable_regcache::raw_read (int regnum
, gdb_byte
*buf
)
600 gdb_assert (buf
!= NULL
);
603 if (m_register_status
[regnum
] != REG_VALID
)
604 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
606 memcpy (buf
, register_buffer (regnum
),
607 m_descr
->sizeof_register
[regnum
]);
609 return m_register_status
[regnum
];
613 regcache_raw_read_signed (struct regcache
*regcache
, int regnum
, LONGEST
*val
)
615 gdb_assert (regcache
!= NULL
);
616 return regcache
->raw_read (regnum
, val
);
619 template<typename T
, typename
>
621 readable_regcache::raw_read (int regnum
, T
*val
)
623 assert_regnum (regnum
);
624 size_t len
= m_descr
->sizeof_register
[regnum
];
625 gdb_byte
*buf
= (gdb_byte
*) alloca (len
);
626 register_status status
= raw_read (regnum
, buf
);
627 if (status
== REG_VALID
)
628 *val
= extract_integer
<T
> ({buf
, len
},
629 gdbarch_byte_order (m_descr
->gdbarch
));
636 regcache_raw_read_unsigned (struct regcache
*regcache
, int regnum
,
639 gdb_assert (regcache
!= NULL
);
640 return regcache
->raw_read (regnum
, val
);
644 regcache_raw_write_signed (struct regcache
*regcache
, int regnum
, LONGEST val
)
646 gdb_assert (regcache
!= NULL
);
647 regcache
->raw_write (regnum
, val
);
650 template<typename T
, typename
>
652 regcache::raw_write (int regnum
, T val
)
656 assert_regnum (regnum
);
657 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
658 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
659 gdbarch_byte_order (m_descr
->gdbarch
), val
);
660 raw_write (regnum
, buf
);
664 regcache_raw_write_unsigned (struct regcache
*regcache
, int regnum
,
667 gdb_assert (regcache
!= NULL
);
668 regcache
->raw_write (regnum
, val
);
672 regcache_raw_get_signed (struct regcache
*regcache
, int regnum
)
675 enum register_status status
;
677 status
= regcache_raw_read_signed (regcache
, regnum
, &value
);
678 if (status
== REG_UNAVAILABLE
)
679 throw_error (NOT_AVAILABLE_ERROR
,
680 _("Register %d is not available"), regnum
);
685 readable_regcache::cooked_read (int regnum
, gdb_byte
*buf
)
687 gdb_assert (regnum
>= 0);
688 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
689 if (regnum
< num_raw_registers ())
690 return raw_read (regnum
, buf
);
691 else if (m_has_pseudo
692 && m_register_status
[regnum
] != REG_UNKNOWN
)
694 if (m_register_status
[regnum
] == REG_VALID
)
695 memcpy (buf
, register_buffer (regnum
),
696 m_descr
->sizeof_register
[regnum
]);
698 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
700 return m_register_status
[regnum
];
702 else if (gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
704 struct value
*mark
, *computed
;
705 enum register_status result
= REG_VALID
;
707 mark
= value_mark ();
709 computed
= gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
711 if (value_entirely_available (computed
))
712 memcpy (buf
, value_contents_raw (computed
).data (),
713 m_descr
->sizeof_register
[regnum
]);
716 memset (buf
, 0, m_descr
->sizeof_register
[regnum
]);
717 result
= REG_UNAVAILABLE
;
720 value_free_to_mark (mark
);
725 return gdbarch_pseudo_register_read (m_descr
->gdbarch
, this,
730 readable_regcache::cooked_read_value (int regnum
)
732 gdb_assert (regnum
>= 0);
733 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
735 if (regnum
< num_raw_registers ()
736 || (m_has_pseudo
&& m_register_status
[regnum
] != REG_UNKNOWN
)
737 || !gdbarch_pseudo_register_read_value_p (m_descr
->gdbarch
))
739 struct value
*result
;
741 result
= allocate_value (register_type (m_descr
->gdbarch
, regnum
));
742 VALUE_LVAL (result
) = lval_register
;
743 VALUE_REGNUM (result
) = regnum
;
745 /* It is more efficient in general to do this delegation in this
746 direction than in the other one, even though the value-based
748 if (cooked_read (regnum
,
749 value_contents_raw (result
).data ()) == REG_UNAVAILABLE
)
750 mark_value_bytes_unavailable (result
, 0,
751 TYPE_LENGTH (value_type (result
)));
756 return gdbarch_pseudo_register_read_value (m_descr
->gdbarch
,
761 regcache_cooked_read_signed (struct regcache
*regcache
, int regnum
,
764 gdb_assert (regcache
!= NULL
);
765 return regcache
->cooked_read (regnum
, val
);
768 template<typename T
, typename
>
770 readable_regcache::cooked_read (int regnum
, T
*val
)
772 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
773 size_t len
= m_descr
->sizeof_register
[regnum
];
774 gdb_byte
*buf
= (gdb_byte
*) alloca (len
);
775 register_status status
= cooked_read (regnum
, buf
);
776 if (status
== REG_VALID
)
777 *val
= extract_integer
<T
> ({buf
, len
},
778 gdbarch_byte_order (m_descr
->gdbarch
));
785 regcache_cooked_read_unsigned (struct regcache
*regcache
, int regnum
,
788 gdb_assert (regcache
!= NULL
);
789 return regcache
->cooked_read (regnum
, val
);
793 regcache_cooked_write_signed (struct regcache
*regcache
, int regnum
,
796 gdb_assert (regcache
!= NULL
);
797 regcache
->cooked_write (regnum
, val
);
800 template<typename T
, typename
>
802 regcache::cooked_write (int regnum
, T val
)
806 gdb_assert (regnum
>=0 && regnum
< m_descr
->nr_cooked_registers
);
807 buf
= (gdb_byte
*) alloca (m_descr
->sizeof_register
[regnum
]);
808 store_integer (buf
, m_descr
->sizeof_register
[regnum
],
809 gdbarch_byte_order (m_descr
->gdbarch
), val
);
810 cooked_write (regnum
, buf
);
814 regcache_cooked_write_unsigned (struct regcache
*regcache
, int regnum
,
817 gdb_assert (regcache
!= NULL
);
818 regcache
->cooked_write (regnum
, val
);
822 regcache::raw_write (int regnum
, const gdb_byte
*buf
)
825 gdb_assert (buf
!= NULL
);
826 assert_regnum (regnum
);
828 /* On the sparc, writing %g0 is a no-op, so we don't even want to
829 change the registers array if something writes to this register. */
830 if (gdbarch_cannot_store_register (arch (), regnum
))
833 /* If we have a valid copy of the register, and new value == old
834 value, then don't bother doing the actual store. */
835 if (get_register_status (regnum
) == REG_VALID
836 && (memcmp (register_buffer (regnum
), buf
,
837 m_descr
->sizeof_register
[regnum
]) == 0))
840 target_prepare_to_store (this);
841 raw_supply (regnum
, buf
);
843 /* Invalidate the register after it is written, in case of a
846 = make_scope_exit ([&] { this->invalidate (regnum
); });
848 target_store_registers (this, regnum
);
850 /* The target did not throw an error so we can discard invalidating
852 invalidator
.release ();
856 regcache::cooked_write (int regnum
, const gdb_byte
*buf
)
858 gdb_assert (regnum
>= 0);
859 gdb_assert (regnum
< m_descr
->nr_cooked_registers
);
860 if (regnum
< num_raw_registers ())
861 raw_write (regnum
, buf
);
863 gdbarch_pseudo_register_write (m_descr
->gdbarch
, this,
867 /* See regcache.h. */
870 readable_regcache::read_part (int regnum
, int offset
, int len
,
871 gdb_byte
*out
, bool is_raw
)
873 int reg_size
= register_size (arch (), regnum
);
875 gdb_assert (out
!= NULL
);
876 gdb_assert (offset
>= 0 && offset
<= reg_size
);
877 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
879 if (offset
== 0 && len
== 0)
885 if (offset
== 0 && len
== reg_size
)
887 /* Read the full register. */
888 return (is_raw
) ? raw_read (regnum
, out
) : cooked_read (regnum
, out
);
891 enum register_status status
;
892 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
894 /* Read full register to buffer. */
895 status
= (is_raw
) ? raw_read (regnum
, reg
) : cooked_read (regnum
, reg
);
896 if (status
!= REG_VALID
)
900 memcpy (out
, reg
+ offset
, len
);
904 /* See regcache.h. */
907 reg_buffer::raw_collect_part (int regnum
, int offset
, int len
,
910 int reg_size
= register_size (arch (), regnum
);
912 gdb_assert (out
!= nullptr);
913 gdb_assert (offset
>= 0 && offset
<= reg_size
);
914 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
916 if (offset
== 0 && len
== 0)
922 if (offset
== 0 && len
== reg_size
)
924 /* Collect the full register. */
925 return raw_collect (regnum
, out
);
928 /* Read to buffer, then write out. */
929 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
930 raw_collect (regnum
, reg
);
931 memcpy (out
, reg
+ offset
, len
);
934 /* See regcache.h. */
937 regcache::write_part (int regnum
, int offset
, int len
,
938 const gdb_byte
*in
, bool is_raw
)
940 int reg_size
= register_size (arch (), regnum
);
942 gdb_assert (in
!= NULL
);
943 gdb_assert (offset
>= 0 && offset
<= reg_size
);
944 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
946 if (offset
== 0 && len
== 0)
952 if (offset
== 0 && len
== reg_size
)
954 /* Write the full register. */
955 (is_raw
) ? raw_write (regnum
, in
) : cooked_write (regnum
, in
);
959 enum register_status status
;
960 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
962 /* Read existing register to buffer. */
963 status
= (is_raw
) ? raw_read (regnum
, reg
) : cooked_read (regnum
, reg
);
964 if (status
!= REG_VALID
)
967 /* Update buffer, then write back to regcache. */
968 memcpy (reg
+ offset
, in
, len
);
969 is_raw
? raw_write (regnum
, reg
) : cooked_write (regnum
, reg
);
973 /* See regcache.h. */
976 reg_buffer::raw_supply_part (int regnum
, int offset
, int len
,
979 int reg_size
= register_size (arch (), regnum
);
981 gdb_assert (in
!= nullptr);
982 gdb_assert (offset
>= 0 && offset
<= reg_size
);
983 gdb_assert (len
>= 0 && offset
+ len
<= reg_size
);
985 if (offset
== 0 && len
== 0)
991 if (offset
== 0 && len
== reg_size
)
993 /* Supply the full register. */
994 return raw_supply (regnum
, in
);
997 gdb_byte
*reg
= (gdb_byte
*) alloca (reg_size
);
999 /* Read existing value to buffer. */
1000 raw_collect (regnum
, reg
);
1002 /* Write to buffer, then write out. */
1003 memcpy (reg
+ offset
, in
, len
);
1004 raw_supply (regnum
, reg
);
1007 enum register_status
1008 readable_regcache::raw_read_part (int regnum
, int offset
, int len
,
1011 assert_regnum (regnum
);
1012 return read_part (regnum
, offset
, len
, buf
, true);
1015 /* See regcache.h. */
1018 regcache::raw_write_part (int regnum
, int offset
, int len
,
1019 const gdb_byte
*buf
)
1021 assert_regnum (regnum
);
1022 write_part (regnum
, offset
, len
, buf
, true);
1025 /* See regcache.h. */
1027 enum register_status
1028 readable_regcache::cooked_read_part (int regnum
, int offset
, int len
,
1031 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1032 return read_part (regnum
, offset
, len
, buf
, false);
1035 /* See regcache.h. */
1038 regcache::cooked_write_part (int regnum
, int offset
, int len
,
1039 const gdb_byte
*buf
)
1041 gdb_assert (regnum
>= 0 && regnum
< m_descr
->nr_cooked_registers
);
1042 write_part (regnum
, offset
, len
, buf
, false);
1045 /* See gdbsupport/common-regcache.h. */
1048 reg_buffer::raw_supply (int regnum
, const void *buf
)
1053 assert_regnum (regnum
);
1055 regbuf
= register_buffer (regnum
);
1056 size
= m_descr
->sizeof_register
[regnum
];
1060 memcpy (regbuf
, buf
, size
);
1061 m_register_status
[regnum
] = REG_VALID
;
1065 /* This memset not strictly necessary, but better than garbage
1066 in case the register value manages to escape somewhere (due
1067 to a bug, no less). */
1068 memset (regbuf
, 0, size
);
1069 m_register_status
[regnum
] = REG_UNAVAILABLE
;
1073 /* See regcache.h. */
1076 reg_buffer::raw_supply_integer (int regnum
, const gdb_byte
*addr
,
1077 int addr_len
, bool is_signed
)
1079 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1083 assert_regnum (regnum
);
1085 regbuf
= register_buffer (regnum
);
1086 regsize
= m_descr
->sizeof_register
[regnum
];
1088 copy_integer_to_size (regbuf
, regsize
, addr
, addr_len
, is_signed
,
1090 m_register_status
[regnum
] = REG_VALID
;
1093 /* See regcache.h. */
1096 reg_buffer::raw_supply_zeroed (int regnum
)
1101 assert_regnum (regnum
);
1103 regbuf
= register_buffer (regnum
);
1104 size
= m_descr
->sizeof_register
[regnum
];
1106 memset (regbuf
, 0, size
);
1107 m_register_status
[regnum
] = REG_VALID
;
1110 /* See gdbsupport/common-regcache.h. */
1113 reg_buffer::raw_collect (int regnum
, void *buf
) const
1118 gdb_assert (buf
!= NULL
);
1119 assert_regnum (regnum
);
1121 regbuf
= register_buffer (regnum
);
1122 size
= m_descr
->sizeof_register
[regnum
];
1123 memcpy (buf
, regbuf
, size
);
1126 /* See regcache.h. */
1129 reg_buffer::raw_collect_integer (int regnum
, gdb_byte
*addr
, int addr_len
,
1130 bool is_signed
) const
1132 enum bfd_endian byte_order
= gdbarch_byte_order (m_descr
->gdbarch
);
1133 const gdb_byte
*regbuf
;
1136 assert_regnum (regnum
);
1138 regbuf
= register_buffer (regnum
);
1139 regsize
= m_descr
->sizeof_register
[regnum
];
1141 copy_integer_to_size (addr
, addr_len
, regbuf
, regsize
, is_signed
,
1145 /* See regcache.h. */
1148 regcache::transfer_regset_register (struct regcache
*out_regcache
, int regnum
,
1149 const gdb_byte
*in_buf
, gdb_byte
*out_buf
,
1150 int slot_size
, int offs
) const
1152 struct gdbarch
*gdbarch
= arch ();
1153 int reg_size
= std::min (register_size (gdbarch
, regnum
), slot_size
);
1155 /* Use part versions and reg_size to prevent possible buffer overflows when
1156 accessing the regcache. */
1158 if (out_buf
!= nullptr)
1160 raw_collect_part (regnum
, 0, reg_size
, out_buf
+ offs
);
1162 /* Ensure any additional space is cleared. */
1163 if (slot_size
> reg_size
)
1164 memset (out_buf
+ offs
+ reg_size
, 0, slot_size
- reg_size
);
1166 else if (in_buf
!= nullptr)
1168 /* Zero-extend the register value if the slot is smaller than the register. */
1169 if (slot_size
< register_size (gdbarch
, regnum
))
1170 out_regcache
->raw_supply_zeroed (regnum
);
1171 out_regcache
->raw_supply_part (regnum
, 0, reg_size
, in_buf
+ offs
);
1175 /* Invalidate the register. */
1176 out_regcache
->raw_supply (regnum
, nullptr);
1180 /* See regcache.h. */
1183 regcache::transfer_regset (const struct regset
*regset
,
1184 struct regcache
*out_regcache
,
1185 int regnum
, const gdb_byte
*in_buf
,
1186 gdb_byte
*out_buf
, size_t size
) const
1188 const struct regcache_map_entry
*map
;
1189 int offs
= 0, count
;
1191 for (map
= (const struct regcache_map_entry
*) regset
->regmap
;
1192 (count
= map
->count
) != 0;
1195 int regno
= map
->regno
;
1196 int slot_size
= map
->size
;
1198 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1199 slot_size
= m_descr
->sizeof_register
[regno
];
1201 if (regno
== REGCACHE_MAP_SKIP
1203 && (regnum
< regno
|| regnum
>= regno
+ count
)))
1204 offs
+= count
* slot_size
;
1206 else if (regnum
== -1)
1207 for (; count
--; regno
++, offs
+= slot_size
)
1209 if (offs
+ slot_size
> size
)
1212 transfer_regset_register (out_regcache
, regno
, in_buf
, out_buf
,
1217 /* Transfer a single register and return. */
1218 offs
+= (regnum
- regno
) * slot_size
;
1219 if (offs
+ slot_size
> size
)
1222 transfer_regset_register (out_regcache
, regnum
, in_buf
, out_buf
,
1229 /* Supply register REGNUM from BUF to REGCACHE, using the register map
1230 in REGSET. If REGNUM is -1, do this for all registers in REGSET.
1231 If BUF is NULL, set the register(s) to "unavailable" status. */
1234 regcache_supply_regset (const struct regset
*regset
,
1235 struct regcache
*regcache
,
1236 int regnum
, const void *buf
, size_t size
)
1238 regcache
->supply_regset (regset
, regnum
, (const gdb_byte
*) buf
, size
);
1242 regcache::supply_regset (const struct regset
*regset
,
1243 int regnum
, const void *buf
, size_t size
)
1245 transfer_regset (regset
, this, regnum
, (const gdb_byte
*) buf
, nullptr, size
);
1248 /* Collect register REGNUM from REGCACHE to BUF, using the register
1249 map in REGSET. If REGNUM is -1, do this for all registers in
1253 regcache_collect_regset (const struct regset
*regset
,
1254 const struct regcache
*regcache
,
1255 int regnum
, void *buf
, size_t size
)
1257 regcache
->collect_regset (regset
, regnum
, (gdb_byte
*) buf
, size
);
1261 regcache::collect_regset (const struct regset
*regset
,
1262 int regnum
, void *buf
, size_t size
) const
1264 transfer_regset (regset
, nullptr, regnum
, nullptr, (gdb_byte
*) buf
, size
);
1267 /* See regcache.h */
1270 regcache_map_supplies (const struct regcache_map_entry
*map
, int regnum
,
1271 struct gdbarch
*gdbarch
, size_t size
)
1273 int offs
= 0, count
;
1275 for (; (count
= map
->count
) != 0; map
++)
1277 int regno
= map
->regno
;
1278 int slot_size
= map
->size
;
1280 if (slot_size
== 0 && regno
!= REGCACHE_MAP_SKIP
)
1281 slot_size
= register_size (gdbarch
, regno
);
1283 if (regno
!= REGCACHE_MAP_SKIP
&& regnum
>= regno
1284 && regnum
< regno
+ count
)
1285 return offs
+ (regnum
- regno
+ 1) * slot_size
<= size
;
1287 offs
+= count
* slot_size
;
1294 /* See gdbsupport/common-regcache.h. */
1297 reg_buffer::raw_compare (int regnum
, const void *buf
, int offset
) const
1299 gdb_assert (buf
!= NULL
);
1300 assert_regnum (regnum
);
1302 const char *regbuf
= (const char *) register_buffer (regnum
);
1303 size_t size
= m_descr
->sizeof_register
[regnum
];
1304 gdb_assert (size
>= offset
);
1306 return (memcmp (buf
, regbuf
+ offset
, size
- offset
) == 0);
1309 /* Special handling for register PC. */
1312 regcache_read_pc (struct regcache
*regcache
)
1314 struct gdbarch
*gdbarch
= regcache
->arch ();
1318 if (gdbarch_read_pc_p (gdbarch
))
1319 pc_val
= gdbarch_read_pc (gdbarch
, regcache
);
1320 /* Else use per-frame method on get_current_frame. */
1321 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1325 if (regcache_cooked_read_unsigned (regcache
,
1326 gdbarch_pc_regnum (gdbarch
),
1327 &raw_val
) == REG_UNAVAILABLE
)
1328 throw_error (NOT_AVAILABLE_ERROR
, _("PC register is not available"));
1330 pc_val
= gdbarch_addr_bits_remove (gdbarch
, raw_val
);
1333 internal_error (__FILE__
, __LINE__
,
1334 _("regcache_read_pc: Unable to find PC"));
1338 /* See gdbsupport/common-regcache.h. */
1341 regcache_read_pc_protected (regcache
*regcache
)
1346 pc
= regcache_read_pc (regcache
);
1348 catch (const gdb_exception_error
&ex
)
1357 regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
)
1359 struct gdbarch
*gdbarch
= regcache
->arch ();
1361 if (gdbarch_write_pc_p (gdbarch
))
1362 gdbarch_write_pc (gdbarch
, regcache
, pc
);
1363 else if (gdbarch_pc_regnum (gdbarch
) >= 0)
1364 regcache_cooked_write_unsigned (regcache
,
1365 gdbarch_pc_regnum (gdbarch
), pc
);
1367 internal_error (__FILE__
, __LINE__
,
1368 _("regcache_write_pc: Unable to update PC"));
1370 /* Writing the PC (for instance, from "load") invalidates the
1372 reinit_frame_cache ();
1376 reg_buffer::num_raw_registers () const
1378 return gdbarch_num_regs (arch ());
1382 regcache::debug_print_register (const char *func
, int regno
)
1384 struct gdbarch
*gdbarch
= arch ();
1386 gdb_printf (gdb_stdlog
, "%s ", func
);
1387 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
)
1388 && gdbarch_register_name (gdbarch
, regno
) != NULL
1389 && gdbarch_register_name (gdbarch
, regno
)[0] != '\0')
1390 gdb_printf (gdb_stdlog
, "(%s)",
1391 gdbarch_register_name (gdbarch
, regno
));
1393 gdb_printf (gdb_stdlog
, "(%d)", regno
);
1394 if (regno
>= 0 && regno
< gdbarch_num_regs (gdbarch
))
1396 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1397 int size
= register_size (gdbarch
, regno
);
1398 gdb_byte
*buf
= register_buffer (regno
);
1400 gdb_printf (gdb_stdlog
, " = ");
1401 for (int i
= 0; i
< size
; i
++)
1403 gdb_printf (gdb_stdlog
, "%02x", buf
[i
]);
1405 if (size
<= sizeof (LONGEST
))
1407 ULONGEST val
= extract_unsigned_integer (buf
, size
, byte_order
);
1409 gdb_printf (gdb_stdlog
, " %s %s",
1410 core_addr_to_string_nz (val
), plongest (val
));
1413 gdb_printf (gdb_stdlog
, "\n");
1416 /* Implement 'maint flush register-cache' command. */
1419 reg_flush_command (const char *command
, int from_tty
)
1421 /* Force-flush the register cache. */
1422 registers_changed ();
1424 gdb_printf (_("Register cache flushed.\n"));
1428 register_dump::dump (ui_file
*file
)
1430 auto descr
= regcache_descr (m_gdbarch
);
1432 int footnote_nr
= 0;
1433 int footnote_register_offset
= 0;
1434 int footnote_register_type_name_null
= 0;
1435 long register_offset
= 0;
1437 gdb_assert (descr
->nr_cooked_registers
1438 == gdbarch_num_cooked_regs (m_gdbarch
));
1440 for (regnum
= -1; regnum
< descr
->nr_cooked_registers
; regnum
++)
1444 gdb_printf (file
, " %-10s", "Name");
1447 const char *p
= gdbarch_register_name (m_gdbarch
, regnum
);
1451 else if (p
[0] == '\0')
1453 gdb_printf (file
, " %-10s", p
);
1458 gdb_printf (file
, " %4s", "Nr");
1460 gdb_printf (file
, " %4d", regnum
);
1462 /* Relative number. */
1464 gdb_printf (file
, " %4s", "Rel");
1465 else if (regnum
< gdbarch_num_regs (m_gdbarch
))
1466 gdb_printf (file
, " %4d", regnum
);
1468 gdb_printf (file
, " %4d",
1469 (regnum
- gdbarch_num_regs (m_gdbarch
)));
1473 gdb_printf (file
, " %6s ", "Offset");
1476 gdb_printf (file
, " %6ld",
1477 descr
->register_offset
[regnum
]);
1478 if (register_offset
!= descr
->register_offset
[regnum
]
1480 && (descr
->register_offset
[regnum
]
1481 != (descr
->register_offset
[regnum
- 1]
1482 + descr
->sizeof_register
[regnum
- 1])))
1485 if (!footnote_register_offset
)
1486 footnote_register_offset
= ++footnote_nr
;
1487 gdb_printf (file
, "*%d", footnote_register_offset
);
1490 gdb_printf (file
, " ");
1491 register_offset
= (descr
->register_offset
[regnum
]
1492 + descr
->sizeof_register
[regnum
]);
1497 gdb_printf (file
, " %5s ", "Size");
1499 gdb_printf (file
, " %5ld", descr
->sizeof_register
[regnum
]);
1504 std::string name_holder
;
1510 static const char blt
[] = "builtin_type";
1512 t
= register_type (m_gdbarch
, regnum
)->name ();
1515 if (!footnote_register_type_name_null
)
1516 footnote_register_type_name_null
= ++footnote_nr
;
1517 name_holder
= string_printf ("*%d",
1518 footnote_register_type_name_null
);
1519 t
= name_holder
.c_str ();
1521 /* Chop a leading builtin_type. */
1522 if (startswith (t
, blt
))
1525 gdb_printf (file
, " %-15s", t
);
1528 /* Leading space always present. */
1529 gdb_printf (file
, " ");
1531 dump_reg (file
, regnum
);
1533 gdb_printf (file
, "\n");
1536 if (footnote_register_offset
)
1537 gdb_printf (file
, "*%d: Inconsistent register offsets.\n",
1538 footnote_register_offset
);
1539 if (footnote_register_type_name_null
)
1541 "*%d: Register type's name NULL.\n",
1542 footnote_register_type_name_null
);
1546 #include "gdbsupport/selftest.h"
1547 #include "selftest-arch.h"
1548 #include "target-float.h"
1550 namespace selftests
{
1557 for (auto pid_ptid_regc_map_it
= regcaches
.cbegin ();
1558 pid_ptid_regc_map_it
!= regcaches
.cend ();
1559 ++pid_ptid_regc_map_it
)
1561 const pid_ptid_regcache_map
&pid_ptid_regc_map
1562 = pid_ptid_regc_map_it
->second
;
1564 for (auto ptid_regc_map_it
= pid_ptid_regc_map
.cbegin ();
1565 ptid_regc_map_it
!= pid_ptid_regc_map
.cend ();
1568 const ptid_regcache_map
&ptid_regc_map
1569 = ptid_regc_map_it
->second
;
1571 size
+= ptid_regc_map
.size ();
1578 /* Return the count of regcaches for (TARGET, PTID) in REGCACHES. */
1581 regcache_count (process_stratum_target
*target
, ptid_t ptid
)
1583 /* Look up map for target. */
1584 auto pid_ptid_regc_map_it
= regcaches
.find (target
);
1585 if (pid_ptid_regc_map_it
!= regcaches
.end ())
1587 pid_ptid_regcache_map
&pid_ptid_regc_map
= pid_ptid_regc_map_it
->second
;
1589 /* Look map for pid. */
1590 auto ptid_regc_map_it
= pid_ptid_regc_map
.find (ptid
.pid ());
1591 if (ptid_regc_map_it
!= pid_ptid_regc_map
.end ())
1593 ptid_regcache_map
&ptid_regc_map
= ptid_regc_map_it
->second
;
1594 auto range
= ptid_regc_map
.equal_range (ptid
);
1596 return std::distance (range
.first
, range
.second
);
1603 /* Wrapper around get_thread_arch_aspace_regcache that does some self checks. */
1606 get_thread_arch_aspace_regcache_and_check (process_stratum_target
*target
,
1609 /* We currently only test with a single gdbarch. Any gdbarch will do, so use
1610 the current inferior's gdbarch. Also use the current inferior's address
1612 gdbarch
*arch
= current_inferior ()->gdbarch
;
1613 address_space
*aspace
= current_inferior ()->aspace
;
1615 = get_thread_arch_aspace_regcache (target
, ptid
, arch
, aspace
);
1617 SELF_CHECK (regcache
!= NULL
);
1618 SELF_CHECK (regcache
->target () == target
);
1619 SELF_CHECK (regcache
->ptid () == ptid
);
1620 SELF_CHECK (regcache
->arch () == arch
);
1621 SELF_CHECK (regcache
->aspace () == aspace
);
1624 /* The data that the regcaches selftests must hold onto for the duration of the
1627 struct regcache_test_data
1629 regcache_test_data ()
1631 /* Ensure the regcaches container is empty at the start. */
1632 registers_changed ();
1635 ~regcache_test_data ()
1637 /* Make sure to leave the global regcaches container empty. */
1638 registers_changed ();
1641 test_target_ops test_target1
;
1642 test_target_ops test_target2
;
1645 using regcache_test_data_up
= std::unique_ptr
<regcache_test_data
>;
1647 /* Set up a few regcaches from two different targets, for use in
1648 regcache-management tests.
1650 Return a pointer, because the `regcache_test_data` type is not moveable. */
1652 static regcache_test_data_up
1653 populate_regcaches_for_test ()
1655 regcache_test_data_up
data (new regcache_test_data
);
1656 size_t expected_regcache_size
= 0;
1658 SELF_CHECK (regcaches_size () == 0);
1660 /* Populate the regcache container with a few regcaches for the two test
1662 for (int pid
: { 1, 2 })
1664 for (long lwp
: { 1, 2, 3 })
1666 get_thread_arch_aspace_regcache_and_check
1667 (&data
->test_target1
, ptid_t (pid
, lwp
));
1668 expected_regcache_size
++;
1669 SELF_CHECK (regcaches_size () == expected_regcache_size
);
1671 get_thread_arch_aspace_regcache_and_check
1672 (&data
->test_target2
, ptid_t (pid
, lwp
));
1673 expected_regcache_size
++;
1674 SELF_CHECK (regcaches_size () == expected_regcache_size
);
1682 get_thread_arch_aspace_regcache_test ()
1684 /* populate_regcaches_for_test already tests most of the
1685 get_thread_arch_aspace_regcache functionality. */
1686 regcache_test_data_up data
= populate_regcaches_for_test ();
1687 size_t regcaches_size_before
= regcaches_size ();
1689 /* Test that getting an existing regcache doesn't create a new one. */
1690 get_thread_arch_aspace_regcache_and_check (&data
->test_target1
, ptid_t (2, 2));
1691 SELF_CHECK (regcaches_size () == regcaches_size_before
);
1694 /* Test marking all regcaches of all targets as changed. */
1697 registers_changed_ptid_all_test ()
1699 regcache_test_data_up data
= populate_regcaches_for_test ();
1701 registers_changed_ptid (nullptr, minus_one_ptid
);
1702 SELF_CHECK (regcaches_size () == 0);
1705 /* Test marking regcaches of a specific target as changed. */
1708 registers_changed_ptid_target_test ()
1710 regcache_test_data_up data
= populate_regcaches_for_test ();
1712 registers_changed_ptid (&data
->test_target1
, minus_one_ptid
);
1713 SELF_CHECK (regcaches_size () == 6);
1715 /* Check that we deleted the regcache for the right target. */
1716 SELF_CHECK (regcache_count (&data
->test_target1
, ptid_t (2, 2)) == 0);
1717 SELF_CHECK (regcache_count (&data
->test_target2
, ptid_t (2, 2)) == 1);
1720 /* Test marking regcaches of a specific (target, pid) as changed. */
1723 registers_changed_ptid_target_pid_test ()
1725 regcache_test_data_up data
= populate_regcaches_for_test ();
1727 registers_changed_ptid (&data
->test_target1
, ptid_t (2));
1728 SELF_CHECK (regcaches_size () == 9);
1730 /* Regcaches from target1 should not exist, while regcaches from target2
1732 SELF_CHECK (regcache_count (&data
->test_target1
, ptid_t (2, 2)) == 0);
1733 SELF_CHECK (regcache_count (&data
->test_target2
, ptid_t (2, 2)) == 1);
1736 /* Test marking regcaches of a specific (target, ptid) as changed. */
1739 registers_changed_ptid_target_ptid_test ()
1741 regcache_test_data_up data
= populate_regcaches_for_test ();
1743 registers_changed_ptid (&data
->test_target1
, ptid_t (2, 2));
1744 SELF_CHECK (regcaches_size () == 11);
1746 /* Check that we deleted the regcache for the right target. */
1747 SELF_CHECK (regcache_count (&data
->test_target1
, ptid_t (2, 2)) == 0);
1748 SELF_CHECK (regcache_count (&data
->test_target2
, ptid_t (2, 2)) == 1);
1751 class target_ops_no_register
: public test_target_ops
1754 target_ops_no_register ()
1755 : test_target_ops
{}
1760 fetch_registers_called
= 0;
1761 store_registers_called
= 0;
1762 xfer_partial_called
= 0;
1765 void fetch_registers (regcache
*regs
, int regno
) override
;
1766 void store_registers (regcache
*regs
, int regno
) override
;
1768 enum target_xfer_status
xfer_partial (enum target_object object
,
1769 const char *annex
, gdb_byte
*readbuf
,
1770 const gdb_byte
*writebuf
,
1771 ULONGEST offset
, ULONGEST len
,
1772 ULONGEST
*xfered_len
) override
;
1774 unsigned int fetch_registers_called
= 0;
1775 unsigned int store_registers_called
= 0;
1776 unsigned int xfer_partial_called
= 0;
1780 target_ops_no_register::fetch_registers (regcache
*regs
, int regno
)
1782 /* Mark register available. */
1783 regs
->raw_supply_zeroed (regno
);
1784 this->fetch_registers_called
++;
1788 target_ops_no_register::store_registers (regcache
*regs
, int regno
)
1790 this->store_registers_called
++;
1793 enum target_xfer_status
1794 target_ops_no_register::xfer_partial (enum target_object object
,
1795 const char *annex
, gdb_byte
*readbuf
,
1796 const gdb_byte
*writebuf
,
1797 ULONGEST offset
, ULONGEST len
,
1798 ULONGEST
*xfered_len
)
1800 this->xfer_partial_called
++;
1803 return TARGET_XFER_OK
;
1806 class readwrite_regcache
: public regcache
1809 readwrite_regcache (process_stratum_target
*target
,
1810 struct gdbarch
*gdbarch
)
1811 : regcache (target
, gdbarch
, nullptr)
1815 /* Return true if regcache::cooked_{read,write}_test should be skipped for
1819 selftest_skiparch (struct gdbarch
*gdbarch
)
1821 const char *name
= gdbarch_bfd_arch_info (gdbarch
)->printable_name
;
1824 Running selftest regcache::cooked_{read,write}_test::m68hc11.
1825 warning: No frame soft register found in the symbol table.
1826 Stack backtrace will not work.
1827 We could instead capture the output and then filter out the warning, but
1828 that seems more trouble than it's worth. */
1829 return (strcmp (name
, "m68hc11") == 0
1830 || strcmp (name
, "m68hc12") == 0
1831 || strcmp (name
, "m68hc12:HCS12") == 0);
1834 /* Test regcache::cooked_read gets registers from raw registers and
1835 memory instead of target to_{fetch,store}_registers. */
1838 cooked_read_test (struct gdbarch
*gdbarch
)
1840 if (selftest_skiparch (gdbarch
))
1843 scoped_mock_context
<target_ops_no_register
> mockctx (gdbarch
);
1845 /* Test that read one raw register from regcache_no_target will go
1846 to the target layer. */
1848 /* Find a raw register which size isn't zero. */
1850 for (nonzero_regnum
= 0;
1851 nonzero_regnum
< gdbarch_num_regs (gdbarch
);
1854 if (register_size (gdbarch
, nonzero_regnum
) != 0)
1858 readwrite_regcache
readwrite (&mockctx
.mock_target
, gdbarch
);
1859 gdb::def_vector
<gdb_byte
> buf (register_size (gdbarch
, nonzero_regnum
));
1861 readwrite
.raw_read (nonzero_regnum
, buf
.data ());
1863 /* raw_read calls target_fetch_registers. */
1864 SELF_CHECK (mockctx
.mock_target
.fetch_registers_called
> 0);
1865 mockctx
.mock_target
.reset ();
1867 /* Mark all raw registers valid, so the following raw registers
1868 accesses won't go to target. */
1869 for (auto i
= 0; i
< gdbarch_num_regs (gdbarch
); i
++)
1870 readwrite
.raw_update (i
);
1872 mockctx
.mock_target
.reset ();
1873 /* Then, read all raw and pseudo registers, and don't expect calling
1874 to_{fetch,store}_registers. */
1875 for (int regnum
= 0; regnum
< gdbarch_num_cooked_regs (gdbarch
); regnum
++)
1877 if (register_size (gdbarch
, regnum
) == 0)
1880 gdb::def_vector
<gdb_byte
> inner_buf (register_size (gdbarch
, regnum
));
1882 SELF_CHECK (REG_VALID
== readwrite
.cooked_read (regnum
,
1883 inner_buf
.data ()));
1885 SELF_CHECK (mockctx
.mock_target
.fetch_registers_called
== 0);
1886 SELF_CHECK (mockctx
.mock_target
.store_registers_called
== 0);
1887 SELF_CHECK (mockctx
.mock_target
.xfer_partial_called
== 0);
1889 mockctx
.mock_target
.reset ();
1892 readonly_detached_regcache
readonly (readwrite
);
1894 /* GDB may go to target layer to fetch all registers and memory for
1895 readonly regcache. */
1896 mockctx
.mock_target
.reset ();
1898 for (int regnum
= 0; regnum
< gdbarch_num_cooked_regs (gdbarch
); regnum
++)
1900 if (register_size (gdbarch
, regnum
) == 0)
1903 gdb::def_vector
<gdb_byte
> inner_buf (register_size (gdbarch
, regnum
));
1904 enum register_status status
= readonly
.cooked_read (regnum
,
1907 if (regnum
< gdbarch_num_regs (gdbarch
))
1909 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1911 if (bfd_arch
== bfd_arch_frv
|| bfd_arch
== bfd_arch_h8300
1912 || bfd_arch
== bfd_arch_m32c
|| bfd_arch
== bfd_arch_sh
1913 || bfd_arch
== bfd_arch_alpha
|| bfd_arch
== bfd_arch_v850
1914 || bfd_arch
== bfd_arch_msp430
|| bfd_arch
== bfd_arch_mep
1915 || bfd_arch
== bfd_arch_mips
|| bfd_arch
== bfd_arch_v850_rh850
1916 || bfd_arch
== bfd_arch_tic6x
|| bfd_arch
== bfd_arch_mn10300
1917 || bfd_arch
== bfd_arch_rl78
|| bfd_arch
== bfd_arch_score
1918 || bfd_arch
== bfd_arch_riscv
|| bfd_arch
== bfd_arch_csky
)
1920 /* Raw registers. If raw registers are not in save_reggroup,
1921 their status are unknown. */
1922 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1923 SELF_CHECK (status
== REG_VALID
);
1925 SELF_CHECK (status
== REG_UNKNOWN
);
1928 SELF_CHECK (status
== REG_VALID
);
1932 if (gdbarch_register_reggroup_p (gdbarch
, regnum
, save_reggroup
))
1933 SELF_CHECK (status
== REG_VALID
);
1936 /* If pseudo registers are not in save_reggroup, some of
1937 them can be computed from saved raw registers, but some
1938 of them are unknown. */
1939 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1941 if (bfd_arch
== bfd_arch_frv
1942 || bfd_arch
== bfd_arch_m32c
1943 || bfd_arch
== bfd_arch_mep
1944 || bfd_arch
== bfd_arch_sh
)
1945 SELF_CHECK (status
== REG_VALID
|| status
== REG_UNKNOWN
);
1946 else if (bfd_arch
== bfd_arch_mips
1947 || bfd_arch
== bfd_arch_h8300
)
1948 SELF_CHECK (status
== REG_UNKNOWN
);
1950 SELF_CHECK (status
== REG_VALID
);
1954 SELF_CHECK (mockctx
.mock_target
.fetch_registers_called
== 0);
1955 SELF_CHECK (mockctx
.mock_target
.store_registers_called
== 0);
1956 SELF_CHECK (mockctx
.mock_target
.xfer_partial_called
== 0);
1958 mockctx
.mock_target
.reset ();
1962 /* Test regcache::cooked_write by writing some expected contents to
1963 registers, and checking that contents read from registers and the
1964 expected contents are the same. */
1967 cooked_write_test (struct gdbarch
*gdbarch
)
1969 if (selftest_skiparch (gdbarch
))
1972 /* Create a mock environment. A process_stratum target pushed. */
1973 scoped_mock_context
<target_ops_no_register
> ctx (gdbarch
);
1974 readwrite_regcache
readwrite (&ctx
.mock_target
, gdbarch
);
1975 const int num_regs
= gdbarch_num_cooked_regs (gdbarch
);
1977 for (auto regnum
= 0; regnum
< num_regs
; regnum
++)
1979 if (register_size (gdbarch
, regnum
) == 0
1980 || gdbarch_cannot_store_register (gdbarch
, regnum
))
1983 auto bfd_arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1985 if (bfd_arch
== bfd_arch_sparc
1986 /* SPARC64_CWP_REGNUM, SPARC64_PSTATE_REGNUM,
1987 SPARC64_ASI_REGNUM and SPARC64_CCR_REGNUM are hard to test. */
1988 && gdbarch_ptr_bit (gdbarch
) == 64
1989 && (regnum
>= gdbarch_num_regs (gdbarch
)
1990 && regnum
<= gdbarch_num_regs (gdbarch
) + 4))
1993 std::vector
<gdb_byte
> expected (register_size (gdbarch
, regnum
), 0);
1994 std::vector
<gdb_byte
> buf (register_size (gdbarch
, regnum
), 0);
1995 const auto type
= register_type (gdbarch
, regnum
);
1997 if (type
->code () == TYPE_CODE_FLT
1998 || type
->code () == TYPE_CODE_DECFLOAT
)
2000 /* Generate valid float format. */
2001 target_float_from_string (expected
.data (), type
, "1.25");
2003 else if (type
->code () == TYPE_CODE_INT
2004 || type
->code () == TYPE_CODE_ARRAY
2005 || type
->code () == TYPE_CODE_PTR
2006 || type
->code () == TYPE_CODE_UNION
2007 || type
->code () == TYPE_CODE_STRUCT
)
2009 if (bfd_arch
== bfd_arch_ia64
2010 || (regnum
>= gdbarch_num_regs (gdbarch
)
2011 && (bfd_arch
== bfd_arch_xtensa
2012 || bfd_arch
== bfd_arch_bfin
2013 || bfd_arch
== bfd_arch_m32c
2014 /* m68hc11 pseudo registers are in memory. */
2015 || bfd_arch
== bfd_arch_m68hc11
2016 || bfd_arch
== bfd_arch_m68hc12
2017 || bfd_arch
== bfd_arch_s390
))
2018 || (bfd_arch
== bfd_arch_frv
2019 /* FRV pseudo registers except iacc0. */
2020 && regnum
> gdbarch_num_regs (gdbarch
)))
2022 /* Skip setting the expected values for some architecture
2025 else if (bfd_arch
== bfd_arch_rl78
&& regnum
== 40)
2027 /* RL78_PC_REGNUM */
2028 for (auto j
= 0; j
< register_size (gdbarch
, regnum
) - 1; j
++)
2033 for (auto j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
2037 else if (type
->code () == TYPE_CODE_FLAGS
)
2039 /* No idea how to test flags. */
2044 /* If we don't know how to create the expected value for the
2045 this type, make it fail. */
2049 readwrite
.cooked_write (regnum
, expected
.data ());
2051 SELF_CHECK (readwrite
.cooked_read (regnum
, buf
.data ()) == REG_VALID
);
2052 SELF_CHECK (expected
== buf
);
2056 /* Verify that when two threads with the same ptid exist (from two different
2057 targets) and one of them changes ptid, we only update the appropriate
2061 regcache_thread_ptid_changed ()
2063 /* This test relies on the global regcache list to initially be empty. */
2064 registers_changed ();
2066 /* Any arch will do. */
2067 gdbarch
*arch
= current_inferior ()->gdbarch
;
2069 /* Prepare two targets with one thread each, with the same ptid. */
2070 scoped_mock_context
<test_target_ops
> target1 (arch
);
2071 scoped_mock_context
<test_target_ops
> target2 (arch
);
2073 ptid_t
old_ptid (111, 222);
2074 ptid_t
new_ptid (111, 333);
2076 target1
.mock_inferior
.pid
= old_ptid
.pid ();
2077 target1
.mock_thread
.ptid
= old_ptid
;
2078 target1
.mock_inferior
.ptid_thread_map
.clear ();
2079 target1
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target1
.mock_thread
;
2081 target2
.mock_inferior
.pid
= old_ptid
.pid ();
2082 target2
.mock_thread
.ptid
= old_ptid
;
2083 target2
.mock_inferior
.ptid_thread_map
.clear ();
2084 target2
.mock_inferior
.ptid_thread_map
[old_ptid
] = &target2
.mock_thread
;
2086 gdb_assert (regcaches
.empty ());
2088 /* Populate the regcaches container. */
2089 get_thread_arch_aspace_regcache (&target1
.mock_target
, old_ptid
, arch
,
2091 get_thread_arch_aspace_regcache (&target2
.mock_target
, old_ptid
, arch
,
2094 gdb_assert (regcaches
.size () == 2);
2095 gdb_assert (regcache_count (&target1
.mock_target
, old_ptid
) == 1);
2096 gdb_assert (regcache_count (&target1
.mock_target
, new_ptid
) == 0);
2097 gdb_assert (regcache_count (&target2
.mock_target
, old_ptid
) == 1);
2098 gdb_assert (regcache_count (&target2
.mock_target
, new_ptid
) == 0);
2100 thread_change_ptid (&target1
.mock_target
, old_ptid
, new_ptid
);
2102 gdb_assert (regcaches
.size () == 2);
2103 gdb_assert (regcache_count (&target1
.mock_target
, old_ptid
) == 0);
2104 gdb_assert (regcache_count (&target1
.mock_target
, new_ptid
) == 1);
2105 gdb_assert (regcache_count (&target2
.mock_target
, old_ptid
) == 1);
2106 gdb_assert (regcache_count (&target2
.mock_target
, new_ptid
) == 0);
2108 /* Leave the regcache list empty. */
2109 registers_changed ();
2110 gdb_assert (regcaches
.empty ());
2113 } // namespace selftests
2114 #endif /* GDB_SELF_TEST */
2116 void _initialize_regcache ();
2118 _initialize_regcache ()
2120 struct cmd_list_element
*c
;
2122 regcache_descr_handle
2123 = gdbarch_data_register_post_init (init_regcache_descr
);
2125 gdb::observers::target_changed
.attach (regcache_observer_target_changed
,
2127 gdb::observers::thread_ptid_changed
.attach (regcache_thread_ptid_changed
,
2130 cmd_list_element
*maintenance_flush_register_cache_cmd
2131 = add_cmd ("register-cache", class_maintenance
, reg_flush_command
,
2132 _("Force gdb to flush its register and frame cache."),
2133 &maintenanceflushlist
);
2134 c
= add_com_alias ("flushregs", maintenance_flush_register_cache_cmd
,
2135 class_maintenance
, 0);
2136 deprecate_cmd (c
, "maintenance flush register-cache");
2139 selftests::register_test ("get_thread_arch_aspace_regcache",
2140 selftests::get_thread_arch_aspace_regcache_test
);
2141 selftests::register_test ("registers_changed_ptid_all",
2142 selftests::registers_changed_ptid_all_test
);
2143 selftests::register_test ("registers_changed_ptid_target",
2144 selftests::registers_changed_ptid_target_test
);
2145 selftests::register_test ("registers_changed_ptid_target_pid",
2146 selftests::registers_changed_ptid_target_pid_test
);
2147 selftests::register_test ("registers_changed_ptid_target_ptid",
2148 selftests::registers_changed_ptid_target_ptid_test
);
2150 selftests::register_test_foreach_arch ("regcache::cooked_read_test",
2151 selftests::cooked_read_test
);
2152 selftests::register_test_foreach_arch ("regcache::cooked_write_test",
2153 selftests::cooked_write_test
);
2154 selftests::register_test ("regcache_thread_ptid_changed",
2155 selftests::regcache_thread_ptid_changed
);