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);
36 /* Return REGCACHE's architecture. */
38 extern struct gdbarch *get_regcache_arch (const struct regcache *regcache);
40 /* Return REGCACHE's address space. */
42 extern struct address_space *get_regcache_aspace (const struct regcache *regcache);
44 /* Transfer a raw register [0..NUM_REGS) between core-gdb and the
47 void regcache_raw_read (struct regcache *regcache, int rawnum, gdb_byte *buf);
48 void regcache_raw_write (struct regcache *regcache, int rawnum,
50 extern void regcache_raw_read_signed (struct regcache *regcache,
51 int regnum, LONGEST *val);
52 extern void regcache_raw_read_unsigned (struct regcache *regcache,
53 int regnum, ULONGEST *val);
54 extern void regcache_raw_write_signed (struct regcache *regcache,
55 int regnum, LONGEST val);
56 extern void regcache_raw_write_unsigned (struct regcache *regcache,
57 int regnum, ULONGEST val);
59 /* Partial transfer of a raw registers. These perform read, modify,
60 write style operations. */
62 void regcache_raw_read_part (struct regcache *regcache, int regnum,
63 int offset, int len, gdb_byte *buf);
64 void regcache_raw_write_part (struct regcache *regcache, int regnum,
65 int offset, int len, const gdb_byte *buf);
67 int regcache_valid_p (const struct regcache *regcache, int regnum);
69 void regcache_invalidate (struct regcache *regcache, int regnum);
71 /* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
72 void regcache_cooked_read (struct regcache *regcache, int rawnum,
74 void regcache_cooked_write (struct regcache *regcache, int rawnum,
77 /* NOTE: cagney/2002-08-13: At present GDB has no reliable mechanism
78 for indicating when a ``cooked'' register was constructed from
79 invalid or unavailable ``raw'' registers. One fairly easy way of
80 adding such a mechanism would be for the cooked functions to return
81 a register valid indication. Given the possibility of such a
82 change, the extract functions below use a reference parameter,
83 rather than a function result. */
85 /* Read a register as a signed/unsigned quantity. */
86 extern void regcache_cooked_read_signed (struct regcache *regcache,
87 int regnum, LONGEST *val);
88 extern void regcache_cooked_read_unsigned (struct regcache *regcache,
89 int regnum, ULONGEST *val);
90 extern void regcache_cooked_write_signed (struct regcache *regcache,
91 int regnum, LONGEST val);
92 extern void regcache_cooked_write_unsigned (struct regcache *regcache,
93 int regnum, ULONGEST val);
95 /* Partial transfer of a cooked register. These perform read, modify,
96 write style operations. */
98 void regcache_cooked_read_part (struct regcache *regcache, int regnum,
99 int offset, int len, gdb_byte *buf);
100 void regcache_cooked_write_part (struct regcache *regcache, int regnum,
101 int offset, int len, const gdb_byte *buf);
103 /* Special routines to read/write the PC. */
105 extern CORE_ADDR regcache_read_pc (struct regcache *regcache);
106 extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc);
108 /* Transfer a raw register [0..NUM_REGS) between the regcache and the
109 target. These functions are called by the target in response to a
110 target_fetch_registers() or target_store_registers(). */
112 extern void regcache_raw_supply (struct regcache *regcache,
113 int regnum, const void *buf);
114 extern void regcache_raw_collect (const struct regcache *regcache,
115 int regnum, void *buf);
118 /* The type of a register. This function is slightly more efficient
119 then its gdbarch vector counterpart since it returns a precomputed
120 value stored in a table. */
122 extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
125 /* Return the size of register REGNUM. All registers should have only
128 extern int register_size (struct gdbarch *gdbarch, int regnum);
131 /* Save/restore a register cache. The set of registers saved /
132 restored into the DST regcache determined by the save_reggroup /
133 restore_reggroup respectively. COOKED_READ returns zero iff the
134 register's value can't be returned. */
136 typedef int (regcache_cooked_read_ftype) (void *src, int regnum,
139 extern void regcache_save (struct regcache *dst,
140 regcache_cooked_read_ftype *cooked_read,
141 void *cooked_read_context);
142 extern void regcache_restore (struct regcache *dst,
143 regcache_cooked_read_ftype *cooked_read,
144 void *cooked_read_context);
146 /* Copy/duplicate the contents of a register cache. By default, the
147 operation is pass-through. Writes to DST and reads from SRC will
148 go through to the target.
150 The ``cpy'' functions can not have overlapping SRC and DST buffers.
152 ``no passthrough'' versions do not go through to the target. They
153 only transfer values already in the cache. */
155 extern struct regcache *regcache_dup (struct regcache *regcache);
156 extern struct regcache *regcache_dup_no_passthrough (struct regcache *regcache);
157 extern void regcache_cpy (struct regcache *dest, struct regcache *src);
158 extern void regcache_cpy_no_passthrough (struct regcache *dest, struct regcache *src);
160 extern void registers_changed (void);
162 #endif /* REGCACHE_H */