gdb/regcache.h

   1 /* Cache and manage the values of registers for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2014 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 regset;
  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 /* Mapping between register numbers and offsets in a buffer, for use
 152    in the '*regset' functions below.  In an array of
 153    'regcache_map_entry' each element is interpreted like follows:
 154
 155    - If 'regno' is a register number: Map register 'regno' to the
 156      current offset (starting with 0) and increase the current offset
 157      by 'size' (or the register's size, if 'size' is zero).  Repeat
 158      this with consecutive register numbers up to 'regno+count-1'.
 159
 160    - If 'regno' is REGCACHE_MAP_SKIP: Add 'count*size' to the current
 161      offset.
 162
 163    - If count=0: End of the map.  */
 164
 165 struct regcache_map_entry
 166 {
 167   int count;
 168   int regno;
 169   int size;
 170 };
 171
 172 /* Special value for the 'regno' field in the struct above.  */
 173
 174 enum
 175   {
 176     REGCACHE_MAP_SKIP = -1,
 177   };
 178
 179 /* Transfer a set of registers (as described by REGSET) between
 180    REGCACHE and BUF.  If REGNUM == -1, transfer all registers
 181    belonging to the regset, otherwise just the register numbered
 182    REGNUM.  The REGSET's 'regmap' field must point to an array of
 183    'struct regcache_map_entry'.
 184
 185    These functions are suitable for the 'regset_supply' and
 186    'regset_collect' fields in a regset structure.  */
 187
 188 extern void regcache_supply_regset (const struct regset *regset,
 189                                     struct regcache *regcache,
 190                                     int regnum, const void *buf,
 191                                     size_t size);
 192 extern void regcache_collect_regset (const struct regset *regset,
 193                                      const struct regcache *regcache,
 194                                      int regnum, void *buf, size_t size);
 195
 196
 197 /* The type of a register.  This function is slightly more efficient
 198    then its gdbarch vector counterpart since it returns a precomputed
 199    value stored in a table.  */
 200
 201 extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
 202
 203
 204 /* Return the size of register REGNUM.  All registers should have only
 205    one size.  */
 206
 207 extern int register_size (struct gdbarch *gdbarch, int regnum);
 208
 209
 210 /* Save/restore a register cache.  The set of registers saved /
 211    restored into the DST regcache determined by the save_reggroup /
 212    restore_reggroup respectively.  COOKED_READ returns zero iff the
 213    register's value can't be returned.  */
 214
 215 typedef enum register_status (regcache_cooked_read_ftype) (void *src,
 216                                                            int regnum,
 217                                                            gdb_byte *buf);
 218
 219 extern void regcache_save (struct regcache *dst,
 220                            regcache_cooked_read_ftype *cooked_read,
 221                            void *cooked_read_context);
 222
 223 /* Copy/duplicate the contents of a register cache.  By default, the
 224    operation is pass-through.  Writes to DST and reads from SRC will
 225    go through to the target.
 226
 227    The ``cpy'' functions can not have overlapping SRC and DST buffers.
 228
 229    ``no passthrough'' versions do not go through to the target.  They
 230    only transfer values already in the cache.  */
 231
 232 extern struct regcache *regcache_dup (struct regcache *regcache);
 233 extern void regcache_cpy (struct regcache *dest, struct regcache *src);
 234 extern void regcache_cpy_no_passthrough (struct regcache *dest,
 235                                          struct regcache *src);
 236
 237 extern void registers_changed (void);
 238 extern void registers_changed_ptid (ptid_t);
 239
 240 #endif /* REGCACHE_H */