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. */
31 * Here is the actual register cache.
34 /* NOTE: this is a write-back cache. There is no "dirty" bit for
35 recording if the register values have been changed (eg. by the
36 user). Therefore all registers must be written back to the
37 target when appropriate. */
39 /* REGISTERS contains the cached register values (in target byte order). */
43 /* REGISTER_VALID is 0 if the register needs to be fetched,
44 1 if it has been fetched, and
45 -1 if the register value was not available.
46 "Not available" means don't try to fetch it again. */
48 signed char *register_valid;
50 /* The thread/process associated with the current set of registers.
51 For now, -1 is special, and means `no current process'. */
53 static int registers_pid = -1;
61 Returns 0 if the value is not in the cache (needs fetch).
62 >0 if the value is in the cache.
63 <0 if the value is permanently unavailable (don't ask again). */
66 register_cached (int regnum)
68 return register_valid[regnum];
71 /* FIND_SAVED_REGISTER ()
73 Return the address in which frame FRAME's value of register REGNUM
74 has been saved in memory. Or return zero if it has not been saved.
75 If REGNUM specifies the SP, the value we return is actually
76 the SP value, not an address where it was saved. */
79 find_saved_register (struct frame_info *frame, int regnum)
81 register struct frame_info *frame1 = NULL;
82 register CORE_ADDR addr = 0;
84 if (frame == NULL) /* No regs saved if want current frame */
87 #ifdef HAVE_REGISTER_WINDOWS
88 /* We assume that a register in a register window will only be saved
89 in one place (since the name changes and/or disappears as you go
90 towards inner frames), so we only call get_frame_saved_regs on
91 the current frame. This is directly in contradiction to the
92 usage below, which assumes that registers used in a frame must be
93 saved in a lower (more interior) frame. This change is a result
94 of working on a register window machine; get_frame_saved_regs
95 always returns the registers saved within a frame, within the
96 context (register namespace) of that frame. */
98 /* However, note that we don't want this to return anything if
99 nothing is saved (if there's a frame inside of this one). Also,
100 callers to this routine asking for the stack pointer want the
101 stack pointer saved for *this* frame; this is returned from the
104 if (REGISTER_IN_WINDOW_P (regnum))
106 frame1 = get_next_frame (frame);
108 return 0; /* Registers of this frame are active. */
110 /* Get the SP from the next frame in; it will be this
112 if (regnum != SP_REGNUM)
115 FRAME_INIT_SAVED_REGS (frame1);
116 return frame1->saved_regs[regnum]; /* ... which might be zero */
118 #endif /* HAVE_REGISTER_WINDOWS */
120 /* Note that this next routine assumes that registers used in
121 frame x will be saved only in the frame that x calls and
122 frames interior to it. This is not true on the sparc, but the
123 above macro takes care of it, so we should be all right. */
127 frame1 = get_prev_frame (frame1);
128 if (frame1 == 0 || frame1 == frame)
130 FRAME_INIT_SAVED_REGS (frame1);
131 if (frame1->saved_regs[regnum])
132 addr = frame1->saved_regs[regnum];
138 /* DEFAULT_GET_SAVED_REGISTER ()
140 Find register number REGNUM relative to FRAME and put its (raw,
141 target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
142 variable was optimized out (and thus can't be fetched). Set *LVAL
143 to lval_memory, lval_register, or not_lval, depending on whether
144 the value was fetched from memory, from a register, or in a strange
145 and non-modifiable way (e.g. a frame pointer which was calculated
146 rather than fetched). Set *ADDRP to the address, either in memory
147 on as a REGISTER_BYTE offset into the registers array.
149 Note that this implementation never sets *LVAL to not_lval. But
150 it can be replaced by defining GET_SAVED_REGISTER and supplying
153 The argument RAW_BUFFER must point to aligned memory. */
156 default_get_saved_register (char *raw_buffer,
159 struct frame_info *frame,
161 enum lval_type *lval)
165 if (!target_has_registers)
166 error ("No registers.");
168 /* Normal systems don't optimize out things with register numbers. */
169 if (optimized != NULL)
171 addr = find_saved_register (frame, regnum);
176 if (regnum == SP_REGNUM)
178 if (raw_buffer != NULL)
180 /* Put it back in target format. */
181 store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
188 if (raw_buffer != NULL)
189 target_read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
194 *lval = lval_register;
195 addr = REGISTER_BYTE (regnum);
196 if (raw_buffer != NULL)
197 read_register_gen (regnum, raw_buffer);
204 get_saved_register (char *raw_buffer,
207 struct frame_info *frame,
209 enum lval_type *lval)
211 GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
214 /* READ_RELATIVE_REGISTER_RAW_BYTES_FOR_FRAME
216 Copy the bytes of register REGNUM, relative to the input stack frame,
217 into our memory at MYADDR, in target byte order.
218 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
220 Returns 1 if could not be read, 0 if could. */
222 /* FIXME: This function increases the confusion between FP_REGNUM
223 and the virtual/pseudo-frame pointer. */
226 read_relative_register_raw_bytes_for_frame (int regnum,
228 struct frame_info *frame)
231 if (regnum == FP_REGNUM && frame)
233 /* Put it back in target format. */
234 store_address (myaddr, REGISTER_RAW_SIZE (FP_REGNUM),
235 (LONGEST) FRAME_FP (frame));
240 get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
241 regnum, (enum lval_type *) NULL);
243 if (register_valid[regnum] < 0)
244 return 1; /* register value not available */
249 /* READ_RELATIVE_REGISTER_RAW_BYTES
251 Copy the bytes of register REGNUM, relative to the current stack
252 frame, into our memory at MYADDR, in target byte order.
253 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
255 Returns 1 if could not be read, 0 if could. */
258 read_relative_register_raw_bytes (int regnum, char *myaddr)
260 return read_relative_register_raw_bytes_for_frame (regnum, myaddr,
265 /* Low level examining and depositing of registers.
267 The caller is responsible for making sure that the inferior is
268 stopped before calling the fetching routines, or it will get
269 garbage. (a change from GDB version 3, in which the caller got the
270 value from the last stop). */
272 /* REGISTERS_CHANGED ()
274 Indicate that registers may have changed, so invalidate the cache. */
277 registers_changed (void)
283 /* Force cleanup of any alloca areas if using C alloca instead of
284 a builtin alloca. This particular call is used to clean up
285 areas allocated by low level target code which may build up
286 during lengthy interactions between gdb and the target before
287 gdb gives control to the user (ie watchpoints). */
290 for (i = 0; i < ARCH_NUM_REGS; i++)
291 register_valid[i] = 0;
293 /* Assume that if all the hardware regs have changed,
294 then so have the pseudo-registers. */
295 for (i = NUM_REGS; i < NUM_REGS + NUM_PSEUDO_REGS; i++)
296 register_valid[i] = 0;
298 if (registers_changed_hook)
299 registers_changed_hook ();
302 /* REGISTERS_FETCHED ()
304 Indicate that all registers have been fetched, so mark them all valid. */
308 registers_fetched (void)
312 for (i = 0; i < ARCH_NUM_REGS; i++)
313 register_valid[i] = 1;
314 /* Do not assume that the pseudo-regs have also been fetched.
315 Fetching all real regs might not account for all pseudo-regs. */
318 /* read_register_bytes and write_register_bytes are generally a *BAD*
319 idea. They are inefficient because they need to check for partial
320 updates, which can only be done by scanning through all of the
321 registers and seeing if the bytes that are being read/written fall
322 inside of an invalid register. [The main reason this is necessary
323 is that register sizes can vary, so a simple index won't suffice.]
324 It is far better to call read_register_gen and write_register_gen
325 if you want to get at the raw register contents, as it only takes a
326 regno as an argument, and therefore can't do a partial register
329 Prior to the recent fixes to check for partial updates, both read
330 and write_register_bytes always checked to see if any registers
331 were stale, and then called target_fetch_registers (-1) to update
332 the whole set. This caused really slowed things down for remote
335 /* Copy INLEN bytes of consecutive data from registers
336 starting with the INREGBYTE'th byte of register data
337 into memory at MYADDR. */
340 read_register_bytes (int inregbyte, char *myaddr, int inlen)
342 int inregend = inregbyte + inlen;
345 if (registers_pid != inferior_pid)
347 registers_changed ();
348 registers_pid = inferior_pid;
351 /* See if we are trying to read bytes from out-of-date registers. If so,
352 update just those registers. */
354 for (regno = 0; regno < NUM_REGS + NUM_PSEUDO_REGS; regno++)
356 int regstart, regend;
358 if (register_valid[regno])
361 if (REGISTER_NAME (regno) == NULL || *REGISTER_NAME (regno) == '\0')
364 regstart = REGISTER_BYTE (regno);
365 regend = regstart + REGISTER_RAW_SIZE (regno);
367 if (regend <= inregbyte || inregend <= regstart)
368 /* The range the user wants to read doesn't overlap with regno. */
371 /* We've found an uncached register where at least one byte will be read.
372 Update it from the target. */
373 if (regno < NUM_REGS)
374 target_fetch_registers (regno);
375 else if (regno < NUM_REGS + NUM_PSEUDO_REGS)
376 FETCH_PSEUDO_REGISTER (regno);
378 if (!register_valid[regno])
379 error ("read_register_bytes: Couldn't update register %d.", regno);
383 memcpy (myaddr, ®isters[inregbyte], inlen);
386 /* Read register REGNO into memory at MYADDR, which must be large
387 enough for REGISTER_RAW_BYTES (REGNO). Target byte-order. If the
388 register is known to be the size of a CORE_ADDR or smaller,
389 read_register can be used instead. */
392 read_register_gen (int regno, char *myaddr)
394 if (registers_pid != inferior_pid)
396 registers_changed ();
397 registers_pid = inferior_pid;
400 if (!register_valid[regno])
402 if (regno < NUM_REGS)
403 target_fetch_registers (regno);
404 else if (regno < NUM_REGS + NUM_PSEUDO_REGS)
405 FETCH_PSEUDO_REGISTER (regno);
407 memcpy (myaddr, ®isters[REGISTER_BYTE (regno)],
408 REGISTER_RAW_SIZE (regno));
411 /* Write register REGNO at MYADDR to the target. MYADDR points at
412 REGISTER_RAW_BYTES(REGNO), which must be in target byte-order. */
414 /* Registers we shouldn't try to store. */
415 #if !defined (CANNOT_STORE_REGISTER)
416 #define CANNOT_STORE_REGISTER(regno) 0
420 write_register_gen (int regno, char *myaddr)
424 /* On the sparc, writing %g0 is a no-op, so we don't even want to
425 change the registers array if something writes to this register. */
426 if (CANNOT_STORE_REGISTER (regno))
429 if (registers_pid != inferior_pid)
431 registers_changed ();
432 registers_pid = inferior_pid;
435 size = REGISTER_RAW_SIZE (regno);
437 /* If we have a valid copy of the register, and new value == old value,
438 then don't bother doing the actual store. */
440 if (register_valid[regno]
441 && memcmp (®isters[REGISTER_BYTE (regno)], myaddr, size) == 0)
444 if (regno < NUM_REGS)
445 target_prepare_to_store ();
447 memcpy (®isters[REGISTER_BYTE (regno)], myaddr, size);
449 register_valid[regno] = 1;
451 if (regno < NUM_REGS)
452 target_store_registers (regno);
453 else if (regno < NUM_REGS + NUM_PSEUDO_REGS)
454 STORE_PSEUDO_REGISTER (regno);
457 /* Copy INLEN bytes of consecutive data from memory at MYADDR
458 into registers starting with the MYREGSTART'th byte of register data. */
461 write_register_bytes (int myregstart, char *myaddr, int inlen)
463 int myregend = myregstart + inlen;
466 target_prepare_to_store ();
468 /* Scan through the registers updating any that are covered by the
469 range myregstart<=>myregend using write_register_gen, which does
470 nice things like handling threads, and avoiding updates when the
471 new and old contents are the same. */
473 for (regno = 0; regno < NUM_REGS + NUM_PSEUDO_REGS; regno++)
475 int regstart, regend;
477 regstart = REGISTER_BYTE (regno);
478 regend = regstart + REGISTER_RAW_SIZE (regno);
480 /* Is this register completely outside the range the user is writing? */
481 if (myregend <= regstart || regend <= myregstart)
484 /* Is this register completely within the range the user is writing? */
485 else if (myregstart <= regstart && regend <= myregend)
486 write_register_gen (regno, myaddr + (regstart - myregstart));
488 /* The register partially overlaps the range being written. */
491 char regbuf[MAX_REGISTER_RAW_SIZE];
492 /* What's the overlap between this register's bytes and
493 those the caller wants to write? */
494 int overlapstart = max (regstart, myregstart);
495 int overlapend = min (regend, myregend);
497 /* We may be doing a partial update of an invalid register.
498 Update it from the target before scribbling on it. */
499 read_register_gen (regno, regbuf);
501 memcpy (registers + overlapstart,
502 myaddr + (overlapstart - myregstart),
503 overlapend - overlapstart);
505 if (regno < NUM_REGS)
506 target_store_registers (regno);
507 else if (regno < NUM_REGS + NUM_PSEUDO_REGS)
508 STORE_PSEUDO_REGISTER (regno);
514 /* Return the raw contents of register REGNO, regarding it as an
518 read_register (int regno)
520 if (registers_pid != inferior_pid)
522 registers_changed ();
523 registers_pid = inferior_pid;
526 if (!register_valid[regno])
528 if (regno < NUM_REGS)
529 target_fetch_registers (regno);
530 else if (regno < NUM_REGS + NUM_PSEUDO_REGS)
531 FETCH_PSEUDO_REGISTER (regno);
534 return (extract_unsigned_integer (®isters[REGISTER_BYTE (regno)],
535 REGISTER_RAW_SIZE (regno)));
539 read_register_pid (int regno, int pid)
544 if (pid == inferior_pid)
545 return read_register (regno);
547 save_pid = inferior_pid;
551 retval = read_register (regno);
553 inferior_pid = save_pid;
558 /* Return the raw contents of register REGNO, regarding it a SIGNED
562 read_signed_register (int regno)
564 if (registers_pid != inferior_pid)
566 registers_changed ();
567 registers_pid = inferior_pid;
570 if (!register_valid[regno])
571 target_fetch_registers (regno);
573 return (extract_signed_integer (®isters[REGISTER_BYTE (regno)],
574 REGISTER_RAW_SIZE (regno)));
578 read_signed_register_pid (int regno, int pid)
583 if (pid == inferior_pid)
584 return read_signed_register (regno);
586 save_pid = inferior_pid;
590 retval = read_signed_register (regno);
592 inferior_pid = save_pid;
597 /* Store VALUE, into the raw contents of register number REGNO. */
600 write_register (int regno, LONGEST val)
605 /* On the sparc, writing %g0 is a no-op, so we don't even want to
606 change the registers array if something writes to this register. */
607 if (CANNOT_STORE_REGISTER (regno))
610 if (registers_pid != inferior_pid)
612 registers_changed ();
613 registers_pid = inferior_pid;
616 size = REGISTER_RAW_SIZE (regno);
618 store_signed_integer (buf, size, (LONGEST) val);
620 /* If we have a valid copy of the register, and new value == old value,
621 then don't bother doing the actual store. */
623 if (register_valid[regno]
624 && memcmp (®isters[REGISTER_BYTE (regno)], buf, size) == 0)
627 if (regno < NUM_REGS)
628 target_prepare_to_store ();
630 memcpy (®isters[REGISTER_BYTE (regno)], buf, size);
632 register_valid[regno] = 1;
634 if (regno < NUM_REGS)
635 target_store_registers (regno);
636 else if (regno < NUM_REGS + NUM_PSEUDO_REGS)
637 STORE_PSEUDO_REGISTER (regno);
641 write_register_pid (int regno, CORE_ADDR val, int pid)
645 if (pid == inferior_pid)
647 write_register (regno, val);
651 save_pid = inferior_pid;
655 write_register (regno, val);
657 inferior_pid = save_pid;
662 Record that register REGNO contains VAL. This is used when the
663 value is obtained from the inferior or core dump, so there is no
664 need to store the value there.
666 If VAL is a NULL pointer, then it's probably an unsupported register.
667 We just set it's value to all zeros. We might want to record this
668 fact, and report it to the users of read_register and friends. */
671 supply_register (int regno, char *val)
674 if (registers_pid != inferior_pid)
676 registers_changed ();
677 registers_pid = inferior_pid;
681 register_valid[regno] = 1;
683 memcpy (®isters[REGISTER_BYTE (regno)], val,
684 REGISTER_RAW_SIZE (regno));
686 memset (®isters[REGISTER_BYTE (regno)], '\000',
687 REGISTER_RAW_SIZE (regno));
689 /* On some architectures, e.g. HPPA, there are a few stray bits in
690 some registers, that the rest of the code would like to ignore. */
692 #ifdef CLEAN_UP_REGISTER_VALUE
693 CLEAN_UP_REGISTER_VALUE (regno, ®isters[REGISTER_BYTE (regno)]);
697 /* read_pc, write_pc, read_sp, write_sp, read_fp, write_fp, etc.
698 Special handling for registers PC, SP, and FP. */
700 /* This routine is getting awfully cluttered with #if's. It's probably
701 time to turn this into READ_PC and define it in the tm.h file.
704 1999-06-08: The following were re-written so that it assumes the
705 existance of a TARGET_READ_PC et.al. macro. A default generic
706 version of that macro is made available where needed.
708 Since the ``TARGET_READ_PC'' et.al. macro is going to be controlled
709 by the multi-arch framework, it will eventually be possible to
710 eliminate the intermediate read_pc_pid(). The client would call
711 TARGET_READ_PC directly. (cagney). */
714 generic_target_read_pc (int pid)
719 CORE_ADDR pc_val = ADDR_BITS_REMOVE ((CORE_ADDR) read_register_pid (PC_REGNUM, pid));
723 internal_error ("generic_target_read_pc");
728 read_pc_pid (int pid)
730 int saved_inferior_pid;
733 /* In case pid != inferior_pid. */
734 saved_inferior_pid = inferior_pid;
737 pc_val = TARGET_READ_PC (pid);
739 inferior_pid = saved_inferior_pid;
746 return read_pc_pid (inferior_pid);
750 generic_target_write_pc (CORE_ADDR pc, int pid)
754 write_register_pid (PC_REGNUM, pc, pid);
756 write_register_pid (NPC_REGNUM, pc + 4, pid);
757 if (NNPC_REGNUM >= 0)
758 write_register_pid (NNPC_REGNUM, pc + 8, pid);
760 internal_error ("generic_target_write_pc");
765 write_pc_pid (CORE_ADDR pc, int pid)
767 int saved_inferior_pid;
769 /* In case pid != inferior_pid. */
770 saved_inferior_pid = inferior_pid;
773 TARGET_WRITE_PC (pc, pid);
775 inferior_pid = saved_inferior_pid;
779 write_pc (CORE_ADDR pc)
781 write_pc_pid (pc, inferior_pid);
784 /* Cope with strage ways of getting to the stack and frame pointers */
787 generic_target_read_sp (void)
791 return read_register (SP_REGNUM);
793 internal_error ("generic_target_read_sp");
799 return TARGET_READ_SP ();
803 generic_target_write_sp (CORE_ADDR val)
808 write_register (SP_REGNUM, val);
812 internal_error ("generic_target_write_sp");
816 write_sp (CORE_ADDR val)
818 TARGET_WRITE_SP (val);
822 generic_target_read_fp (void)
826 return read_register (FP_REGNUM);
828 internal_error ("generic_target_read_fp");
834 return TARGET_READ_FP ();
838 generic_target_write_fp (CORE_ADDR val)
843 write_register (FP_REGNUM, val);
847 internal_error ("generic_target_write_fp");
851 write_fp (CORE_ADDR val)
853 TARGET_WRITE_FP (val);
857 build_regcache (void)
859 /* We allocate some extra slop since we do a lot of memcpy's around
860 `registers', and failing-soft is better than failing hard. */
861 int sizeof_registers = REGISTER_BYTES + /* SLOP */ 256;
862 int sizeof_register_valid =
863 (NUM_REGS + NUM_PSEUDO_REGS) * sizeof (*register_valid);
864 registers = xmalloc (sizeof_registers);
865 memset (registers, 0, sizeof_registers);
866 register_valid = xmalloc (sizeof_register_valid);
867 memset (register_valid, 0, sizeof_register_valid);
871 _initialize_regcache (void)
875 register_gdbarch_swap (®isters, sizeof (registers), NULL);
876 register_gdbarch_swap (®ister_valid, sizeof (register_valid), NULL);
877 register_gdbarch_swap (NULL, 0, build_regcache);