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