7b462dedcc9afc182fb859e78b6dc3a0d5f2dcb1
1 /* Cache and manage the values of registers for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996, 1998, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GDB.
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 2 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
33 * Here is the actual register cache.
36 /* NOTE: this is a write-through cache. There is no "dirty" bit for
37 recording if the register values have been changed (eg. by the
38 user). Therefore all registers must be written back to the
39 target when appropriate. */
41 /* REGISTERS contains the cached register values (in target byte order). */
45 /* REGISTER_VALID is 0 if the register needs to be fetched,
46 1 if it has been fetched, and
47 -1 if the register value was not available.
48 "Not available" means don't try to fetch it again. */
50 signed char *register_valid
;
52 /* The thread/process associated with the current set of registers.
53 For now, -1 is special, and means `no current process'. */
55 static int registers_pid
= -1;
63 Returns 0 if the value is not in the cache (needs fetch).
64 >0 if the value is in the cache.
65 <0 if the value is permanently unavailable (don't ask again). */
68 register_cached (int regnum
)
70 return register_valid
[regnum
];
73 /* Record that REGNUM's value is cached if STATE is >0, uncached but
74 fetchable if STATE is 0, and uncached and unfetchable if STATE is <0. */
77 set_register_cached (int regnum
, int state
)
79 register_valid
[regnum
] = state
;
84 invalidate a single register REGNUM in the cache */
86 register_changed (int regnum
)
88 set_register_cached (regnum
, 0);
91 /* If REGNUM >= 0, return a pointer to register REGNUM's cache buffer area,
92 else return a pointer to the start of the cache buffer. */
95 register_buffer (int regnum
)
100 return ®isters
[REGISTER_BYTE (regnum
)];
103 /* Return whether register REGNUM is a real register. */
106 real_register (int regnum
)
108 return regnum
>= 0 && regnum
< NUM_REGS
;
111 /* Return whether register REGNUM is a pseudo register. */
114 pseudo_register (int regnum
)
116 return regnum
>= NUM_REGS
&& regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
;
119 /* Fetch register REGNUM into the cache. */
122 fetch_register (int regnum
)
124 if (real_register (regnum
))
125 target_fetch_registers (regnum
);
126 else if (pseudo_register (regnum
))
127 FETCH_PSEUDO_REGISTER (regnum
);
130 /* Write register REGNUM cached value to the target. */
133 store_register (int regnum
)
135 if (real_register (regnum
))
136 target_store_registers (regnum
);
137 else if (pseudo_register (regnum
))
138 STORE_PSEUDO_REGISTER (regnum
);
141 /* Low level examining and depositing of registers.
143 The caller is responsible for making sure that the inferior is
144 stopped before calling the fetching routines, or it will get
145 garbage. (a change from GDB version 3, in which the caller got the
146 value from the last stop). */
148 /* REGISTERS_CHANGED ()
150 Indicate that registers may have changed, so invalidate the cache. */
153 registers_changed (void)
159 /* Force cleanup of any alloca areas if using C alloca instead of
160 a builtin alloca. This particular call is used to clean up
161 areas allocated by low level target code which may build up
162 during lengthy interactions between gdb and the target before
163 gdb gives control to the user (ie watchpoints). */
166 for (i
= 0; i
< NUM_REGS
; i
++)
167 set_register_cached (i
, 0);
169 /* Assume that if all the hardware regs have changed,
170 then so have the pseudo-registers. */
171 for (i
= NUM_REGS
; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
172 set_register_cached (i
, 0);
174 if (registers_changed_hook
)
175 registers_changed_hook ();
178 /* REGISTERS_FETCHED ()
180 Indicate that all registers have been fetched, so mark them all valid. */
184 registers_fetched (void)
188 for (i
= 0; i
< NUM_REGS
; i
++)
189 set_register_cached (i
, 1);
190 /* Do not assume that the pseudo-regs have also been fetched.
191 Fetching all real regs might not account for all pseudo-regs. */
194 /* read_register_bytes and write_register_bytes are generally a *BAD*
195 idea. They are inefficient because they need to check for partial
196 updates, which can only be done by scanning through all of the
197 registers and seeing if the bytes that are being read/written fall
198 inside of an invalid register. [The main reason this is necessary
199 is that register sizes can vary, so a simple index won't suffice.]
200 It is far better to call read_register_gen and write_register_gen
201 if you want to get at the raw register contents, as it only takes a
202 regnum as an argument, and therefore can't do a partial register
205 Prior to the recent fixes to check for partial updates, both read
206 and write_register_bytes always checked to see if any registers
207 were stale, and then called target_fetch_registers (-1) to update
208 the whole set. This caused really slowed things down for remote
211 /* Copy INLEN bytes of consecutive data from registers
212 starting with the INREGBYTE'th byte of register data
213 into memory at MYADDR. */
216 read_register_bytes (int inregbyte
, char *myaddr
, int inlen
)
218 int inregend
= inregbyte
+ inlen
;
221 if (registers_pid
!= inferior_pid
)
223 registers_changed ();
224 registers_pid
= inferior_pid
;
227 /* See if we are trying to read bytes from out-of-date registers. If so,
228 update just those registers. */
230 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
232 int regstart
, regend
;
234 if (register_cached (regnum
))
237 if (REGISTER_NAME (regnum
) == NULL
|| *REGISTER_NAME (regnum
) == '\0')
240 regstart
= REGISTER_BYTE (regnum
);
241 regend
= regstart
+ REGISTER_RAW_SIZE (regnum
);
243 if (regend
<= inregbyte
|| inregend
<= regstart
)
244 /* The range the user wants to read doesn't overlap with regnum. */
247 /* We've found an uncached register where at least one byte will be read.
248 Update it from the target. */
249 fetch_register (regnum
);
251 if (!register_cached (regnum
))
253 /* Sometimes pseudoregs are never marked valid, so that they
254 will be fetched every time (it can be complicated to know
255 if a pseudoreg is valid, while "fetching" them can be cheap).
257 if (regnum
< NUM_REGS
)
258 error ("read_register_bytes: Couldn't update register %d.", regnum
);
263 memcpy (myaddr
, register_buffer (-1) + inregbyte
, inlen
);
266 /* Read register REGNUM into memory at MYADDR, which must be large
267 enough for REGISTER_RAW_BYTES (REGNUM). Target byte-order. If the
268 register is known to be the size of a CORE_ADDR or smaller,
269 read_register can be used instead. */
272 read_register_gen (int regnum
, char *myaddr
)
274 if (registers_pid
!= inferior_pid
)
276 registers_changed ();
277 registers_pid
= inferior_pid
;
280 if (!register_cached (regnum
))
281 fetch_register (regnum
);
283 memcpy (myaddr
, register_buffer (regnum
),
284 REGISTER_RAW_SIZE (regnum
));
287 /* Write register REGNUM at MYADDR to the target. MYADDR points at
288 REGISTER_RAW_BYTES(REGNUM), which must be in target byte-order. */
290 /* Registers we shouldn't try to store. */
291 #if !defined (CANNOT_STORE_REGISTER)
292 #define CANNOT_STORE_REGISTER(regnum) 0
296 write_register_gen (int regnum
, char *myaddr
)
300 /* On the sparc, writing %g0 is a no-op, so we don't even want to
301 change the registers array if something writes to this register. */
302 if (CANNOT_STORE_REGISTER (regnum
))
305 if (registers_pid
!= inferior_pid
)
307 registers_changed ();
308 registers_pid
= inferior_pid
;
311 size
= REGISTER_RAW_SIZE (regnum
);
313 /* If we have a valid copy of the register, and new value == old value,
314 then don't bother doing the actual store. */
316 if (register_cached (regnum
)
317 && memcmp (register_buffer (regnum
), myaddr
, size
) == 0)
320 if (real_register (regnum
))
321 target_prepare_to_store ();
323 memcpy (register_buffer (regnum
), myaddr
, size
);
325 set_register_cached (regnum
, 1);
326 store_register (regnum
);
329 /* Copy INLEN bytes of consecutive data from memory at MYADDR
330 into registers starting with the MYREGSTART'th byte of register data. */
333 write_register_bytes (int myregstart
, char *myaddr
, int inlen
)
335 int myregend
= myregstart
+ inlen
;
338 target_prepare_to_store ();
340 /* Scan through the registers updating any that are covered by the
341 range myregstart<=>myregend using write_register_gen, which does
342 nice things like handling threads, and avoiding updates when the
343 new and old contents are the same. */
345 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
347 int regstart
, regend
;
349 regstart
= REGISTER_BYTE (regnum
);
350 regend
= regstart
+ REGISTER_RAW_SIZE (regnum
);
352 /* Is this register completely outside the range the user is writing? */
353 if (myregend
<= regstart
|| regend
<= myregstart
)
356 /* Is this register completely within the range the user is writing? */
357 else if (myregstart
<= regstart
&& regend
<= myregend
)
358 write_register_gen (regnum
, myaddr
+ (regstart
- myregstart
));
360 /* The register partially overlaps the range being written. */
363 char *regbuf
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
364 /* What's the overlap between this register's bytes and
365 those the caller wants to write? */
366 int overlapstart
= max (regstart
, myregstart
);
367 int overlapend
= min (regend
, myregend
);
369 /* We may be doing a partial update of an invalid register.
370 Update it from the target before scribbling on it. */
371 read_register_gen (regnum
, regbuf
);
373 memcpy (registers
+ overlapstart
,
374 myaddr
+ (overlapstart
- myregstart
),
375 overlapend
- overlapstart
);
377 store_register (regnum
);
383 /* Return the contents of register REGNUM as an unsigned integer. */
386 read_register (int regnum
)
388 if (registers_pid
!= inferior_pid
)
390 registers_changed ();
391 registers_pid
= inferior_pid
;
394 if (!register_cached (regnum
))
395 fetch_register (regnum
);
397 return (extract_unsigned_integer (register_buffer (regnum
),
398 REGISTER_RAW_SIZE (regnum
)));
402 read_register_pid (int regnum
, int pid
)
407 if (pid
== inferior_pid
)
408 return read_register (regnum
);
410 save_pid
= inferior_pid
;
414 retval
= read_register (regnum
);
416 inferior_pid
= save_pid
;
421 /* Return the contents of register REGNUM as a signed integer. */
424 read_signed_register (int regnum
)
426 if (registers_pid
!= inferior_pid
)
428 registers_changed ();
429 registers_pid
= inferior_pid
;
432 if (!register_cached (regnum
))
433 fetch_register (regnum
);
435 return (extract_signed_integer (register_buffer (regnum
),
436 REGISTER_RAW_SIZE (regnum
)));
440 read_signed_register_pid (int regnum
, int pid
)
445 if (pid
== inferior_pid
)
446 return read_signed_register (regnum
);
448 save_pid
= inferior_pid
;
452 retval
= read_signed_register (regnum
);
454 inferior_pid
= save_pid
;
459 /* Store VALUE into the raw contents of register number REGNUM. */
462 write_register (int regnum
, LONGEST val
)
467 /* On the sparc, writing %g0 is a no-op, so we don't even want to
468 change the registers array if something writes to this register. */
469 if (CANNOT_STORE_REGISTER (regnum
))
472 if (registers_pid
!= inferior_pid
)
474 registers_changed ();
475 registers_pid
= inferior_pid
;
478 size
= REGISTER_RAW_SIZE (regnum
);
480 store_signed_integer (buf
, size
, (LONGEST
) val
);
482 /* If we have a valid copy of the register, and new value == old value,
483 then don't bother doing the actual store. */
485 if (register_cached (regnum
)
486 && memcmp (register_buffer (regnum
), buf
, size
) == 0)
489 if (real_register (regnum
))
490 target_prepare_to_store ();
492 memcpy (register_buffer (regnum
), buf
, size
);
494 set_register_cached (regnum
, 1);
495 store_register (regnum
);
499 write_register_pid (int regnum
, CORE_ADDR val
, int pid
)
503 if (pid
== inferior_pid
)
505 write_register (regnum
, val
);
509 save_pid
= inferior_pid
;
513 write_register (regnum
, val
);
515 inferior_pid
= save_pid
;
520 Record that register REGNUM contains VAL. This is used when the
521 value is obtained from the inferior or core dump, so there is no
522 need to store the value there.
524 If VAL is a NULL pointer, then it's probably an unsupported register.
525 We just set its value to all zeros. We might want to record this
526 fact, and report it to the users of read_register and friends. */
529 supply_register (int regnum
, char *val
)
532 if (registers_pid
!= inferior_pid
)
534 registers_changed ();
535 registers_pid
= inferior_pid
;
539 set_register_cached (regnum
, 1);
541 memcpy (register_buffer (regnum
), val
,
542 REGISTER_RAW_SIZE (regnum
));
544 memset (register_buffer (regnum
), '\000',
545 REGISTER_RAW_SIZE (regnum
));
547 /* On some architectures, e.g. HPPA, there are a few stray bits in
548 some registers, that the rest of the code would like to ignore. */
550 #ifdef CLEAN_UP_REGISTER_VALUE
551 CLEAN_UP_REGISTER_VALUE (regnum
, register_buffer (regnum
));
555 /* read_pc, write_pc, read_sp, write_sp, read_fp, write_fp, etc.
556 Special handling for registers PC, SP, and FP. */
558 /* NOTE: cagney/2001-02-18: The functions generic_target_read_pc(),
559 read_pc_pid(), read_pc(), generic_target_write_pc(),
560 write_pc_pid(), write_pc(), generic_target_read_sp(), read_sp(),
561 generic_target_write_sp(), write_sp(), generic_target_read_fp(),
562 read_fp(), generic_target_write_fp(), write_fp will eventually be
563 moved out of the reg-cache into either frame.[hc] or to the
564 multi-arch framework. The are not part of the raw register cache. */
566 /* This routine is getting awfully cluttered with #if's. It's probably
567 time to turn this into READ_PC and define it in the tm.h file.
570 1999-06-08: The following were re-written so that it assumes the
571 existence of a TARGET_READ_PC et.al. macro. A default generic
572 version of that macro is made available where needed.
574 Since the ``TARGET_READ_PC'' et.al. macro is going to be controlled
575 by the multi-arch framework, it will eventually be possible to
576 eliminate the intermediate read_pc_pid(). The client would call
577 TARGET_READ_PC directly. (cagney). */
580 generic_target_read_pc (int pid
)
585 CORE_ADDR pc_val
= ADDR_BITS_REMOVE ((CORE_ADDR
) read_register_pid (PC_REGNUM
, pid
));
589 internal_error (__FILE__
, __LINE__
,
590 "generic_target_read_pc");
595 read_pc_pid (int pid
)
597 int saved_inferior_pid
;
600 /* In case pid != inferior_pid. */
601 saved_inferior_pid
= inferior_pid
;
604 pc_val
= TARGET_READ_PC (pid
);
606 inferior_pid
= saved_inferior_pid
;
613 return read_pc_pid (inferior_pid
);
617 generic_target_write_pc (CORE_ADDR pc
, int pid
)
621 write_register_pid (PC_REGNUM
, pc
, pid
);
623 write_register_pid (NPC_REGNUM
, pc
+ 4, pid
);
624 if (NNPC_REGNUM
>= 0)
625 write_register_pid (NNPC_REGNUM
, pc
+ 8, pid
);
627 internal_error (__FILE__
, __LINE__
,
628 "generic_target_write_pc");
633 write_pc_pid (CORE_ADDR pc
, int pid
)
635 int saved_inferior_pid
;
637 /* In case pid != inferior_pid. */
638 saved_inferior_pid
= inferior_pid
;
641 TARGET_WRITE_PC (pc
, pid
);
643 inferior_pid
= saved_inferior_pid
;
647 write_pc (CORE_ADDR pc
)
649 write_pc_pid (pc
, inferior_pid
);
652 /* Cope with strage ways of getting to the stack and frame pointers */
655 generic_target_read_sp (void)
659 return read_register (SP_REGNUM
);
661 internal_error (__FILE__
, __LINE__
,
662 "generic_target_read_sp");
668 return TARGET_READ_SP ();
672 generic_target_write_sp (CORE_ADDR val
)
677 write_register (SP_REGNUM
, val
);
681 internal_error (__FILE__
, __LINE__
,
682 "generic_target_write_sp");
686 write_sp (CORE_ADDR val
)
688 TARGET_WRITE_SP (val
);
692 generic_target_read_fp (void)
696 return read_register (FP_REGNUM
);
698 internal_error (__FILE__
, __LINE__
,
699 "generic_target_read_fp");
705 return TARGET_READ_FP ();
709 generic_target_write_fp (CORE_ADDR val
)
714 write_register (FP_REGNUM
, val
);
718 internal_error (__FILE__
, __LINE__
,
719 "generic_target_write_fp");
723 write_fp (CORE_ADDR val
)
725 TARGET_WRITE_FP (val
);
730 reg_flush_command (char *command
, int from_tty
)
732 /* Force-flush the register cache. */
733 registers_changed ();
735 printf_filtered ("Register cache flushed.\n");
740 build_regcache (void)
742 /* We allocate some extra slop since we do a lot of memcpy's around
743 `registers', and failing-soft is better than failing hard. */
744 int sizeof_registers
= REGISTER_BYTES
+ /* SLOP */ 256;
745 int sizeof_register_valid
=
746 (NUM_REGS
+ NUM_PSEUDO_REGS
) * sizeof (*register_valid
);
747 registers
= xmalloc (sizeof_registers
);
748 memset (registers
, 0, sizeof_registers
);
749 register_valid
= xmalloc (sizeof_register_valid
);
750 memset (register_valid
, 0, sizeof_register_valid
);
754 _initialize_regcache (void)
758 register_gdbarch_swap (®isters
, sizeof (registers
), NULL
);
759 register_gdbarch_swap (®ister_valid
, sizeof (register_valid
), NULL
);
760 register_gdbarch_swap (NULL
, 0, build_regcache
);
762 add_com ("flushregs", class_maintenance
, reg_flush_command
,
763 "Force gdb to flush its register cache (maintainer command)");