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