1 /* Find a variable's value in memory, for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1989, 1991, 1994, 1995, 1996 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #include "gdb_string.h"
30 /* Registers we shouldn't try to store. */
31 #if !defined (CANNOT_STORE_REGISTER)
32 #define CANNOT_STORE_REGISTER(regno) 0
35 static void write_register_pid
PARAMS ((int regno
, LONGEST val
, int pid
));
37 /* Basic byte-swapping routines. GDB has needed these for a long time...
38 All extract a target-format integer at ADDR which is LEN bytes long. */
40 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
41 /* 8 bit characters are a pretty safe assumption these days, so we
42 assume it throughout all these swapping routines. If we had to deal with
43 9 bit characters, we would need to make len be in bits and would have
44 to re-write these routines... */
49 extract_signed_integer (addr
, len
)
55 unsigned char *startaddr
= (unsigned char *)addr
;
56 unsigned char *endaddr
= startaddr
+ len
;
58 if (len
> (int) sizeof (LONGEST
))
60 That operation is not available on integers of more than %d bytes.",
63 /* Start at the most significant end of the integer, and work towards
64 the least significant. */
65 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
68 /* Do the sign extension once at the start. */
69 retval
= ((LONGEST
)*p
^ 0x80) - 0x80;
70 for (++p
; p
< endaddr
; ++p
)
71 retval
= (retval
<< 8) | *p
;
76 /* Do the sign extension once at the start. */
77 retval
= ((LONGEST
)*p
^ 0x80) - 0x80;
78 for (--p
; p
>= startaddr
; --p
)
79 retval
= (retval
<< 8) | *p
;
85 extract_unsigned_integer (addr
, len
)
89 unsigned LONGEST retval
;
91 unsigned char *startaddr
= (unsigned char *)addr
;
92 unsigned char *endaddr
= startaddr
+ len
;
94 if (len
> (int) sizeof (unsigned LONGEST
))
96 That operation is not available on integers of more than %d bytes.",
97 sizeof (unsigned LONGEST
));
99 /* Start at the most significant end of the integer, and work towards
100 the least significant. */
102 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
104 for (p
= startaddr
; p
< endaddr
; ++p
)
105 retval
= (retval
<< 8) | *p
;
109 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
110 retval
= (retval
<< 8) | *p
;
115 /* Sometimes a long long unsigned integer can be extracted as a
116 LONGEST value. This is done so that we can print these values
117 better. If this integer can be converted to a LONGEST, this
118 function returns 1 and sets *PVAL. Otherwise it returns 0. */
121 extract_long_unsigned_integer (addr
, orig_len
, pval
)
126 char *p
, *first_addr
;
130 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
132 for (p
= (char *) addr
;
133 len
> (int) sizeof (LONGEST
) && p
< (char *) addr
+ orig_len
;
145 first_addr
= (char *) addr
;
146 for (p
= (char *) addr
+ orig_len
- 1;
147 len
> (int) sizeof (LONGEST
) && p
>= (char *) addr
;
157 if (len
<= (int) sizeof (LONGEST
))
159 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
168 extract_address (addr
, len
)
172 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
173 whether we want this to be true eventually. */
174 return extract_unsigned_integer (addr
, len
);
178 store_signed_integer (addr
, len
, val
)
184 unsigned char *startaddr
= (unsigned char *)addr
;
185 unsigned char *endaddr
= startaddr
+ len
;
187 /* Start at the least significant end of the integer, and work towards
188 the most significant. */
189 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
191 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
199 for (p
= startaddr
; p
< endaddr
; ++p
)
208 store_unsigned_integer (addr
, len
, val
)
211 unsigned LONGEST val
;
214 unsigned char *startaddr
= (unsigned char *)addr
;
215 unsigned char *endaddr
= startaddr
+ len
;
217 /* Start at the least significant end of the integer, and work towards
218 the most significant. */
219 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
221 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
229 for (p
= startaddr
; p
< endaddr
; ++p
)
238 store_address (addr
, len
, val
)
243 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
244 whether we want this to be true eventually. */
245 store_unsigned_integer (addr
, len
, (LONGEST
)val
);
248 /* Swap LEN bytes at BUFFER between target and host byte-order. */
249 #define SWAP_FLOATING(buffer,len) \
252 if (TARGET_BYTE_ORDER != HOST_BYTE_ORDER) \
255 char *p = (char *)(buffer); \
256 char *q = ((char *)(buffer)) + len - 1; \
257 for (; p < q; p++, q--) \
267 /* There are various problems with the extract_floating and store_floating
270 1. These routines only handle byte-swapping, not conversion of
271 formats. So if host is IEEE floating and target is VAX floating,
272 or vice-versa, it loses. This means that we can't (yet) use these
273 routines for extendeds. Extendeds are handled by
274 REGISTER_CONVERTIBLE. What we want is to use floatformat.h, but that
275 doesn't yet handle VAX floating at all.
277 2. We can't deal with it if there is more than one floating point
278 format in use. This has to be fixed at the unpack_double level.
280 3. We probably should have a LONGEST_DOUBLE or DOUBLEST or whatever
281 we want to call it which is long double where available. */
284 extract_floating (addr
, len
)
288 if (len
== sizeof (float))
291 memcpy (&retval
, addr
, sizeof (retval
));
292 SWAP_FLOATING (&retval
, sizeof (retval
));
295 else if (len
== sizeof (double))
298 memcpy (&retval
, addr
, sizeof (retval
));
299 SWAP_FLOATING (&retval
, sizeof (retval
));
302 else if (len
== sizeof (DOUBLEST
))
305 memcpy (&retval
, addr
, sizeof (retval
));
306 SWAP_FLOATING (&retval
, sizeof (retval
));
311 error ("Can't deal with a floating point number of %d bytes.", len
);
316 store_floating (addr
, len
, val
)
321 if (len
== sizeof (float))
323 float floatval
= val
;
324 SWAP_FLOATING (&floatval
, sizeof (floatval
));
325 memcpy (addr
, &floatval
, sizeof (floatval
));
327 else if (len
== sizeof (double))
329 double doubleval
= val
;
331 SWAP_FLOATING (&doubleval
, sizeof (doubleval
));
332 memcpy (addr
, &doubleval
, sizeof (doubleval
));
334 else if (len
== sizeof (DOUBLEST
))
336 SWAP_FLOATING (&val
, sizeof (val
));
337 memcpy (addr
, &val
, sizeof (val
));
341 error ("Can't deal with a floating point number of %d bytes.", len
);
345 #if !defined (GET_SAVED_REGISTER)
347 /* Return the address in which frame FRAME's value of register REGNUM
348 has been saved in memory. Or return zero if it has not been saved.
349 If REGNUM specifies the SP, the value we return is actually
350 the SP value, not an address where it was saved. */
353 find_saved_register (frame
, regnum
)
354 struct frame_info
*frame
;
357 struct frame_saved_regs saved_regs
;
359 register struct frame_info
*frame1
= NULL
;
360 register CORE_ADDR addr
= 0;
362 if (frame
== NULL
) /* No regs saved if want current frame */
365 #ifdef HAVE_REGISTER_WINDOWS
366 /* We assume that a register in a register window will only be saved
367 in one place (since the name changes and/or disappears as you go
368 towards inner frames), so we only call get_frame_saved_regs on
369 the current frame. This is directly in contradiction to the
370 usage below, which assumes that registers used in a frame must be
371 saved in a lower (more interior) frame. This change is a result
372 of working on a register window machine; get_frame_saved_regs
373 always returns the registers saved within a frame, within the
374 context (register namespace) of that frame. */
376 /* However, note that we don't want this to return anything if
377 nothing is saved (if there's a frame inside of this one). Also,
378 callers to this routine asking for the stack pointer want the
379 stack pointer saved for *this* frame; this is returned from the
382 if (REGISTER_IN_WINDOW_P(regnum
))
384 frame1
= get_next_frame (frame
);
385 if (!frame1
) return 0; /* Registers of this frame are active. */
387 /* Get the SP from the next frame in; it will be this
389 if (regnum
!= SP_REGNUM
)
392 get_frame_saved_regs (frame1
, &saved_regs
);
393 return saved_regs
.regs
[regnum
]; /* ... which might be zero */
395 #endif /* HAVE_REGISTER_WINDOWS */
397 /* Note that this next routine assumes that registers used in
398 frame x will be saved only in the frame that x calls and
399 frames interior to it. This is not true on the sparc, but the
400 above macro takes care of it, so we should be all right. */
404 frame1
= get_prev_frame (frame1
);
405 if (frame1
== 0 || frame1
== frame
)
407 get_frame_saved_regs (frame1
, &saved_regs
);
408 if (saved_regs
.regs
[regnum
])
409 addr
= saved_regs
.regs
[regnum
];
415 /* Find register number REGNUM relative to FRAME and put its (raw,
416 target format) contents in *RAW_BUFFER. Set *OPTIMIZED if the
417 variable was optimized out (and thus can't be fetched). Set *LVAL
418 to lval_memory, lval_register, or not_lval, depending on whether
419 the value was fetched from memory, from a register, or in a strange
420 and non-modifiable way (e.g. a frame pointer which was calculated
421 rather than fetched). Set *ADDRP to the address, either in memory
422 on as a REGISTER_BYTE offset into the registers array.
424 Note that this implementation never sets *LVAL to not_lval. But
425 it can be replaced by defining GET_SAVED_REGISTER and supplying
428 The argument RAW_BUFFER must point to aligned memory. */
431 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
435 struct frame_info
*frame
;
437 enum lval_type
*lval
;
441 if (!target_has_registers
)
442 error ("No registers.");
444 /* Normal systems don't optimize out things with register numbers. */
445 if (optimized
!= NULL
)
447 addr
= find_saved_register (frame
, regnum
);
452 if (regnum
== SP_REGNUM
)
454 if (raw_buffer
!= NULL
)
456 /* Put it back in target format. */
457 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
), addr
);
463 if (raw_buffer
!= NULL
)
464 read_memory (addr
, raw_buffer
, REGISTER_RAW_SIZE (regnum
));
469 *lval
= lval_register
;
470 addr
= REGISTER_BYTE (regnum
);
471 if (raw_buffer
!= NULL
)
472 read_register_gen (regnum
, raw_buffer
);
477 #endif /* GET_SAVED_REGISTER. */
479 /* Copy the bytes of register REGNUM, relative to the current stack frame,
480 into our memory at MYADDR, in target byte order.
481 The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
483 Returns 1 if could not be read, 0 if could. */
486 read_relative_register_raw_bytes (regnum
, myaddr
)
491 if (regnum
== FP_REGNUM
&& selected_frame
)
493 /* Put it back in target format. */
494 store_address (myaddr
, REGISTER_RAW_SIZE(FP_REGNUM
),
495 FRAME_FP(selected_frame
));
499 get_saved_register (myaddr
, &optim
, (CORE_ADDR
*) NULL
, selected_frame
,
500 regnum
, (enum lval_type
*)NULL
);
504 /* Return a `value' with the contents of register REGNUM
505 in its virtual format, with the type specified by
506 REGISTER_VIRTUAL_TYPE. */
509 value_of_register (regnum
)
514 register value_ptr reg_val
;
515 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
518 get_saved_register (raw_buffer
, &optim
, &addr
,
519 selected_frame
, regnum
, &lval
);
521 reg_val
= allocate_value (REGISTER_VIRTUAL_TYPE (regnum
));
523 /* Convert raw data to virtual format if necessary. */
525 #ifdef REGISTER_CONVERTIBLE
526 if (REGISTER_CONVERTIBLE (regnum
))
528 REGISTER_CONVERT_TO_VIRTUAL (regnum
, REGISTER_VIRTUAL_TYPE (regnum
),
529 raw_buffer
, VALUE_CONTENTS_RAW (reg_val
));
533 memcpy (VALUE_CONTENTS_RAW (reg_val
), raw_buffer
,
534 REGISTER_RAW_SIZE (regnum
));
535 VALUE_LVAL (reg_val
) = lval
;
536 VALUE_ADDRESS (reg_val
) = addr
;
537 VALUE_REGNO (reg_val
) = regnum
;
538 VALUE_OPTIMIZED_OUT (reg_val
) = optim
;
542 /* Low level examining and depositing of registers.
544 The caller is responsible for making
545 sure that the inferior is stopped before calling the fetching routines,
546 or it will get garbage. (a change from GDB version 3, in which
547 the caller got the value from the last stop). */
549 /* Contents of the registers in target byte order.
550 We allocate some extra slop since we do a lot of memcpy's around `registers',
551 and failing-soft is better than failing hard. */
552 char registers
[REGISTER_BYTES
+ /* SLOP */ 256];
554 /* Nonzero if that register has been fetched. */
555 char register_valid
[NUM_REGS
];
557 /* The thread/process associated with the current set of registers. For now,
558 -1 is special, and means `no current process'. */
559 int registers_pid
= -1;
561 /* Indicate that registers may have changed, so invalidate the cache. */
567 int numregs
= ARCH_NUM_REGS
;
571 for (i
= 0; i
< numregs
; i
++)
572 register_valid
[i
] = 0;
574 if (registers_changed_hook
)
575 registers_changed_hook ();
578 /* Indicate that all registers have been fetched, so mark them all valid. */
583 int numregs
= ARCH_NUM_REGS
;
584 for (i
= 0; i
< numregs
; i
++)
585 register_valid
[i
] = 1;
588 /* read_register_bytes and write_register_bytes are generally a *BAD* idea.
589 They are inefficient because they need to check for partial updates, which
590 can only be done by scanning through all of the registers and seeing if the
591 bytes that are being read/written fall inside of an invalid register. [The
592 main reason this is necessary is that register sizes can vary, so a simple
593 index won't suffice.] It is far better to call read_register_gen if you
594 want to get at the raw register contents, as it only takes a regno as an
595 argument, and therefore can't do a partial register update. It would also
596 be good to have a write_register_gen for similar reasons.
598 Prior to the recent fixes to check for partial updates, both read and
599 write_register_bytes always checked to see if any registers were stale, and
600 then called target_fetch_registers (-1) to update the whole set. This
601 caused really slowed things down for remote targets. */
603 /* Copy INLEN bytes of consecutive data from registers
604 starting with the INREGBYTE'th byte of register data
605 into memory at MYADDR. */
608 read_register_bytes (inregbyte
, myaddr
, inlen
)
613 int inregend
= inregbyte
+ inlen
;
616 if (registers_pid
!= inferior_pid
)
618 registers_changed ();
619 registers_pid
= inferior_pid
;
622 /* See if we are trying to read bytes from out-of-date registers. If so,
623 update just those registers. */
625 for (regno
= 0; regno
< NUM_REGS
; regno
++)
627 int regstart
, regend
;
630 if (register_valid
[regno
])
633 regstart
= REGISTER_BYTE (regno
);
634 regend
= regstart
+ REGISTER_RAW_SIZE (regno
);
636 startin
= regstart
>= inregbyte
&& regstart
< inregend
;
637 endin
= regend
> inregbyte
&& regend
<= inregend
;
639 if (!startin
&& !endin
)
642 /* We've found an invalid register where at least one byte will be read.
643 Update it from the target. */
645 target_fetch_registers (regno
);
647 if (!register_valid
[regno
])
648 error ("read_register_bytes: Couldn't update register %d.", regno
);
652 memcpy (myaddr
, ®isters
[inregbyte
], inlen
);
655 /* Read register REGNO into memory at MYADDR, which must be large enough
656 for REGISTER_RAW_BYTES (REGNO). Target byte-order.
657 If the register is known to be the size of a CORE_ADDR or smaller,
658 read_register can be used instead. */
660 read_register_gen (regno
, myaddr
)
664 if (registers_pid
!= inferior_pid
)
666 registers_changed ();
667 registers_pid
= inferior_pid
;
670 if (!register_valid
[regno
])
671 target_fetch_registers (regno
);
672 memcpy (myaddr
, ®isters
[REGISTER_BYTE (regno
)],
673 REGISTER_RAW_SIZE (regno
));
676 /* Write register REGNO at MYADDR to the target. MYADDR points at
677 REGISTER_RAW_BYTES(REGNO), which must be in target byte-order. */
680 write_register_gen (regno
, myaddr
)
686 /* On the sparc, writing %g0 is a no-op, so we don't even want to change
687 the registers array if something writes to this register. */
688 if (CANNOT_STORE_REGISTER (regno
))
691 if (registers_pid
!= inferior_pid
)
693 registers_changed ();
694 registers_pid
= inferior_pid
;
697 size
= REGISTER_RAW_SIZE(regno
);
699 /* If we have a valid copy of the register, and new value == old value,
700 then don't bother doing the actual store. */
702 if (register_valid
[regno
]
703 && memcmp (®isters
[REGISTER_BYTE (regno
)], myaddr
, size
) == 0)
706 target_prepare_to_store ();
708 memcpy (®isters
[REGISTER_BYTE (regno
)], myaddr
, size
);
710 register_valid
[regno
] = 1;
712 target_store_registers (regno
);
715 /* Copy INLEN bytes of consecutive data from memory at MYADDR
716 into registers starting with the MYREGSTART'th byte of register data. */
719 write_register_bytes (myregstart
, myaddr
, inlen
)
724 int myregend
= myregstart
+ inlen
;
727 target_prepare_to_store ();
729 /* Scan through the registers updating any that are covered by the range
730 myregstart<=>myregend using write_register_gen, which does nice things
731 like handling threads, and avoiding updates when the new and old contents
734 for (regno
= 0; regno
< NUM_REGS
; regno
++)
736 int regstart
, regend
;
738 char regbuf
[MAX_REGISTER_RAW_SIZE
];
740 regstart
= REGISTER_BYTE (regno
);
741 regend
= regstart
+ REGISTER_RAW_SIZE (regno
);
743 startin
= regstart
>= myregstart
&& regstart
< myregend
;
744 endin
= regend
> myregstart
&& regend
<= myregend
;
746 if (!startin
&& !endin
)
747 continue; /* Register is completely out of range */
749 if (startin
&& endin
) /* register is completely in range */
751 write_register_gen (regno
, myaddr
+ (regstart
- myregstart
));
755 /* We may be doing a partial update of an invalid register. Update it
756 from the target before scribbling on it. */
757 read_register_gen (regno
, regbuf
);
760 memcpy (registers
+ regstart
,
761 myaddr
+ regstart
- myregstart
,
762 myregend
- regstart
);
764 memcpy (registers
+ myregstart
,
766 regend
- myregstart
);
767 target_store_registers (regno
);
771 /* Return the raw contents of register REGNO, regarding it as an integer. */
772 /* This probably should be returning LONGEST rather than CORE_ADDR. */
775 read_register (regno
)
778 if (registers_pid
!= inferior_pid
)
780 registers_changed ();
781 registers_pid
= inferior_pid
;
784 if (!register_valid
[regno
])
785 target_fetch_registers (regno
);
787 return extract_address (®isters
[REGISTER_BYTE (regno
)],
788 REGISTER_RAW_SIZE(regno
));
792 read_register_pid (regno
, pid
)
798 if (pid
== inferior_pid
)
799 return read_register (regno
);
801 save_pid
= inferior_pid
;
805 retval
= read_register (regno
);
807 inferior_pid
= save_pid
;
812 /* Store VALUE, into the raw contents of register number REGNO. */
815 write_register (regno
, val
)
822 /* On the sparc, writing %g0 is a no-op, so we don't even want to change
823 the registers array if something writes to this register. */
824 if (CANNOT_STORE_REGISTER (regno
))
827 if (registers_pid
!= inferior_pid
)
829 registers_changed ();
830 registers_pid
= inferior_pid
;
833 size
= REGISTER_RAW_SIZE(regno
);
835 store_signed_integer (buf
, size
, (LONGEST
) val
);
837 /* If we have a valid copy of the register, and new value == old value,
838 then don't bother doing the actual store. */
840 if (register_valid
[regno
]
841 && memcmp (®isters
[REGISTER_BYTE (regno
)], buf
, size
) == 0)
844 target_prepare_to_store ();
846 memcpy (®isters
[REGISTER_BYTE (regno
)], buf
, size
);
848 register_valid
[regno
] = 1;
850 target_store_registers (regno
);
854 write_register_pid (regno
, val
, pid
)
861 if (pid
== inferior_pid
)
863 write_register (regno
, val
);
867 save_pid
= inferior_pid
;
871 write_register (regno
, val
);
873 inferior_pid
= save_pid
;
876 /* Record that register REGNO contains VAL.
877 This is used when the value is obtained from the inferior or core dump,
878 so there is no need to store the value there. */
881 supply_register (regno
, val
)
885 if (registers_pid
!= inferior_pid
)
887 registers_changed ();
888 registers_pid
= inferior_pid
;
891 register_valid
[regno
] = 1;
892 memcpy (®isters
[REGISTER_BYTE (regno
)], val
, REGISTER_RAW_SIZE (regno
));
894 /* On some architectures, e.g. HPPA, there are a few stray bits in some
895 registers, that the rest of the code would like to ignore. */
896 #ifdef CLEAN_UP_REGISTER_VALUE
897 CLEAN_UP_REGISTER_VALUE(regno
, ®isters
[REGISTER_BYTE(regno
)]);
902 /* This routine is getting awfully cluttered with #if's. It's probably
903 time to turn this into READ_PC and define it in the tm.h file.
904 Ditto for write_pc. */
909 #ifdef TARGET_READ_PC
910 return TARGET_READ_PC (inferior_pid
);
912 return ADDR_BITS_REMOVE ((CORE_ADDR
) read_register_pid (PC_REGNUM
, inferior_pid
));
920 #ifdef TARGET_READ_PC
921 return TARGET_READ_PC (pid
);
923 return ADDR_BITS_REMOVE ((CORE_ADDR
) read_register_pid (PC_REGNUM
, pid
));
931 #ifdef TARGET_WRITE_PC
932 TARGET_WRITE_PC (val
, inferior_pid
);
934 write_register_pid (PC_REGNUM
, val
, inferior_pid
);
936 write_register_pid (NPC_REGNUM
, val
+ 4, inferior_pid
);
938 write_register_pid (NNPC_REGNUM
, val
+ 8, inferior_pid
);
945 write_pc_pid (val
, pid
)
949 #ifdef TARGET_WRITE_PC
950 TARGET_WRITE_PC (val
, pid
);
952 write_register_pid (PC_REGNUM
, val
, pid
);
954 write_register_pid (NPC_REGNUM
, val
+ 4, pid
);
956 write_register_pid (NNPC_REGNUM
, val
+ 8, pid
);
962 /* Cope with strage ways of getting to the stack and frame pointers */
967 #ifdef TARGET_READ_SP
968 return TARGET_READ_SP ();
970 return read_register (SP_REGNUM
);
978 #ifdef TARGET_WRITE_SP
979 TARGET_WRITE_SP (val
);
981 write_register (SP_REGNUM
, val
);
988 #ifdef TARGET_READ_FP
989 return TARGET_READ_FP ();
991 return read_register (FP_REGNUM
);
999 #ifdef TARGET_WRITE_FP
1000 TARGET_WRITE_FP (val
);
1002 write_register (FP_REGNUM
, val
);
1006 /* Will calling read_var_value or locate_var_value on SYM end
1007 up caring what frame it is being evaluated relative to? SYM must
1010 symbol_read_needs_frame (sym
)
1013 switch (SYMBOL_CLASS (sym
))
1015 /* All cases listed explicitly so that gcc -Wall will detect it if
1016 we failed to consider one. */
1021 case LOC_REGPARM_ADDR
:
1025 case LOC_BASEREG_ARG
:
1034 /* Getting the address of a label can be done independently of the block,
1035 even if some *uses* of that address wouldn't work so well without
1039 case LOC_CONST_BYTES
:
1040 case LOC_UNRESOLVED
:
1041 case LOC_OPTIMIZED_OUT
:
1047 /* Given a struct symbol for a variable,
1048 and a stack frame id, read the value of the variable
1049 and return a (pointer to a) struct value containing the value.
1050 If the variable cannot be found, return a zero pointer.
1051 If FRAME is NULL, use the selected_frame. */
1054 read_var_value (var
, frame
)
1055 register struct symbol
*var
;
1056 struct frame_info
*frame
;
1058 register value_ptr v
;
1059 struct type
*type
= SYMBOL_TYPE (var
);
1063 v
= allocate_value (type
);
1064 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
1065 len
= TYPE_LENGTH (type
);
1067 if (frame
== NULL
) frame
= selected_frame
;
1069 switch (SYMBOL_CLASS (var
))
1072 /* Put the constant back in target format. */
1073 store_signed_integer (VALUE_CONTENTS_RAW (v
), len
,
1074 (LONGEST
) SYMBOL_VALUE (var
));
1075 VALUE_LVAL (v
) = not_lval
;
1079 /* Put the constant back in target format. */
1080 store_address (VALUE_CONTENTS_RAW (v
), len
, SYMBOL_VALUE_ADDRESS (var
));
1081 VALUE_LVAL (v
) = not_lval
;
1084 case LOC_CONST_BYTES
:
1087 bytes_addr
= SYMBOL_VALUE_BYTES (var
);
1088 memcpy (VALUE_CONTENTS_RAW (v
), bytes_addr
, len
);
1089 VALUE_LVAL (v
) = not_lval
;
1094 addr
= SYMBOL_VALUE_ADDRESS (var
);
1100 addr
= FRAME_ARGS_ADDRESS (frame
);
1103 addr
+= SYMBOL_VALUE (var
);
1109 addr
= FRAME_ARGS_ADDRESS (frame
);
1112 addr
+= SYMBOL_VALUE (var
);
1113 addr
= read_memory_unsigned_integer
1114 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
1121 addr
= FRAME_LOCALS_ADDRESS (frame
);
1122 addr
+= SYMBOL_VALUE (var
);
1126 case LOC_BASEREG_ARG
:
1128 char buf
[MAX_REGISTER_RAW_SIZE
];
1129 get_saved_register (buf
, NULL
, NULL
, frame
, SYMBOL_BASEREG (var
),
1131 addr
= extract_address (buf
, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var
)));
1132 addr
+= SYMBOL_VALUE (var
);
1137 error ("Cannot look up value of a typedef");
1141 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
1146 case LOC_REGPARM_ADDR
:
1152 b
= get_frame_block (frame
);
1155 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
1158 value_as_pointer (value_from_register (lookup_pointer_type (type
),
1161 VALUE_LVAL (v
) = lval_memory
;
1164 return value_from_register (type
, SYMBOL_VALUE (var
), frame
);
1168 case LOC_UNRESOLVED
:
1170 struct minimal_symbol
*msym
;
1172 msym
= lookup_minimal_symbol (SYMBOL_NAME (var
), NULL
, NULL
);
1175 addr
= SYMBOL_VALUE_ADDRESS (msym
);
1179 case LOC_OPTIMIZED_OUT
:
1180 VALUE_LVAL (v
) = not_lval
;
1181 VALUE_OPTIMIZED_OUT (v
) = 1;
1185 error ("Cannot look up value of a botched symbol.");
1189 VALUE_ADDRESS (v
) = addr
;
1194 /* Return a value of type TYPE, stored in register REGNUM, in frame
1198 value_from_register (type
, regnum
, frame
)
1201 struct frame_info
*frame
;
1203 char raw_buffer
[MAX_REGISTER_RAW_SIZE
];
1206 value_ptr v
= allocate_value (type
);
1207 char *value_bytes
= 0;
1208 int value_bytes_copied
= 0;
1209 int num_storage_locs
;
1210 enum lval_type lval
;
1213 CHECK_TYPEDEF (type
);
1214 len
= TYPE_LENGTH (type
);
1216 VALUE_REGNO (v
) = regnum
;
1218 num_storage_locs
= (len
> REGISTER_VIRTUAL_SIZE (regnum
) ?
1219 ((len
- 1) / REGISTER_RAW_SIZE (regnum
)) + 1 :
1222 if (num_storage_locs
> 1
1223 #ifdef GDB_TARGET_IS_H8500
1224 || TYPE_CODE (type
) == TYPE_CODE_PTR
1228 /* Value spread across multiple storage locations. */
1231 int mem_stor
= 0, reg_stor
= 0;
1232 int mem_tracking
= 1;
1233 CORE_ADDR last_addr
= 0;
1234 CORE_ADDR first_addr
= 0;
1236 value_bytes
= (char *) alloca (len
+ MAX_REGISTER_RAW_SIZE
);
1238 /* Copy all of the data out, whereever it may be. */
1240 #ifdef GDB_TARGET_IS_H8500
1241 /* This piece of hideosity is required because the H8500 treats registers
1242 differently depending upon whether they are used as pointers or not. As a
1243 pointer, a register needs to have a page register tacked onto the front.
1244 An alternate way to do this would be to have gcc output different register
1245 numbers for the pointer & non-pointer form of the register. But, it
1246 doesn't, so we're stuck with this. */
1248 if (TYPE_CODE (type
) == TYPE_CODE_PTR
1255 case R0_REGNUM
: case R1_REGNUM
: case R2_REGNUM
: case R3_REGNUM
:
1256 page_regnum
= SEG_D_REGNUM
;
1258 case R4_REGNUM
: case R5_REGNUM
:
1259 page_regnum
= SEG_E_REGNUM
;
1261 case R6_REGNUM
: case R7_REGNUM
:
1262 page_regnum
= SEG_T_REGNUM
;
1267 get_saved_register (value_bytes
+ 1,
1274 if (lval
== lval_register
)
1281 get_saved_register (value_bytes
+ 2,
1288 if (lval
== lval_register
)
1293 mem_tracking
= mem_tracking
&& (addr
== last_addr
);
1298 #endif /* GDB_TARGET_IS_H8500 */
1299 for (local_regnum
= regnum
;
1300 value_bytes_copied
< len
;
1301 (value_bytes_copied
+= REGISTER_RAW_SIZE (local_regnum
),
1304 get_saved_register (value_bytes
+ value_bytes_copied
,
1311 if (regnum
== local_regnum
)
1313 if (lval
== lval_register
)
1321 && (regnum
== local_regnum
1322 || addr
== last_addr
));
1327 if ((reg_stor
&& mem_stor
)
1328 || (mem_stor
&& !mem_tracking
))
1329 /* Mixed storage; all of the hassle we just went through was
1330 for some good purpose. */
1332 VALUE_LVAL (v
) = lval_reg_frame_relative
;
1333 VALUE_FRAME (v
) = FRAME_FP (frame
);
1334 VALUE_FRAME_REGNUM (v
) = regnum
;
1338 VALUE_LVAL (v
) = lval_memory
;
1339 VALUE_ADDRESS (v
) = first_addr
;
1343 VALUE_LVAL (v
) = lval_register
;
1344 VALUE_ADDRESS (v
) = first_addr
;
1347 fatal ("value_from_register: Value not stored anywhere!");
1349 VALUE_OPTIMIZED_OUT (v
) = optim
;
1351 /* Any structure stored in more than one register will always be
1352 an integral number of registers. Otherwise, you'd need to do
1353 some fiddling with the last register copied here for little
1356 /* Copy into the contents section of the value. */
1357 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
, len
);
1359 /* Finally do any conversion necessary when extracting this
1360 type from more than one register. */
1361 #ifdef REGISTER_CONVERT_TO_TYPE
1362 REGISTER_CONVERT_TO_TYPE(regnum
, type
, VALUE_CONTENTS_RAW(v
));
1367 /* Data is completely contained within a single register. Locate the
1368 register's contents in a real register or in core;
1369 read the data in raw format. */
1371 get_saved_register (raw_buffer
, &optim
, &addr
, frame
, regnum
, &lval
);
1372 VALUE_OPTIMIZED_OUT (v
) = optim
;
1373 VALUE_LVAL (v
) = lval
;
1374 VALUE_ADDRESS (v
) = addr
;
1376 /* Convert raw data to virtual format if necessary. */
1378 #ifdef REGISTER_CONVERTIBLE
1379 if (REGISTER_CONVERTIBLE (regnum
))
1381 REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
,
1382 raw_buffer
, VALUE_CONTENTS_RAW (v
));
1387 /* Raw and virtual formats are the same for this register. */
1389 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
&& len
< REGISTER_RAW_SIZE (regnum
))
1391 /* Big-endian, and we want less than full size. */
1392 VALUE_OFFSET (v
) = REGISTER_RAW_SIZE (regnum
) - len
;
1395 memcpy (VALUE_CONTENTS_RAW (v
), raw_buffer
+ VALUE_OFFSET (v
), len
);
1401 /* Given a struct symbol for a variable or function,
1402 and a stack frame id,
1403 return a (pointer to a) struct value containing the properly typed
1407 locate_var_value (var
, frame
)
1408 register struct symbol
*var
;
1409 struct frame_info
*frame
;
1412 struct type
*type
= SYMBOL_TYPE (var
);
1413 value_ptr lazy_value
;
1415 /* Evaluate it first; if the result is a memory address, we're fine.
1416 Lazy evaluation pays off here. */
1418 lazy_value
= read_var_value (var
, frame
);
1419 if (lazy_value
== 0)
1420 error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
1422 if (VALUE_LAZY (lazy_value
)
1423 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
1425 addr
= VALUE_ADDRESS (lazy_value
);
1426 return value_from_longest (lookup_pointer_type (type
), (LONGEST
) addr
);
1429 /* Not a memory address; check what the problem was. */
1430 switch (VALUE_LVAL (lazy_value
))
1433 case lval_reg_frame_relative
:
1434 error ("Address requested for identifier \"%s\" which is in a register.",
1435 SYMBOL_SOURCE_NAME (var
));
1439 error ("Can't take address of \"%s\" which isn't an lvalue.",
1440 SYMBOL_SOURCE_NAME (var
));
1443 return 0; /* For lint -- never reached */