gdb/regcache.h

   1 /* Cache and manage the values of registers for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2018 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 #include <forward_list>
  25
  26 struct regcache;
  27 struct regset;
  28 struct gdbarch;
  29 struct address_space;
  30
  31 extern struct regcache *get_current_regcache (void);
  32 extern struct regcache *get_thread_regcache (ptid_t ptid);
  33 extern struct regcache *get_thread_arch_regcache (ptid_t, struct gdbarch *);
  34 extern struct regcache *get_thread_arch_aspace_regcache (ptid_t,
  35                                                          struct gdbarch *,
  36                                                          struct address_space *);
  37
  38 extern enum register_status
  39   regcache_raw_read_signed (struct regcache *regcache,
  40                             int regnum, LONGEST *val);
  41
  42 extern void regcache_raw_write_signed (struct regcache *regcache,
  43                                        int regnum, LONGEST val);
  44 extern void regcache_raw_write_unsigned (struct regcache *regcache,
  45                                          int regnum, ULONGEST val);
  46
  47 /* Return the register's value in signed or throw if it's not
  48    available.  */
  49
  50 extern LONGEST regcache_raw_get_signed (struct regcache *regcache,
  51                                         int regnum);
  52
  53 /* Read a register as a signed/unsigned quantity.  */
  54 extern enum register_status
  55   regcache_cooked_read_signed (struct regcache *regcache,
  56                                int regnum, LONGEST *val);
  57 extern enum register_status
  58   regcache_cooked_read_unsigned (struct regcache *regcache,
  59                                  int regnum, ULONGEST *val);
  60 extern void regcache_cooked_write_signed (struct regcache *regcache,
  61                                           int regnum, LONGEST val);
  62 extern void regcache_cooked_write_unsigned (struct regcache *regcache,
  63                                             int regnum, ULONGEST val);
  64
  65 /* Special routines to read/write the PC.  */
  66
  67 /* For regcache_read_pc see common/common-regcache.h.  */
  68 extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc);
  69
  70 /* Transfer a raw register [0..NUM_REGS) between the regcache and the
  71    target.  These functions are called by the target in response to a
  72    target_fetch_registers() or target_store_registers().  */
  73
  74 extern void regcache_raw_supply (struct regcache *regcache,
  75                                  int regnum, const void *buf);
  76 extern void regcache_raw_collect (const struct regcache *regcache,
  77                                   int regnum, void *buf);
  78
  79 /* Mapping between register numbers and offsets in a buffer, for use
  80    in the '*regset' functions below.  In an array of
  81    'regcache_map_entry' each element is interpreted like follows:
  82
  83    - If 'regno' is a register number: Map register 'regno' to the
  84      current offset (starting with 0) and increase the current offset
  85      by 'size' (or the register's size, if 'size' is zero).  Repeat
  86      this with consecutive register numbers up to 'regno+count-1'.
  87
  88    - If 'regno' is REGCACHE_MAP_SKIP: Add 'count*size' to the current
  89      offset.
  90
  91    - If count=0: End of the map.  */
  92
  93 struct regcache_map_entry
  94 {
  95   int count;
  96   int regno;
  97   int size;
  98 };
  99
 100 /* Special value for the 'regno' field in the struct above.  */
 101
 102 enum
 103   {
 104     REGCACHE_MAP_SKIP = -1,
 105   };
 106
 107 /* Transfer a set of registers (as described by REGSET) between
 108    REGCACHE and BUF.  If REGNUM == -1, transfer all registers
 109    belonging to the regset, otherwise just the register numbered
 110    REGNUM.  The REGSET's 'regmap' field must point to an array of
 111    'struct regcache_map_entry'.
 112
 113    These functions are suitable for the 'regset_supply' and
 114    'regset_collect' fields in a regset structure.  */
 115
 116 extern void regcache_supply_regset (const struct regset *regset,
 117                                     struct regcache *regcache,
 118                                     int regnum, const void *buf,
 119                                     size_t size);
 120 extern void regcache_collect_regset (const struct regset *regset,
 121                                      const struct regcache *regcache,
 122                                      int regnum, void *buf, size_t size);
 123
 124
 125 /* The type of a register.  This function is slightly more efficient
 126    then its gdbarch vector counterpart since it returns a precomputed
 127    value stored in a table.  */
 128
 129 extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
 130
 131
 132 /* Return the size of register REGNUM.  All registers should have only
 133    one size.  */
 134
 135 extern int register_size (struct gdbarch *gdbarch, int regnum);
 136
 137 typedef enum register_status (regcache_cooked_read_ftype) (void *src,
 138                                                            int regnum,
 139                                                            gdb_byte *buf);
 140
 141 /* A (register_number, register_value) pair.  */
 142
 143 typedef struct cached_reg
 144 {
 145   int num;
 146   gdb_byte *data;
 147 } cached_reg_t;
 148
 149 /* Buffer of registers.  */
 150
 151 class reg_buffer
 152 {
 153 public:
 154   reg_buffer (gdbarch *gdbarch, bool has_pseudo);
 155
 156   DISABLE_COPY_AND_ASSIGN (reg_buffer);
 157
 158   /* Return regcache's architecture.  */
 159   gdbarch *arch () const;
 160
 161   /* Get the availability status of the value of register REGNUM in this
 162      buffer.  */
 163   enum register_status get_register_status (int regnum) const;
 164
 165   virtual ~reg_buffer ()
 166   {
 167     xfree (m_registers);
 168     xfree (m_register_status);
 169   }
 170 protected:
 171   /* Assert on the range of REGNUM.  */
 172   void assert_regnum (int regnum) const;
 173
 174   int num_raw_registers () const;
 175
 176   gdb_byte *register_buffer (int regnum) const;
 177
 178   /* Save a register cache.  The set of registers saved into the
 179      regcache determined by the save_reggroup.  COOKED_READ returns
 180      zero iff the register's value can't be returned.  */
 181   void save (regcache_cooked_read_ftype *cooked_read, void *src);
 182
 183   struct regcache_descr *m_descr;
 184
 185   bool m_has_pseudo;
 186   /* The register buffers.  */
 187   gdb_byte *m_registers;
 188   /* Register cache status.  */
 189   signed char *m_register_status;
 190
 191   friend class regcache;
 192   friend class detached_regcache;
 193 };
 194
 195 /* An abstract class which only has methods doing read.  */
 196
 197 class readable_regcache : public reg_buffer
 198 {
 199 public:
 200   readable_regcache (gdbarch *gdbarch, bool has_pseudo)
 201     : reg_buffer (gdbarch, has_pseudo)
 202   {}
 203
 204   /* Transfer a raw register [0..NUM_REGS) from core-gdb to this regcache,
 205      return its value in *BUF and return its availability status.  */
 206
 207   enum register_status raw_read (int regnum, gdb_byte *buf);
 208   template<typename T, typename = RequireLongest<T>>
 209   enum register_status raw_read (int regnum, T *val);
 210
 211   /* Partial transfer of raw registers.  Return the status of the register.  */
 212   enum register_status raw_read_part (int regnum, int offset, int len,
 213                                       gdb_byte *buf);
 214
 215   /* Make certain that the register REGNUM is up-to-date.  */
 216   virtual void raw_update (int regnum) = 0;
 217
 218   /* Transfer a raw register [0..NUM_REGS+NUM_PSEUDO_REGS) from core-gdb to
 219      this regcache, return its value in *BUF and return its availability status.  */
 220   enum register_status cooked_read (int regnum, gdb_byte *buf);
 221   template<typename T, typename = RequireLongest<T>>
 222   enum register_status cooked_read (int regnum, T *val);
 223
 224   /* Partial transfer of a cooked register.  */
 225   enum register_status cooked_read_part (int regnum, int offset, int len,
 226                                          gdb_byte *buf);
 227
 228   /* Read register REGNUM from the regcache and return a new value.  This
 229      will call mark_value_bytes_unavailable as appropriate.  */
 230   struct value *cooked_read_value (int regnum);
 231
 232 protected:
 233   enum register_status read_part (int regnum, int offset, int len, void *in,
 234                                   bool is_raw);
 235 };
 236
 237 /* Buffer of registers, can be read and written.  */
 238
 239 class detached_regcache : public readable_regcache
 240 {
 241 public:
 242   detached_regcache (gdbarch *gdbarch, bool has_pseudo)
 243     : readable_regcache (gdbarch, has_pseudo)
 244   {}
 245
 246   void raw_supply (int regnum, const void *buf);
 247
 248   void raw_supply (int regnum, const reg_buffer &src)
 249   {
 250     raw_supply (regnum, src.register_buffer (regnum));
 251   }
 252
 253   void raw_update (int regnum) override
 254   {}
 255
 256   void raw_supply_integer (int regnum, const gdb_byte *addr, int addr_len,
 257                            bool is_signed);
 258
 259   void raw_supply_zeroed (int regnum);
 260
 261   void invalidate (int regnum);
 262
 263   DISABLE_COPY_AND_ASSIGN (detached_regcache);
 264 };
 265
 266 class readonly_detached_regcache;
 267
 268 /* The register cache for storing raw register values.  */
 269
 270 class regcache : public detached_regcache
 271 {
 272 public:
 273   DISABLE_COPY_AND_ASSIGN (regcache);
 274
 275   /* Return REGCACHE's address space.  */
 276   const address_space *aspace () const
 277   {
 278     return m_aspace;
 279   }
 280
 281   /* Restore 'this' regcache.  The set of registers restored into
 282      the regcache determined by the restore_reggroup.
 283      Writes to regcache will go through to the target.  SRC is a
 284      read-only register cache.  */
 285   void restore (readonly_detached_regcache *src);
 286
 287   /* Update the value of raw register REGNUM (in the range [0..NUM_REGS)) and
 288      transfer its value to core-gdb.  */
 289
 290   void raw_write (int regnum, const gdb_byte *buf);
 291
 292   template<typename T, typename = RequireLongest<T>>
 293   void raw_write (int regnum, T val);
 294
 295   /* Transfer of pseudo-registers.  */
 296   void cooked_write (int regnum, const gdb_byte *buf);
 297
 298   template<typename T, typename = RequireLongest<T>>
 299   void cooked_write (int regnum, T val);
 300
 301   void raw_update (int regnum) override;
 302
 303   void raw_collect (int regnum, void *buf) const;
 304
 305   void raw_collect_integer (int regnum, gdb_byte *addr, int addr_len,
 306                             bool is_signed) const;
 307
 308   /* Partial transfer of raw registers.  Perform read, modify, write style
 309      operations.  */
 310   void raw_write_part (int regnum, int offset, int len, const gdb_byte *buf);
 311
 312   /* Partial transfer of a cooked register.  Perform read, modify, write style
 313      operations.  */
 314   void cooked_write_part (int regnum, int offset, int len,
 315                           const gdb_byte *buf);
 316
 317   void supply_regset (const struct regset *regset,
 318                       int regnum, const void *buf, size_t size);
 319
 320
 321   void collect_regset (const struct regset *regset, int regnum,
 322                        void *buf, size_t size) const;
 323
 324   /* Return REGCACHE's ptid.  */
 325
 326   ptid_t ptid () const
 327   {
 328     gdb_assert (m_ptid != minus_one_ptid);
 329
 330     return m_ptid;
 331   }
 332
 333   void set_ptid (const ptid_t ptid)
 334   {
 335     this->m_ptid = ptid;
 336   }
 337
 338 /* Dump the contents of a register from the register cache to the target
 339    debug.  */
 340   void debug_print_register (const char *func, int regno);
 341
 342   static void regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid);
 343 protected:
 344   regcache (gdbarch *gdbarch, const address_space *aspace_);
 345   static std::forward_list<regcache *> current_regcache;
 346
 347 private:
 348
 349   void transfer_regset (const struct regset *regset,
 350                         struct regcache *out_regcache,
 351                         int regnum, const void *in_buf,
 352                         void *out_buf, size_t size) const;
 353
 354   enum register_status write_part (int regnum, int offset, int len,
 355                                    const void *out, bool is_raw);
 356
 357
 358   /* The address space of this register cache (for registers where it
 359      makes sense, like PC or SP).  */
 360   const address_space * const m_aspace;
 361
 362   /* If this is a read-write cache, which thread's registers is
 363      it connected to?  */
 364   ptid_t m_ptid;
 365
 366   friend struct regcache *
 367   get_thread_arch_aspace_regcache (ptid_t ptid, struct gdbarch *gdbarch,
 368                                    struct address_space *aspace);
 369
 370   friend void
 371   registers_changed_ptid (ptid_t ptid);
 372 };
 373
 374 class readonly_detached_regcache : public readable_regcache
 375 {
 376 public:
 377   readonly_detached_regcache (const regcache &src);
 378
 379   /* Create a readonly regcache by getting contents from COOKED_READ.  */
 380
 381   readonly_detached_regcache (gdbarch *gdbarch,
 382                               regcache_cooked_read_ftype *cooked_read,
 383                               void *src)
 384     : readable_regcache (gdbarch, true)
 385   {
 386     save (cooked_read, src);
 387   }
 388
 389   DISABLE_COPY_AND_ASSIGN (readonly_detached_regcache);
 390
 391   void raw_update (int regnum) override
 392   {}
 393 };
 394
 395 extern void registers_changed (void);
 396 extern void registers_changed_ptid (ptid_t);
 397
 398 /* An abstract base class for register dump.  */
 399
 400 class register_dump
 401 {
 402 public:
 403   void dump (ui_file *file);
 404   virtual ~register_dump () = default;
 405
 406 protected:
 407   register_dump (gdbarch *arch)
 408     : m_gdbarch (arch)
 409   {}
 410
 411   /* Dump the register REGNUM contents.  If REGNUM is -1, print the
 412      header.  */
 413   virtual void dump_reg (ui_file *file, int regnum) = 0;
 414
 415   gdbarch *m_gdbarch;
 416 };
 417
 418 #endif /* REGCACHE_H */