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