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