Upgrade GDB from 7.4.1 to 7.6.1 on the 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
ef5ccd6c 3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
5796c8dc
SS
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20#ifndef REGCACHE_H
21#define REGCACHE_H
22
23struct regcache;
24struct gdbarch;
cf7f2e2d 25struct address_space;
5796c8dc
SS
26
27extern struct regcache *get_current_regcache (void);
28extern struct regcache *get_thread_regcache (ptid_t ptid);
29extern struct regcache *get_thread_arch_regcache (ptid_t, struct gdbarch *);
a45ae5f8
JM
30extern struct regcache *get_thread_arch_aspace_regcache (ptid_t,
31 struct gdbarch *,
32 struct address_space *);
5796c8dc
SS
33
34void regcache_xfree (struct regcache *regcache);
35struct cleanup *make_cleanup_regcache_xfree (struct regcache *regcache);
cf7f2e2d
JM
36struct regcache *regcache_xmalloc (struct gdbarch *gdbarch,
37 struct address_space *aspace);
5796c8dc
SS
38
39/* Return REGCACHE's architecture. */
40
41extern struct gdbarch *get_regcache_arch (const struct regcache *regcache);
42
cf7f2e2d
JM
43/* Return REGCACHE's address space. */
44
c50c785c
JM
45extern struct address_space *get_regcache_aspace (const struct regcache *);
46
47enum register_status
48 {
49 /* The register value is not in the cache, and we don't know yet
50 whether it's available in the target (or traceframe). */
51 REG_UNKNOWN = 0,
52
53 /* The register value is valid and cached. */
54 REG_VALID = 1,
55
56 /* The register value is unavailable. E.g., we're inspecting a
57 traceframe, and this register wasn't collected. Note that this
58 is different a different "unavailable" from saying the register
59 does not exist in the target's architecture --- in that case,
60 the target should have given us a target description that does
61 not include the register in the first place. */
62 REG_UNAVAILABLE = -1
63 };
64
65enum register_status regcache_register_status (const struct regcache *regcache,
66 int regnum);
cf7f2e2d 67
5796c8dc 68/* Transfer a raw register [0..NUM_REGS) between core-gdb and the
c50c785c 69 regcache. The read variants return the status of the register. */
5796c8dc 70
c50c785c
JM
71enum register_status regcache_raw_read (struct regcache *regcache,
72 int rawnum, gdb_byte *buf);
5796c8dc
SS
73void regcache_raw_write (struct regcache *regcache, int rawnum,
74 const gdb_byte *buf);
c50c785c
JM
75extern enum register_status
76 regcache_raw_read_signed (struct regcache *regcache,
77 int regnum, LONGEST *val);
78extern enum register_status
79 regcache_raw_read_unsigned (struct regcache *regcache,
80 int regnum, ULONGEST *val);
5796c8dc
SS
81extern void regcache_raw_write_signed (struct regcache *regcache,
82 int regnum, LONGEST val);
83extern void regcache_raw_write_unsigned (struct regcache *regcache,
84 int regnum, ULONGEST val);
85
c50c785c
JM
86/* Partial transfer of raw registers. These perform read, modify,
87 write style operations. The read variant returns the status of the
88 register. */
5796c8dc 89
c50c785c
JM
90extern enum register_status
91 regcache_raw_read_part (struct regcache *regcache, int regnum,
92 int offset, int len, gdb_byte *buf);
5796c8dc
SS
93void regcache_raw_write_part (struct regcache *regcache, int regnum,
94 int offset, int len, const gdb_byte *buf);
95
5796c8dc
SS
96void regcache_invalidate (struct regcache *regcache, int regnum);
97
c50c785c
JM
98/* Transfer of pseudo-registers. The read variants return a register
99 status, as an indication of when a ``cooked'' register was
100 constructed from valid, invalid or unavailable ``raw''
101 registers. */
102
5796c8dc 103/* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
c50c785c
JM
104enum register_status regcache_cooked_read (struct regcache *regcache,
105 int rawnum, gdb_byte *buf);
5796c8dc
SS
106void regcache_cooked_write (struct regcache *regcache, int rawnum,
107 const gdb_byte *buf);
108
a45ae5f8
JM
109/* Read register REGNUM from REGCACHE and return a new value. This
110 will call mark_value_bytes_unavailable as appropriate. */
111
112struct value *regcache_cooked_read_value (struct regcache *regcache,
113 int regnum);
114
5796c8dc 115/* Read a register as a signed/unsigned quantity. */
c50c785c
JM
116extern enum register_status
117 regcache_cooked_read_signed (struct regcache *regcache,
118 int regnum, LONGEST *val);
119extern enum register_status
120 regcache_cooked_read_unsigned (struct regcache *regcache,
121 int regnum, ULONGEST *val);
5796c8dc
SS
122extern void regcache_cooked_write_signed (struct regcache *regcache,
123 int regnum, LONGEST val);
124extern void regcache_cooked_write_unsigned (struct regcache *regcache,
125 int regnum, ULONGEST val);
126
127/* Partial transfer of a cooked register. These perform read, modify,
128 write style operations. */
129
c50c785c
JM
130enum register_status regcache_cooked_read_part (struct regcache *regcache,
131 int regnum, int offset,
132 int len, gdb_byte *buf);
5796c8dc
SS
133void regcache_cooked_write_part (struct regcache *regcache, int regnum,
134 int offset, int len, const gdb_byte *buf);
135
136/* Special routines to read/write the PC. */
137
138extern CORE_ADDR regcache_read_pc (struct regcache *regcache);
139extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc);
140
141/* Transfer a raw register [0..NUM_REGS) between the regcache and the
142 target. These functions are called by the target in response to a
143 target_fetch_registers() or target_store_registers(). */
144
145extern void regcache_raw_supply (struct regcache *regcache,
146 int regnum, const void *buf);
147extern void regcache_raw_collect (const struct regcache *regcache,
148 int regnum, void *buf);
149
150
151/* The type of a register. This function is slightly more efficient
152 then its gdbarch vector counterpart since it returns a precomputed
153 value stored in a table. */
154
155extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
156
157
158/* Return the size of register REGNUM. All registers should have only
159 one size. */
160
161extern int register_size (struct gdbarch *gdbarch, int regnum);
162
163
164/* Save/restore a register cache. The set of registers saved /
165 restored into the DST regcache determined by the save_reggroup /
166 restore_reggroup respectively. COOKED_READ returns zero iff the
167 register's value can't be returned. */
168
c50c785c
JM
169typedef enum register_status (regcache_cooked_read_ftype) (void *src,
170 int regnum,
171 gdb_byte *buf);
5796c8dc
SS
172
173extern void regcache_save (struct regcache *dst,
174 regcache_cooked_read_ftype *cooked_read,
175 void *cooked_read_context);
5796c8dc
SS
176
177/* Copy/duplicate the contents of a register cache. By default, the
178 operation is pass-through. Writes to DST and reads from SRC will
179 go through to the target.
180
181 The ``cpy'' functions can not have overlapping SRC and DST buffers.
182
183 ``no passthrough'' versions do not go through to the target. They
184 only transfer values already in the cache. */
185
186extern struct regcache *regcache_dup (struct regcache *regcache);
5796c8dc 187extern void regcache_cpy (struct regcache *dest, struct regcache *src);
c50c785c
JM
188extern void regcache_cpy_no_passthrough (struct regcache *dest,
189 struct regcache *src);
5796c8dc
SS
190
191extern void registers_changed (void);
cf7f2e2d 192extern void registers_changed_ptid (ptid_t);
5796c8dc
SS
193
194#endif /* REGCACHE_H */