tuxillo's projects / dragonfly.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / regcache.h
... / ...
CommitLineData
1/* Cache and manage the values of registers for GDB, the GNU debugger.
2
3 Copyright (C) 1986-2013 Free Software Foundation, Inc.
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;
25struct address_space;
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 *);
30extern struct regcache *get_thread_arch_aspace_regcache (ptid_t,
31 struct gdbarch *,
32 struct address_space *);
33
34void regcache_xfree (struct regcache *regcache);
35struct cleanup *make_cleanup_regcache_xfree (struct regcache *regcache);
36struct regcache *regcache_xmalloc (struct gdbarch *gdbarch,
37 struct address_space *aspace);
38
39/* Return REGCACHE's architecture. */
40
41extern struct gdbarch *get_regcache_arch (const struct regcache *regcache);
42
43/* Return REGCACHE's address space. */
44
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);
67
68/* Transfer a raw register [0..NUM_REGS) between core-gdb and the
69 regcache. The read variants return the status of the register. */
70
71enum register_status regcache_raw_read (struct regcache *regcache,
72 int rawnum, gdb_byte *buf);
73void regcache_raw_write (struct regcache *regcache, int rawnum,
74 const gdb_byte *buf);
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);
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
86/* Partial transfer of raw registers. These perform read, modify,
87 write style operations. The read variant returns the status of the
88 register. */
89
90extern enum register_status
91 regcache_raw_read_part (struct regcache *regcache, int regnum,
92 int offset, int len, gdb_byte *buf);
93void regcache_raw_write_part (struct regcache *regcache, int regnum,
94 int offset, int len, const gdb_byte *buf);
95
96void regcache_invalidate (struct regcache *regcache, int regnum);
97
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
103/* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
104enum register_status regcache_cooked_read (struct regcache *regcache,
105 int rawnum, gdb_byte *buf);
106void regcache_cooked_write (struct regcache *regcache, int rawnum,
107 const gdb_byte *buf);
108
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
115/* Read a register as a signed/unsigned quantity. */
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);
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
130enum register_status regcache_cooked_read_part (struct regcache *regcache,
131 int regnum, int offset,
132 int len, gdb_byte *buf);
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
169typedef enum register_status (regcache_cooked_read_ftype) (void *src,
170 int regnum,
171 gdb_byte *buf);
172
173extern void regcache_save (struct regcache *dst,
174 regcache_cooked_read_ftype *cooked_read,
175 void *cooked_read_context);
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);
187extern void regcache_cpy (struct regcache *dest, struct regcache *src);
188extern void regcache_cpy_no_passthrough (struct regcache *dest,
189 struct regcache *src);
190
191extern void registers_changed (void);
192extern void registers_changed_ptid (ptid_t);
193
194#endif /* REGCACHE_H */
WIP repository