1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986-2020 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/>. */
23 #include "gdbsupport/common-regcache.h"
24 #include "gdbsupport/function-view.h"
25 #include <forward_list>
32 struct process_stratum_target
;
34 extern struct regcache
*get_current_regcache (void);
35 extern struct regcache
*get_thread_regcache (process_stratum_target
*target
,
38 /* Get the regcache of THREAD. */
39 extern struct regcache
*get_thread_regcache (thread_info
*thread
);
41 extern struct regcache
*get_thread_arch_regcache
42 (process_stratum_target
*targ
, ptid_t
, struct gdbarch
*);
43 extern struct regcache
*get_thread_arch_aspace_regcache
44 (process_stratum_target
*target
, ptid_t
,
45 struct gdbarch
*, struct address_space
*);
47 extern enum register_status
48 regcache_raw_read_signed (struct regcache
*regcache
,
49 int regnum
, LONGEST
*val
);
51 extern void regcache_raw_write_signed (struct regcache
*regcache
,
52 int regnum
, LONGEST val
);
53 extern void regcache_raw_write_unsigned (struct regcache
*regcache
,
54 int regnum
, ULONGEST val
);
56 /* Return the register's value in signed or throw if it's not
59 extern LONGEST
regcache_raw_get_signed (struct regcache
*regcache
,
62 /* Read a register as a signed/unsigned quantity. */
63 extern enum register_status
64 regcache_cooked_read_signed (struct regcache
*regcache
,
65 int regnum
, LONGEST
*val
);
66 extern enum register_status
67 regcache_cooked_read_unsigned (struct regcache
*regcache
,
68 int regnum
, ULONGEST
*val
);
69 extern void regcache_cooked_write_signed (struct regcache
*regcache
,
70 int regnum
, LONGEST val
);
71 extern void regcache_cooked_write_unsigned (struct regcache
*regcache
,
72 int regnum
, ULONGEST val
);
74 /* Special routines to read/write the PC. */
76 /* For regcache_read_pc see gdbsupport/common-regcache.h. */
77 extern void regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
);
79 /* Mapping between register numbers and offsets in a buffer, for use
80 in the '*regset' functions below and with traditional frame caches.
81 In an array of 'regcache_map_entry' each element is interpreted
84 - If 'regno' is a register number: Map register 'regno' to the
85 current offset (starting with 0) and increase the current offset
86 by 'size' (or the register's size, if 'size' is zero). Repeat
87 this with consecutive register numbers up to 'regno+count-1'.
89 For each described register, if 'size' is larger than the
90 register's size, the register's value is assumed to be stored in
91 the first N (where N is the register size) bytes at the current
92 offset. The remaining 'size' - N bytes are filled with zeroes by
93 'regcache_collect_regset' and ignored by other consumers.
95 If 'size' is smaller than the register's size, only the first
96 'size' bytes of a register's value are assumed to be stored at
97 the current offset. 'regcache_collect_regset' copies the first
98 'size' bytes of a register's value to the output buffer.
99 'regcache_supply_regset' copies the bytes from the input buffer
100 into the first 'size' bytes of the register's value leaving the
101 remaining bytes of the register's value unchanged. Frame caches
102 read the 'size' bytes from the stack frame and zero extend them
103 to generate the register's value.
105 - If 'regno' is REGCACHE_MAP_SKIP: Add 'count*size' to the current
108 - If count=0: End of the map. */
110 struct regcache_map_entry
117 /* Special value for the 'regno' field in the struct above. */
121 REGCACHE_MAP_SKIP
= -1,
124 /* Calculate and return the total size of all the registers in a
125 regcache_map_entry. */
128 regcache_map_entry_size (const struct regcache_map_entry
*map
)
131 for (int i
= 0; map
[i
].count
!= 0; i
++)
132 size
+= (map
[i
].count
* map
[i
].size
);
136 /* Transfer a set of registers (as described by REGSET) between
137 REGCACHE and BUF. If REGNUM == -1, transfer all registers
138 belonging to the regset, otherwise just the register numbered
139 REGNUM. The REGSET's 'regmap' field must point to an array of
140 'struct regcache_map_entry'.
142 These functions are suitable for the 'regset_supply' and
143 'regset_collect' fields in a regset structure. */
145 extern void regcache_supply_regset (const struct regset
*regset
,
146 struct regcache
*regcache
,
147 int regnum
, const void *buf
,
149 extern void regcache_collect_regset (const struct regset
*regset
,
150 const struct regcache
*regcache
,
151 int regnum
, void *buf
, size_t size
);
154 /* The type of a register. This function is slightly more efficient
155 then its gdbarch vector counterpart since it returns a precomputed
156 value stored in a table. */
158 extern struct type
*register_type (struct gdbarch
*gdbarch
, int regnum
);
161 /* Return the size of register REGNUM. All registers should have only
164 extern int register_size (struct gdbarch
*gdbarch
, int regnum
);
166 typedef gdb::function_view
<register_status (int regnum
, gdb_byte
*buf
)>
169 /* A (register_number, register_value) pair. */
171 typedef struct cached_reg
177 /* Buffer of registers. */
179 class reg_buffer
: public reg_buffer_common
182 reg_buffer (gdbarch
*gdbarch
, bool has_pseudo
);
184 DISABLE_COPY_AND_ASSIGN (reg_buffer
);
186 /* Return regcache's architecture. */
187 gdbarch
*arch () const;
189 /* See gdbsupport/common-regcache.h. */
190 enum register_status
get_register_status (int regnum
) const override
;
192 /* See gdbsupport/common-regcache.h. */
193 void raw_collect (int regnum
, void *buf
) const override
;
195 /* Collect register REGNUM from REGCACHE. Store collected value as an integer
196 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
197 If ADDR_LEN is greater than the register size, then the integer will be
198 sign or zero extended. If ADDR_LEN is smaller than the register size, then
199 the most significant bytes of the integer will be truncated. */
200 void raw_collect_integer (int regnum
, gdb_byte
*addr
, int addr_len
,
201 bool is_signed
) const;
203 /* Collect register REGNUM from REGCACHE, starting at OFFSET in register,
205 void raw_collect_part (int regnum
, int offset
, int len
, gdb_byte
*out
) const;
207 /* See gdbsupport/common-regcache.h. */
208 void raw_supply (int regnum
, const void *buf
) override
;
210 void raw_supply (int regnum
, const reg_buffer
&src
)
212 raw_supply (regnum
, src
.register_buffer (regnum
));
215 /* Supply register REGNUM to REGCACHE. Value to supply is an integer stored
216 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
217 If the register size is greater than ADDR_LEN, then the integer will be
218 sign or zero extended. If the register size is smaller than the integer,
219 then the most significant bytes of the integer will be truncated. */
220 void raw_supply_integer (int regnum
, const gdb_byte
*addr
, int addr_len
,
223 /* Supply register REGNUM with zeroed value to REGCACHE. This is not the same
224 as calling raw_supply with NULL (which will set the state to
226 void raw_supply_zeroed (int regnum
);
228 /* Supply register REGNUM to REGCACHE, starting at OFFSET in register, writing
229 only LEN, without editing the rest of the register. */
230 void raw_supply_part (int regnum
, int offset
, int len
, const gdb_byte
*in
);
232 void invalidate (int regnum
);
234 virtual ~reg_buffer () = default;
236 /* See gdbsupport/common-regcache.h. */
237 bool raw_compare (int regnum
, const void *buf
, int offset
) const override
;
240 /* Assert on the range of REGNUM. */
241 void assert_regnum (int regnum
) const;
243 int num_raw_registers () const;
245 gdb_byte
*register_buffer (int regnum
) const;
247 /* Save a register cache. The set of registers saved into the
248 regcache determined by the save_reggroup. COOKED_READ returns
249 zero iff the register's value can't be returned. */
250 void save (register_read_ftype cooked_read
);
252 struct regcache_descr
*m_descr
;
255 /* The register buffers. */
256 std::unique_ptr
<gdb_byte
[]> m_registers
;
257 /* Register cache status. */
258 std::unique_ptr
<register_status
[]> m_register_status
;
260 friend class regcache
;
261 friend class detached_regcache
;
264 /* An abstract class which only has methods doing read. */
266 class readable_regcache
: public reg_buffer
269 readable_regcache (gdbarch
*gdbarch
, bool has_pseudo
)
270 : reg_buffer (gdbarch
, has_pseudo
)
273 /* Transfer a raw register [0..NUM_REGS) from core-gdb to this regcache,
274 return its value in *BUF and return its availability status. */
276 enum register_status
raw_read (int regnum
, gdb_byte
*buf
);
277 template<typename T
, typename
= RequireLongest
<T
>>
278 enum register_status
raw_read (int regnum
, T
*val
);
280 /* Partial transfer of raw registers. Return the status of the register. */
281 enum register_status
raw_read_part (int regnum
, int offset
, int len
,
284 /* Make certain that the register REGNUM is up-to-date. */
285 virtual void raw_update (int regnum
) = 0;
287 /* Transfer a raw register [0..NUM_REGS+NUM_PSEUDO_REGS) from core-gdb to
288 this regcache, return its value in *BUF and return its availability status. */
289 enum register_status
cooked_read (int regnum
, gdb_byte
*buf
);
290 template<typename T
, typename
= RequireLongest
<T
>>
291 enum register_status
cooked_read (int regnum
, T
*val
);
293 /* Partial transfer of a cooked register. */
294 enum register_status
cooked_read_part (int regnum
, int offset
, int len
,
297 /* Read register REGNUM from the regcache and return a new value. This
298 will call mark_value_bytes_unavailable as appropriate. */
299 struct value
*cooked_read_value (int regnum
);
303 /* Perform a partial register transfer using a read, modify, write
304 operation. Will fail if register is currently invalid. */
305 enum register_status
read_part (int regnum
, int offset
, int len
,
306 gdb_byte
*out
, bool is_raw
);
309 /* Buffer of registers, can be read and written. */
311 class detached_regcache
: public readable_regcache
314 detached_regcache (gdbarch
*gdbarch
, bool has_pseudo
)
315 : readable_regcache (gdbarch
, has_pseudo
)
318 void raw_update (int regnum
) override
321 DISABLE_COPY_AND_ASSIGN (detached_regcache
);
324 class readonly_detached_regcache
;
326 /* The register cache for storing raw register values. */
328 class regcache
: public detached_regcache
331 DISABLE_COPY_AND_ASSIGN (regcache
);
333 /* Return REGCACHE's address space. */
334 const address_space
*aspace () const
339 /* Restore 'this' regcache. The set of registers restored into
340 the regcache determined by the restore_reggroup.
341 Writes to regcache will go through to the target. SRC is a
342 read-only register cache. */
343 void restore (readonly_detached_regcache
*src
);
345 /* Update the value of raw register REGNUM (in the range [0..NUM_REGS)) and
346 transfer its value to core-gdb. */
348 void raw_write (int regnum
, const gdb_byte
*buf
);
350 template<typename T
, typename
= RequireLongest
<T
>>
351 void raw_write (int regnum
, T val
);
353 /* Transfer of pseudo-registers. */
354 void cooked_write (int regnum
, const gdb_byte
*buf
);
356 template<typename T
, typename
= RequireLongest
<T
>>
357 void cooked_write (int regnum
, T val
);
359 void raw_update (int regnum
) override
;
361 /* Partial transfer of raw registers. Perform read, modify, write style
363 void raw_write_part (int regnum
, int offset
, int len
, const gdb_byte
*buf
);
365 /* Partial transfer of a cooked register. Perform read, modify, write style
367 void cooked_write_part (int regnum
, int offset
, int len
,
368 const gdb_byte
*buf
);
370 void supply_regset (const struct regset
*regset
,
371 int regnum
, const void *buf
, size_t size
);
374 void collect_regset (const struct regset
*regset
, int regnum
,
375 void *buf
, size_t size
) const;
377 /* Return REGCACHE's ptid. */
381 gdb_assert (m_ptid
!= minus_one_ptid
);
386 void set_ptid (const ptid_t ptid
)
391 process_stratum_target
*target () const
396 /* Dump the contents of a register from the register cache to the target
398 void debug_print_register (const char *func
, int regno
);
400 static void regcache_thread_ptid_changed (ptid_t old_ptid
, ptid_t new_ptid
);
402 regcache (process_stratum_target
*target
, gdbarch
*gdbarch
,
403 const address_space
*aspace
);
405 static std::forward_list
<regcache
*> current_regcache
;
409 /* Helper function for transfer_regset. Copies across a single register. */
410 void transfer_regset_register (struct regcache
*out_regcache
, int regnum
,
411 const gdb_byte
*in_buf
, gdb_byte
*out_buf
,
412 int slot_size
, int offs
) const;
414 /* Transfer a single or all registers belonging to a certain register
415 set to or from a buffer. This is the main worker function for
416 regcache_supply_regset and regcache_collect_regset. */
417 void transfer_regset (const struct regset
*regset
,
418 struct regcache
*out_regcache
,
419 int regnum
, const gdb_byte
*in_buf
,
420 gdb_byte
*out_buf
, size_t size
) const;
422 /* Perform a partial register transfer using a read, modify, write
424 enum register_status
write_part (int regnum
, int offset
, int len
,
425 const gdb_byte
*in
, bool is_raw
);
427 /* The address space of this register cache (for registers where it
428 makes sense, like PC or SP). */
429 const address_space
* const m_aspace
;
431 /* If this is a read-write cache, which thread's registers is
433 process_stratum_target
*m_target
;
436 friend struct regcache
*
437 get_thread_arch_aspace_regcache (process_stratum_target
*target
, ptid_t ptid
,
438 struct gdbarch
*gdbarch
,
439 struct address_space
*aspace
);
442 registers_changed_ptid (process_stratum_target
*target
, ptid_t ptid
);
445 class readonly_detached_regcache
: public readable_regcache
448 readonly_detached_regcache (regcache
&src
);
450 /* Create a readonly regcache by getting contents from COOKED_READ. */
452 readonly_detached_regcache (gdbarch
*gdbarch
, register_read_ftype cooked_read
)
453 : readable_regcache (gdbarch
, true)
458 DISABLE_COPY_AND_ASSIGN (readonly_detached_regcache
);
460 void raw_update (int regnum
) override
464 extern void registers_changed (void);
465 extern void registers_changed_ptid (process_stratum_target
*target
,
468 /* Indicate that registers of THREAD may have changed, so invalidate
470 extern void registers_changed_thread (thread_info
*thread
);
472 /* An abstract base class for register dump. */
477 void dump (ui_file
*file
);
478 virtual ~register_dump () = default;
481 register_dump (gdbarch
*arch
)
485 /* Dump the register REGNUM contents. If REGNUM is -1, print the
487 virtual void dump_reg (ui_file
*file
, int regnum
) = 0;
492 #endif /* REGCACHE_H */