1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986-2016 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 "common-regcache.h"
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
*);
33 extern struct regcache
*get_thread_arch_aspace_regcache (ptid_t
,
35 struct address_space
*);
37 void regcache_xfree (struct regcache
*regcache
);
38 struct cleanup
*make_cleanup_regcache_xfree (struct regcache
*regcache
);
39 struct regcache
*regcache_xmalloc (struct gdbarch
*gdbarch
,
40 struct address_space
*aspace
);
42 /* Return REGCACHE's architecture. */
44 extern struct gdbarch
*get_regcache_arch (const struct regcache
*regcache
);
46 /* Return REGCACHE's address space. */
48 extern struct address_space
*get_regcache_aspace (const struct regcache
*);
50 enum register_status
regcache_register_status (const struct regcache
*regcache
,
53 /* Transfer a raw register [0..NUM_REGS) between core-gdb and the
54 regcache. The read variants return the status of the register. */
56 enum register_status
regcache_raw_read (struct regcache
*regcache
,
57 int rawnum
, gdb_byte
*buf
);
58 void regcache_raw_write (struct regcache
*regcache
, int rawnum
,
60 extern enum register_status
61 regcache_raw_read_signed (struct regcache
*regcache
,
62 int regnum
, LONGEST
*val
);
64 extern void regcache_raw_write_signed (struct regcache
*regcache
,
65 int regnum
, LONGEST val
);
66 extern void regcache_raw_write_unsigned (struct regcache
*regcache
,
67 int regnum
, ULONGEST val
);
69 /* Partial transfer of raw registers. These perform read, modify,
70 write style operations. The read variant returns the status of the
73 extern enum register_status
74 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
75 int offset
, int len
, gdb_byte
*buf
);
76 void regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
77 int offset
, int len
, const gdb_byte
*buf
);
79 void regcache_invalidate (struct regcache
*regcache
, int regnum
);
81 /* Transfer of pseudo-registers. The read variants return a register
82 status, as an indication of when a ``cooked'' register was
83 constructed from valid, invalid or unavailable ``raw''
86 /* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
87 enum register_status
regcache_cooked_read (struct regcache
*regcache
,
88 int rawnum
, gdb_byte
*buf
);
89 void regcache_cooked_write (struct regcache
*regcache
, int rawnum
,
92 /* Read register REGNUM from REGCACHE and return a new value. This
93 will call mark_value_bytes_unavailable as appropriate. */
95 struct value
*regcache_cooked_read_value (struct regcache
*regcache
,
98 /* Read a register as a signed/unsigned quantity. */
99 extern enum register_status
100 regcache_cooked_read_signed (struct regcache
*regcache
,
101 int regnum
, LONGEST
*val
);
102 extern enum register_status
103 regcache_cooked_read_unsigned (struct regcache
*regcache
,
104 int regnum
, ULONGEST
*val
);
105 extern void regcache_cooked_write_signed (struct regcache
*regcache
,
106 int regnum
, LONGEST val
);
107 extern void regcache_cooked_write_unsigned (struct regcache
*regcache
,
108 int regnum
, ULONGEST val
);
110 /* Partial transfer of a cooked register. These perform read, modify,
111 write style operations. */
113 enum register_status
regcache_cooked_read_part (struct regcache
*regcache
,
114 int regnum
, int offset
,
115 int len
, gdb_byte
*buf
);
116 void regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
117 int offset
, int len
, const gdb_byte
*buf
);
119 /* Special routines to read/write the PC. */
121 /* For regcache_read_pc see common/common-regcache.h. */
122 extern void regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
);
124 /* Transfer a raw register [0..NUM_REGS) between the regcache and the
125 target. These functions are called by the target in response to a
126 target_fetch_registers() or target_store_registers(). */
128 extern void regcache_raw_supply (struct regcache
*regcache
,
129 int regnum
, const void *buf
);
130 extern void regcache_raw_collect (const struct regcache
*regcache
,
131 int regnum
, void *buf
);
133 /* Mapping between register numbers and offsets in a buffer, for use
134 in the '*regset' functions below. In an array of
135 'regcache_map_entry' each element is interpreted like follows:
137 - If 'regno' is a register number: Map register 'regno' to the
138 current offset (starting with 0) and increase the current offset
139 by 'size' (or the register's size, if 'size' is zero). Repeat
140 this with consecutive register numbers up to 'regno+count-1'.
142 - If 'regno' is REGCACHE_MAP_SKIP: Add 'count*size' to the current
145 - If count=0: End of the map. */
147 struct regcache_map_entry
154 /* Special value for the 'regno' field in the struct above. */
158 REGCACHE_MAP_SKIP
= -1,
161 /* Transfer a set of registers (as described by REGSET) between
162 REGCACHE and BUF. If REGNUM == -1, transfer all registers
163 belonging to the regset, otherwise just the register numbered
164 REGNUM. The REGSET's 'regmap' field must point to an array of
165 'struct regcache_map_entry'.
167 These functions are suitable for the 'regset_supply' and
168 'regset_collect' fields in a regset structure. */
170 extern void regcache_supply_regset (const struct regset
*regset
,
171 struct regcache
*regcache
,
172 int regnum
, const void *buf
,
174 extern void regcache_collect_regset (const struct regset
*regset
,
175 const struct regcache
*regcache
,
176 int regnum
, void *buf
, size_t size
);
179 /* The type of a register. This function is slightly more efficient
180 then its gdbarch vector counterpart since it returns a precomputed
181 value stored in a table. */
183 extern struct type
*register_type (struct gdbarch
*gdbarch
, int regnum
);
186 /* Return the size of register REGNUM. All registers should have only
189 extern int register_size (struct gdbarch
*gdbarch
, int regnum
);
192 /* Save/restore a register cache. The set of registers saved /
193 restored into the DST regcache determined by the save_reggroup /
194 restore_reggroup respectively. COOKED_READ returns zero iff the
195 register's value can't be returned. */
197 typedef enum register_status (regcache_cooked_read_ftype
) (void *src
,
201 extern void regcache_save (struct regcache
*dst
,
202 regcache_cooked_read_ftype
*cooked_read
,
203 void *cooked_read_context
);
205 /* Copy/duplicate the contents of a register cache. By default, the
206 operation is pass-through. Writes to DST and reads from SRC will
207 go through to the target. See also regcache_cpy_no_passthrough.
209 regcache_cpy can not have overlapping SRC and DST buffers. */
211 extern struct regcache
*regcache_dup (struct regcache
*regcache
);
212 extern void regcache_cpy (struct regcache
*dest
, struct regcache
*src
);
214 extern void registers_changed (void);
215 extern void registers_changed_ptid (ptid_t
);
217 #endif /* REGCACHE_H */