2002-08-13 Andrew Cagney <cagney@redhat.com>
[deliverable/binutils-gdb.git] / gdb / regcache.h
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
26 struct regcache;
27 struct gdbarch;
28
29 extern struct regcache *current_regcache;
30
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);
34
35 /* Transfer a raw register [0..NUM_REGS) between core-gdb and the
36 regcache. */
37
38 void regcache_raw_read (struct regcache *regcache, int rawnum, void *buf);
39 void regcache_raw_write (struct regcache *regcache, int rawnum,
40 const void *buf);
41 extern void regcache_raw_read_signed (struct regcache *regcache,
42 int regnum, LONGEST *val);
43 extern void regcache_raw_read_unsigned (struct regcache *regcache,
44 int regnum, ULONGEST *val);
45 int regcache_valid_p (struct regcache *regcache, int regnum);
46
47 /* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
48 void regcache_cooked_read (struct regcache *regcache, int rawnum, void *buf);
49 void regcache_cooked_write (struct regcache *regcache, int rawnum,
50 const void *buf);
51
52 /* NOTE: cagney/2002-08-13: At present GDB has no reliable mechanism
53 for indicating when a ``cooked'' register was constructed from
54 invalid or unavailable ``raw'' registers. One fairly easy way of
55 adding such a mechanism would be for the cooked functions to return
56 a register valid indication. Given the possibility of such a
57 change, the extract functions below use a reference parameter,
58 rather than a function result. */
59
60 /* Read a register as a signed/unsigned quantity. */
61 extern void regcache_cooked_read_signed (struct regcache *regcache,
62 int regnum, LONGEST *val);
63 extern void regcache_cooked_read_unsigned (struct regcache *regcache,
64 int regnum, ULONGEST *val);
65
66 /* Transfer a raw register [0..NUM_REGS) between the regcache and the
67 target. These functions are called by the target in response to a
68 target_fetch_registers() or target_store_registers(). */
69
70 extern void supply_register (int regnum, const void *val);
71 extern void regcache_collect (int regnum, void *buf);
72
73
74 /* DEPRECATED: Character array containing an image of the inferior
75 programs' registers for the most recently referenced thread. */
76
77 extern char *registers;
78
79 /* DEPRECATED: Character array containing the current state of each
80 register (unavailable<0, invalid=0, valid>0) for the most recently
81 referenced thread. */
82
83 extern signed char *register_valid;
84
85 /* Copy/duplicate the contents of a register cache. By default, the
86 operation is pass-through. Writes to DST and reads from SRC will
87 go through to the target.
88
89 The ``cpy'' functions can not have overlapping SRC and DST buffers.
90
91 ``no passthrough'' versions do not go through to the target. They
92 only transfer values already in the cache. */
93
94 extern struct regcache *regcache_dup (struct regcache *regcache);
95 extern struct regcache *regcache_dup_no_passthrough (struct regcache *regcache);
96 extern void regcache_cpy (struct regcache *dest, struct regcache *src);
97 extern void regcache_cpy_no_passthrough (struct regcache *dest, struct regcache *src);
98
99 extern char *deprecated_grub_regcache_for_registers (struct regcache *);
100 extern char *deprecated_grub_regcache_for_register_valid (struct regcache *);
101
102 extern int register_cached (int regnum);
103
104 extern void set_register_cached (int regnum, int state);
105
106 extern void register_changed (int regnum);
107
108 extern void registers_changed (void);
109
110 extern void registers_fetched (void);
111
112 extern void read_register_bytes (int regbyte, char *myaddr, int len);
113
114 extern void read_register_gen (int regnum, char *myaddr);
115
116 extern void write_register_gen (int regnum, char *myaddr);
117
118 extern void write_register_bytes (int regbyte, char *myaddr, int len);
119
120 /* Rename to read_unsigned_register()? */
121 extern ULONGEST read_register (int regnum);
122
123 /* Rename to read_unsigned_register_pid()? */
124 extern ULONGEST read_register_pid (int regnum, ptid_t ptid);
125
126 extern LONGEST read_signed_register (int regnum);
127
128 extern LONGEST read_signed_register_pid (int regnum, ptid_t ptid);
129
130 extern void write_register (int regnum, LONGEST val);
131
132 extern void write_register_pid (int regnum, CORE_ADDR val, ptid_t ptid);
133
134 #endif /* REGCACHE_H */
This page took 0.037209 seconds and 5 git commands to generate.