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