1 /* Cache and manage the values of registers for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
4 2002, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
28 extern struct regcache
*get_current_regcache (void);
29 extern struct regcache
*get_thread_regcache (ptid_t ptid
);
30 extern struct regcache
*get_thread_arch_regcache (ptid_t
, struct gdbarch
*);
32 void regcache_xfree (struct regcache
*regcache
);
33 struct cleanup
*make_cleanup_regcache_xfree (struct regcache
*regcache
);
34 struct regcache
*regcache_xmalloc (struct gdbarch
*gdbarch
,
35 struct address_space
*aspace
);
37 /* Return REGCACHE's architecture. */
39 extern struct gdbarch
*get_regcache_arch (const struct regcache
*regcache
);
41 /* Return REGCACHE's address space. */
43 extern struct address_space
*get_regcache_aspace (const struct regcache
*);
47 /* The register value is not in the cache, and we don't know yet
48 whether it's available in the target (or traceframe). */
51 /* The register value is valid and cached. */
54 /* The register value is unavailable. E.g., we're inspecting a
55 traceframe, and this register wasn't collected. Note that this
56 is different a different "unavailable" from saying the register
57 does not exist in the target's architecture --- in that case,
58 the target should have given us a target description that does
59 not include the register in the first place. */
63 enum register_status
regcache_register_status (const struct regcache
*regcache
,
66 /* Transfer a raw register [0..NUM_REGS) between core-gdb and the
67 regcache. The read variants return the status of the register. */
69 enum register_status
regcache_raw_read (struct regcache
*regcache
,
70 int rawnum
, gdb_byte
*buf
);
71 void regcache_raw_write (struct regcache
*regcache
, int rawnum
,
73 extern enum register_status
74 regcache_raw_read_signed (struct regcache
*regcache
,
75 int regnum
, LONGEST
*val
);
76 extern enum register_status
77 regcache_raw_read_unsigned (struct regcache
*regcache
,
78 int regnum
, ULONGEST
*val
);
79 extern void regcache_raw_write_signed (struct regcache
*regcache
,
80 int regnum
, LONGEST val
);
81 extern void regcache_raw_write_unsigned (struct regcache
*regcache
,
82 int regnum
, ULONGEST val
);
84 /* Partial transfer of raw registers. These perform read, modify,
85 write style operations. The read variant returns the status of the
88 extern enum register_status
89 regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
90 int offset
, int len
, gdb_byte
*buf
);
91 void regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
92 int offset
, int len
, const gdb_byte
*buf
);
94 void regcache_invalidate (struct regcache
*regcache
, int regnum
);
96 /* Transfer of pseudo-registers. The read variants return a register
97 status, as an indication of when a ``cooked'' register was
98 constructed from valid, invalid or unavailable ``raw''
101 /* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
102 enum register_status
regcache_cooked_read (struct regcache
*regcache
,
103 int rawnum
, gdb_byte
*buf
);
104 void regcache_cooked_write (struct regcache
*regcache
, int rawnum
,
105 const gdb_byte
*buf
);
107 /* Read register REGNUM from REGCACHE and return a new value. This
108 will call mark_value_bytes_unavailable as appropriate. */
110 struct value
*regcache_cooked_read_value (struct regcache
*regcache
,
113 /* Read a register as a signed/unsigned quantity. */
114 extern enum register_status
115 regcache_cooked_read_signed (struct regcache
*regcache
,
116 int regnum
, LONGEST
*val
);
117 extern enum register_status
118 regcache_cooked_read_unsigned (struct regcache
*regcache
,
119 int regnum
, ULONGEST
*val
);
120 extern void regcache_cooked_write_signed (struct regcache
*regcache
,
121 int regnum
, LONGEST val
);
122 extern void regcache_cooked_write_unsigned (struct regcache
*regcache
,
123 int regnum
, ULONGEST val
);
125 /* Partial transfer of a cooked register. These perform read, modify,
126 write style operations. */
128 enum register_status
regcache_cooked_read_part (struct regcache
*regcache
,
129 int regnum
, int offset
,
130 int len
, gdb_byte
*buf
);
131 void regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
132 int offset
, int len
, const gdb_byte
*buf
);
134 /* Special routines to read/write the PC. */
136 extern CORE_ADDR
regcache_read_pc (struct regcache
*regcache
);
137 extern void regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
);
139 /* Transfer a raw register [0..NUM_REGS) between the regcache and the
140 target. These functions are called by the target in response to a
141 target_fetch_registers() or target_store_registers(). */
143 extern void regcache_raw_supply (struct regcache
*regcache
,
144 int regnum
, const void *buf
);
145 extern void regcache_raw_collect (const struct regcache
*regcache
,
146 int regnum
, void *buf
);
149 /* The type of a register. This function is slightly more efficient
150 then its gdbarch vector counterpart since it returns a precomputed
151 value stored in a table. */
153 extern struct type
*register_type (struct gdbarch
*gdbarch
, int regnum
);
156 /* Return the size of register REGNUM. All registers should have only
159 extern int register_size (struct gdbarch
*gdbarch
, int regnum
);
162 /* Save/restore a register cache. The set of registers saved /
163 restored into the DST regcache determined by the save_reggroup /
164 restore_reggroup respectively. COOKED_READ returns zero iff the
165 register's value can't be returned. */
167 typedef enum register_status (regcache_cooked_read_ftype
) (void *src
,
171 extern void regcache_save (struct regcache
*dst
,
172 regcache_cooked_read_ftype
*cooked_read
,
173 void *cooked_read_context
);
174 extern void regcache_restore (struct regcache
*dst
,
175 regcache_cooked_read_ftype
*cooked_read
,
176 void *cooked_read_context
);
178 /* Copy/duplicate the contents of a register cache. By default, the
179 operation is pass-through. Writes to DST and reads from SRC will
180 go through to the target.
182 The ``cpy'' functions can not have overlapping SRC and DST buffers.
184 ``no passthrough'' versions do not go through to the target. They
185 only transfer values already in the cache. */
187 extern struct regcache
*regcache_dup (struct regcache
*regcache
);
188 extern void regcache_cpy (struct regcache
*dest
, struct regcache
*src
);
189 extern void regcache_cpy_no_passthrough (struct regcache
*dest
,
190 struct regcache
*src
);
192 extern void registers_changed (void);
193 extern void registers_changed_ptid (ptid_t
);
195 #endif /* REGCACHE_H */