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 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 extern struct regcache *get_thread_arch_regcache (ptid_t, struct gdbarch *); 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 /* Return REGCACHE's architecture. */ 36 37 extern 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 42 void regcache_raw_read (struct regcache *regcache, int rawnum, gdb_byte *buf); 43 void regcache_raw_write (struct regcache *regcache, int rawnum, 44 const gdb_byte *buf); 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); 53 54 /* Partial transfer of a raw registers. These perform read, modify, 55 write style operations. */ 56 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); 61 62 int regcache_valid_p (const struct regcache *regcache, int regnum); 63 64 void regcache_invalidate (struct regcache *regcache, int regnum); 65 66 /* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */ 67 void regcache_cooked_read (struct regcache *regcache, int rawnum, 68 gdb_byte *buf); 69 void 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. */ 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); 89 90 /* Partial transfer of a cooked register. These perform read, modify, 91 write style operations. */ 92 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); 97 98 /* Special routines to read/write the PC. */ 99 100 extern CORE_ADDR regcache_read_pc (struct regcache *regcache); 101 extern 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 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); 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 117 extern 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 123 extern 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 131 typedef int (regcache_cooked_read_ftype) (void *src, int regnum, 132 gdb_byte *buf); 133 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); 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 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); 154 155 extern void registers_changed (void); 156 157 #endif /* REGCACHE_H */ 158