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 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 */