OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [regcache.h] - Blame information for rev 827

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.