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, 2010, 2011 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 struct address_space; 27 28 extern struct regcache *get_current_regcache (void); 29 extern struct regcache *get_thread_regcache (ptid_t ptid); 30 extern struct regcache *get_thread_arch_regcache (ptid_t, struct gdbarch *); 31 32 void regcache_xfree (struct regcache *regcache); 33 struct cleanup *make_cleanup_regcache_xfree (struct regcache *regcache); 34 struct regcache *regcache_xmalloc (struct gdbarch *gdbarch, 35 struct address_space *aspace); 36 37 /* Return REGCACHE's architecture. */ 38 39 extern struct gdbarch *get_regcache_arch (const struct regcache *regcache); 40 41 /* Return REGCACHE's address space. */ 42 43 extern struct address_space *get_regcache_aspace (const struct regcache *); 44 45 enum register_status 46 { 47 /* The register value is not in the cache, and we don't know yet 48 whether it's available in the target (or traceframe). */ 49 REG_UNKNOWN = 0, 50 51 /* The register value is valid and cached. */ 52 REG_VALID = 1, 53 54 /* The register value is unavailable. E.g., we're inspecting a 55 traceframe, and this register wasn't collected. Note that this 56 is different a different "unavailable" from saying the register 57 does not exist in the target's architecture --- in that case, 58 the target should have given us a target description that does 59 not include the register in the first place. */ 60 REG_UNAVAILABLE = -1 61 }; 62 63 enum register_status regcache_register_status (const struct regcache *regcache, 64 int regnum); 65 66 /* Transfer a raw register [0..NUM_REGS) between core-gdb and the 67 regcache. The read variants return the status of the register. */ 68 69 enum register_status regcache_raw_read (struct regcache *regcache, 70 int rawnum, gdb_byte *buf); 71 void regcache_raw_write (struct regcache *regcache, int rawnum, 72 const gdb_byte *buf); 73 extern enum register_status 74 regcache_raw_read_signed (struct regcache *regcache, 75 int regnum, LONGEST *val); 76 extern enum register_status 77 regcache_raw_read_unsigned (struct regcache *regcache, 78 int regnum, ULONGEST *val); 79 extern void regcache_raw_write_signed (struct regcache *regcache, 80 int regnum, LONGEST val); 81 extern void regcache_raw_write_unsigned (struct regcache *regcache, 82 int regnum, ULONGEST val); 83 84 /* Partial transfer of raw registers. These perform read, modify, 85 write style operations. The read variant returns the status of the 86 register. */ 87 88 extern enum register_status 89 regcache_raw_read_part (struct regcache *regcache, int regnum, 90 int offset, int len, gdb_byte *buf); 91 void regcache_raw_write_part (struct regcache *regcache, int regnum, 92 int offset, int len, const gdb_byte *buf); 93 94 void regcache_invalidate (struct regcache *regcache, int regnum); 95 96 /* Transfer of pseudo-registers. The read variants return a register 97 status, as an indication of when a ``cooked'' register was 98 constructed from valid, invalid or unavailable ``raw'' 99 registers. */ 100 101 /* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS). */ 102 enum register_status regcache_cooked_read (struct regcache *regcache, 103 int rawnum, gdb_byte *buf); 104 void regcache_cooked_write (struct regcache *regcache, int rawnum, 105 const gdb_byte *buf); 106 107 /* Read a register as a signed/unsigned quantity. */ 108 extern enum register_status 109 regcache_cooked_read_signed (struct regcache *regcache, 110 int regnum, LONGEST *val); 111 extern enum register_status 112 regcache_cooked_read_unsigned (struct regcache *regcache, 113 int regnum, ULONGEST *val); 114 extern void regcache_cooked_write_signed (struct regcache *regcache, 115 int regnum, LONGEST val); 116 extern void regcache_cooked_write_unsigned (struct regcache *regcache, 117 int regnum, ULONGEST val); 118 119 /* Partial transfer of a cooked register. These perform read, modify, 120 write style operations. */ 121 122 enum register_status regcache_cooked_read_part (struct regcache *regcache, 123 int regnum, int offset, 124 int len, gdb_byte *buf); 125 void regcache_cooked_write_part (struct regcache *regcache, int regnum, 126 int offset, int len, const gdb_byte *buf); 127 128 /* Special routines to read/write the PC. */ 129 130 extern CORE_ADDR regcache_read_pc (struct regcache *regcache); 131 extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc); 132 133 /* Transfer a raw register [0..NUM_REGS) between the regcache and the 134 target. These functions are called by the target in response to a 135 target_fetch_registers() or target_store_registers(). */ 136 137 extern void regcache_raw_supply (struct regcache *regcache, 138 int regnum, const void *buf); 139 extern void regcache_raw_collect (const struct regcache *regcache, 140 int regnum, void *buf); 141 142 143 /* The type of a register. This function is slightly more efficient 144 then its gdbarch vector counterpart since it returns a precomputed 145 value stored in a table. */ 146 147 extern struct type *register_type (struct gdbarch *gdbarch, int regnum); 148 149 150 /* Return the size of register REGNUM. All registers should have only 151 one size. */ 152 153 extern int register_size (struct gdbarch *gdbarch, int regnum); 154 155 156 /* Save/restore a register cache. The set of registers saved / 157 restored into the DST regcache determined by the save_reggroup / 158 restore_reggroup respectively. COOKED_READ returns zero iff the 159 register's value can't be returned. */ 160 161 typedef enum register_status (regcache_cooked_read_ftype) (void *src, 162 int regnum, 163 gdb_byte *buf); 164 165 extern void regcache_save (struct regcache *dst, 166 regcache_cooked_read_ftype *cooked_read, 167 void *cooked_read_context); 168 extern void regcache_restore (struct regcache *dst, 169 regcache_cooked_read_ftype *cooked_read, 170 void *cooked_read_context); 171 172 /* Copy/duplicate the contents of a register cache. By default, the 173 operation is pass-through. Writes to DST and reads from SRC will 174 go through to the target. 175 176 The ``cpy'' functions can not have overlapping SRC and DST buffers. 177 178 ``no passthrough'' versions do not go through to the target. They 179 only transfer values already in the cache. */ 180 181 extern struct regcache *regcache_dup (struct regcache *regcache); 182 extern void regcache_cpy (struct regcache *dest, struct regcache *src); 183 extern void regcache_cpy_no_passthrough (struct regcache *dest, 184 struct regcache *src); 185 186 extern void registers_changed (void); 187 extern void registers_changed_ptid (ptid_t); 188 189 #endif /* REGCACHE_H */ 190