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