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 */