gdb/regcache.h

   1 /* Cache and manage the values of registers for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2020 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 "gdbsupport/common-regcache.h"
  24 #include "gdbsupport/function-view.h"
  25
  26 struct regcache;
  27 struct regset;
  28 struct gdbarch;
  29 struct address_space;
  30 class thread_info;
  31 struct process_stratum_target;
  32
  33 extern struct regcache *get_current_regcache (void);
  34 extern struct regcache *get_thread_regcache (process_stratum_target *target,
  35                                              ptid_t ptid);
  36
  37 /* Get the regcache of THREAD.  */
  38 extern struct regcache *get_thread_regcache (thread_info *thread);
  39
  40 extern struct regcache *get_thread_arch_regcache
  41   (process_stratum_target *targ, ptid_t, struct gdbarch *);
  42 extern struct regcache *get_thread_arch_aspace_regcache
  43   (process_stratum_target *target, ptid_t,
  44    struct gdbarch *, struct address_space *);
  45
  46 extern enum register_status
  47   regcache_raw_read_signed (struct regcache *regcache,
  48                             int regnum, LONGEST *val);
  49
  50 extern void regcache_raw_write_signed (struct regcache *regcache,
  51                                        int regnum, LONGEST val);
  52 extern void regcache_raw_write_unsigned (struct regcache *regcache,
  53                                          int regnum, ULONGEST val);
  54
  55 /* Return the register's value in signed or throw if it's not
  56    available.  */
  57
  58 extern LONGEST regcache_raw_get_signed (struct regcache *regcache,
  59                                         int regnum);
  60
  61 /* Read a register as a signed/unsigned quantity.  */
  62 extern enum register_status
  63   regcache_cooked_read_signed (struct regcache *regcache,
  64                                int regnum, LONGEST *val);
  65 extern enum register_status
  66   regcache_cooked_read_unsigned (struct regcache *regcache,
  67                                  int regnum, ULONGEST *val);
  68 extern void regcache_cooked_write_signed (struct regcache *regcache,
  69                                           int regnum, LONGEST val);
  70 extern void regcache_cooked_write_unsigned (struct regcache *regcache,
  71                                             int regnum, ULONGEST val);
  72
  73 /* Special routines to read/write the PC.  */
  74
  75 /* For regcache_read_pc see gdbsupport/common-regcache.h.  */
  76 extern void regcache_write_pc (struct regcache *regcache, CORE_ADDR pc);
  77
  78 /* Mapping between register numbers and offsets in a buffer, for use
  79    in the '*regset' functions below and with traditional frame caches.
  80    In an array of 'regcache_map_entry' each element is interpreted
  81    like follows:
  82
  83    - If 'regno' is a register number: Map register 'regno' to the
  84      current offset (starting with 0) and increase the current offset
  85      by 'size' (or the register's size, if 'size' is zero).  Repeat
  86      this with consecutive register numbers up to 'regno+count-1'.
  87
  88      For each described register, if 'size' is larger than the
  89      register's size, the register's value is assumed to be stored in
  90      the first N (where N is the register size) bytes at the current
  91      offset.  The remaining 'size' - N bytes are filled with zeroes by
  92      'regcache_collect_regset' and ignored by other consumers.
  93
  94      If 'size' is smaller than the register's size, only the first
  95      'size' bytes of a register's value are assumed to be stored at
  96      the current offset.  'regcache_collect_regset' copies the first
  97      'size' bytes of a register's value to the output buffer.
  98      'regcache_supply_regset' copies the bytes from the input buffer
  99      into the first 'size' bytes of the register's value leaving the
 100      remaining bytes of the register's value unchanged.  Frame caches
 101      read the 'size' bytes from the stack frame and zero extend them
 102      to generate the register's value.
 103
 104    - If 'regno' is REGCACHE_MAP_SKIP: Add 'count*size' to the current
 105      offset.
 106
 107    - If count=0: End of the map.  */
 108
 109 struct regcache_map_entry
 110 {
 111   int count;
 112   int regno;
 113   int size;
 114 };
 115
 116 /* Special value for the 'regno' field in the struct above.  */
 117
 118 enum
 119   {
 120     REGCACHE_MAP_SKIP = -1,
 121   };
 122
 123 /* Calculate and return the total size of all the registers in a
 124    regcache_map_entry.  */
 125
 126 static inline int
 127 regcache_map_entry_size (const struct regcache_map_entry *map)
 128 {
 129   int size = 0;
 130   for (int i = 0; map[i].count != 0; i++)
 131     size += (map[i].count * map[i].size);
 132   return size;
 133 }
 134
 135 /* Transfer a set of registers (as described by REGSET) between
 136    REGCACHE and BUF.  If REGNUM == -1, transfer all registers
 137    belonging to the regset, otherwise just the register numbered
 138    REGNUM.  The REGSET's 'regmap' field must point to an array of
 139    'struct regcache_map_entry'.
 140
 141    These functions are suitable for the 'regset_supply' and
 142    'regset_collect' fields in a regset structure.  */
 143
 144 extern void regcache_supply_regset (const struct regset *regset,
 145                                     struct regcache *regcache,
 146                                     int regnum, const void *buf,
 147                                     size_t size);
 148 extern void regcache_collect_regset (const struct regset *regset,
 149                                      const struct regcache *regcache,
 150                                      int regnum, void *buf, size_t size);
 151
 152
 153 /* The type of a register.  This function is slightly more efficient
 154    then its gdbarch vector counterpart since it returns a precomputed
 155    value stored in a table.  */
 156
 157 extern struct type *register_type (struct gdbarch *gdbarch, int regnum);
 158
 159
 160 /* Return the size of register REGNUM.  All registers should have only
 161    one size.  */
 162
 163 extern int register_size (struct gdbarch *gdbarch, int regnum);
 164
 165 typedef gdb::function_view<register_status (int regnum, gdb_byte *buf)>
 166   register_read_ftype;
 167
 168 /* A (register_number, register_value) pair.  */
 169
 170 typedef struct cached_reg
 171 {
 172   int num;
 173   gdb_byte *data;
 174 } cached_reg_t;
 175
 176 /* Buffer of registers.  */
 177
 178 class reg_buffer : public reg_buffer_common
 179 {
 180 public:
 181   reg_buffer (gdbarch *gdbarch, bool has_pseudo);
 182
 183   DISABLE_COPY_AND_ASSIGN (reg_buffer);
 184
 185   /* Return regcache's architecture.  */
 186   gdbarch *arch () const;
 187
 188   /* See gdbsupport/common-regcache.h.  */
 189   enum register_status get_register_status (int regnum) const override;
 190
 191   /* See gdbsupport/common-regcache.h.  */
 192   void raw_collect (int regnum, void *buf) const override;
 193
 194   /* Collect register REGNUM from REGCACHE.  Store collected value as an integer
 195      at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
 196      If ADDR_LEN is greater than the register size, then the integer will be
 197      sign or zero extended.  If ADDR_LEN is smaller than the register size, then
 198      the most significant bytes of the integer will be truncated.  */
 199   void raw_collect_integer (int regnum, gdb_byte *addr, int addr_len,
 200                             bool is_signed) const;
 201
 202   /* Collect register REGNUM from REGCACHE, starting at OFFSET in register,
 203      reading only LEN.  */
 204   void raw_collect_part (int regnum, int offset, int len, gdb_byte *out) const;
 205
 206   /* See gdbsupport/common-regcache.h.  */
 207   void raw_supply (int regnum, const void *buf) override;
 208
 209   void raw_supply (int regnum, const reg_buffer &src)
 210   {
 211     raw_supply (regnum, src.register_buffer (regnum));
 212   }
 213
 214   /* Supply register REGNUM to REGCACHE.  Value to supply is an integer stored
 215      at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED.
 216      If the register size is greater than ADDR_LEN, then the integer will be
 217      sign or zero extended.  If the register size is smaller than the integer,
 218      then the most significant bytes of the integer will be truncated.  */
 219   void raw_supply_integer (int regnum, const gdb_byte *addr, int addr_len,
 220                            bool is_signed);
 221
 222   /* Supply register REGNUM with zeroed value to REGCACHE.  This is not the same
 223      as calling raw_supply with NULL (which will set the state to
 224      unavailable).  */
 225   void raw_supply_zeroed (int regnum);
 226
 227   /* Supply register REGNUM to REGCACHE, starting at OFFSET in register, writing
 228      only LEN, without editing the rest of the register.  */
 229   void raw_supply_part (int regnum, int offset, int len, const gdb_byte *in);
 230
 231   void invalidate (int regnum);
 232
 233   virtual ~reg_buffer () = default;
 234
 235   /* See gdbsupport/common-regcache.h.  */
 236   bool raw_compare (int regnum, const void *buf, int offset) const override;
 237
 238 protected:
 239   /* Assert on the range of REGNUM.  */
 240   void assert_regnum (int regnum) const;
 241
 242   int num_raw_registers () const;
 243
 244   gdb_byte *register_buffer (int regnum) const;
 245
 246   /* Save a register cache.  The set of registers saved into the
 247      regcache determined by the save_reggroup.  COOKED_READ returns
 248      zero iff the register's value can't be returned.  */
 249   void save (register_read_ftype cooked_read);
 250
 251   struct regcache_descr *m_descr;
 252
 253   bool m_has_pseudo;
 254   /* The register buffers.  */
 255   std::unique_ptr<gdb_byte[]> m_registers;
 256   /* Register cache status.  */
 257   std::unique_ptr<register_status[]> m_register_status;
 258
 259   friend class regcache;
 260   friend class detached_regcache;
 261 };
 262
 263 /* An abstract class which only has methods doing read.  */
 264
 265 class readable_regcache : public reg_buffer
 266 {
 267 public:
 268   readable_regcache (gdbarch *gdbarch, bool has_pseudo)
 269     : reg_buffer (gdbarch, has_pseudo)
 270   {}
 271
 272   /* Transfer a raw register [0..NUM_REGS) from core-gdb to this regcache,
 273      return its value in *BUF and return its availability status.  */
 274
 275   enum register_status raw_read (int regnum, gdb_byte *buf);
 276   template<typename T, typename = RequireLongest<T>>
 277   enum register_status raw_read (int regnum, T *val);
 278
 279   /* Partial transfer of raw registers.  Return the status of the register.  */
 280   enum register_status raw_read_part (int regnum, int offset, int len,
 281                                       gdb_byte *buf);
 282
 283   /* Make certain that the register REGNUM is up-to-date.  */
 284   virtual void raw_update (int regnum) = 0;
 285
 286   /* Transfer a raw register [0..NUM_REGS+NUM_PSEUDO_REGS) from core-gdb to
 287      this regcache, return its value in *BUF and return its availability status.  */
 288   enum register_status cooked_read (int regnum, gdb_byte *buf);
 289   template<typename T, typename = RequireLongest<T>>
 290   enum register_status cooked_read (int regnum, T *val);
 291
 292   /* Partial transfer of a cooked register.  */
 293   enum register_status cooked_read_part (int regnum, int offset, int len,
 294                                          gdb_byte *buf);
 295
 296   /* Read register REGNUM from the regcache and return a new value.  This
 297      will call mark_value_bytes_unavailable as appropriate.  */
 298   struct value *cooked_read_value (int regnum);
 299
 300 protected:
 301
 302   /* Perform a partial register transfer using a read, modify, write
 303      operation.  Will fail if register is currently invalid.  */
 304   enum register_status read_part (int regnum, int offset, int len,
 305                                   gdb_byte *out, bool is_raw);
 306 };
 307
 308 /* Buffer of registers, can be read and written.  */
 309
 310 class detached_regcache : public readable_regcache
 311 {
 312 public:
 313   detached_regcache (gdbarch *gdbarch, bool has_pseudo)
 314     : readable_regcache (gdbarch, has_pseudo)
 315   {}
 316
 317   void raw_update (int regnum) override
 318   {}
 319
 320   DISABLE_COPY_AND_ASSIGN (detached_regcache);
 321 };
 322
 323 class readonly_detached_regcache;
 324
 325 /* The register cache for storing raw register values.  */
 326
 327 class regcache : public detached_regcache
 328 {
 329 public:
 330   DISABLE_COPY_AND_ASSIGN (regcache);
 331
 332   /* Return REGCACHE's address space.  */
 333   const address_space *aspace () const
 334   {
 335     return m_aspace;
 336   }
 337
 338   /* Restore 'this' regcache.  The set of registers restored into
 339      the regcache determined by the restore_reggroup.
 340      Writes to regcache will go through to the target.  SRC is a
 341      read-only register cache.  */
 342   void restore (readonly_detached_regcache *src);
 343
 344   /* Update the value of raw register REGNUM (in the range [0..NUM_REGS)) and
 345      transfer its value to core-gdb.  */
 346
 347   void raw_write (int regnum, const gdb_byte *buf);
 348
 349   template<typename T, typename = RequireLongest<T>>
 350   void raw_write (int regnum, T val);
 351
 352   /* Transfer of pseudo-registers.  */
 353   void cooked_write (int regnum, const gdb_byte *buf);
 354
 355   template<typename T, typename = RequireLongest<T>>
 356   void cooked_write (int regnum, T val);
 357
 358   void raw_update (int regnum) override;
 359
 360   /* Partial transfer of raw registers.  Perform read, modify, write style
 361      operations.  */
 362   void raw_write_part (int regnum, int offset, int len, const gdb_byte *buf);
 363
 364   /* Partial transfer of a cooked register.  Perform read, modify, write style
 365      operations.  */
 366   void cooked_write_part (int regnum, int offset, int len,
 367                           const gdb_byte *buf);
 368
 369   void supply_regset (const struct regset *regset,
 370                       int regnum, const void *buf, size_t size);
 371
 372
 373   void collect_regset (const struct regset *regset, int regnum,
 374                        void *buf, size_t size) const;
 375
 376   /* Return REGCACHE's ptid.  */
 377
 378   ptid_t ptid () const
 379   {
 380     gdb_assert (m_ptid != minus_one_ptid);
 381
 382     return m_ptid;
 383   }
 384
 385   void set_ptid (const ptid_t ptid)
 386   {
 387     this->m_ptid = ptid;
 388   }
 389
 390   process_stratum_target *target () const
 391   {
 392     return m_target;
 393   }
 394
 395 /* Dump the contents of a register from the register cache to the target
 396    debug.  */
 397   void debug_print_register (const char *func, int regno);
 398
 399 protected:
 400   regcache (process_stratum_target *target, gdbarch *gdbarch,
 401             const address_space *aspace);
 402
 403 private:
 404
 405   /* Helper function for transfer_regset.  Copies across a single register.  */
 406   void transfer_regset_register (struct regcache *out_regcache, int regnum,
 407                                  const gdb_byte *in_buf, gdb_byte *out_buf,
 408                                  int slot_size, int offs) const;
 409
 410   /* Transfer a single or all registers belonging to a certain register
 411      set to or from a buffer.  This is the main worker function for
 412      regcache_supply_regset and regcache_collect_regset.  */
 413   void transfer_regset (const struct regset *regset,
 414                         struct regcache *out_regcache,
 415                         int regnum, const gdb_byte *in_buf,
 416                         gdb_byte *out_buf, size_t size) const;
 417
 418   /* Perform a partial register transfer using a read, modify, write
 419      operation.  */
 420   enum register_status write_part (int regnum, int offset, int len,
 421                                    const gdb_byte *in, bool is_raw);
 422
 423   /* The address space of this register cache (for registers where it
 424      makes sense, like PC or SP).  */
 425   const address_space * const m_aspace;
 426
 427   /* If this is a read-write cache, which thread's registers is
 428      it connected to?  */
 429   process_stratum_target *m_target;
 430   ptid_t m_ptid;
 431
 432   friend struct regcache *
 433   get_thread_arch_aspace_regcache (process_stratum_target *target, ptid_t ptid,
 434                                    struct gdbarch *gdbarch,
 435                                    struct address_space *aspace);
 436 };
 437
 438 using regcache_up = std::unique_ptr<regcache>;
 439
 440 class readonly_detached_regcache : public readable_regcache
 441 {
 442 public:
 443   readonly_detached_regcache (regcache &src);
 444
 445   /* Create a readonly regcache by getting contents from COOKED_READ.  */
 446
 447   readonly_detached_regcache (gdbarch *gdbarch, register_read_ftype cooked_read)
 448     : readable_regcache (gdbarch, true)
 449   {
 450     save (cooked_read);
 451   }
 452
 453   DISABLE_COPY_AND_ASSIGN (readonly_detached_regcache);
 454
 455   void raw_update (int regnum) override
 456   {}
 457 };
 458
 459 extern void registers_changed (void);
 460 extern void registers_changed_ptid (process_stratum_target *target,
 461                                     ptid_t ptid);
 462
 463 /* Indicate that registers of THREAD may have changed, so invalidate
 464    the cache.  */
 465 extern void registers_changed_thread (thread_info *thread);
 466
 467 /* An abstract base class for register dump.  */
 468
 469 class register_dump
 470 {
 471 public:
 472   void dump (ui_file *file);
 473   virtual ~register_dump () = default;
 474
 475 protected:
 476   register_dump (gdbarch *arch)
 477     : m_gdbarch (arch)
 478   {}
 479
 480   /* Dump the register REGNUM contents.  If REGNUM is -1, print the
 481      header.  */
 482   virtual void dump_reg (ui_file *file, int regnum) = 0;
 483
 484   gdbarch *m_gdbarch;
 485 };
 486
 487 #endif /* REGCACHE_H */