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