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