Import gdb 7.3 into vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / regcache.h
CommitLineData
5796c8dc
SS
1/* Cache and manage the values of registers for GDB, the GNU debugger.
2
3 Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
c50c785c 4 2002, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
5796c8dc
SS
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 3 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, see <http://www.gnu.org/licenses/>. */
20
21#ifndef REGCACHE_H
22#define REGCACHE_H
23
24struct regcache;
25struct gdbarch;
cf7f2e2d 26struct address_space;
5796c8dc
SS
27
28extern struct regcache *get_current_regcache (void);
29extern struct regcache *get_thread_regcache (ptid_t ptid);
30extern struct regcache *get_thread_arch_regcache (ptid_t, struct gdbarch *);
31
32void regcache_xfree (struct regcache *regcache);
33struct cleanup *make_cleanup_regcache_xfree (struct regcache *regcache);
cf7f2e2d
JM
34struct regcache *regcache_xmalloc (struct gdbarch *gdbarch,
35 struct address_space *aspace);
5796c8dc
SS
36
37/* Return REGCACHE's architecture. */
38
39extern struct gdbarch *get_regcache_arch (const struct regcache *regcache);
40
cf7f2e2d
JM
41/* Return REGCACHE's address space. */
42
c50c785c
JM
43extern struct address_space *get_regcache_aspace (const struct regcache *);
44
45enum register_status
46 {
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). */
49 REG_UNKNOWN = 0,
50
51 /* The register value is valid and cached. */
52 REG_VALID = 1,
53
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. */
60 REG_UNAVAILABLE = -1
61 };
62
63enum register_status regcache_register_status (const struct regcache *regcache,
64 int regnum);
cf7f2e2d 65
5796c8dc 66/* Transfer a raw register [0..NUM_REGS) between core-gdb and the
c50c785c 67 regcache. The read variants return the status of the register. */
5796c8dc 68
c50c785c
JM
69enum register_status regcache_raw_read (struct regcache *regcache,
70 int rawnum, gdb_byte *buf);
5796c8dc
SS
71void regcache_raw_write (struct regcache *regcache, int rawnum,
72 const gdb_byte *buf);
c50c785c
JM
73extern enum register_status
74 regcache_raw_read_signed (struct regcache *regcache,
75 int regnum, LONGEST *val);
76extern enum register_status
77 regcache_raw_read_unsigned (struct regcache *regcache,
78 int regnum, ULONGEST *val);
5796c8dc
SS
79extern void regcache_raw_write_signed (struct regcache *regcache,
80 int regnum, LONGEST val);
81extern void regcache_raw_write_unsigned (struct regcache *regcache,
82 int regnum, ULONGEST val);
83
c50c785c
JM
84/* Partial transfer of raw registers. These perform read, modify,
85 write style operations. The read variant returns the status of the
86 register. */
5796c8dc 87
c50c785c
JM
88extern enum register_status
89 regcache_raw_read_part (struct regcache *regcache, int regnum,
90 int offset, int len, gdb_byte *buf);
5796c8dc
SS
91void regcache_raw_write_part (struct regcache *regcache, int regnum,
92 int offset, int len, const gdb_byte *buf);
93
5796c8dc
SS
94void regcache_invalidate (struct regcache *regcache, int regnum);
95
c50c785c
JM
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''
99 registers. */
100
5796c8dc 101/* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
c50c785c
JM
102enum register_status regcache_cooked_read (struct regcache *regcache,
103 int rawnum, gdb_byte *buf);
5796c8dc
SS
104void regcache_cooked_write (struct regcache *regcache, int rawnum,
105 const gdb_byte *buf);
106
5796c8dc 107/* Read a register as a signed/unsigned quantity. */
c50c785c
JM
108extern enum register_status
109 regcache_cooked_read_signed (struct regcache *regcache,
110 int regnum, LONGEST *val);
111extern enum register_status
112 regcache_cooked_read_unsigned (struct regcache *regcache,
113 int regnum, ULONGEST *val);
5796c8dc
SS
114extern void regcache_cooked_write_signed (struct regcache *regcache,
115 int regnum, LONGEST val);
116extern void regcache_cooked_write_unsigned (struct regcache *regcache,
117 int regnum, ULONGEST val);
118
119/* Partial transfer of a cooked register. These perform read, modify,
120 write style operations. */
121
c50c785c
JM
122enum register_status regcache_cooked_read_part (struct regcache *regcache,
123 int regnum, int offset,
124 int len, gdb_byte *buf);
5796c8dc
SS
125void regcache_cooked_write_part (struct regcache *regcache, int regnum,
126 int offset, int len, const gdb_byte *buf);
127
128/* Special routines to read/write the PC. */
129
130extern CORE_ADDR regcache_read_pc (struct regcache *regcache);
131extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc);
132
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(). */
136
137extern void regcache_raw_supply (struct regcache *regcache,
138 int regnum, const void *buf);
139extern void regcache_raw_collect (const struct regcache *regcache,
140 int regnum, void *buf);
141
142
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. */
146
147extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
148
149
150/* Return the size of register REGNUM. All registers should have only
151 one size. */
152
153extern int register_size (struct gdbarch *gdbarch, int regnum);
154
155
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. */
160
c50c785c
JM
161typedef enum register_status (regcache_cooked_read_ftype) (void *src,
162 int regnum,
163 gdb_byte *buf);
5796c8dc
SS
164
165extern void regcache_save (struct regcache *dst,
166 regcache_cooked_read_ftype *cooked_read,
167 void *cooked_read_context);
168extern void regcache_restore (struct regcache *dst,
169 regcache_cooked_read_ftype *cooked_read,
170 void *cooked_read_context);
171
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.
175
176 The ``cpy'' functions can not have overlapping SRC and DST buffers.
177
178 ``no passthrough'' versions do not go through to the target. They
179 only transfer values already in the cache. */
180
181extern struct regcache *regcache_dup (struct regcache *regcache);
5796c8dc 182extern void regcache_cpy (struct regcache *dest, struct regcache *src);
c50c785c
JM
183extern void regcache_cpy_no_passthrough (struct regcache *dest,
184 struct regcache *src);
5796c8dc
SS
185
186extern void registers_changed (void);
cf7f2e2d 187extern void registers_changed_ptid (ptid_t);
5796c8dc
SS
188
189#endif /* REGCACHE_H */