1 /* Find a variable's value in memory, for GDB, the GNU debugger.
2 Copyright 1986, 87, 89, 91, 94, 95, 96, 1998
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, Boston, MA 02111-1307, USA. */
29 #include "gdb_string.h"
30 #include "floatformat.h"
31 #include "symfile.h" /* for overlay functions */
33 /* This is used to indicate that we don't know the format of the floating point
34 number. Typically, this is useful for native ports, where the actual format
35 is irrelevant, since no conversions will be taking place. */
37 const struct floatformat floatformat_unknown
;
39 /* Registers we shouldn't try to store. */
40 #if !defined (CANNOT_STORE_REGISTER)
41 #define CANNOT_STORE_REGISTER(regno) 0
44 static void write_register_gen
PARAMS ((int, char *));
46 static int read_relative_register_raw_bytes_for_frame
PARAMS ((int regnum
, char *myaddr
, struct frame_info
*frame
));
48 /* Basic byte-swapping routines. GDB has needed these for a long time...
49 All extract a target-format integer at ADDR which is LEN bytes long. */
51 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
52 /* 8 bit characters are a pretty safe assumption these days, so we
53 assume it throughout all these swapping routines. If we had to deal with
54 9 bit characters, we would need to make len be in bits and would have
55 to re-write these routines... */
60 extract_signed_integer (addr
, len
)
66 unsigned char *startaddr
= (unsigned char *)addr
;
67 unsigned char *endaddr
= startaddr
+ len
;
69 if (len
> (int) sizeof (LONGEST
))
71 That operation is not available on integers of more than %d bytes.",
74 /* Start at the most significant end of the integer, and work towards
75 the least significant. */
76 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
79 /* Do the sign extension once at the start. */
80 retval
= ((LONGEST
)*p
^ 0x80) - 0x80;
81 for (++p
; p
< endaddr
; ++p
)
82 retval
= (retval
<< 8) | *p
;
87 /* Do the sign extension once at the start. */
88 retval
= ((LONGEST
)*p
^ 0x80) - 0x80;
89 for (--p
; p
>= startaddr
; --p
)
90 retval
= (retval
<< 8) | *p
;
96 extract_unsigned_integer (addr
, len
)
102 unsigned char *startaddr
= (unsigned char *)addr
;
103 unsigned char *endaddr
= startaddr
+ len
;
105 if (len
> (int) sizeof (ULONGEST
))
107 That operation is not available on integers of more than %d bytes.",
110 /* Start at the most significant end of the integer, and work towards
111 the least significant. */
113 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
115 for (p
= startaddr
; p
< endaddr
; ++p
)
116 retval
= (retval
<< 8) | *p
;
120 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
121 retval
= (retval
<< 8) | *p
;
126 /* Sometimes a long long unsigned integer can be extracted as a
127 LONGEST value. This is done so that we can print these values
128 better. If this integer can be converted to a LONGEST, this
129 function returns 1 and sets *PVAL. Otherwise it returns 0. */
132 extract_long_unsigned_integer (addr
, orig_len
, pval
)
137 char *p
, *first_addr
;
141 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
143 for (p
= (char *) addr
;
144 len
> (int) sizeof (LONGEST
) && p
< (char *) addr
+ orig_len
;
156 first_addr
= (char *) addr
;
157 for (p
= (char *) addr
+ orig_len
- 1;
158 len
> (int) sizeof (LONGEST
) && p
>= (char *) addr
;
168 if (len
<= (int) sizeof (LONGEST
))
170 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
179 extract_address (addr
, len
)
183 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
184 whether we want this to be true eventually. */
185 return (CORE_ADDR
)extract_unsigned_integer (addr
, len
);
189 store_signed_integer (addr
, len
, val
)
195 unsigned char *startaddr
= (unsigned char *)addr
;
196 unsigned char *endaddr
= startaddr
+ len
;
198 /* Start at the least significant end of the integer, and work towards
199 the most significant. */
200 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
202 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
210 for (p
= startaddr
; p
< endaddr
; ++p
)
219 store_unsigned_integer (addr
, len
, val
)
225 unsigned char *startaddr
= (unsigned char *)addr
;
226 unsigned char *endaddr
= startaddr
+ len
;
228 /* Start at the least significant end of the integer, and work towards
229 the most significant. */
230 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
232 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
240 for (p
= startaddr
; p
< endaddr
; ++p
)
248 /* Store the literal address "val" into
249 gdb-local memory pointed to by "addr"
252 store_address (addr
, len
, val
)
257 store_unsigned_integer (addr
, len
, val
);
260 /* Swap LEN bytes at BUFFER between target and host byte-order. */
261 #define SWAP_FLOATING(buffer,len) \
264 if (TARGET_BYTE_ORDER != HOST_BYTE_ORDER) \
267 char *p = (char *)(buffer); \
268 char *q = ((char *)(buffer)) + len - 1; \
269 for (; p < q; p++, q--) \
279 /* Extract a floating-point number from a target-order byte-stream at ADDR.
280 Returns the value as type DOUBLEST.
282 If the host and target formats agree, we just copy the raw data into the
283 appropriate type of variable and return, letting the host increase precision
284 as necessary. Otherwise, we call the conversion routine and let it do the
288 extract_floating (addr
, len
)
294 if (len
== sizeof (float))
296 if (HOST_FLOAT_FORMAT
== TARGET_FLOAT_FORMAT
)
300 memcpy (&retval
, addr
, sizeof (retval
));
304 floatformat_to_doublest (TARGET_FLOAT_FORMAT
, addr
, &dretval
);
306 else if (len
== sizeof (double))
308 if (HOST_DOUBLE_FORMAT
== TARGET_DOUBLE_FORMAT
)
312 memcpy (&retval
, addr
, sizeof (retval
));
316 floatformat_to_doublest (TARGET_DOUBLE_FORMAT
, addr
, &dretval
);
318 else if (len
== sizeof (DOUBLEST
))
320 if (HOST_LONG_DOUBLE_FORMAT
== TARGET_LONG_DOUBLE_FORMAT
)
324 memcpy (&retval
, addr
, sizeof (retval
));
328 floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT
, addr
, &dretval
);
332 error ("Can't deal with a floating point number of %d bytes.", len
);
339 store_floating (addr
, len
, val
)
344 if (len
== sizeof (float))
346 if (HOST_FLOAT_FORMAT
== TARGET_FLOAT_FORMAT
)
348 float floatval
= val
;
350 memcpy (addr
, &floatval
, sizeof (floatval
));
353 floatformat_from_doublest (TARGET_FLOAT_FORMAT
, &val
, addr
);
355 else if (len
== sizeof (double))
357 if (HOST_DOUBLE_FORMAT
== TARGET_DOUBLE_FORMAT
)
359 double doubleval
= val
;
361 memcpy (addr
, &doubleval
, sizeof (doubleval
));
364 floatformat_from_doublest (TARGET_DOUBLE_FORMAT
, &val
, addr
);
366 else if (len
== sizeof (DOUBLEST
))
368 if (HOST_LONG_DOUBLE_FORMAT
== TARGET_LONG_DOUBLE_FORMAT
)
369 memcpy (addr
, &val
, sizeof (val
));
371 floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT
, &val
, addr
);
375 error ("Can't deal with a floating point number of %d bytes.", len
);
380 /* Return the address in which frame FRAME's value of register REGNUM
381 has been saved in memory. Or return zero if it has not been saved.
382 If REGNUM specifies the SP, the value we return is actually
383 the SP value, not an address where it was saved. */
386 find_saved_register (frame
, regnum
)
387 struct frame_info
*frame
;
390 register struct frame_info
*frame1
= NULL
;
391 register CORE_ADDR addr
= 0;
393 if (frame
== NULL
) /* No regs saved if want current frame */
396 #ifdef HAVE_REGISTER_WINDOWS
397 /* We assume that a register in a register window will only be saved
398 in one place (since the name changes and/or disappears as you go
399 towards inner frames), so we only call get_frame_saved_regs on
400 the current frame. This is directly in contradiction to the
401 usage below, which assumes that registers used in a frame must be
402 saved in a lower (more interior) frame. This change is a result
403 of working on a register window machine; get_frame_saved_regs
404 always returns the registers saved within a frame, within the
405 context (register namespace) of that frame. */
407 /* However, note that we don't want this to return anything if
408 nothing is saved (if there's a frame inside of this one). Also,
409 callers to this routine asking for the stack pointer want the
410 stack pointer saved for *this* frame; this is returned from the
413 if (REGISTER_IN_WINDOW_P(regnum
))
415 frame1
= get_next_frame (frame
);
416 if (!frame1
) return 0; /* Registers of this frame are active. */
418 /* Get the SP from the next frame in; it will be this
420 if (regnum
!= SP_REGNUM
)
423 FRAME_INIT_SAVED_REGS (frame1
);
424 return frame1
->saved_regs
[regnum
]; /* ... which might be zero */
426 #endif /* HAVE_REGISTER_WINDOWS */
428 /* Note that this next routine assumes that registers used in
429 frame x will be saved only in the frame that x calls and
430 frames interior to it. This is not true on the sparc, but the
431 above macro takes care of it, so we should be all right. */
435 frame1
= get_prev_frame (frame1
);
436 if (frame1
== 0 || frame1
== frame
)
438 FRAME_INIT_SAVED_REGS (frame1
);
439 if (frame1
->saved_regs
[regnum
])
440 addr
= frame1
->saved_regs
[regnum
];
446 /* Find register number REGNUM relative to FRAME and put its (raw,
447 target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
448 variable was optimized out (and thus can't be fetched). Set *LVAL
449 to lval_memory, lval_register, or not_lval, depending on whether
450 the value was fetched from memory, from a register, or in a strange
451 and non-modifiable way (e.g. a frame pointer which was calculated
452 rather than fetched). Set *ADDRP to the address, either in memory
453 on as a REGISTER_BYTE offset into the registers array.
455 Note that this implementation never sets *LVAL to not_lval. But
456 it can be replaced by defining GET_SAVED_REGISTER and supplying
459 The argument RAW_BUFFER must point to aligned memory. */
462 default_get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
466 struct frame_info
*frame
;
468 enum lval_type
*lval
;
472 if (!target_has_registers
)
473 error ("No registers.");
475 /* Normal systems don't optimize out things with register numbers. */
476 if (optimized
!= NULL
)
478 addr
= find_saved_register (frame
, regnum
);
483 if (regnum
== SP_REGNUM
)
485 if (raw_buffer
!= NULL
)
487 /* Put it back in target format. */
488 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
), (LONGEST
)addr
);
494 if (raw_buffer
!= NULL
)
495 read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
500 *lval
= lval_register
;
501 addr
= REGISTER_BYTE (regnum
);
502 if (raw_buffer
!= NULL
)
503 read_register_gen (regnum
, raw_buffer
);
509 #if !defined (GET_SAVED_REGISTER)
510 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
511 default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
514 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
518 struct frame_info
*frame
;
520 enum lval_type
*lval
;
522 GET_SAVED_REGISTER (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
);
525 /* Copy the bytes of register REGNUM, relative to the input stack frame,
526 into our memory at MYADDR, in target byte order.
527 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
529 Returns 1 if could not be read, 0 if could. */
532 read_relative_register_raw_bytes_for_frame (regnum
, myaddr
, frame
)
535 struct frame_info
*frame
;
538 if (regnum
== FP_REGNUM
&& frame
)
540 /* Put it back in target format. */
541 store_address (myaddr
, REGISTER_RAW_SIZE(FP_REGNUM
),
542 (LONGEST
)FRAME_FP(frame
));
547 get_saved_register (myaddr
, &optim
, (CORE_ADDR
*) NULL
, frame
,
548 regnum
, (enum lval_type
*)NULL
);
550 if (register_valid
[regnum
] < 0)
551 return 1; /* register value not available */
556 /* Copy the bytes of register REGNUM, relative to the current stack frame,
557 into our memory at MYADDR, in target byte order.
558 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
560 Returns 1 if could not be read, 0 if could. */
563 read_relative_register_raw_bytes (regnum
, myaddr
)
567 return read_relative_register_raw_bytes_for_frame (regnum
, myaddr
,
571 /* Return a `value' with the contents of register REGNUM
572 in its virtual format, with the type specified by
573 REGISTER_VIRTUAL_TYPE.
575 NOTE: returns NULL if register value is not available.
576 Caller will check return value or die! */
579 value_of_register (regnum
)
584 register value_ptr reg_val
;
585 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
588 get_saved_register (raw_buffer
, &optim
, &addr
,
589 selected_frame
, regnum
, &lval
);
591 if (register_valid
[regnum
] < 0)
592 return NULL
; /* register value not available */
594 reg_val
= allocate_value (REGISTER_VIRTUAL_TYPE (regnum
));
596 /* Convert raw data to virtual format if necessary. */
598 #ifdef REGISTER_CONVERTIBLE
599 if (REGISTER_CONVERTIBLE (regnum
))
601 REGISTER_CONVERT_TO_VIRTUAL (regnum
, REGISTER_VIRTUAL_TYPE (regnum
),
602 raw_buffer
, VALUE_CONTENTS_RAW (reg_val
));
606 if (REGISTER_RAW_SIZE (regnum
) == REGISTER_VIRTUAL_SIZE (regnum
))
607 memcpy (VALUE_CONTENTS_RAW (reg_val
), raw_buffer
,
608 REGISTER_RAW_SIZE (regnum
));
610 fatal ("Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
611 REGISTER_NAME (regnum
), regnum
,
612 REGISTER_RAW_SIZE (regnum
), REGISTER_VIRTUAL_SIZE (regnum
));
613 VALUE_LVAL (reg_val
) = lval
;
614 VALUE_ADDRESS (reg_val
) = addr
;
615 VALUE_REGNO (reg_val
) = regnum
;
616 VALUE_OPTIMIZED_OUT (reg_val
) = optim
;
620 /* Low level examining and depositing of registers.
622 The caller is responsible for making
623 sure that the inferior is stopped before calling the fetching routines,
624 or it will get garbage. (a change from GDB version 3, in which
625 the caller got the value from the last stop). */
627 /* Contents and state of the registers (in target byte order). */
631 /* VALID_REGISTER is non-zero if it has been fetched, -1 if the
632 register value was not available. */
634 signed char *register_valid
;
636 /* The thread/process associated with the current set of registers. For now,
637 -1 is special, and means `no current process'. */
638 int registers_pid
= -1;
640 /* Indicate that registers may have changed, so invalidate the cache. */
646 int numregs
= ARCH_NUM_REGS
;
650 /* Force cleanup of any alloca areas if using C alloca instead of
651 a builtin alloca. This particular call is used to clean up
652 areas allocated by low level target code which may build up
653 during lengthy interactions between gdb and the target before
654 gdb gives control to the user (ie watchpoints). */
657 for (i
= 0; i
< numregs
; i
++)
658 register_valid
[i
] = 0;
660 if (registers_changed_hook
)
661 registers_changed_hook ();
664 /* Indicate that all registers have been fetched, so mark them all valid. */
669 int numregs
= ARCH_NUM_REGS
;
670 for (i
= 0; i
< numregs
; i
++)
671 register_valid
[i
] = 1;
674 /* read_register_bytes and write_register_bytes are generally a *BAD* idea.
675 They are inefficient because they need to check for partial updates, which
676 can only be done by scanning through all of the registers and seeing if the
677 bytes that are being read/written fall inside of an invalid register. [The
678 main reason this is necessary is that register sizes can vary, so a simple
679 index won't suffice.] It is far better to call read_register_gen if you
680 want to get at the raw register contents, as it only takes a regno as an
681 argument, and therefore can't do a partial register update. It would also
682 be good to have a write_register_gen for similar reasons.
684 Prior to the recent fixes to check for partial updates, both read and
685 write_register_bytes always checked to see if any registers were stale, and
686 then called target_fetch_registers (-1) to update the whole set. This
687 caused really slowed things down for remote targets. */
689 /* Copy INLEN bytes of consecutive data from registers
690 starting with the INREGBYTE'th byte of register data
691 into memory at MYADDR. */
694 read_register_bytes (inregbyte
, myaddr
, inlen
)
699 int inregend
= inregbyte
+ inlen
;
702 if (registers_pid
!= inferior_pid
)
704 registers_changed ();
705 registers_pid
= inferior_pid
;
708 /* See if we are trying to read bytes from out-of-date registers. If so,
709 update just those registers. */
711 for (regno
= 0; regno
< NUM_REGS
; regno
++)
713 int regstart
, regend
;
716 if (register_valid
[regno
])
719 if (REGISTER_NAME (regno
) == NULL
|| *REGISTER_NAME (regno
) == '\0')
722 regstart
= REGISTER_BYTE (regno
);
723 regend
= regstart
+ REGISTER_RAW_SIZE (regno
);
725 startin
= regstart
>= inregbyte
&& regstart
< inregend
;
726 endin
= regend
> inregbyte
&& regend
<= inregend
;
728 if (!startin
&& !endin
)
731 /* We've found an invalid register where at least one byte will be read.
732 Update it from the target. */
734 target_fetch_registers (regno
);
736 if (!register_valid
[regno
])
737 error ("read_register_bytes: Couldn't update register %d.", regno
);
741 memcpy (myaddr
, ®isters
[inregbyte
], inlen
);
744 /* Read register REGNO into memory at MYADDR, which must be large enough
745 for REGISTER_RAW_BYTES (REGNO). Target byte-order.
746 If the register is known to be the size of a CORE_ADDR or smaller,
747 read_register can be used instead. */
749 read_register_gen (regno
, myaddr
)
753 if (registers_pid
!= inferior_pid
)
755 registers_changed ();
756 registers_pid
= inferior_pid
;
759 if (!register_valid
[regno
])
760 target_fetch_registers (regno
);
761 memcpy (myaddr
, ®isters
[REGISTER_BYTE (regno
)],
762 REGISTER_RAW_SIZE (regno
));
765 /* Write register REGNO at MYADDR to the target. MYADDR points at
766 REGISTER_RAW_BYTES(REGNO), which must be in target byte-order. */
769 write_register_gen (regno
, myaddr
)
775 /* On the sparc, writing %g0 is a no-op, so we don't even want to change
776 the registers array if something writes to this register. */
777 if (CANNOT_STORE_REGISTER (regno
))
780 if (registers_pid
!= inferior_pid
)
782 registers_changed ();
783 registers_pid
= inferior_pid
;
786 size
= REGISTER_RAW_SIZE(regno
);
788 /* If we have a valid copy of the register, and new value == old value,
789 then don't bother doing the actual store. */
791 if (register_valid
[regno
]
792 && memcmp (®isters
[REGISTER_BYTE (regno
)], myaddr
, size
) == 0)
795 target_prepare_to_store ();
797 memcpy (®isters
[REGISTER_BYTE (regno
)], myaddr
, size
);
799 register_valid
[regno
] = 1;
801 target_store_registers (regno
);
804 /* Copy INLEN bytes of consecutive data from memory at MYADDR
805 into registers starting with the MYREGSTART'th byte of register data. */
808 write_register_bytes (myregstart
, myaddr
, inlen
)
813 int myregend
= myregstart
+ inlen
;
816 target_prepare_to_store ();
818 /* Scan through the registers updating any that are covered by the range
819 myregstart<=>myregend using write_register_gen, which does nice things
820 like handling threads, and avoiding updates when the new and old contents
823 for (regno
= 0; regno
< NUM_REGS
; regno
++)
825 int regstart
, regend
;
827 char regbuf
[MAX_REGISTER_RAW_SIZE
];
829 regstart
= REGISTER_BYTE (regno
);
830 regend
= regstart
+ REGISTER_RAW_SIZE (regno
);
832 startin
= regstart
>= myregstart
&& regstart
< myregend
;
833 endin
= regend
> myregstart
&& regend
<= myregend
;
835 if (!startin
&& !endin
)
836 continue; /* Register is completely out of range */
838 if (startin
&& endin
) /* register is completely in range */
840 write_register_gen (regno
, myaddr
+ (regstart
- myregstart
));
844 /* We may be doing a partial update of an invalid register. Update it
845 from the target before scribbling on it. */
846 read_register_gen (regno
, regbuf
);
849 memcpy (registers
+ regstart
,
850 myaddr
+ regstart
- myregstart
,
851 myregend
- regstart
);
853 memcpy (registers
+ myregstart
,
855 regend
- myregstart
);
856 target_store_registers (regno
);
860 /* Return the raw contents of register REGNO, regarding it as an integer. */
861 /* This probably should be returning LONGEST rather than CORE_ADDR. */
864 read_register (regno
)
867 if (registers_pid
!= inferior_pid
)
869 registers_changed ();
870 registers_pid
= inferior_pid
;
873 if (!register_valid
[regno
])
874 target_fetch_registers (regno
);
876 return (CORE_ADDR
)extract_address (®isters
[REGISTER_BYTE (regno
)],
877 REGISTER_RAW_SIZE(regno
));
881 read_register_pid (regno
, pid
)
887 if (pid
== inferior_pid
)
888 return read_register (regno
);
890 save_pid
= inferior_pid
;
894 retval
= read_register (regno
);
896 inferior_pid
= save_pid
;
901 /* Store VALUE, into the raw contents of register number REGNO.
902 This should probably write a LONGEST rather than a CORE_ADDR */
905 write_register (regno
, val
)
912 /* On the sparc, writing %g0 is a no-op, so we don't even want to change
913 the registers array if something writes to this register. */
914 if (CANNOT_STORE_REGISTER (regno
))
917 if (registers_pid
!= inferior_pid
)
919 registers_changed ();
920 registers_pid
= inferior_pid
;
923 size
= REGISTER_RAW_SIZE(regno
);
925 store_signed_integer (buf
, size
, (LONGEST
)val
);
927 /* If we have a valid copy of the register, and new value == old value,
928 then don't bother doing the actual store. */
930 if (register_valid
[regno
]
931 && memcmp (®isters
[REGISTER_BYTE (regno
)], buf
, size
) == 0)
934 target_prepare_to_store ();
936 memcpy (®isters
[REGISTER_BYTE (regno
)], buf
, size
);
938 register_valid
[regno
] = 1;
940 target_store_registers (regno
);
944 write_register_pid (regno
, val
, pid
)
951 if (pid
== inferior_pid
)
953 write_register (regno
, val
);
957 save_pid
= inferior_pid
;
961 write_register (regno
, val
);
963 inferior_pid
= save_pid
;
966 /* Record that register REGNO contains VAL.
967 This is used when the value is obtained from the inferior or core dump,
968 so there is no need to store the value there.
970 If VAL is a NULL pointer, then it's probably an unsupported register. We
971 just set it's value to all zeros. We might want to record this fact, and
972 report it to the users of read_register and friends.
976 supply_register (regno
, val
)
981 if (registers_pid
!= inferior_pid
)
983 registers_changed ();
984 registers_pid
= inferior_pid
;
988 register_valid
[regno
] = 1;
990 memcpy (®isters
[REGISTER_BYTE (regno
)], val
, REGISTER_RAW_SIZE (regno
));
992 memset (®isters
[REGISTER_BYTE (regno
)], '\000', REGISTER_RAW_SIZE (regno
));
994 /* On some architectures, e.g. HPPA, there are a few stray bits in some
995 registers, that the rest of the code would like to ignore. */
996 #ifdef CLEAN_UP_REGISTER_VALUE
997 CLEAN_UP_REGISTER_VALUE(regno
, ®isters
[REGISTER_BYTE(regno
)]);
1002 /* This routine is getting awfully cluttered with #if's. It's probably
1003 time to turn this into READ_PC and define it in the tm.h file.
1004 Ditto for write_pc. */
1010 int saved_inferior_pid
;
1013 /* In case pid != inferior_pid. */
1014 saved_inferior_pid
= inferior_pid
;
1017 #ifdef TARGET_READ_PC
1018 pc_val
= TARGET_READ_PC (pid
);
1020 pc_val
= ADDR_BITS_REMOVE ((CORE_ADDR
) read_register_pid (PC_REGNUM
, pid
));
1023 inferior_pid
= saved_inferior_pid
;
1030 return read_pc_pid (inferior_pid
);
1034 write_pc_pid (pc
, pid
)
1038 int saved_inferior_pid
;
1040 /* In case pid != inferior_pid. */
1041 saved_inferior_pid
= inferior_pid
;
1044 #ifdef TARGET_WRITE_PC
1045 TARGET_WRITE_PC (pc
, pid
);
1047 write_register_pid (PC_REGNUM
, pc
, pid
);
1049 write_register_pid (NPC_REGNUM
, pc
+ 4, pid
);
1051 write_register_pid (NNPC_REGNUM
, pc
+ 8, pid
);
1056 inferior_pid
= saved_inferior_pid
;
1063 write_pc_pid (pc
, inferior_pid
);
1066 /* Cope with strage ways of getting to the stack and frame pointers */
1071 #ifdef TARGET_READ_SP
1072 return TARGET_READ_SP ();
1074 return read_register (SP_REGNUM
);
1082 #ifdef TARGET_WRITE_SP
1083 TARGET_WRITE_SP (val
);
1085 write_register (SP_REGNUM
, val
);
1092 #ifdef TARGET_READ_FP
1093 return TARGET_READ_FP ();
1095 return read_register (FP_REGNUM
);
1103 #ifdef TARGET_WRITE_FP
1104 TARGET_WRITE_FP (val
);
1106 write_register (FP_REGNUM
, val
);
1110 /* Will calling read_var_value or locate_var_value on SYM end
1111 up caring what frame it is being evaluated relative to? SYM must
1114 symbol_read_needs_frame (sym
)
1117 switch (SYMBOL_CLASS (sym
))
1119 /* All cases listed explicitly so that gcc -Wall will detect it if
1120 we failed to consider one. */
1125 case LOC_REGPARM_ADDR
:
1129 case LOC_BASEREG_ARG
:
1130 case LOC_THREAD_LOCAL_STATIC
:
1140 /* Getting the address of a label can be done independently of the block,
1141 even if some *uses* of that address wouldn't work so well without
1145 case LOC_CONST_BYTES
:
1146 case LOC_UNRESOLVED
:
1147 case LOC_OPTIMIZED_OUT
:
1153 /* Given a struct symbol for a variable,
1154 and a stack frame id, read the value of the variable
1155 and return a (pointer to a) struct value containing the value.
1156 If the variable cannot be found, return a zero pointer.
1157 If FRAME is NULL, use the selected_frame. */
1160 read_var_value (var
, frame
)
1161 register struct symbol
*var
;
1162 struct frame_info
*frame
;
1164 register value_ptr v
;
1165 struct type
*type
= SYMBOL_TYPE (var
);
1169 v
= allocate_value (type
);
1170 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
1171 VALUE_BFD_SECTION (v
) = SYMBOL_BFD_SECTION (var
);
1173 len
= TYPE_LENGTH (type
);
1175 if (frame
== NULL
) frame
= selected_frame
;
1177 switch (SYMBOL_CLASS (var
))
1180 /* Put the constant back in target format. */
1181 store_signed_integer (VALUE_CONTENTS_RAW (v
), len
,
1182 (LONGEST
) SYMBOL_VALUE (var
));
1183 VALUE_LVAL (v
) = not_lval
;
1187 /* Put the constant back in target format. */
1188 if (overlay_debugging
)
1189 store_address (VALUE_CONTENTS_RAW (v
), len
,
1190 (LONGEST
)symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
1191 SYMBOL_BFD_SECTION (var
)));
1193 store_address (VALUE_CONTENTS_RAW (v
), len
,
1194 (LONGEST
)SYMBOL_VALUE_ADDRESS (var
));
1195 VALUE_LVAL (v
) = not_lval
;
1198 case LOC_CONST_BYTES
:
1201 bytes_addr
= SYMBOL_VALUE_BYTES (var
);
1202 memcpy (VALUE_CONTENTS_RAW (v
), bytes_addr
, len
);
1203 VALUE_LVAL (v
) = not_lval
;
1208 if (overlay_debugging
)
1209 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
1210 SYMBOL_BFD_SECTION (var
));
1212 addr
= SYMBOL_VALUE_ADDRESS (var
);
1216 /* The import slot does not have a real address in it from the
1217 dynamic loader (dld.sl on HP-UX), if the target hasn't begun
1218 execution yet, so check for that. */
1219 if (!target_has_execution
)
1221 Attempt to access variable defined in different shared object or load module when\n\
1222 addresses have not been bound by the dynamic loader. Try again when executable is running.");
1224 addr
= SYMBOL_VALUE_ADDRESS (var
);
1225 addr
= read_memory_unsigned_integer
1226 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1232 addr
= FRAME_ARGS_ADDRESS (frame
);
1235 addr
+= SYMBOL_VALUE (var
);
1241 addr
= FRAME_ARGS_ADDRESS (frame
);
1244 addr
+= SYMBOL_VALUE (var
);
1245 addr
= read_memory_unsigned_integer
1246 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1253 addr
= FRAME_LOCALS_ADDRESS (frame
);
1254 addr
+= SYMBOL_VALUE (var
);
1258 case LOC_BASEREG_ARG
:
1260 char buf
[MAX_REGISTER_RAW_SIZE
];
1261 get_saved_register (buf
, NULL
, NULL
, frame
, SYMBOL_BASEREG (var
),
1263 addr
= extract_address (buf
, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var
)));
1264 addr
+= SYMBOL_VALUE (var
);
1268 case LOC_THREAD_LOCAL_STATIC
:
1270 char buf
[MAX_REGISTER_RAW_SIZE
];
1272 get_saved_register(buf
, NULL
, NULL
, frame
, SYMBOL_BASEREG (var
),
1274 addr
= extract_address (buf
, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var
)));
1275 addr
+= SYMBOL_VALUE (var
);
1280 error ("Cannot look up value of a typedef");
1284 if (overlay_debugging
)
1285 VALUE_ADDRESS (v
) = symbol_overlayed_address
1286 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_BFD_SECTION (var
));
1288 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
1293 case LOC_REGPARM_ADDR
:
1296 int regno
= SYMBOL_VALUE (var
);
1301 b
= get_frame_block (frame
);
1303 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
1305 regval
= value_from_register (lookup_pointer_type (type
),
1310 error ("Value of register variable not available.");
1312 addr
= value_as_pointer (regval
);
1313 VALUE_LVAL (v
) = lval_memory
;
1317 regval
= value_from_register (type
, regno
, frame
);
1320 error ("Value of register variable not available.");
1326 case LOC_UNRESOLVED
:
1328 struct minimal_symbol
*msym
;
1330 msym
= lookup_minimal_symbol (SYMBOL_NAME (var
), NULL
, NULL
);
1333 if (overlay_debugging
)
1334 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
1335 SYMBOL_BFD_SECTION (msym
));
1337 addr
= SYMBOL_VALUE_ADDRESS (msym
);
1341 case LOC_OPTIMIZED_OUT
:
1342 VALUE_LVAL (v
) = not_lval
;
1343 VALUE_OPTIMIZED_OUT (v
) = 1;
1347 error ("Cannot look up value of a botched symbol.");
1351 VALUE_ADDRESS (v
) = addr
;
1356 /* Return a value of type TYPE, stored in register REGNUM, in frame
1359 NOTE: returns NULL if register value is not available.
1360 Caller will check return value or die! */
1363 value_from_register (type
, regnum
, frame
)
1366 struct frame_info
*frame
;
1368 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1371 value_ptr v
= allocate_value (type
);
1372 char *value_bytes
= 0;
1373 int value_bytes_copied
= 0;
1374 int num_storage_locs
;
1375 enum lval_type lval
;
1378 CHECK_TYPEDEF (type
);
1379 len
= TYPE_LENGTH (type
);
1381 VALUE_REGNO (v
) = regnum
;
1383 num_storage_locs
= (len
> REGISTER_VIRTUAL_SIZE (regnum
) ?
1384 ((len
- 1) / REGISTER_RAW_SIZE (regnum
)) + 1 :
1387 if (num_storage_locs
> 1
1388 #ifdef GDB_TARGET_IS_H8500
1389 || TYPE_CODE (type
) == TYPE_CODE_PTR
1393 /* Value spread across multiple storage locations. */
1396 int mem_stor
= 0, reg_stor
= 0;
1397 int mem_tracking
= 1;
1398 CORE_ADDR last_addr
= 0;
1399 CORE_ADDR first_addr
= 0;
1401 value_bytes
= (char *) alloca (len
+ MAX_REGISTER_RAW_SIZE
);
1403 /* Copy all of the data out, whereever it may be. */
1405 #ifdef GDB_TARGET_IS_H8500
1406 /* This piece of hideosity is required because the H8500 treats registers
1407 differently depending upon whether they are used as pointers or not. As a
1408 pointer, a register needs to have a page register tacked onto the front.
1409 An alternate way to do this would be to have gcc output different register
1410 numbers for the pointer & non-pointer form of the register. But, it
1411 doesn't, so we're stuck with this. */
1413 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1420 case R0_REGNUM
: case R1_REGNUM
: case R2_REGNUM
: case R3_REGNUM
:
1421 page_regnum
= SEG_D_REGNUM
;
1423 case R4_REGNUM
: case R5_REGNUM
:
1424 page_regnum
= SEG_E_REGNUM
;
1426 case R6_REGNUM
: case R7_REGNUM
:
1427 page_regnum
= SEG_T_REGNUM
;
1432 get_saved_register (value_bytes
+ 1,
1439 if (register_valid
[page_regnum
] == -1)
1440 return NULL
; /* register value not available */
1442 if (lval
== lval_register
)
1449 get_saved_register (value_bytes
+ 2,
1456 if (register_valid
[regnum
] == -1)
1457 return NULL
; /* register value not available */
1459 if (lval
== lval_register
)
1464 mem_tracking
= mem_tracking
&& (addr
== last_addr
);
1469 #endif /* GDB_TARGET_IS_H8500 */
1470 for (local_regnum
= regnum
;
1471 value_bytes_copied
< len
;
1472 (value_bytes_copied
+= REGISTER_RAW_SIZE (local_regnum
),
1475 get_saved_register (value_bytes
+ value_bytes_copied
,
1482 if (register_valid
[local_regnum
] == -1)
1483 return NULL
; /* register value not available */
1485 if (regnum
== local_regnum
)
1487 if (lval
== lval_register
)
1495 && (regnum
== local_regnum
1496 || addr
== last_addr
));
1501 if ((reg_stor
&& mem_stor
)
1502 || (mem_stor
&& !mem_tracking
))
1503 /* Mixed storage; all of the hassle we just went through was
1504 for some good purpose. */
1506 VALUE_LVAL (v
) = lval_reg_frame_relative
;
1507 VALUE_FRAME (v
) = FRAME_FP (frame
);
1508 VALUE_FRAME_REGNUM (v
) = regnum
;
1512 VALUE_LVAL (v
) = lval_memory
;
1513 VALUE_ADDRESS (v
) = first_addr
;
1517 VALUE_LVAL (v
) = lval_register
;
1518 VALUE_ADDRESS (v
) = first_addr
;
1521 fatal ("value_from_register: Value not stored anywhere!");
1523 VALUE_OPTIMIZED_OUT (v
) = optim
;
1525 /* Any structure stored in more than one register will always be
1526 an integral number of registers. Otherwise, you'd need to do
1527 some fiddling with the last register copied here for little
1530 /* Copy into the contents section of the value. */
1531 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
, len
);
1533 /* Finally do any conversion necessary when extracting this
1534 type from more than one register. */
1535 #ifdef REGISTER_CONVERT_TO_TYPE
1536 REGISTER_CONVERT_TO_TYPE(regnum
, type
, VALUE_CONTENTS_RAW(v
));
1541 /* Data is completely contained within a single register. Locate the
1542 register's contents in a real register or in core;
1543 read the data in raw format. */
1545 get_saved_register (raw_buffer
, &optim
, &addr
, frame
, regnum
, &lval
);
1547 if (register_valid
[regnum
] == -1)
1548 return NULL
; /* register value not available */
1550 VALUE_OPTIMIZED_OUT (v
) = optim
;
1551 VALUE_LVAL (v
) = lval
;
1552 VALUE_ADDRESS (v
) = addr
;
1554 /* Convert raw data to virtual format if necessary. */
1556 #ifdef REGISTER_CONVERTIBLE
1557 if (REGISTER_CONVERTIBLE (regnum
))
1559 REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
,
1560 raw_buffer
, VALUE_CONTENTS_RAW (v
));
1565 /* Raw and virtual formats are the same for this register. */
1567 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
&& len
< REGISTER_RAW_SIZE (regnum
))
1569 /* Big-endian, and we want less than full size. */
1570 VALUE_OFFSET (v
) = REGISTER_RAW_SIZE (regnum
) - len
;
1573 memcpy (VALUE_CONTENTS_RAW (v
), raw_buffer
+ VALUE_OFFSET (v
), len
);
1579 /* Given a struct symbol for a variable or function,
1580 and a stack frame id,
1581 return a (pointer to a) struct value containing the properly typed
1585 locate_var_value (var
, frame
)
1586 register struct symbol
*var
;
1587 struct frame_info
*frame
;
1590 struct type
*type
= SYMBOL_TYPE (var
);
1591 value_ptr lazy_value
;
1593 /* Evaluate it first; if the result is a memory address, we're fine.
1594 Lazy evaluation pays off here. */
1596 lazy_value
= read_var_value (var
, frame
);
1597 if (lazy_value
== 0)
1598 error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
1600 if (VALUE_LAZY (lazy_value
)
1601 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1605 addr
= VALUE_ADDRESS (lazy_value
);
1606 val
= value_from_longest (lookup_pointer_type (type
), (LONGEST
) addr
);
1607 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (lazy_value
);
1611 /* Not a memory address; check what the problem was. */
1612 switch (VALUE_LVAL (lazy_value
))
1615 case lval_reg_frame_relative
:
1616 error ("Address requested for identifier \"%s\" which is in a register.",
1617 SYMBOL_SOURCE_NAME (var
));
1621 error ("Can't take address of \"%s\" which isn't an lvalue.",
1622 SYMBOL_SOURCE_NAME (var
));
1625 return 0; /* For lint -- never reached */
1629 static void build_findvar
PARAMS ((void));
1633 /* We allocate some extra slop since we do a lot of memcpy's around
1634 `registers', and failing-soft is better than failing hard. */
1635 int sizeof_registers
= REGISTER_BYTES
+ /* SLOP */ 256;
1636 int sizeof_register_valid
= NUM_REGS
* sizeof (*register_valid
);
1637 registers
= xmalloc (sizeof_registers
);
1638 memset (registers
, 0, sizeof_registers
);
1639 register_valid
= xmalloc (sizeof_register_valid
);
1640 memset (register_valid
, 0, sizeof_register_valid
);
1643 void _initialize_findvar
PARAMS ((void));
1645 _initialize_findvar ()