GDB (xrefs)
Loading...
Searching...
No Matches
regcache.h
Go to the documentation of this file.
1/* Cache and manage the values of registers for GDB, the GNU debugger.
2
3 Copyright (C) 1986-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#ifndef REGCACHE_H
21#define REGCACHE_H
22
23#include "gdbsupport/common-regcache.h"
24#include "gdbsupport/function-view.h"
25
26struct regcache;
27struct regset;
28struct gdbarch;
29struct address_space;
30class thread_info;
32
33extern struct regcache *get_current_regcache (void);
35 ptid_t ptid);
36
37/* Get the regcache of THREAD. */
38extern struct regcache *get_thread_regcache (thread_info *thread);
39
41 (process_stratum_target *targ, ptid_t, struct gdbarch *);
44 struct gdbarch *, struct address_space *);
45
46extern enum register_status
48 int regnum, LONGEST *val);
49
51 int regnum, LONGEST val);
53 int regnum, ULONGEST val);
54
55/* Return the register's value in signed or throw if it's not
56 available. */
57
58extern LONGEST regcache_raw_get_signed (struct regcache *regcache,
59 int regnum);
60
61/* Read a register as a signed/unsigned quantity. */
62extern enum register_status
64 int regnum, LONGEST *val);
65extern enum register_status
67 int regnum, ULONGEST *val);
69 int regnum, LONGEST val);
71 int regnum, ULONGEST val);
72
73/* Special routines to read/write the PC. */
74
75/* For regcache_read_pc see gdbsupport/common-regcache.h. */
76extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc);
77
78/* Mapping between register numbers and offsets in a buffer, for use
79 in the '*regset' functions below and with traditional frame caches.
80 In an array of 'regcache_map_entry' each element is interpreted
81 like follows:
82
83 - If 'regno' is a register number: Map register 'regno' to the
84 current offset (starting with 0) and increase the current offset
85 by 'size' (or the register's size, if 'size' is zero). Repeat
86 this with consecutive register numbers up to 'regno+count-1'.
87
88 For each described register, if 'size' is larger than the
89 register's size, the register's value is assumed to be stored in
90 the first N (where N is the register size) bytes at the current
91 offset. The remaining 'size' - N bytes are filled with zeroes by
92 'regcache_collect_regset' and ignored by other consumers.
93
94 If 'size' is smaller than the register's size, only the first
95 'size' bytes of a register's value are assumed to be stored at
96 the current offset. 'regcache_collect_regset' copies the first
97 'size' bytes of a register's value to the output buffer.
98 'regcache_supply_regset' copies the bytes from the input buffer
99 into the first 'size' bytes of the register's value leaving the
100 remaining bytes of the register's value unchanged. Frame caches
101 read the 'size' bytes from the stack frame and zero extend them
102 to generate the register's value.
103
104 - If 'regno' is REGCACHE_MAP_SKIP: Add 'count*size' to the current
105 offset.
106
107 - If count=0: End of the map. */
108
110{
111 int count;
112 int regno;
113 int size;
114};
115
116/* Special value for the 'regno' field in the struct above. */
117
118enum
119 {
121 };
122
123/* Calculate and return the total size of all the registers in a
124 regcache_map_entry. */
125
126static inline int
128{
129 int size = 0;
130 for (int i = 0; map[i].count != 0; i++)
131 size += (map[i].count * map[i].size);
132 return size;
133}
134
135/* Transfer a set of registers (as described by REGSET) between
136 REGCACHE and BUF. If REGNUM == -1, transfer all registers
137 belonging to the regset, otherwise just the register numbered
138 REGNUM. The REGSET's 'regmap' field must point to an array of
139 'struct regcache_map_entry'.
140
141 These functions are suitable for the 'regset_supply' and
142 'regset_collect' fields in a regset structure. */
143
144extern void regcache_supply_regset (const struct regset *regset,
145 struct regcache *regcache,
146 int regnum, const void *buf,
147 size_t size);
148extern void regcache_collect_regset (const struct regset *regset,
149 const struct regcache *regcache,
150 int regnum, void *buf, size_t size);
151
152
153/* Return true if a set of registers contains the value of the
154 register numbered REGNUM. The size of the set of registers is
155 given in SIZE, and the layout of the set of registers is described
156 by MAP. */
157
158extern bool regcache_map_supplies (const struct regcache_map_entry *map,
159 int regnum, struct gdbarch *gdbarch,
160 size_t size);
161
162/* The type of a register. This function is slightly more efficient
163 then its gdbarch vector counterpart since it returns a precomputed
164 value stored in a table. */
165
166extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
167
168
169/* Return the size of register REGNUM. All registers should have only
170 one size. */
171
172extern int register_size (struct gdbarch *gdbarch, int regnum);
173
174typedef gdb::function_view<register_status (int regnum, gdb_byte *buf)>
176
177/* A (register_number, register_value) pair. */
178
180{
181 int num;
182 gdb_byte *data;
183};
184
185/* Buffer of registers. */
186
187class reg_buffer : public reg_buffer_common
188{
189public:
190 reg_buffer (gdbarch *gdbarch, bool has_pseudo);
191
193
194 /* Return regcache's architecture. */
195 gdbarch *arch () const;
196
197 /* See gdbsupport/common-regcache.h. */
198 enum register_status get_register_status (int regnum) const override;
199
200 /* See gdbsupport/common-regcache.h. */
201 void raw_collect (int regnum, void *buf) const override;
202
203 /* Collect register REGNUM from REGCACHE. Store collected value as an integer
204 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
205 If ADDR_LEN is greater than the register size, then the integer will be
206 sign or zero extended. If ADDR_LEN is smaller than the register size, then
207 the most significant bytes of the integer will be truncated. */
208 void raw_collect_integer (int regnum, gdb_byte *addr, int addr_len,
209 bool is_signed) const;
210
211 /* Collect register REGNUM from REGCACHE, starting at OFFSET in register,
212 reading only LEN. */
213 void raw_collect_part (int regnum, int offset, int len, gdb_byte *out) const;
214
215 /* See gdbsupport/common-regcache.h. */
216 void raw_supply (int regnum, const void *buf) override;
217
218 void raw_supply (int regnum, const reg_buffer &src)
219 {
221 }
222
223 /* Supply register REGNUM to REGCACHE. Value to supply is an integer stored
224 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
225 If the register size is greater than ADDR_LEN, then the integer will be
226 sign or zero extended. If the register size is smaller than the integer,
227 then the most significant bytes of the integer will be truncated. */
228 void raw_supply_integer (int regnum, const gdb_byte *addr, int addr_len,
229 bool is_signed);
230
231 /* Supply register REGNUM with zeroed value to REGCACHE. This is not the same
232 as calling raw_supply with NULL (which will set the state to
233 unavailable). */
234 void raw_supply_zeroed (int regnum);
235
236 /* Supply register REGNUM to REGCACHE, starting at OFFSET in register, writing
237 only LEN, without editing the rest of the register. */
238 void raw_supply_part (int regnum, int offset, int len, const gdb_byte *in);
239
240 void invalidate (int regnum);
241
242 virtual ~reg_buffer () = default;
243
244 /* See gdbsupport/common-regcache.h. */
245 bool raw_compare (int regnum, const void *buf, int offset) const override;
246
247protected:
248 /* Assert on the range of REGNUM. */
249 void assert_regnum (int regnum) const;
250
251 int num_raw_registers () const;
252
253 gdb_byte *register_buffer (int regnum) const;
254
255 /* Save a register cache. The set of registers saved into the
256 regcache determined by the save_reggroup. COOKED_READ returns
257 zero iff the register's value can't be returned. */
258 void save (register_read_ftype cooked_read);
259
261
263 /* The register buffers. */
264 std::unique_ptr<gdb_byte[]> m_registers;
265 /* Register cache status. */
266 std::unique_ptr<register_status[]> m_register_status;
267
268 friend class regcache;
269 friend class detached_regcache;
270};
271
272/* An abstract class which only has methods doing read. */
273
275{
276public:
278 : reg_buffer (gdbarch, has_pseudo)
279 {}
280
281 /* Transfer a raw register [0..NUM_REGS) from core-gdb to this regcache,
282 return its value in *BUF and return its availability status. */
283
284 enum register_status raw_read (int regnum, gdb_byte *buf);
285 template<typename T, typename = RequireLongest<T>>
286 enum register_status raw_read (int regnum, T *val);
287
288 /* Partial transfer of raw registers. Return the status of the register. */
289 enum register_status raw_read_part (int regnum, int offset, int len,
290 gdb_byte *buf);
291
292 /* Make certain that the register REGNUM is up-to-date. */
293 virtual void raw_update (int regnum) = 0;
294
295 /* Transfer a raw register [0..NUM_REGS+NUM_PSEUDO_REGS) from core-gdb to
296 this regcache, return its value in *BUF and return its availability status. */
297 enum register_status cooked_read (int regnum, gdb_byte *buf);
298 template<typename T, typename = RequireLongest<T>>
299 enum register_status cooked_read (int regnum, T *val);
300
301 /* Partial transfer of a cooked register. */
302 enum register_status cooked_read_part (int regnum, int offset, int len,
303 gdb_byte *buf);
304
305 /* Read register REGNUM from the regcache and return a new value. This
306 will call mark_value_bytes_unavailable as appropriate. */
307 struct value *cooked_read_value (int regnum);
308
309protected:
310
311 /* Perform a partial register transfer using a read, modify, write
312 operation. Will fail if register is currently invalid. */
313 enum register_status read_part (int regnum, int offset, int len,
314 gdb_byte *out, bool is_raw);
315};
316
317/* Buffer of registers, can be read and written. */
318
320{
321public:
323 : readable_regcache (gdbarch, has_pseudo)
324 {}
325
326 void raw_update (int regnum) override
327 {}
328
330};
331
333
334/* The register cache for storing raw register values. */
335
337{
338public:
340
341 /* Return REGCACHE's address space. */
342 const address_space *aspace () const
343 {
344 return m_aspace;
345 }
346
347 /* Restore 'this' regcache. The set of registers restored into
348 the regcache determined by the restore_reggroup.
349 Writes to regcache will go through to the target. SRC is a
350 read-only register cache. */
352
353 /* Update the value of raw register REGNUM (in the range [0..NUM_REGS)) and
354 transfer its value to core-gdb. */
355
356 void raw_write (int regnum, const gdb_byte *buf);
357
358 template<typename T, typename = RequireLongest<T>>
359 void raw_write (int regnum, T val);
360
361 /* Transfer of pseudo-registers. */
362 void cooked_write (int regnum, const gdb_byte *buf);
363
364 template<typename T, typename = RequireLongest<T>>
365 void cooked_write (int regnum, T val);
366
367 void raw_update (int regnum) override;
368
369 /* Partial transfer of raw registers. Perform read, modify, write style
370 operations. */
371 void raw_write_part (int regnum, int offset, int len, const gdb_byte *buf);
372
373 /* Partial transfer of a cooked register. Perform read, modify, write style
374 operations. */
375 void cooked_write_part (int regnum, int offset, int len,
376 const gdb_byte *buf);
377
378 /* Transfer a set of registers (as described by REGSET) between
379 REGCACHE and BUF. If REGNUM == -1, transfer all registers
380 belonging to the regset, otherwise just the register numbered
381 REGNUM. The REGSET's 'regmap' field must point to an array of
382 'struct regcache_map_entry'. The valid register numbers in each
383 entry in 'struct regcache_map_entry' are offset by REGBASE. */
384
385 void supply_regset (const struct regset *regset, int regbase,
386 int regnum, const void *buf, size_t size);
387
388 void collect_regset (const struct regset *regset, int regbase, int regnum,
389 void *buf, size_t size) const;
390
391 /* Same as the above, but with REGBASE == 0. */
392
393 void supply_regset (const struct regset *regset,
394 int regnum, const void *buf, size_t size)
395 {
396 supply_regset (regset, 0, regnum, buf, size);
397 }
398
399 void collect_regset (const struct regset *regset, int regnum,
400 void *buf, size_t size) const
401 {
402 collect_regset (regset, 0, regnum, buf, size);
403 }
404
405 /* Return REGCACHE's ptid. */
406
407 ptid_t ptid () const
408 {
409 gdb_assert (m_ptid != minus_one_ptid);
410
411 return m_ptid;
412 }
413
414 void set_ptid (const ptid_t ptid)
415 {
416 this->m_ptid = ptid;
417 }
418
420 {
421 return m_target;
422 }
423
424/* Dump the contents of a register from the register cache to the target
425 debug. */
426 void debug_print_register (const char *func, int regno);
427
428protected:
430 const address_space *aspace);
431
432private:
433
434 /* Helper function for transfer_regset. Copies across a single register. */
435 void transfer_regset_register (struct regcache *out_regcache, int regnum,
436 const gdb_byte *in_buf, gdb_byte *out_buf,
437 int slot_size, int offs) const;
438
439 /* Transfer a single or all registers belonging to a certain register
440 set to or from a buffer. This is the main worker function for
441 regcache_supply_regset and regcache_collect_regset. */
442 void transfer_regset (const struct regset *regset, int regbase,
443 struct regcache *out_regcache,
444 int regnum, const gdb_byte *in_buf,
445 gdb_byte *out_buf, size_t size) const;
446
447 /* Perform a partial register transfer using a read, modify, write
448 operation. */
449 enum register_status write_part (int regnum, int offset, int len,
450 const gdb_byte *in, bool is_raw);
451
452 /* The address space of this register cache (for registers where it
453 makes sense, like PC or SP). */
454 const address_space * const m_aspace;
455
456 /* If this is a read-write cache, which thread's registers is
457 it connected to? */
459 ptid_t m_ptid;
460
461 friend struct regcache *
463 struct gdbarch *gdbarch,
464 struct address_space *aspace);
465};
466
467using regcache_up = std::unique_ptr<regcache>;
468
470{
471public:
473
474 /* Create a readonly regcache by getting contents from COOKED_READ. */
475
477 : readable_regcache (gdbarch, true)
478 {
480 }
481
483
484 void raw_update (int regnum) override
485 {}
486};
487
488extern void registers_changed (void);
490 ptid_t ptid);
491
492/* Indicate that registers of THREAD may have changed, so invalidate
493 the cache. */
494extern void registers_changed_thread (thread_info *thread);
495
496/* An abstract base class for register dump. */
497
499{
500public:
501 void dump (ui_file *file);
502 virtual ~register_dump () = default;
503
504protected:
506 : m_gdbarch (arch)
507 {}
508
509 /* Dump the register REGNUM contents. If REGNUM is -1, print the
510 header. */
511 virtual void dump_reg (ui_file *file, int regnum) = 0;
512
514};
515
516#endif /* REGCACHE_H */
int regnum
DISABLE_COPY_AND_ASSIGN(detached_regcache)
void raw_update(int regnum) override
Definition regcache.h:326
detached_regcache(gdbarch *gdbarch, bool has_pseudo)
Definition regcache.h:322
virtual void raw_update(int regnum)=0
enum register_status raw_read(int regnum, gdb_byte *buf)
Definition regcache.c:605
struct value * cooked_read_value(int regnum)
Definition regcache.c:735
enum register_status read_part(int regnum, int offset, int len, gdb_byte *out, bool is_raw)
Definition regcache.c:875
enum register_status cooked_read_part(int regnum, int offset, int len, gdb_byte *buf)
Definition regcache.c:1033
enum register_status raw_read_part(int regnum, int offset, int len, gdb_byte *buf)
Definition regcache.c:1013
enum register_status cooked_read(int regnum, gdb_byte *buf)
Definition regcache.c:692
readable_regcache(gdbarch *gdbarch, bool has_pseudo)
Definition regcache.h:277
readonly_detached_regcache(gdbarch *gdbarch, register_read_ftype cooked_read)
Definition regcache.h:476
DISABLE_COPY_AND_ASSIGN(readonly_detached_regcache)
void raw_update(int regnum) override
Definition regcache.h:484
void raw_supply(int regnum, const reg_buffer &src)
Definition regcache.h:218
gdb_byte * register_buffer(int regnum) const
Definition regcache.c:238
gdbarch * arch() const
Definition regcache.c:230
void raw_collect_integer(int regnum, gdb_byte *addr, int addr_len, bool is_signed) const
Definition regcache.c:1134
void raw_supply_integer(int regnum, const gdb_byte *addr, int addr_len, bool is_signed)
Definition regcache.c:1081
void assert_regnum(int regnum) const
Definition regcache.c:318
bool m_has_pseudo
Definition regcache.h:262
void invalidate(int regnum)
Definition regcache.c:311
void raw_collect(int regnum, void *buf) const override
Definition regcache.c:1118
std::unique_ptr< gdb_byte[]> m_registers
Definition regcache.h:264
void raw_supply(int regnum, const void *buf) override
Definition regcache.c:1053
void raw_supply_part(int regnum, int offset, int len, const gdb_byte *in)
Definition regcache.c:981
DISABLE_COPY_AND_ASSIGN(reg_buffer)
int num_raw_registers() const
Definition regcache.c:1386
enum register_status get_register_status(int regnum) const override
Definition regcache.c:303
std::unique_ptr< register_status[]> m_register_status
Definition regcache.h:266
void raw_supply_zeroed(int regnum)
Definition regcache.c:1101
bool raw_compare(int regnum, const void *buf, int offset) const override
Definition regcache.c:1309
struct regcache_descr * m_descr
Definition regcache.h:260
void raw_collect_part(int regnum, int offset, int len, gdb_byte *out) const
Definition regcache.c:912
virtual ~reg_buffer()=default
void save(register_read_ftype cooked_read)
Definition regcache.c:244
void cooked_write(int regnum, const gdb_byte *buf)
Definition regcache.c:861
void raw_write_part(int regnum, int offset, int len, const gdb_byte *buf)
Definition regcache.c:1023
process_stratum_target * m_target
Definition regcache.h:458
void collect_regset(const struct regset *regset, int regnum, void *buf, size_t size) const
Definition regcache.h:399
void cooked_write_part(int regnum, int offset, int len, const gdb_byte *buf)
Definition regcache.c:1043
void raw_write(int regnum, const gdb_byte *buf)
Definition regcache.c:827
void transfer_regset_register(struct regcache *out_regcache, int regnum, const gdb_byte *in_buf, gdb_byte *out_buf, int slot_size, int offs) const
Definition regcache.c:1153
void raw_update(int regnum) override
Definition regcache.c:583
void transfer_regset(const struct regset *regset, int regbase, struct regcache *out_regcache, int regnum, const gdb_byte *in_buf, gdb_byte *out_buf, size_t size) const
Definition regcache.c:1188
void collect_regset(const struct regset *regset, int regbase, int regnum, void *buf, size_t size) const
Definition regcache.c:1274
ptid_t ptid() const
Definition regcache.h:407
const address_space * aspace() const
Definition regcache.h:342
void restore(readonly_detached_regcache *src)
Definition regcache.c:276
process_stratum_target * target() const
Definition regcache.h:419
friend struct regcache * get_thread_arch_aspace_regcache(process_stratum_target *target, ptid_t ptid, struct gdbarch *gdbarch, struct address_space *aspace)
Definition regcache.c:351
void debug_print_register(const char *func, int regno)
Definition regcache.c:1392
enum register_status write_part(int regnum, int offset, int len, const gdb_byte *in, bool is_raw)
Definition regcache.c:942
const address_space *const m_aspace
Definition regcache.h:454
void supply_regset(const struct regset *regset, int regnum, const void *buf, size_t size)
Definition regcache.h:393
DISABLE_COPY_AND_ASSIGN(regcache)
ptid_t m_ptid
Definition regcache.h:459
void set_ptid(const ptid_t ptid)
Definition regcache.h:414
void supply_regset(const struct regset *regset, int regbase, int regnum, const void *buf, size_t size)
Definition regcache.c:1252
register_dump(gdbarch *arch)
Definition regcache.h:505
virtual ~register_dump()=default
gdbarch * m_gdbarch
Definition regcache.h:513
virtual void dump_reg(ui_file *file, int regnum)=0
void dump(ui_file *file)
Definition regcache.c:1437
size_t size
Definition go32-nat.c:241
void registers_changed_ptid(process_stratum_target *target, ptid_t ptid)
Definition regcache.c:494
enum register_status regcache_raw_read_signed(struct regcache *regcache, int regnum, LONGEST *val)
Definition regcache.c:620
enum register_status regcache_cooked_read_signed(struct regcache *regcache, int regnum, LONGEST *val)
Definition regcache.c:766
void regcache_raw_write_signed(struct regcache *regcache, int regnum, LONGEST val)
Definition regcache.c:651
void regcache_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *buf, size_t size)
Definition regcache.c:1264
int register_size(struct gdbarch *gdbarch, int regnum)
Definition regcache.c:170
struct regcache * get_thread_arch_regcache(process_stratum_target *targ, ptid_t, struct gdbarch *)
Definition regcache.c:382
void regcache_cooked_write_signed(struct regcache *regcache, int regnum, LONGEST val)
Definition regcache.c:798
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition regcache.c:790
bool regcache_map_supplies(const struct regcache_map_entry *map, int regnum, struct gdbarch *gdbarch, size_t size)
Definition regcache.c:1282
LONGEST regcache_raw_get_signed(struct regcache *regcache, int regnum)
Definition regcache.c:679
void regcache_raw_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition regcache.c:671
void registers_changed_thread(thread_info *thread)
Definition regcache.c:571
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition regcache.c:1368
@ REGCACHE_MAP_SKIP
Definition regcache.h:120
struct regcache * get_thread_arch_aspace_regcache(process_stratum_target *target, ptid_t, struct gdbarch *, struct address_space *)
Definition regcache.c:351
struct regcache * get_current_regcache(void)
Definition regcache.c:426
static int regcache_map_entry_size(const struct regcache_map_entry *map)
Definition regcache.h:127
gdb::function_view< register_status(int regnum, gdb_byte *buf)> register_read_ftype
Definition regcache.h:175
struct regcache * get_thread_regcache(process_stratum_target *target, ptid_t ptid)
Definition regcache.c:397
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition regcache.c:819
void registers_changed(void)
Definition regcache.c:577
void regcache_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *buf, size_t size)
Definition regcache.c:1242
std::unique_ptr< regcache > regcache_up
Definition regcache.h:467
struct type * register_type(struct gdbarch *gdbarch, int regnum)
Definition regcache.c:158
void(* func)(remote_target *remote, char *)
Definition 1.cc:26
gdb_byte * data
Definition regcache.h:182
Definition regcache.h:110
int count
Definition regcache.h:111
int regno
Definition regcache.h:112
int size
Definition regcache.h:113
Definition value.c:181