Import gdb-7.0
[dragonfly.git] / contrib / gdb-7 / gdb / regcache.h
CommitLineData
5796c8dc
SS
1/* Cache and manage the values of registers for GDB, the GNU debugger.
2
3 Copyright (C) 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001,
4 2002, 2007, 2008, 2009 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 3 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, see <http://www.gnu.org/licenses/>. */
20
21#ifndef REGCACHE_H
22#define REGCACHE_H
23
24struct regcache;
25struct gdbarch;
26
27extern struct regcache *get_current_regcache (void);
28extern struct regcache *get_thread_regcache (ptid_t ptid);
29extern struct regcache *get_thread_arch_regcache (ptid_t, struct gdbarch *);
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, gdb_byte *buf);
43void regcache_raw_write (struct regcache *regcache, int rawnum,
44 const gdb_byte *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, gdb_byte *buf);
59void regcache_raw_write_part (struct regcache *regcache, int regnum,
60 int offset, int len, const gdb_byte *buf);
61
62int regcache_valid_p (const struct regcache *regcache, int regnum);
63
64void regcache_invalidate (struct regcache *regcache, int regnum);
65
66/* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */
67void regcache_cooked_read (struct regcache *regcache, int rawnum,
68 gdb_byte *buf);
69void regcache_cooked_write (struct regcache *regcache, int rawnum,
70 const gdb_byte *buf);
71
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. */
79
80/* Read a register as a signed/unsigned quantity. */
81extern void regcache_cooked_read_signed (struct regcache *regcache,
82 int regnum, LONGEST *val);
83extern void regcache_cooked_read_unsigned (struct regcache *regcache,
84 int regnum, ULONGEST *val);
85extern void regcache_cooked_write_signed (struct regcache *regcache,
86 int regnum, LONGEST val);
87extern void regcache_cooked_write_unsigned (struct regcache *regcache,
88 int regnum, ULONGEST val);
89
90/* Partial transfer of a cooked register. These perform read, modify,
91 write style operations. */
92
93void regcache_cooked_read_part (struct regcache *regcache, int regnum,
94 int offset, int len, gdb_byte *buf);
95void regcache_cooked_write_part (struct regcache *regcache, int regnum,
96 int offset, int len, const gdb_byte *buf);
97
98/* Special routines to read/write the PC. */
99
100extern CORE_ADDR regcache_read_pc (struct regcache *regcache);
101extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc);
102
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(). */
106
107extern void regcache_raw_supply (struct regcache *regcache,
108 int regnum, const void *buf);
109extern void regcache_raw_collect (const struct regcache *regcache,
110 int regnum, void *buf);
111
112
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. */
116
117extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
118
119
120/* Return the size of register REGNUM. All registers should have only
121 one size. */
122
123extern int register_size (struct gdbarch *gdbarch, int regnum);
124
125
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. */
130
131typedef int (regcache_cooked_read_ftype) (void *src, int regnum,
132 gdb_byte *buf);
133
134extern void regcache_save (struct regcache *dst,
135 regcache_cooked_read_ftype *cooked_read,
136 void *cooked_read_context);
137extern void regcache_restore (struct regcache *dst,
138 regcache_cooked_read_ftype *cooked_read,
139 void *cooked_read_context);
140
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.
144
145 The ``cpy'' functions can not have overlapping SRC and DST buffers.
146
147 ``no passthrough'' versions do not go through to the target. They
148 only transfer values already in the cache. */
149
150extern struct regcache *regcache_dup (struct regcache *regcache);
151extern struct regcache *regcache_dup_no_passthrough (struct regcache *regcache);
152extern void regcache_cpy (struct regcache *dest, struct regcache *src);
153extern void regcache_cpy_no_passthrough (struct regcache *dest, struct regcache *src);
154
155extern void registers_changed (void);
156
157#endif /* REGCACHE_H */