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 a register as a signed/unsigned quantity. */
108 extern enum register_status
109 regcache_cooked_read_signed (struct regcache
*regcache
,
110 int regnum
, LONGEST
*val
);
111 extern enum register_status
112 regcache_cooked_read_unsigned (struct regcache
*regcache
,
113 int regnum
, ULONGEST
*val
);
114 extern void regcache_cooked_write_signed (struct regcache
*regcache
,
115 int regnum
, LONGEST val
);
116 extern void regcache_cooked_write_unsigned (struct regcache
*regcache
,
117 int regnum
, ULONGEST val
);
119 /* Partial transfer of a cooked register. These perform read, modify,
120 write style operations. */
122 enum register_status
regcache_cooked_read_part (struct regcache
*regcache
,
123 int regnum
, int offset
,
124 int len
, gdb_byte
*buf
);
125 void regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
126 int offset
, int len
, const gdb_byte
*buf
);
128 /* Special routines to read/write the PC. */
130 extern CORE_ADDR
regcache_read_pc (struct regcache
*regcache
);
131 extern void regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
);
133 /* Transfer a raw register [0..NUM_REGS) between the regcache and the
134 target. These functions are called by the target in response to a
135 target_fetch_registers() or target_store_registers(). */
137 extern void regcache_raw_supply (struct regcache
*regcache
,
138 int regnum
, const void *buf
);
139 extern void regcache_raw_collect (const struct regcache
*regcache
,
140 int regnum
, void *buf
);
143 /* The type of a register. This function is slightly more efficient
144 then its gdbarch vector counterpart since it returns a precomputed
145 value stored in a table. */
147 extern struct type
*register_type (struct gdbarch
*gdbarch
, int regnum
);
150 /* Return the size of register REGNUM. All registers should have only
153 extern int register_size (struct gdbarch
*gdbarch
, int regnum
);
156 /* Save/restore a register cache. The set of registers saved /
157 restored into the DST regcache determined by the save_reggroup /
158 restore_reggroup respectively. COOKED_READ returns zero iff the
159 register's value can't be returned. */
161 typedef enum register_status (regcache_cooked_read_ftype
) (void *src
,
165 extern void regcache_save (struct regcache
*dst
,
166 regcache_cooked_read_ftype
*cooked_read
,
167 void *cooked_read_context
);
168 extern void regcache_restore (struct regcache
*dst
,
169 regcache_cooked_read_ftype
*cooked_read
,
170 void *cooked_read_context
);
172 /* Copy/duplicate the contents of a register cache. By default, the
173 operation is pass-through. Writes to DST and reads from SRC will
174 go through to the target.
176 The ``cpy'' functions can not have overlapping SRC and DST buffers.
178 ``no passthrough'' versions do not go through to the target. They
179 only transfer values already in the cache. */
181 extern struct regcache
*regcache_dup (struct regcache
*regcache
);
182 extern void regcache_cpy (struct regcache
*dest
, struct regcache
*src
);
183 extern void regcache_cpy_no_passthrough (struct regcache
*dest
,
184 struct regcache
*src
);
186 extern void registers_changed (void);
187 extern void registers_changed_ptid (ptid_t
);
189 #endif /* REGCACHE_H */