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