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