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 */ 488