1 /* Cache and manage the values of registers for GDB, the GNU debugger. 2 3 Copyright (C) 1986-2019 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/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 34 /* Get the regcache of THREAD. */ 35 extern struct regcache *get_thread_regcache (thread_info *thread); 36 37 extern struct regcache *get_thread_arch_regcache (ptid_t, struct gdbarch *); 38 extern struct regcache *get_thread_arch_aspace_regcache (ptid_t, 39 struct gdbarch *, 40 struct address_space *); 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 common/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 /* The type of a register. This function is slightly more efficient 150 then its gdbarch vector counterpart since it returns a precomputed 151 value stored in a table. */ 152 153 extern struct type *register_type (struct gdbarch *gdbarch, int regnum); 154 155 156 /* Return the size of register REGNUM. All registers should have only 157 one size. */ 158 159 extern int register_size (struct gdbarch *gdbarch, int regnum); 160 161 typedef gdb::function_view<register_status (int regnum, gdb_byte *buf)> 162 register_read_ftype; 163 164 /* A (register_number, register_value) pair. */ 165 166 typedef struct cached_reg 167 { 168 int num; 169 gdb_byte *data; 170 } cached_reg_t; 171 172 /* Buffer of registers. */ 173 174 class reg_buffer : public reg_buffer_common 175 { 176 public: 177 reg_buffer (gdbarch *gdbarch, bool has_pseudo); 178 179 DISABLE_COPY_AND_ASSIGN (reg_buffer); 180 181 /* Return regcache's architecture. */ 182 gdbarch *arch () const; 183 184 /* See common/common-regcache.h. */ 185 enum register_status get_register_status (int regnum) const override; 186 187 /* See common/common-regcache.h. */ 188 void raw_collect (int regnum, void *buf) const override; 189 190 /* Collect register REGNUM from REGCACHE. Store collected value as an integer 191 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED. 192 If ADDR_LEN is greater than the register size, then the integer will be 193 sign or zero extended. If ADDR_LEN is smaller than the register size, then 194 the most significant bytes of the integer will be truncated. */ 195 void raw_collect_integer (int regnum, gdb_byte *addr, int addr_len, 196 bool is_signed) const; 197 198 /* Collect register REGNUM from REGCACHE, starting at OFFSET in register, 199 reading only LEN. */ 200 void raw_collect_part (int regnum, int offset, int len, gdb_byte *out) const; 201 202 /* See common/common-regcache.h. */ 203 void raw_supply (int regnum, const void *buf) override; 204 205 void raw_supply (int regnum, const reg_buffer &src) 206 { 207 raw_supply (regnum, src.register_buffer (regnum)); 208 } 209 210 /* Supply register REGNUM to REGCACHE. Value to supply is an integer stored 211 at address ADDR, in target endian, with length ADDR_LEN and sign IS_SIGNED. 212 If the register size is greater than ADDR_LEN, then the integer will be 213 sign or zero extended. If the register size is smaller than the integer, 214 then the most significant bytes of the integer will be truncated. */ 215 void raw_supply_integer (int regnum, const gdb_byte *addr, int addr_len, 216 bool is_signed); 217 218 /* Supply register REGNUM with zeroed value to REGCACHE. This is not the same 219 as calling raw_supply with NULL (which will set the state to 220 unavailable). */ 221 void raw_supply_zeroed (int regnum); 222 223 /* Supply register REGNUM to REGCACHE, starting at OFFSET in register, writing 224 only LEN, without editing the rest of the register. */ 225 void raw_supply_part (int regnum, int offset, int len, const gdb_byte *in); 226 227 void invalidate (int regnum); 228 229 virtual ~reg_buffer () = default; 230 231 /* See common/common-regcache.h. */ 232 bool raw_compare (int regnum, const void *buf, int offset) const override; 233 234 protected: 235 /* Assert on the range of REGNUM. */ 236 void assert_regnum (int regnum) const; 237 238 int num_raw_registers () const; 239 240 gdb_byte *register_buffer (int regnum) const; 241 242 /* Save a register cache. The set of registers saved into the 243 regcache determined by the save_reggroup. COOKED_READ returns 244 zero iff the register's value can't be returned. */ 245 void save (register_read_ftype cooked_read); 246 247 struct regcache_descr *m_descr; 248 249 bool m_has_pseudo; 250 /* The register buffers. */ 251 std::unique_ptr<gdb_byte[]> m_registers; 252 /* Register cache status. */ 253 std::unique_ptr<register_status[]> m_register_status; 254 255 friend class regcache; 256 friend class detached_regcache; 257 }; 258 259 /* An abstract class which only has methods doing read. */ 260 261 class readable_regcache : public reg_buffer 262 { 263 public: 264 readable_regcache (gdbarch *gdbarch, bool has_pseudo) 265 : reg_buffer (gdbarch, has_pseudo) 266 {} 267 268 /* Transfer a raw register [0..NUM_REGS) from core-gdb to this regcache, 269 return its value in *BUF and return its availability status. */ 270 271 enum register_status raw_read (int regnum, gdb_byte *buf); 272 template<typename T, typename = RequireLongest<T>> 273 enum register_status raw_read (int regnum, T *val); 274 275 /* Partial transfer of raw registers. Return the status of the register. */ 276 enum register_status raw_read_part (int regnum, int offset, int len, 277 gdb_byte *buf); 278 279 /* Make certain that the register REGNUM is up-to-date. */ 280 virtual void raw_update (int regnum) = 0; 281 282 /* Transfer a raw register [0..NUM_REGS+NUM_PSEUDO_REGS) from core-gdb to 283 this regcache, return its value in *BUF and return its availability status. */ 284 enum register_status cooked_read (int regnum, gdb_byte *buf); 285 template<typename T, typename = RequireLongest<T>> 286 enum register_status cooked_read (int regnum, T *val); 287 288 /* Partial transfer of a cooked register. */ 289 enum register_status cooked_read_part (int regnum, int offset, int len, 290 gdb_byte *buf); 291 292 /* Read register REGNUM from the regcache and return a new value. This 293 will call mark_value_bytes_unavailable as appropriate. */ 294 struct value *cooked_read_value (int regnum); 295 296 protected: 297 298 /* Perform a partial register transfer using a read, modify, write 299 operation. Will fail if register is currently invalid. */ 300 enum register_status read_part (int regnum, int offset, int len, 301 gdb_byte *out, bool is_raw); 302 }; 303 304 /* Buffer of registers, can be read and written. */ 305 306 class detached_regcache : public readable_regcache 307 { 308 public: 309 detached_regcache (gdbarch *gdbarch, bool has_pseudo) 310 : readable_regcache (gdbarch, has_pseudo) 311 {} 312 313 void raw_update (int regnum) override 314 {} 315 316 DISABLE_COPY_AND_ASSIGN (detached_regcache); 317 }; 318 319 class readonly_detached_regcache; 320 321 /* The register cache for storing raw register values. */ 322 323 class regcache : public detached_regcache 324 { 325 public: 326 DISABLE_COPY_AND_ASSIGN (regcache); 327 328 /* Return REGCACHE's address space. */ 329 const address_space *aspace () const 330 { 331 return m_aspace; 332 } 333 334 /* Restore 'this' regcache. The set of registers restored into 335 the regcache determined by the restore_reggroup. 336 Writes to regcache will go through to the target. SRC is a 337 read-only register cache. */ 338 void restore (readonly_detached_regcache *src); 339 340 /* Update the value of raw register REGNUM (in the range [0..NUM_REGS)) and 341 transfer its value to core-gdb. */ 342 343 void raw_write (int regnum, const gdb_byte *buf); 344 345 template<typename T, typename = RequireLongest<T>> 346 void raw_write (int regnum, T val); 347 348 /* Transfer of pseudo-registers. */ 349 void cooked_write (int regnum, const gdb_byte *buf); 350 351 template<typename T, typename = RequireLongest<T>> 352 void cooked_write (int regnum, T val); 353 354 void raw_update (int regnum) override; 355 356 /* Partial transfer of raw registers. Perform read, modify, write style 357 operations. */ 358 void raw_write_part (int regnum, int offset, int len, const gdb_byte *buf); 359 360 /* Partial transfer of a cooked register. Perform read, modify, write style 361 operations. */ 362 void cooked_write_part (int regnum, int offset, int len, 363 const gdb_byte *buf); 364 365 void supply_regset (const struct regset *regset, 366 int regnum, const void *buf, size_t size); 367 368 369 void collect_regset (const struct regset *regset, int regnum, 370 void *buf, size_t size) const; 371 372 /* Return REGCACHE's ptid. */ 373 374 ptid_t ptid () const 375 { 376 gdb_assert (m_ptid != minus_one_ptid); 377 378 return m_ptid; 379 } 380 381 void set_ptid (const ptid_t ptid) 382 { 383 this->m_ptid = ptid; 384 } 385 386 /* Dump the contents of a register from the register cache to the target 387 debug. */ 388 void debug_print_register (const char *func, int regno); 389 390 static void regcache_thread_ptid_changed (ptid_t old_ptid, ptid_t new_ptid); 391 protected: 392 regcache (gdbarch *gdbarch, const address_space *aspace_); 393 394 static std::forward_list<regcache *> current_regcache; 395 396 private: 397 398 /* Helper function for transfer_regset. Copies across a single register. */ 399 void transfer_regset_register (struct regcache *out_regcache, int regnum, 400 const gdb_byte *in_buf, gdb_byte *out_buf, 401 int slot_size, int offs) const; 402 403 /* Transfer a single or all registers belonging to a certain register 404 set to or from a buffer. This is the main worker function for 405 regcache_supply_regset and regcache_collect_regset. */ 406 void transfer_regset (const struct regset *regset, 407 struct regcache *out_regcache, 408 int regnum, const gdb_byte *in_buf, 409 gdb_byte *out_buf, size_t size) const; 410 411 /* Perform a partial register transfer using a read, modify, write 412 operation. */ 413 enum register_status write_part (int regnum, int offset, int len, 414 const gdb_byte *in, bool is_raw); 415 416 /* The address space of this register cache (for registers where it 417 makes sense, like PC or SP). */ 418 const address_space * const m_aspace; 419 420 /* If this is a read-write cache, which thread's registers is 421 it connected to? */ 422 ptid_t m_ptid; 423 424 friend struct regcache * 425 get_thread_arch_aspace_regcache (ptid_t ptid, struct gdbarch *gdbarch, 426 struct address_space *aspace); 427 428 friend void 429 registers_changed_ptid (ptid_t ptid); 430 }; 431 432 class readonly_detached_regcache : public readable_regcache 433 { 434 public: 435 readonly_detached_regcache (regcache &src); 436 437 /* Create a readonly regcache by getting contents from COOKED_READ. */ 438 439 readonly_detached_regcache (gdbarch *gdbarch, register_read_ftype cooked_read) 440 : readable_regcache (gdbarch, true) 441 { 442 save (cooked_read); 443 } 444 445 DISABLE_COPY_AND_ASSIGN (readonly_detached_regcache); 446 447 void raw_update (int regnum) override 448 {} 449 }; 450 451 extern void registers_changed (void); 452 extern void registers_changed_ptid (ptid_t); 453 454 /* Indicate that registers of THREAD may have changed, so invalidate 455 the cache. */ 456 extern void registers_changed_thread (thread_info *thread); 457 458 /* An abstract base class for register dump. */ 459 460 class register_dump 461 { 462 public: 463 void dump (ui_file *file); 464 virtual ~register_dump () = default; 465 466 protected: 467 register_dump (gdbarch *arch) 468 : m_gdbarch (arch) 469 {} 470 471 /* Dump the register REGNUM contents. If REGNUM is -1, print the 472 header. */ 473 virtual void dump_reg (ui_file *file, int regnum) = 0; 474 475 gdbarch *m_gdbarch; 476 }; 477 478 #endif /* REGCACHE_H */ 479