GDB (xrefs)
/tmp/gdb-7.10/gdb/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-2015 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 "common-regcache.h"
24 
25 struct regcache;
26 struct regset;
27 struct gdbarch;
28 struct address_space;
29 
30 extern struct regcache *get_current_regcache (void);
31 extern struct regcache *get_thread_regcache (ptid_t ptid);
32 extern struct regcache *get_thread_arch_regcache (ptid_t, struct gdbarch *);
34  struct gdbarch *,
35  struct address_space *);
36 
37 void regcache_xfree (struct regcache *regcache);
39 struct regcache *regcache_xmalloc (struct gdbarch *gdbarch,
40  struct address_space *aspace);
41 
42 /* Return REGCACHE's architecture. */
43 
44 extern struct gdbarch *get_regcache_arch (const struct regcache *regcache);
45 
46 /* Return REGCACHE's address space. */
47 
48 extern struct address_space *get_regcache_aspace (const struct regcache *);
49 
51  {
52  /* The register value is not in the cache, and we don't know yet
53  whether it's available in the target (or traceframe). */
55 
56  /* The register value is valid and cached. */
57  REG_VALID = 1,
58 
59  /* The register value is unavailable. E.g., we're inspecting a
60  traceframe, and this register wasn't collected. Note that this
61  is different a different "unavailable" from saying the register
62  does not exist in the target's architecture --- in that case,
63  the target should have given us a target description that does
64  not include the register in the first place. */
66  };
67 
69  int regnum);
70 
71 /* Transfer a raw register [0..NUM_REGS) between core-gdb and the
72  regcache. The read variants return the status of the register. */
73 
75  int rawnum, gdb_byte *buf);
76 void regcache_raw_write (struct regcache *regcache, int rawnum,
77  const gdb_byte *buf);
78 extern enum register_status
80  int regnum, LONGEST *val);
81 extern enum register_status
83  int regnum, ULONGEST *val);
84 extern void regcache_raw_write_signed (struct regcache *regcache,
85  int regnum, LONGEST val);
86 extern void regcache_raw_write_unsigned (struct regcache *regcache,
87  int regnum, ULONGEST val);
88 
89 /* Partial transfer of raw registers. These perform read, modify,
90  write style operations. The read variant returns the status of the
91  register. */
92 
93 extern enum register_status
95  int offset, int len, gdb_byte *buf);
97  int offset, int len, const gdb_byte *buf);
98 
99 void regcache_invalidate (struct regcache *regcache, int regnum);
100 
101 /* Transfer of pseudo-registers. The read variants return a register
102  status, as an indication of when a ``cooked'' register was
103  constructed from valid, invalid or unavailable ``raw''
104  registers. */
105 
106 /* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
108  int rawnum, gdb_byte *buf);
109 void regcache_cooked_write (struct regcache *regcache, int rawnum,
110  const gdb_byte *buf);
111 
112 /* Read register REGNUM from REGCACHE and return a new value. This
113  will call mark_value_bytes_unavailable as appropriate. */
114 
116  int regnum);
117 
118 /* Read a register as a signed/unsigned quantity. */
119 extern enum register_status
121  int regnum, LONGEST *val);
122 extern enum register_status
124  int regnum, ULONGEST *val);
125 extern void regcache_cooked_write_signed (struct regcache *regcache,
126  int regnum, LONGEST val);
128  int regnum, ULONGEST val);
129 
130 /* Partial transfer of a cooked register. These perform read, modify,
131  write style operations. */
132 
134  int regnum, int offset,
135  int len, gdb_byte *buf);
137  int offset, int len, const gdb_byte *buf);
138 
139 /* Special routines to read/write the PC. */
140 
141 /* For regcache_read_pc see common/common-regcache.h. */
142 extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc);
143 
144 /* Transfer a raw register [0..NUM_REGS) between the regcache and the
145  target. These functions are called by the target in response to a
146  target_fetch_registers() or target_store_registers(). */
147 
148 extern void regcache_raw_supply (struct regcache *regcache,
149  int regnum, const void *buf);
150 extern void regcache_raw_collect (const struct regcache *regcache,
151  int regnum, void *buf);
152 
153 /* Mapping between register numbers and offsets in a buffer, for use
154  in the '*regset' functions below. In an array of
155  'regcache_map_entry' each element is interpreted like follows:
156 
157  - If 'regno' is a register number: Map register 'regno' to the
158  current offset (starting with 0) and increase the current offset
159  by 'size' (or the register's size, if 'size' is zero). Repeat
160  this with consecutive register numbers up to 'regno+count-1'.
161 
162  - If 'regno' is REGCACHE_MAP_SKIP: Add 'count*size' to the current
163  offset.
164 
165  - If count=0: End of the map. */
166 
168 {
169  int count;
170  int regno;
171  int size;
172 };
173 
174 /* Special value for the 'regno' field in the struct above. */
175 
176 enum
177  {
179  };
180 
181 /* Transfer a set of registers (as described by REGSET) between
182  REGCACHE and BUF. If REGNUM == -1, transfer all registers
183  belonging to the regset, otherwise just the register numbered
184  REGNUM. The REGSET's 'regmap' field must point to an array of
185  'struct regcache_map_entry'.
186 
187  These functions are suitable for the 'regset_supply' and
188  'regset_collect' fields in a regset structure. */
189 
190 extern void regcache_supply_regset (const struct regset *regset,
191  struct regcache *regcache,
192  int regnum, const void *buf,
193  size_t size);
194 extern void regcache_collect_regset (const struct regset *regset,
195  const struct regcache *regcache,
196  int regnum, void *buf, size_t size);
197 
198 
199 /* The type of a register. This function is slightly more efficient
200  then its gdbarch vector counterpart since it returns a precomputed
201  value stored in a table. */
202 
203 extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
204 
205 
206 /* Return the size of register REGNUM. All registers should have only
207  one size. */
208 
209 extern int register_size (struct gdbarch *gdbarch, int regnum);
210 
211 
212 /* Save/restore a register cache. The set of registers saved /
213  restored into the DST regcache determined by the save_reggroup /
214  restore_reggroup respectively. COOKED_READ returns zero iff the
215  register's value can't be returned. */
216 
217 typedef enum register_status (regcache_cooked_read_ftype) (void *src,
218  int regnum,
219  gdb_byte *buf);
220 
221 extern void regcache_save (struct regcache *dst,
222  regcache_cooked_read_ftype *cooked_read,
223  void *cooked_read_context);
224 
225 /* Copy/duplicate the contents of a register cache. By default, the
226  operation is pass-through. Writes to DST and reads from SRC will
227  go through to the target. See also regcache_cpy_no_passthrough.
228 
229  regcache_cpy can not have overlapping SRC and DST buffers. */
230 
231 extern struct regcache *regcache_dup (struct regcache *regcache);
232 extern void regcache_cpy (struct regcache *dest, struct regcache *src);
233 
234 extern void registers_changed (void);
235 extern void registers_changed_ptid (ptid_t);
236 
237 #endif /* REGCACHE_H */
enum register_status regcache_raw_read(struct regcache *regcache, int rawnum, gdb_byte *buf)
Definition: regcache.c:637
struct address_space * get_regcache_aspace(const struct regcache *)
Definition: regcache.c:303
bfd_vma CORE_ADDR
Definition: common-types.h:41
void regcache_raw_collect(const struct regcache *regcache, int regnum, void *buf)
Definition: regcache.c:1071
void regcache_cooked_write(struct regcache *regcache, int rawnum, const gdb_byte *buf)
Definition: regcache.c:930
struct regcache * get_current_regcache(void)
Definition: regcache.c:541
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:871
struct cleanup * make_cleanup_regcache_xfree(struct regcache *regcache)
Definition: regcache.c:263
void regcache_collect_regset(const struct regset *regset, const struct regcache *regcache, int regnum, void *buf, size_t size)
Definition: regcache.c:1162
void regcache_cooked_write_signed(struct regcache *regcache, int regnum, LONGEST val)
Definition: regcache.c:857
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:837
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:529
int count
Definition: regcache.h:169
struct value * regcache_cooked_read_value(struct regcache *regcache, int regnum)
Definition: regcache.c:784
void regcache_save(struct regcache *dst, regcache_cooked_read_ftype *cooked_read, void *cooked_read_context)
Definition: regcache.c:317
Definition: ptid.h:35
void regcache_raw_write_signed(struct regcache *regcache, int regnum, LONGEST val)
Definition: regcache.c:710
enum register_status regcache_cooked_read_signed(struct regcache *regcache, int regnum, LONGEST *val)
Definition: regcache.c:817
struct type * register_type(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:157
Definition: regset.h:34
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition: regcache.c:1201
struct regcache * get_thread_arch_regcache(ptid_t, struct gdbarch *)
Definition: regcache.c:508
enum register_status regcache_cooked_read_part(struct regcache *regcache, int regnum, int offset, int len, gdb_byte *buf)
Definition: regcache.c:1017
enum register_status regcache_raw_read_signed(struct regcache *regcache, int regnum, LONGEST *val)
Definition: regcache.c:671
register_status
Definition: regcache.h:50
void regcache_cooked_write_part(struct regcache *regcache, int regnum, int offset, int len, const gdb_byte *buf)
Definition: regcache.c:1028
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1041
int size
Definition: regcache.h:171
enum register_status regcache_raw_read_part(struct regcache *regcache, int regnum, int offset, int len, gdb_byte *buf)
Definition: regcache.c:995
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
void regcache_raw_write(struct regcache *regcache, int rawnum, const gdb_byte *buf)
Definition: regcache.c:885
Definition: gdbtypes.h:749
void regcache_invalidate(struct regcache *regcache, int regnum)
Definition: regcache.c:459
int regnum
Definition: aarch64-tdep.c:69
void registers_changed(void)
Definition: regcache.c:624
enum register_status regcache_register_status(const struct regcache *regcache, int regnum)
Definition: regcache.c:446
struct regcache * regcache_xmalloc(struct gdbarch *gdbarch, struct address_space *aspace)
Definition: regcache.c:241
Definition: value.c:172
void regcache_raw_write_part(struct regcache *regcache, int regnum, int offset, int len, const gdb_byte *buf)
Definition: regcache.c:1006
bfd_byte gdb_byte
Definition: common-types.h:38
void registers_changed_ptid(ptid_t)
Definition: regcache.c:586
void regcache_cpy(struct regcache *dest, struct regcache *src)
Definition: regcache.c:398
struct regcache * get_thread_arch_aspace_regcache(ptid_t, struct gdbarch *, struct address_space *)
Definition: regcache.c:485
void regcache_xfree(struct regcache *regcache)
Definition: regcache.c:247
struct regcache * regcache_dup(struct regcache *regcache)
Definition: regcache.c:436
int offset
Definition: agent.c:65
struct address_space * aspace
Definition: regcache.c:189
enum register_status() regcache_cooked_read_ftype(void *src, int regnum, gdb_byte *buf)
void regcache_raw_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:723
unsigned long long ULONGEST
Definition: common-types.h:53
enum register_status regcache_cooked_read(struct regcache *regcache, int rawnum, gdb_byte *buf)
Definition: regcache.c:737
int regno
Definition: regcache.h:170
enum register_status regcache_raw_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:690
void regcache_supply_regset(const struct regset *regset, struct regcache *regcache, int regnum, const void *buf, size_t size)
Definition: regcache.c:1149
size_t size
Definition: go32-nat.c:242
long long LONGEST
Definition: common-types.h:52
Definition: regcache.h:167
const ULONGEST const LONGEST len
Definition: target.h:309