1/* Cache and manage the values of registers for GDB, the GNU debugger.
2
3   Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000,
4   2001, 2002 Free Software Foundation, Inc.
5
6   This file is part of GDB.
7
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 2 of the License, or
11   (at your option) any later version.
12
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.
17
18   You should have received a copy of the GNU General Public License
19   along with this program; if not, write to the Free Software
20   Foundation, Inc., 59 Temple Place - Suite 330,
21   Boston, MA 02111-1307, USA.  */
22
23#ifndef REGCACHE_H
24#define REGCACHE_H
25
26struct regcache;
27struct gdbarch;
28
29extern struct regcache *current_regcache;
30
31void regcache_xfree (struct regcache *regcache);
32struct cleanup *make_cleanup_regcache_xfree (struct regcache *regcache);
33struct regcache *regcache_xmalloc (struct gdbarch *gdbarch);
34
35/* Return REGCACHE's architecture.  */
36
37extern struct gdbarch *get_regcache_arch (const struct regcache *regcache);
38
39/* Transfer a raw register [0..NUM_REGS) between core-gdb and the
40   regcache. */
41
42void regcache_raw_read (struct regcache *regcache, int rawnum, void *buf);
43void regcache_raw_write (struct regcache *regcache, int rawnum,
44			 const void *buf);
45extern void regcache_raw_read_signed (struct regcache *regcache,
46				      int regnum, LONGEST *val);
47extern void regcache_raw_read_unsigned (struct regcache *regcache,
48					int regnum, ULONGEST *val);
49extern void regcache_raw_write_signed (struct regcache *regcache,
50				       int regnum, LONGEST val);
51extern void regcache_raw_write_unsigned (struct regcache *regcache,
52					 int regnum, ULONGEST val);
53
54/* Partial transfer of a raw registers.  These perform read, modify,
55   write style operations.  */
56
57void regcache_raw_read_part (struct regcache *regcache, int regnum,
58			     int offset, int len, void *buf);
59void regcache_raw_write_part (struct regcache *regcache, int regnum,
60			      int offset, int len, const void *buf);
61
62int regcache_valid_p (struct regcache *regcache, int regnum);
63
64/* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS).  */
65void regcache_cooked_read (struct regcache *regcache, int rawnum, void *buf);
66void regcache_cooked_write (struct regcache *regcache, int rawnum,
67			    const void *buf);
68
69/* NOTE: cagney/2002-08-13: At present GDB has no reliable mechanism
70   for indicating when a ``cooked'' register was constructed from
71   invalid or unavailable ``raw'' registers.  One fairly easy way of
72   adding such a mechanism would be for the cooked functions to return
73   a register valid indication.  Given the possibility of such a
74   change, the extract functions below use a reference parameter,
75   rather than a function result.  */
76
77/* Read a register as a signed/unsigned quantity.  */
78extern void regcache_cooked_read_signed (struct regcache *regcache,
79					 int regnum, LONGEST *val);
80extern void regcache_cooked_read_unsigned (struct regcache *regcache,
81					   int regnum, ULONGEST *val);
82extern void regcache_cooked_write_signed (struct regcache *regcache,
83					  int regnum, LONGEST val);
84extern void regcache_cooked_write_unsigned (struct regcache *regcache,
85					    int regnum, ULONGEST val);
86
87/* Partial transfer of a cooked register.  These perform read, modify,
88   write style operations.  */
89
90void regcache_cooked_read_part (struct regcache *regcache, int regnum,
91				int offset, int len, void *buf);
92void regcache_cooked_write_part (struct regcache *regcache, int regnum,
93				 int offset, int len, const void *buf);
94
95/* Transfer a raw register [0..NUM_REGS) between the regcache and the
96   target.  These functions are called by the target in response to a
97   target_fetch_registers() or target_store_registers().  */
98
99extern void regcache_raw_supply (struct regcache *regcache,
100				 int regnum, const void *buf);
101extern void regcache_raw_collect (const struct regcache *regcache,
102				  int regnum, void *buf);
103
104
105/* The register's ``offset''.
106
107   FIXME: cagney/2002-11-07: The frame_register() function, when
108   specifying the real location of a register, does so using that
109   registers offset in the register cache.  That offset is then used
110   by valops.c to determine the location of the register.  The code
111   should instead use the register's number and a location expression
112   to describe a value spread across multiple registers or memory.  */
113
114extern int register_offset_hack (struct gdbarch *gdbarch, int regnum);
115
116/* Similar.  The total number of bytes occupied by a regcache.  */
117
118extern int deprecated_register_bytes (void );
119
120
121/* The type of a register.  This function is slightly more efficient
122   then its gdbarch vector counterpart since it returns a precomputed
123   value stored in a table.  */
124
125extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
126
127
128/* Return the size of register REGNUM.  All registers should have only
129   one size.  */
130
131extern int register_size (struct gdbarch *gdbarch, int regnum);
132
133
134/* Save/restore a register cache.  The set of registers saved /
135   restored into the DST regcache determined by the save_reggroup /
136   restore_reggroup respectively.  COOKED_READ returns zero iff the
137   register's value can't be returned.  */
138
139typedef int (regcache_cooked_read_ftype) (void *src, int regnum, void *buf);
140
141extern void regcache_save (struct regcache *dst,
142			   regcache_cooked_read_ftype *cooked_read,
143			   void *src);
144extern void regcache_restore (struct regcache *dst,
145			      regcache_cooked_read_ftype *cooked_read,
146			      void *src);
147
148/* Copy/duplicate the contents of a register cache.  By default, the
149   operation is pass-through.  Writes to DST and reads from SRC will
150   go through to the target.
151
152   The ``cpy'' functions can not have overlapping SRC and DST buffers.
153
154   ``no passthrough'' versions do not go through to the target.  They
155   only transfer values already in the cache.  */
156
157extern struct regcache *regcache_dup (struct regcache *regcache);
158extern struct regcache *regcache_dup_no_passthrough (struct regcache *regcache);
159extern void regcache_cpy (struct regcache *dest, struct regcache *src);
160extern void regcache_cpy_no_passthrough (struct regcache *dest, struct regcache *src);
161
162/* NOTE: cagney/2002-11-02: The below have been superseded by the
163   regcache_cooked_*() functions found above, and the frame_*()
164   functions found in "frame.h".  Take care though, often more than a
165   simple substitution is required when updating the code.  The
166   change, as far as practical, should avoid adding references to
167   global variables (e.g., current_regcache, current_frame,
168   current_gdbarch or deprecated_selected_frame) and instead refer to
169   the FRAME or REGCACHE that has been passed into the containing
170   function as parameters.  Consequently, the change typically
171   involves modifying the containing function so that it takes a FRAME
172   or REGCACHE parameter.  In the case of an architecture vector
173   method, there should already be a non-deprecated variant that is
174   parameterized with FRAME or REGCACHE.  */
175
176extern char *deprecated_grub_regcache_for_registers (struct regcache *);
177extern void deprecated_read_register_gen (int regnum, char *myaddr);
178extern void deprecated_write_register_gen (int regnum, char *myaddr);
179extern void deprecated_read_register_bytes (int regbyte, char *myaddr,
180					    int len);
181extern void deprecated_write_register_bytes (int regbyte, char *myaddr,
182					     int len);
183
184/* Character array containing the current state of each register
185   (unavailable<0, invalid=0, valid>0) for the most recently
186   referenced thread.  This global is often found in close proximity
187   to code that is directly manipulating the deprecated_registers[]
188   array.  In such cases, it should be possible to replace the lot
189   with a call to regcache_raw_supply().  If you find yourself in dire
190   straits, still needing access to the cache status bit, the
191   regcache_valid_p() and set_register_cached() functions are
192   available.  */
193extern signed char *deprecated_register_valid;
194
195/* Character array containing an image of the inferior programs'
196   registers for the most recently referenced thread.
197
198   NOTE: cagney/2002-11-14: Target side code should be using
199   regcache_raw_supply() and/or regcache_collect() while architecture
200   side code should use the more generic regcache methods.  */
201
202extern char *deprecated_registers;
203
204/* NOTE: cagney/2002-11-05: This function, and its co-conspirator
205   deprecated_registers[], have been superseeded by
206   regcache_raw_supply().  */
207extern void deprecated_registers_fetched (void);
208
209extern int register_cached (int regnum);
210
211extern void set_register_cached (int regnum, int state);
212
213extern void registers_changed (void);
214
215
216/* Rename to read_unsigned_register()? */
217extern ULONGEST read_register (int regnum);
218
219/* Rename to read_unsigned_register_pid()? */
220extern ULONGEST read_register_pid (int regnum, ptid_t ptid);
221
222extern void write_register (int regnum, LONGEST val);
223
224extern void write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid);
225
226#endif /* REGCACHE_H */
227