1 /* Cache and manage the values of registers for GDB, the GNU debugger.
2 Copyright 1986, 87, 89, 91, 94, 95, 96, 1998, 2000
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. */
32 * Here is the actual register cache.
35 /* NOTE: this is a write-through cache. There is no "dirty" bit for
36 recording if the register values have been changed (eg. by the
37 user). Therefore all registers must be written back to the
38 target when appropriate. */
40 /* REGISTERS contains the cached register values (in target byte order). */
44 /* REGISTER_VALID is 0 if the register needs to be fetched,
45 1 if it has been fetched, and
46 -1 if the register value was not available.
47 "Not available" means don't try to fetch it again. */
49 signed char *register_valid
;
51 /* The thread/process associated with the current set of registers.
52 For now, -1 is special, and means `no current process'. */
54 static int registers_pid
= -1;
62 Returns 0 if the value is not in the cache (needs fetch).
63 >0 if the value is in the cache.
64 <0 if the value is permanently unavailable (don't ask again). */
67 register_cached (int regnum
)
69 return register_valid
[regnum
];
74 invalidate a single register REGNUM in the cache */
76 register_changed (int regnum
)
78 register_valid
[regnum
] = 0;
81 /* FIND_SAVED_REGISTER ()
83 Return the address in which frame FRAME's value of register REGNUM
84 has been saved in memory. Or return zero if it has not been saved.
85 If REGNUM specifies the SP, the value we return is actually
86 the SP value, not an address where it was saved. */
89 find_saved_register (struct frame_info
*frame
, int regnum
)
91 register struct frame_info
*frame1
= NULL
;
92 register CORE_ADDR addr
= 0;
94 if (frame
== NULL
) /* No regs saved if want current frame */
97 #ifdef HAVE_REGISTER_WINDOWS
98 /* We assume that a register in a register window will only be saved
99 in one place (since the name changes and/or disappears as you go
100 towards inner frames), so we only call get_frame_saved_regs on
101 the current frame. This is directly in contradiction to the
102 usage below, which assumes that registers used in a frame must be
103 saved in a lower (more interior) frame. This change is a result
104 of working on a register window machine; get_frame_saved_regs
105 always returns the registers saved within a frame, within the
106 context (register namespace) of that frame. */
108 /* However, note that we don't want this to return anything if
109 nothing is saved (if there's a frame inside of this one). Also,
110 callers to this routine asking for the stack pointer want the
111 stack pointer saved for *this* frame; this is returned from the
114 if (REGISTER_IN_WINDOW_P (regnum
))
116 frame1
= get_next_frame (frame
);
118 return 0; /* Registers of this frame are active. */
120 /* Get the SP from the next frame in; it will be this
122 if (regnum
!= SP_REGNUM
)
125 FRAME_INIT_SAVED_REGS (frame1
);
126 return frame1
->saved_regs
[regnum
]; /* ... which might be zero */
128 #endif /* HAVE_REGISTER_WINDOWS */
130 /* Note that this next routine assumes that registers used in
131 frame x will be saved only in the frame that x calls and
132 frames interior to it. This is not true on the sparc, but the
133 above macro takes care of it, so we should be all right. */
137 frame1
= get_prev_frame (frame1
);
138 if (frame1
== 0 || frame1
== frame
)
140 FRAME_INIT_SAVED_REGS (frame1
);
141 if (frame1
->saved_regs
[regnum
])
142 addr
= frame1
->saved_regs
[regnum
];
148 /* DEFAULT_GET_SAVED_REGISTER ()
150 Find register number REGNUM relative to FRAME and put its (raw,
151 target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
152 variable was optimized out (and thus can't be fetched). Set *LVAL
153 to lval_memory, lval_register, or not_lval, depending on whether
154 the value was fetched from memory, from a register, or in a strange
155 and non-modifiable way (e.g. a frame pointer which was calculated
156 rather than fetched). Set *ADDRP to the address, either in memory
157 on as a REGISTER_BYTE offset into the registers array.
159 Note that this implementation never sets *LVAL to not_lval. But
160 it can be replaced by defining GET_SAVED_REGISTER and supplying
163 The argument RAW_BUFFER must point to aligned memory. */
166 default_get_saved_register (char *raw_buffer
,
169 struct frame_info
*frame
,
171 enum lval_type
*lval
)
175 if (!target_has_registers
)
176 error ("No registers.");
178 /* Normal systems don't optimize out things with register numbers. */
179 if (optimized
!= NULL
)
181 addr
= find_saved_register (frame
, regnum
);
186 if (regnum
== SP_REGNUM
)
188 if (raw_buffer
!= NULL
)
190 /* Put it back in target format. */
191 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
198 if (raw_buffer
!= NULL
)
199 target_read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
204 *lval
= lval_register
;
205 addr
= REGISTER_BYTE (regnum
);
206 if (raw_buffer
!= NULL
)
207 read_register_gen (regnum
, raw_buffer
);
213 #if !defined (GET_SAVED_REGISTER)
214 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
215 default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
219 get_saved_register (char *raw_buffer
,
222 struct frame_info
*frame
,
224 enum lval_type
*lval
)
226 GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
229 /* READ_RELATIVE_REGISTER_RAW_BYTES_FOR_FRAME
231 Copy the bytes of register REGNUM, relative to the input stack frame,
232 into our memory at MYADDR, in target byte order.
233 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
235 Returns 1 if could not be read, 0 if could. */
237 /* FIXME: This function increases the confusion between FP_REGNUM
238 and the virtual/pseudo-frame pointer. */
241 read_relative_register_raw_bytes_for_frame (int regnum
,
243 struct frame_info
*frame
)
246 if (regnum
== FP_REGNUM
&& frame
)
248 /* Put it back in target format. */
249 store_address (myaddr
, REGISTER_RAW_SIZE (FP_REGNUM
),
250 (LONGEST
) FRAME_FP (frame
));
255 get_saved_register (myaddr
, &optim
, (CORE_ADDR
*) NULL
, frame
,
256 regnum
, (enum lval_type
*) NULL
);
258 if (register_valid
[regnum
] < 0)
259 return 1; /* register value not available */
264 /* READ_RELATIVE_REGISTER_RAW_BYTES
266 Copy the bytes of register REGNUM, relative to the current stack
267 frame, into our memory at MYADDR, in target byte order.
268 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
270 Returns 1 if could not be read, 0 if could. */
273 read_relative_register_raw_bytes (int regnum
, char *myaddr
)
275 return read_relative_register_raw_bytes_for_frame (regnum
, myaddr
,
280 /* Low level examining and depositing of registers.
282 The caller is responsible for making sure that the inferior is
283 stopped before calling the fetching routines, or it will get
284 garbage. (a change from GDB version 3, in which the caller got the
285 value from the last stop). */
287 /* REGISTERS_CHANGED ()
289 Indicate that registers may have changed, so invalidate the cache. */
292 registers_changed (void)
298 /* Force cleanup of any alloca areas if using C alloca instead of
299 a builtin alloca. This particular call is used to clean up
300 areas allocated by low level target code which may build up
301 during lengthy interactions between gdb and the target before
302 gdb gives control to the user (ie watchpoints). */
305 for (i
= 0; i
< ARCH_NUM_REGS
; i
++)
306 register_valid
[i
] = 0;
308 /* Assume that if all the hardware regs have changed,
309 then so have the pseudo-registers. */
310 for (i
= NUM_REGS
; i
< NUM_REGS
+ NUM_PSEUDO_REGS
; i
++)
311 register_valid
[i
] = 0;
313 if (registers_changed_hook
)
314 registers_changed_hook ();
317 /* REGISTERS_FETCHED ()
319 Indicate that all registers have been fetched, so mark them all valid. */
323 registers_fetched (void)
327 for (i
= 0; i
< ARCH_NUM_REGS
; i
++)
328 register_valid
[i
] = 1;
329 /* Do not assume that the pseudo-regs have also been fetched.
330 Fetching all real regs might not account for all pseudo-regs. */
333 /* read_register_bytes and write_register_bytes are generally a *BAD*
334 idea. They are inefficient because they need to check for partial
335 updates, which can only be done by scanning through all of the
336 registers and seeing if the bytes that are being read/written fall
337 inside of an invalid register. [The main reason this is necessary
338 is that register sizes can vary, so a simple index won't suffice.]
339 It is far better to call read_register_gen and write_register_gen
340 if you want to get at the raw register contents, as it only takes a
341 regnum as an argument, and therefore can't do a partial register
344 Prior to the recent fixes to check for partial updates, both read
345 and write_register_bytes always checked to see if any registers
346 were stale, and then called target_fetch_registers (-1) to update
347 the whole set. This caused really slowed things down for remote
350 /* Copy INLEN bytes of consecutive data from registers
351 starting with the INREGBYTE'th byte of register data
352 into memory at MYADDR. */
355 read_register_bytes (int inregbyte
, char *myaddr
, int inlen
)
357 int inregend
= inregbyte
+ inlen
;
360 if (registers_pid
!= inferior_pid
)
362 registers_changed ();
363 registers_pid
= inferior_pid
;
366 /* See if we are trying to read bytes from out-of-date registers. If so,
367 update just those registers. */
369 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
371 int regstart
, regend
;
373 if (register_valid
[regnum
])
376 if (REGISTER_NAME (regnum
) == NULL
|| *REGISTER_NAME (regnum
) == '\0')
379 regstart
= REGISTER_BYTE (regnum
);
380 regend
= regstart
+ REGISTER_RAW_SIZE (regnum
);
382 if (regend
<= inregbyte
|| inregend
<= regstart
)
383 /* The range the user wants to read doesn't overlap with regnum. */
386 /* We've found an uncached register where at least one byte will be read.
387 Update it from the target. */
388 if (regnum
< NUM_REGS
)
389 target_fetch_registers (regnum
);
390 else if (regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
)
391 FETCH_PSEUDO_REGISTER (regnum
);
393 if (!register_valid
[regnum
])
395 /* Sometimes pseudoregs are never marked valid, so that they
396 will be fetched every time (it can be complicated to know
397 if a pseudoreg is valid, while "fetching" them can be cheap).
399 if (regnum
< NUM_REGS
)
400 error ("read_register_bytes: Couldn't update register %d.",
406 memcpy (myaddr
, ®isters
[inregbyte
], inlen
);
409 /* Read register REGNUM into memory at MYADDR, which must be large
410 enough for REGISTER_RAW_BYTES (REGNUM). Target byte-order. If the
411 register is known to be the size of a CORE_ADDR or smaller,
412 read_register can be used instead. */
415 read_register_gen (int regnum
, char *myaddr
)
417 if (registers_pid
!= inferior_pid
)
419 registers_changed ();
420 registers_pid
= inferior_pid
;
423 if (!register_valid
[regnum
])
425 if (regnum
< NUM_REGS
)
426 target_fetch_registers (regnum
);
427 else if (regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
)
428 FETCH_PSEUDO_REGISTER (regnum
);
430 memcpy (myaddr
, ®isters
[REGISTER_BYTE (regnum
)],
431 REGISTER_RAW_SIZE (regnum
));
434 /* Write register REGNUM at MYADDR to the target. MYADDR points at
435 REGISTER_RAW_BYTES(REGNUM), which must be in target byte-order. */
437 /* Registers we shouldn't try to store. */
438 #if !defined (CANNOT_STORE_REGISTER)
439 #define CANNOT_STORE_REGISTER(regnum) 0
443 write_register_gen (int regnum
, char *myaddr
)
447 /* On the sparc, writing %g0 is a no-op, so we don't even want to
448 change the registers array if something writes to this register. */
449 if (CANNOT_STORE_REGISTER (regnum
))
452 if (registers_pid
!= inferior_pid
)
454 registers_changed ();
455 registers_pid
= inferior_pid
;
458 size
= REGISTER_RAW_SIZE (regnum
);
460 /* If we have a valid copy of the register, and new value == old value,
461 then don't bother doing the actual store. */
463 if (register_valid
[regnum
]
464 && memcmp (®isters
[REGISTER_BYTE (regnum
)], myaddr
, size
) == 0)
467 if (regnum
< NUM_REGS
)
468 target_prepare_to_store ();
470 memcpy (®isters
[REGISTER_BYTE (regnum
)], myaddr
, size
);
472 register_valid
[regnum
] = 1;
474 if (regnum
< NUM_REGS
)
475 target_store_registers (regnum
);
476 else if (regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
)
477 STORE_PSEUDO_REGISTER (regnum
);
480 /* Copy INLEN bytes of consecutive data from memory at MYADDR
481 into registers starting with the MYREGSTART'th byte of register data. */
484 write_register_bytes (int myregstart
, char *myaddr
, int inlen
)
486 int myregend
= myregstart
+ inlen
;
489 target_prepare_to_store ();
491 /* Scan through the registers updating any that are covered by the
492 range myregstart<=>myregend using write_register_gen, which does
493 nice things like handling threads, and avoiding updates when the
494 new and old contents are the same. */
496 for (regnum
= 0; regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
; regnum
++)
498 int regstart
, regend
;
500 regstart
= REGISTER_BYTE (regnum
);
501 regend
= regstart
+ REGISTER_RAW_SIZE (regnum
);
503 /* Is this register completely outside the range the user is writing? */
504 if (myregend
<= regstart
|| regend
<= myregstart
)
507 /* Is this register completely within the range the user is writing? */
508 else if (myregstart
<= regstart
&& regend
<= myregend
)
509 write_register_gen (regnum
, myaddr
+ (regstart
- myregstart
));
511 /* The register partially overlaps the range being written. */
514 char regbuf
[MAX_REGISTER_RAW_SIZE
];
515 /* What's the overlap between this register's bytes and
516 those the caller wants to write? */
517 int overlapstart
= max (regstart
, myregstart
);
518 int overlapend
= min (regend
, myregend
);
520 /* We may be doing a partial update of an invalid register.
521 Update it from the target before scribbling on it. */
522 read_register_gen (regnum
, regbuf
);
524 memcpy (registers
+ overlapstart
,
525 myaddr
+ (overlapstart
- myregstart
),
526 overlapend
- overlapstart
);
528 if (regnum
< NUM_REGS
)
529 target_store_registers (regnum
);
530 else if (regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
)
531 STORE_PSEUDO_REGISTER (regnum
);
537 /* Return the contents of register REGNUM as an unsigned integer. */
540 read_register (int regnum
)
542 if (registers_pid
!= inferior_pid
)
544 registers_changed ();
545 registers_pid
= inferior_pid
;
548 if (!register_valid
[regnum
])
550 if (regnum
< NUM_REGS
)
551 target_fetch_registers (regnum
);
552 else if (regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
)
553 FETCH_PSEUDO_REGISTER (regnum
);
556 return (extract_unsigned_integer (®isters
[REGISTER_BYTE (regnum
)],
557 REGISTER_RAW_SIZE (regnum
)));
561 read_register_pid (int regnum
, int pid
)
566 if (pid
== inferior_pid
)
567 return read_register (regnum
);
569 save_pid
= inferior_pid
;
573 retval
= read_register (regnum
);
575 inferior_pid
= save_pid
;
580 /* Return the contents of register REGNUM as a signed integer. */
583 read_signed_register (int regnum
)
585 if (registers_pid
!= inferior_pid
)
587 registers_changed ();
588 registers_pid
= inferior_pid
;
591 if (!register_valid
[regnum
])
592 target_fetch_registers (regnum
);
594 return (extract_signed_integer (®isters
[REGISTER_BYTE (regnum
)],
595 REGISTER_RAW_SIZE (regnum
)));
599 read_signed_register_pid (int regnum
, int pid
)
604 if (pid
== inferior_pid
)
605 return read_signed_register (regnum
);
607 save_pid
= inferior_pid
;
611 retval
= read_signed_register (regnum
);
613 inferior_pid
= save_pid
;
618 /* Store VALUE into the raw contents of register number REGNUM. */
621 write_register (int regnum
, LONGEST val
)
626 /* On the sparc, writing %g0 is a no-op, so we don't even want to
627 change the registers array if something writes to this register. */
628 if (CANNOT_STORE_REGISTER (regnum
))
631 if (registers_pid
!= inferior_pid
)
633 registers_changed ();
634 registers_pid
= inferior_pid
;
637 size
= REGISTER_RAW_SIZE (regnum
);
639 store_signed_integer (buf
, size
, (LONGEST
) val
);
641 /* If we have a valid copy of the register, and new value == old value,
642 then don't bother doing the actual store. */
644 if (register_valid
[regnum
]
645 && memcmp (®isters
[REGISTER_BYTE (regnum
)], buf
, size
) == 0)
648 if (regnum
< NUM_REGS
)
649 target_prepare_to_store ();
651 memcpy (®isters
[REGISTER_BYTE (regnum
)], buf
, size
);
653 register_valid
[regnum
] = 1;
655 if (regnum
< NUM_REGS
)
656 target_store_registers (regnum
);
657 else if (regnum
< NUM_REGS
+ NUM_PSEUDO_REGS
)
658 STORE_PSEUDO_REGISTER (regnum
);
662 write_register_pid (int regnum
, CORE_ADDR val
, int pid
)
666 if (pid
== inferior_pid
)
668 write_register (regnum
, val
);
672 save_pid
= inferior_pid
;
676 write_register (regnum
, val
);
678 inferior_pid
= save_pid
;
683 Record that register REGNUM contains VAL. This is used when the
684 value is obtained from the inferior or core dump, so there is no
685 need to store the value there.
687 If VAL is a NULL pointer, then it's probably an unsupported register.
688 We just set its value to all zeros. We might want to record this
689 fact, and report it to the users of read_register and friends. */
692 supply_register (int regnum
, char *val
)
695 if (registers_pid
!= inferior_pid
)
697 registers_changed ();
698 registers_pid
= inferior_pid
;
702 register_valid
[regnum
] = 1;
704 memcpy (®isters
[REGISTER_BYTE (regnum
)], val
,
705 REGISTER_RAW_SIZE (regnum
));
707 memset (®isters
[REGISTER_BYTE (regnum
)], '\000',
708 REGISTER_RAW_SIZE (regnum
));
710 /* On some architectures, e.g. HPPA, there are a few stray bits in
711 some registers, that the rest of the code would like to ignore. */
713 #ifdef CLEAN_UP_REGISTER_VALUE
714 CLEAN_UP_REGISTER_VALUE (regnum
, ®isters
[REGISTER_BYTE (regnum
)]);
718 /* read_pc, write_pc, read_sp, write_sp, read_fp, write_fp, etc.
719 Special handling for registers PC, SP, and FP. */
721 /* This routine is getting awfully cluttered with #if's. It's probably
722 time to turn this into READ_PC and define it in the tm.h file.
725 1999-06-08: The following were re-written so that it assumes the
726 existence of a TARGET_READ_PC et.al. macro. A default generic
727 version of that macro is made available where needed.
729 Since the ``TARGET_READ_PC'' et.al. macro is going to be controlled
730 by the multi-arch framework, it will eventually be possible to
731 eliminate the intermediate read_pc_pid(). The client would call
732 TARGET_READ_PC directly. (cagney). */
735 generic_target_read_pc (int pid
)
740 CORE_ADDR pc_val
= ADDR_BITS_REMOVE ((CORE_ADDR
) read_register_pid (PC_REGNUM
, pid
));
744 internal_error ("generic_target_read_pc");
749 read_pc_pid (int pid
)
751 int saved_inferior_pid
;
754 /* In case pid != inferior_pid. */
755 saved_inferior_pid
= inferior_pid
;
758 pc_val
= TARGET_READ_PC (pid
);
760 inferior_pid
= saved_inferior_pid
;
767 return read_pc_pid (inferior_pid
);
771 generic_target_write_pc (CORE_ADDR pc
, int pid
)
775 write_register_pid (PC_REGNUM
, pc
, pid
);
777 write_register_pid (NPC_REGNUM
, pc
+ 4, pid
);
778 if (NNPC_REGNUM
>= 0)
779 write_register_pid (NNPC_REGNUM
, pc
+ 8, pid
);
781 internal_error ("generic_target_write_pc");
786 write_pc_pid (CORE_ADDR pc
, int pid
)
788 int saved_inferior_pid
;
790 /* In case pid != inferior_pid. */
791 saved_inferior_pid
= inferior_pid
;
794 TARGET_WRITE_PC (pc
, pid
);
796 inferior_pid
= saved_inferior_pid
;
800 write_pc (CORE_ADDR pc
)
802 write_pc_pid (pc
, inferior_pid
);
805 /* Cope with strage ways of getting to the stack and frame pointers */
808 generic_target_read_sp (void)
812 return read_register (SP_REGNUM
);
814 internal_error ("generic_target_read_sp");
820 return TARGET_READ_SP ();
824 generic_target_write_sp (CORE_ADDR val
)
829 write_register (SP_REGNUM
, val
);
833 internal_error ("generic_target_write_sp");
837 write_sp (CORE_ADDR val
)
839 TARGET_WRITE_SP (val
);
843 generic_target_read_fp (void)
847 return read_register (FP_REGNUM
);
849 internal_error ("generic_target_read_fp");
855 return TARGET_READ_FP ();
859 generic_target_write_fp (CORE_ADDR val
)
864 write_register (FP_REGNUM
, val
);
868 internal_error ("generic_target_write_fp");
872 write_fp (CORE_ADDR val
)
874 TARGET_WRITE_FP (val
);
879 reg_flush_command (char *command
, int from_tty
)
881 /* Force-flush the register cache. */
882 registers_changed ();
884 printf_filtered ("Register cache flushed.\n");
889 build_regcache (void)
891 /* We allocate some extra slop since we do a lot of memcpy's around
892 `registers', and failing-soft is better than failing hard. */
893 int sizeof_registers
= REGISTER_BYTES
+ /* SLOP */ 256;
894 int sizeof_register_valid
=
895 (NUM_REGS
+ NUM_PSEUDO_REGS
) * sizeof (*register_valid
);
896 registers
= xmalloc (sizeof_registers
);
897 memset (registers
, 0, sizeof_registers
);
898 register_valid
= xmalloc (sizeof_register_valid
);
899 memset (register_valid
, 0, sizeof_register_valid
);
903 _initialize_regcache (void)
907 register_gdbarch_swap (®isters
, sizeof (registers
), NULL
);
908 register_gdbarch_swap (®ister_valid
, sizeof (register_valid
), NULL
);
909 register_gdbarch_swap (NULL
, 0, build_regcache
);
911 add_com ("flushregs", class_maintenance
, reg_flush_command
,
912 "Force gdb to flush its register cache (maintainer command)");
This page took 0.064176 seconds and 4 git commands to generate.