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
69 void regcache_raw_read (struct regcache
*regcache
, int rawnum
, gdb_byte
*buf
);
70 void regcache_raw_write (struct regcache
*regcache
, int rawnum
,
72 extern void regcache_raw_read_signed (struct regcache
*regcache
,
73 int regnum
, LONGEST
*val
);
74 extern void regcache_raw_read_unsigned (struct regcache
*regcache
,
75 int regnum
, ULONGEST
*val
);
76 extern void regcache_raw_write_signed (struct regcache
*regcache
,
77 int regnum
, LONGEST val
);
78 extern void regcache_raw_write_unsigned (struct regcache
*regcache
,
79 int regnum
, ULONGEST val
);
81 /* Partial transfer of a raw registers. These perform read, modify,
82 write style operations. */
84 void regcache_raw_read_part (struct regcache
*regcache
, int regnum
,
85 int offset
, int len
, gdb_byte
*buf
);
86 void regcache_raw_write_part (struct regcache
*regcache
, int regnum
,
87 int offset
, int len
, const gdb_byte
*buf
);
89 void regcache_invalidate (struct regcache
*regcache
, int regnum
);
91 /* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
92 void regcache_cooked_read (struct regcache
*regcache
, int rawnum
,
94 void regcache_cooked_write (struct regcache
*regcache
, int rawnum
,
97 /* NOTE: cagney/2002-08-13: At present GDB has no reliable mechanism
98 for indicating when a ``cooked'' register was constructed from
99 invalid or unavailable ``raw'' registers. One fairly easy way of
100 adding such a mechanism would be for the cooked functions to return
101 a register valid indication. Given the possibility of such a
102 change, the extract functions below use a reference parameter,
103 rather than a function result. */
105 /* Read a register as a signed/unsigned quantity. */
106 extern void regcache_cooked_read_signed (struct regcache
*regcache
,
107 int regnum
, LONGEST
*val
);
108 extern void regcache_cooked_read_unsigned (struct regcache
*regcache
,
109 int regnum
, ULONGEST
*val
);
110 extern void regcache_cooked_write_signed (struct regcache
*regcache
,
111 int regnum
, LONGEST val
);
112 extern void regcache_cooked_write_unsigned (struct regcache
*regcache
,
113 int regnum
, ULONGEST val
);
115 /* Partial transfer of a cooked register. These perform read, modify,
116 write style operations. */
118 void regcache_cooked_read_part (struct regcache
*regcache
, int regnum
,
119 int offset
, int len
, gdb_byte
*buf
);
120 void regcache_cooked_write_part (struct regcache
*regcache
, int regnum
,
121 int offset
, int len
, const gdb_byte
*buf
);
123 /* Special routines to read/write the PC. */
125 extern CORE_ADDR
regcache_read_pc (struct regcache
*regcache
);
126 extern void regcache_write_pc (struct regcache
*regcache
, CORE_ADDR pc
);
128 /* Transfer a raw register [0..NUM_REGS) between the regcache and the
129 target. These functions are called by the target in response to a
130 target_fetch_registers() or target_store_registers(). */
132 extern void regcache_raw_supply (struct regcache
*regcache
,
133 int regnum
, const void *buf
);
134 extern void regcache_raw_collect (const struct regcache
*regcache
,
135 int regnum
, void *buf
);
138 /* The type of a register. This function is slightly more efficient
139 then its gdbarch vector counterpart since it returns a precomputed
140 value stored in a table. */
142 extern struct type
*register_type (struct gdbarch
*gdbarch
, int regnum
);
145 /* Return the size of register REGNUM. All registers should have only
148 extern int register_size (struct gdbarch
*gdbarch
, int regnum
);
151 /* Save/restore a register cache. The set of registers saved /
152 restored into the DST regcache determined by the save_reggroup /
153 restore_reggroup respectively. COOKED_READ returns zero iff the
154 register's value can't be returned. */
156 typedef int (regcache_cooked_read_ftype
) (void *src
, int regnum
,
159 extern void regcache_save (struct regcache
*dst
,
160 regcache_cooked_read_ftype
*cooked_read
,
161 void *cooked_read_context
);
162 extern void regcache_restore (struct regcache
*dst
,
163 regcache_cooked_read_ftype
*cooked_read
,
164 void *cooked_read_context
);
166 /* Copy/duplicate the contents of a register cache. By default, the
167 operation is pass-through. Writes to DST and reads from SRC will
168 go through to the target.
170 The ``cpy'' functions can not have overlapping SRC and DST buffers.
172 ``no passthrough'' versions do not go through to the target. They
173 only transfer values already in the cache. */
175 extern struct regcache
*regcache_dup (struct regcache
*regcache
);
176 extern void regcache_cpy (struct regcache
*dest
, struct regcache
*src
);
177 extern void regcache_cpy_no_passthrough (struct regcache
*dest
,
178 struct regcache
*src
);
180 extern void registers_changed (void);
181 extern void registers_changed_ptid (ptid_t
);
183 #endif /* REGCACHE_H */