gdb/regcache.h

   1 /* Cache and manage the values of registers for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2015 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 #include "common-regcache.h"
  24
  25 struct regcache;
  26 struct regset;
  27 struct gdbarch;
  28 struct address_space;
  29
  30 extern struct regcache *get_current_regcache (void);
  31 extern struct regcache *get_thread_regcache (ptid_t ptid);
  32 extern struct regcache *get_thread_arch_regcache (ptid_t, struct gdbarch *);
  33 extern struct regcache *get_thread_arch_aspace_regcache (ptid_t,
  34                                                          struct gdbarch *,
  35                                                          struct address_space *);
  36
  37 void regcache_xfree (struct regcache *regcache);
  38 struct cleanup *make_cleanup_regcache_xfree (struct regcache *regcache);
  39 struct regcache *regcache_xmalloc (struct gdbarch *gdbarch,
  40                                    struct address_space *aspace);
  41
  42 /* Return REGCACHE's architecture.  */
  43
  44 extern struct gdbarch *get_regcache_arch (const struct regcache *regcache);
  45
  46 /* Return REGCACHE's address space.  */
  47
  48 extern struct address_space *get_regcache_aspace (const struct regcache *);
  49
  50 enum register_status regcache_register_status (const struct regcache *regcache,
  51                                                int regnum);
  52
  53 /* Transfer a raw register [0..NUM_REGS) between core-gdb and the
  54    regcache.  The read variants return the status of the register.  */
  55
  56 enum register_status regcache_raw_read (struct regcache *regcache,
  57                                         int rawnum, gdb_byte *buf);
  58 void regcache_raw_write (struct regcache *regcache, int rawnum,
  59                          const gdb_byte *buf);
  60 extern enum register_status
  61   regcache_raw_read_signed (struct regcache *regcache,
  62                             int regnum, LONGEST *val);
  63
  64 extern void regcache_raw_write_signed (struct regcache *regcache,
  65                                        int regnum, LONGEST val);
  66 extern void regcache_raw_write_unsigned (struct regcache *regcache,
  67                                          int regnum, ULONGEST val);
  68
  69 /* Partial transfer of raw registers.  These perform read, modify,
  70    write style operations.  The read variant returns the status of the
  71    register.  */
  72
  73 extern enum register_status
  74   regcache_raw_read_part (struct regcache *regcache, int regnum,
  75                           int offset, int len, gdb_byte *buf);
  76 void regcache_raw_write_part (struct regcache *regcache, int regnum,
  77                               int offset, int len, const gdb_byte *buf);
  78
  79 void regcache_invalidate (struct regcache *regcache, int regnum);
  80
  81 /* Transfer of pseudo-registers.  The read variants return a register
  82    status, as an indication of when a ``cooked'' register was
  83    constructed from valid, invalid or unavailable ``raw''
  84    registers.  */
  85
  86 /* Transfer a cooked register [0..NUM_REGS+NUM_PSEUDO_REGS).  */
  87 enum register_status regcache_cooked_read (struct regcache *regcache,
  88                                            int rawnum, gdb_byte *buf);
  89 void regcache_cooked_write (struct regcache *regcache, int rawnum,
  90                             const gdb_byte *buf);
  91
  92 /* Read register REGNUM from REGCACHE and return a new value.  This
  93    will call mark_value_bytes_unavailable as appropriate.  */
  94
  95 struct value *regcache_cooked_read_value (struct regcache *regcache,
  96                                           int regnum);
  97
  98 /* Read a register as a signed/unsigned quantity.  */
  99 extern enum register_status
 100   regcache_cooked_read_signed (struct regcache *regcache,
 101                                int regnum, LONGEST *val);
 102 extern enum register_status
 103   regcache_cooked_read_unsigned (struct regcache *regcache,
 104                                  int regnum, ULONGEST *val);
 105 extern void regcache_cooked_write_signed (struct regcache *regcache,
 106                                           int regnum, LONGEST val);
 107 extern void regcache_cooked_write_unsigned (struct regcache *regcache,
 108                                             int regnum, ULONGEST val);
 109
 110 /* Partial transfer of a cooked register.  These perform read, modify,
 111    write style operations.  */
 112
 113 enum register_status regcache_cooked_read_part (struct regcache *regcache,
 114                                                 int regnum, int offset,
 115                                                 int len, gdb_byte *buf);
 116 void regcache_cooked_write_part (struct regcache *regcache, int regnum,
 117                                  int offset, int len, const gdb_byte *buf);
 118
 119 /* Special routines to read/write the PC.  */
 120
 121 /* For regcache_read_pc see common/common-regcache.h.  */
 122 extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc);
 123
 124 /* Transfer a raw register [0..NUM_REGS) between the regcache and the
 125    target.  These functions are called by the target in response to a
 126    target_fetch_registers() or target_store_registers().  */
 127
 128 extern void regcache_raw_supply (struct regcache *regcache,
 129                                  int regnum, const void *buf);
 130 extern void regcache_raw_collect (const struct regcache *regcache,
 131                                   int regnum, void *buf);
 132
 133 /* Mapping between register numbers and offsets in a buffer, for use
 134    in the '*regset' functions below.  In an array of
 135    'regcache_map_entry' each element is interpreted like follows:
 136
 137    - If 'regno' is a register number: Map register 'regno' to the
 138      current offset (starting with 0) and increase the current offset
 139      by 'size' (or the register's size, if 'size' is zero).  Repeat
 140      this with consecutive register numbers up to 'regno+count-1'.
 141
 142    - If 'regno' is REGCACHE_MAP_SKIP: Add 'count*size' to the current
 143      offset.
 144
 145    - If count=0: End of the map.  */
 146
 147 struct regcache_map_entry
 148 {
 149   int count;
 150   int regno;
 151   int size;
 152 };
 153
 154 /* Special value for the 'regno' field in the struct above.  */
 155
 156 enum
 157   {
 158     REGCACHE_MAP_SKIP = -1,
 159   };
 160
 161 /* Transfer a set of registers (as described by REGSET) between
 162    REGCACHE and BUF.  If REGNUM == -1, transfer all registers
 163    belonging to the regset, otherwise just the register numbered
 164    REGNUM.  The REGSET's 'regmap' field must point to an array of
 165    'struct regcache_map_entry'.
 166
 167    These functions are suitable for the 'regset_supply' and
 168    'regset_collect' fields in a regset structure.  */
 169
 170 extern void regcache_supply_regset (const struct regset *regset,
 171                                     struct regcache *regcache,
 172                                     int regnum, const void *buf,
 173                                     size_t size);
 174 extern void regcache_collect_regset (const struct regset *regset,
 175                                      const struct regcache *regcache,
 176                                      int regnum, void *buf, size_t size);
 177
 178
 179 /* The type of a register.  This function is slightly more efficient
 180    then its gdbarch vector counterpart since it returns a precomputed
 181    value stored in a table.  */
 182
 183 extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
 184
 185
 186 /* Return the size of register REGNUM.  All registers should have only
 187    one size.  */
 188
 189 extern int register_size (struct gdbarch *gdbarch, int regnum);
 190
 191
 192 /* Save/restore a register cache.  The set of registers saved /
 193    restored into the DST regcache determined by the save_reggroup /
 194    restore_reggroup respectively.  COOKED_READ returns zero iff the
 195    register's value can't be returned.  */
 196
 197 typedef enum register_status (regcache_cooked_read_ftype) (void *src,
 198                                                            int regnum,
 199                                                            gdb_byte *buf);
 200
 201 extern void regcache_save (struct regcache *dst,
 202                            regcache_cooked_read_ftype *cooked_read,
 203                            void *cooked_read_context);
 204
 205 /* Copy/duplicate the contents of a register cache.  By default, the
 206    operation is pass-through.  Writes to DST and reads from SRC will
 207    go through to the target.  See also regcache_cpy_no_passthrough.
 208
 209    regcache_cpy can not have overlapping SRC and DST buffers.  */
 210
 211 extern struct regcache *regcache_dup (struct regcache *regcache);
 212 extern void regcache_cpy (struct regcache *dest, struct regcache *src);
 213
 214 extern void registers_changed (void);
 215 extern void registers_changed_ptid (ptid_t);
 216
 217 #endif /* REGCACHE_H */