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