gdb/regcache.h

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