]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/regcache.h
Copyright updates for 2007.
[thirdparty/binutils-gdb.git] / gdb / regcache.h
CommitLineData
4e052eda 1/* Cache and manage the values of registers for GDB, the GNU debugger.
3fadccb3 2
6aba47ca
DJ
3 Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
4 2002, 2007 Free Software Foundation, Inc.
4e052eda
AC
5
6 This file is part of GDB.
7
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 2 of the License, or
11 (at your option) any later version.
12
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.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
197e01b6
EZ
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
4e052eda
AC
22
23#ifndef REGCACHE_H
24#define REGCACHE_H
25
3fadccb3
AC
26struct regcache;
27struct gdbarch;
28
29extern struct regcache *current_regcache;
30
31void regcache_xfree (struct regcache *regcache);
36160dc4 32struct cleanup *make_cleanup_regcache_xfree (struct regcache *regcache);
3fadccb3
AC
33struct regcache *regcache_xmalloc (struct gdbarch *gdbarch);
34
41d35cb0
MK
35/* Return REGCACHE's architecture. */
36
37extern struct gdbarch *get_regcache_arch (const struct regcache *regcache);
38
61a0eb5b
AC
39/* Transfer a raw register [0..NUM_REGS) between core-gdb and the
40 regcache. */
41
2d522557 42void regcache_raw_read (struct regcache *regcache, int rawnum, gdb_byte *buf);
1aaa5f99 43void regcache_raw_write (struct regcache *regcache, int rawnum,
2d522557 44 const gdb_byte *buf);
28fc6740
AC
45extern void regcache_raw_read_signed (struct regcache *regcache,
46 int regnum, LONGEST *val);
47extern void regcache_raw_read_unsigned (struct regcache *regcache,
48 int regnum, ULONGEST *val);
c00dcbe9
MK
49extern void regcache_raw_write_signed (struct regcache *regcache,
50 int regnum, LONGEST val);
51extern void regcache_raw_write_unsigned (struct regcache *regcache,
52 int regnum, ULONGEST val);
06c0b04e
AC
53
54/* Partial transfer of a raw registers. These perform read, modify,
55 write style operations. */
56
57void regcache_raw_read_part (struct regcache *regcache, int regnum,
2d522557 58 int offset, int len, gdb_byte *buf);
06c0b04e 59void regcache_raw_write_part (struct regcache *regcache, int regnum,
2d522557 60 int offset, int len, const gdb_byte *buf);
06c0b04e 61
3fadccb3 62int regcache_valid_p (struct regcache *regcache, int regnum);
61a0eb5b 63
68365089 64/* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
2d522557
AC
65void regcache_cooked_read (struct regcache *regcache, int rawnum,
66 gdb_byte *buf);
68365089 67void regcache_cooked_write (struct regcache *regcache, int rawnum,
2d522557 68 const gdb_byte *buf);
68365089 69
a378f419
AC
70/* NOTE: cagney/2002-08-13: At present GDB has no reliable mechanism
71 for indicating when a ``cooked'' register was constructed from
72 invalid or unavailable ``raw'' registers. One fairly easy way of
73 adding such a mechanism would be for the cooked functions to return
74 a register valid indication. Given the possibility of such a
75 change, the extract functions below use a reference parameter,
76 rather than a function result. */
77
78/* Read a register as a signed/unsigned quantity. */
79extern void regcache_cooked_read_signed (struct regcache *regcache,
80 int regnum, LONGEST *val);
81extern void regcache_cooked_read_unsigned (struct regcache *regcache,
82 int regnum, ULONGEST *val);
a66a9c23
AC
83extern void regcache_cooked_write_signed (struct regcache *regcache,
84 int regnum, LONGEST val);
85extern void regcache_cooked_write_unsigned (struct regcache *regcache,
86 int regnum, ULONGEST val);
a378f419 87
06c0b04e
AC
88/* Partial transfer of a cooked register. These perform read, modify,
89 write style operations. */
90
91void regcache_cooked_read_part (struct regcache *regcache, int regnum,
2d522557 92 int offset, int len, gdb_byte *buf);
06c0b04e 93void regcache_cooked_write_part (struct regcache *regcache, int regnum,
2d522557 94 int offset, int len, const gdb_byte *buf);
06c0b04e 95
193cb69f
AC
96/* Transfer a raw register [0..NUM_REGS) between the regcache and the
97 target. These functions are called by the target in response to a
98 target_fetch_registers() or target_store_registers(). */
99
9a661b68 100extern void regcache_raw_supply (struct regcache *regcache,
6618125d 101 int regnum, const void *buf);
9a661b68 102extern void regcache_raw_collect (const struct regcache *regcache,
6618125d 103 int regnum, void *buf);
193cb69f
AC
104
105
d3b22ed5
AC
106/* The register's ``offset''.
107
ac2adee5 108 FIXME: cagney/2002-11-07: The frame_register() function, when
e600bd34
AC
109 specifying the real location of a register, does so using that
110 registers offset in the register cache. That offset is then used
111 by valops.c to determine the location of the register. The code
112 should instead use the register's number and a location expression
113 to describe a value spread across multiple registers or memory. */
d3b22ed5
AC
114
115extern int register_offset_hack (struct gdbarch *gdbarch, int regnum);
d3b22ed5 116
f42accbe
AC
117/* Similar. The total number of bytes occupied by a regcache. */
118
119extern int deprecated_register_bytes (void );
120
d3b22ed5 121
bb425013
AC
122/* The type of a register. This function is slightly more efficient
123 then its gdbarch vector counterpart since it returns a precomputed
01e1877c 124 value stored in a table. */
bb425013
AC
125
126extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
127
128
08a617da 129/* Return the size of register REGNUM. All registers should have only
01e1877c 130 one size. */
08a617da
AC
131
132extern int register_size (struct gdbarch *gdbarch, int regnum);
133
134
5602984a
AC
135/* Save/restore a register cache. The set of registers saved /
136 restored into the DST regcache determined by the save_reggroup /
137 restore_reggroup respectively. COOKED_READ returns zero iff the
138 register's value can't be returned. */
139
2d522557
AC
140typedef int (regcache_cooked_read_ftype) (void *src, int regnum,
141 gdb_byte *buf);
5602984a
AC
142
143extern void regcache_save (struct regcache *dst,
144 regcache_cooked_read_ftype *cooked_read,
2d522557 145 void *cooked_read_context);
5602984a
AC
146extern void regcache_restore (struct regcache *dst,
147 regcache_cooked_read_ftype *cooked_read,
2d522557 148 void *cooked_read_context);
2d28509a 149
37e71372
AC
150/* Copy/duplicate the contents of a register cache. By default, the
151 operation is pass-through. Writes to DST and reads from SRC will
152 go through to the target.
153
154 The ``cpy'' functions can not have overlapping SRC and DST buffers.
3fadccb3
AC
155
156 ``no passthrough'' versions do not go through to the target. They
37e71372 157 only transfer values already in the cache. */
3fadccb3 158
3fadccb3 159extern struct regcache *regcache_dup (struct regcache *regcache);
3fadccb3
AC
160extern struct regcache *regcache_dup_no_passthrough (struct regcache *regcache);
161extern void regcache_cpy (struct regcache *dest, struct regcache *src);
162extern void regcache_cpy_no_passthrough (struct regcache *dest, struct regcache *src);
163
192dbe33
AC
164/* NOTE: cagney/2002-11-02: The below have been superseded by the
165 regcache_cooked_*() functions found above, and the frame_*()
166 functions found in "frame.h". Take care though, often more than a
167 simple substitution is required when updating the code. The
168 change, as far as practical, should avoid adding references to
169 global variables (e.g., current_regcache, current_frame,
6e7f8b9c
AC
170 current_gdbarch or deprecated_selected_frame) and instead refer to
171 the FRAME or REGCACHE that has been passed into the containing
172 function as parameters. Consequently, the change typically
173 involves modifying the containing function so that it takes a FRAME
174 or REGCACHE parameter. In the case of an architecture vector
175 method, there should already be a non-deprecated variant that is
176 parameterized with FRAME or REGCACHE. */
192dbe33 177
2d522557
AC
178extern gdb_byte *deprecated_grub_regcache_for_registers (struct regcache *);
179extern void deprecated_read_register_gen (int regnum, gdb_byte *myaddr);
180extern void deprecated_write_register_gen (int regnum, gdb_byte *myaddr);
181extern void deprecated_read_register_bytes (int regbyte, gdb_byte *myaddr,
73937e03 182 int len);
2d522557 183extern void deprecated_write_register_bytes (int regbyte, gdb_byte *myaddr,
73937e03 184 int len);
3fadccb3 185
8851ec7a 186/* NOTE: cagney/2002-11-05: This function has been superseeded by
23a6d369 187 regcache_raw_supply(). */
2b9e5f3f
AC
188extern void deprecated_registers_fetched (void);
189
4e052eda
AC
190extern int register_cached (int regnum);
191
192extern void set_register_cached (int regnum, int state);
193
4e052eda
AC
194extern void registers_changed (void);
195
4e052eda 196
4e052eda
AC
197/* Rename to read_unsigned_register()? */
198extern ULONGEST read_register (int regnum);
199
200/* Rename to read_unsigned_register_pid()? */
39f77062 201extern ULONGEST read_register_pid (int regnum, ptid_t ptid);
4e052eda 202
4e052eda
AC
203extern void write_register (int regnum, LONGEST val);
204
39f77062 205extern void write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid);
4e052eda 206
4e052eda 207#endif /* REGCACHE_H */