1 /* Find a variable's value in memory, for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000, 2001
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
31 #include "gdb_string.h"
32 #include "floatformat.h"
33 #include "symfile.h" /* for overlay functions */
36 /* This is used to indicate that we don't know the format of the floating point
37 number. Typically, this is useful for native ports, where the actual format
38 is irrelevant, since no conversions will be taking place. */
40 const struct floatformat floatformat_unknown
;
42 /* Basic byte-swapping routines. GDB has needed these for a long time...
43 All extract a target-format integer at ADDR which is LEN bytes long. */
45 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
46 /* 8 bit characters are a pretty safe assumption these days, so we
47 assume it throughout all these swapping routines. If we had to deal with
48 9 bit characters, we would need to make len be in bits and would have
49 to re-write these routines... */
54 extract_signed_integer (void *addr
, int len
)
58 unsigned char *startaddr
= (unsigned char *) addr
;
59 unsigned char *endaddr
= startaddr
+ len
;
61 if (len
> (int) sizeof (LONGEST
))
63 That operation is not available on integers of more than %d bytes.",
66 /* Start at the most significant end of the integer, and work towards
67 the least significant. */
68 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
71 /* Do the sign extension once at the start. */
72 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
73 for (++p
; p
< endaddr
; ++p
)
74 retval
= (retval
<< 8) | *p
;
79 /* Do the sign extension once at the start. */
80 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
81 for (--p
; p
>= startaddr
; --p
)
82 retval
= (retval
<< 8) | *p
;
88 extract_unsigned_integer (void *addr
, int len
)
92 unsigned char *startaddr
= (unsigned char *) addr
;
93 unsigned char *endaddr
= startaddr
+ len
;
95 if (len
> (int) sizeof (ULONGEST
))
97 That operation is not available on integers of more than %d bytes.",
100 /* Start at the most significant end of the integer, and work towards
101 the least significant. */
103 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
105 for (p
= startaddr
; p
< endaddr
; ++p
)
106 retval
= (retval
<< 8) | *p
;
110 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
111 retval
= (retval
<< 8) | *p
;
116 /* Sometimes a long long unsigned integer can be extracted as a
117 LONGEST value. This is done so that we can print these values
118 better. If this integer can be converted to a LONGEST, this
119 function returns 1 and sets *PVAL. Otherwise it returns 0. */
122 extract_long_unsigned_integer (void *addr
, int orig_len
, LONGEST
*pval
)
124 char *p
, *first_addr
;
128 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
130 for (p
= (char *) addr
;
131 len
> (int) sizeof (LONGEST
) && p
< (char *) addr
+ orig_len
;
143 first_addr
= (char *) addr
;
144 for (p
= (char *) addr
+ orig_len
- 1;
145 len
> (int) sizeof (LONGEST
) && p
>= (char *) addr
;
155 if (len
<= (int) sizeof (LONGEST
))
157 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
166 /* Treat the LEN bytes at ADDR as a target-format address, and return
167 that address. ADDR is a buffer in the GDB process, not in the
170 This function should only be used by target-specific code. It
171 assumes that a pointer has the same representation as that thing's
172 address represented as an integer. Some machines use word
173 addresses, or similarly munged things, for certain types of
174 pointers, so that assumption doesn't hold everywhere.
176 Common code should use extract_typed_address instead, or something
177 else based on POINTER_TO_ADDRESS. */
180 extract_address (void *addr
, int len
)
182 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
183 whether we want this to be true eventually. */
184 return (CORE_ADDR
) extract_unsigned_integer (addr
, len
);
188 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
189 address it represents. */
191 extract_typed_address (void *buf
, struct type
*type
)
193 if (TYPE_CODE (type
) != TYPE_CODE_PTR
194 && TYPE_CODE (type
) != TYPE_CODE_REF
)
195 internal_error (__FILE__
, __LINE__
,
196 "extract_typed_address: "
197 "type is not a pointer or reference");
199 return POINTER_TO_ADDRESS (type
, buf
);
204 store_signed_integer (void *addr
, int len
, LONGEST val
)
207 unsigned char *startaddr
= (unsigned char *) addr
;
208 unsigned char *endaddr
= startaddr
+ len
;
210 /* Start at the least significant end of the integer, and work towards
211 the most significant. */
212 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
214 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
222 for (p
= startaddr
; p
< endaddr
; ++p
)
231 store_unsigned_integer (void *addr
, int len
, ULONGEST val
)
234 unsigned char *startaddr
= (unsigned char *) addr
;
235 unsigned char *endaddr
= startaddr
+ len
;
237 /* Start at the least significant end of the integer, and work towards
238 the most significant. */
239 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
241 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
249 for (p
= startaddr
; p
< endaddr
; ++p
)
257 /* Store the address VAL as a LEN-byte value in target byte order at
258 ADDR. ADDR is a buffer in the GDB process, not in the inferior.
260 This function should only be used by target-specific code. It
261 assumes that a pointer has the same representation as that thing's
262 address represented as an integer. Some machines use word
263 addresses, or similarly munged things, for certain types of
264 pointers, so that assumption doesn't hold everywhere.
266 Common code should use store_typed_address instead, or something else
267 based on ADDRESS_TO_POINTER. */
269 store_address (void *addr
, int len
, LONGEST val
)
271 store_unsigned_integer (addr
, len
, val
);
275 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
278 store_typed_address (void *buf
, struct type
*type
, CORE_ADDR addr
)
280 if (TYPE_CODE (type
) != TYPE_CODE_PTR
281 && TYPE_CODE (type
) != TYPE_CODE_REF
)
282 internal_error (__FILE__
, __LINE__
,
283 "store_typed_address: "
284 "type is not a pointer or reference");
286 ADDRESS_TO_POINTER (type
, buf
, addr
);
291 /* Return a `value' with the contents of register REGNUM
292 in its virtual format, with the type specified by
293 REGISTER_VIRTUAL_TYPE.
295 NOTE: returns NULL if register value is not available.
296 Caller will check return value or die! */
299 value_of_register (int regnum
)
303 register value_ptr reg_val
;
304 char *raw_buffer
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
307 get_saved_register (raw_buffer
, &optim
, &addr
,
308 selected_frame
, regnum
, &lval
);
310 if (register_cached (regnum
) < 0)
311 return NULL
; /* register value not available */
313 reg_val
= allocate_value (REGISTER_VIRTUAL_TYPE (regnum
));
315 /* Convert raw data to virtual format if necessary. */
317 if (REGISTER_CONVERTIBLE (regnum
))
319 REGISTER_CONVERT_TO_VIRTUAL (regnum
, REGISTER_VIRTUAL_TYPE (regnum
),
320 raw_buffer
, VALUE_CONTENTS_RAW (reg_val
));
322 else if (REGISTER_RAW_SIZE (regnum
) == REGISTER_VIRTUAL_SIZE (regnum
))
323 memcpy (VALUE_CONTENTS_RAW (reg_val
), raw_buffer
,
324 REGISTER_RAW_SIZE (regnum
));
326 internal_error (__FILE__
, __LINE__
,
327 "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
328 REGISTER_NAME (regnum
),
330 REGISTER_RAW_SIZE (regnum
),
331 REGISTER_VIRTUAL_SIZE (regnum
));
332 VALUE_LVAL (reg_val
) = lval
;
333 VALUE_ADDRESS (reg_val
) = addr
;
334 VALUE_REGNO (reg_val
) = regnum
;
335 VALUE_OPTIMIZED_OUT (reg_val
) = optim
;
339 /* Given a pointer of type TYPE in target form in BUF, return the
340 address it represents. */
342 unsigned_pointer_to_address (struct type
*type
, void *buf
)
344 return extract_address (buf
, TYPE_LENGTH (type
));
348 signed_pointer_to_address (struct type
*type
, void *buf
)
350 return extract_signed_integer (buf
, TYPE_LENGTH (type
));
353 /* Given an address, store it as a pointer of type TYPE in target
356 unsigned_address_to_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
358 store_address (buf
, TYPE_LENGTH (type
), addr
);
362 address_to_signed_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
364 store_signed_integer (buf
, TYPE_LENGTH (type
), addr
);
367 /* Will calling read_var_value or locate_var_value on SYM end
368 up caring what frame it is being evaluated relative to? SYM must
371 symbol_read_needs_frame (struct symbol
*sym
)
373 switch (SYMBOL_CLASS (sym
))
375 /* All cases listed explicitly so that gcc -Wall will detect it if
376 we failed to consider one. */
381 case LOC_REGPARM_ADDR
:
385 case LOC_BASEREG_ARG
:
386 case LOC_THREAD_LOCAL_STATIC
:
396 /* Getting the address of a label can be done independently of the block,
397 even if some *uses* of that address wouldn't work so well without
401 case LOC_CONST_BYTES
:
403 case LOC_OPTIMIZED_OUT
:
409 /* Given a struct symbol for a variable,
410 and a stack frame id, read the value of the variable
411 and return a (pointer to a) struct value containing the value.
412 If the variable cannot be found, return a zero pointer.
413 If FRAME is NULL, use the selected_frame. */
416 read_var_value (register struct symbol
*var
, struct frame_info
*frame
)
418 register value_ptr v
;
419 struct type
*type
= SYMBOL_TYPE (var
);
423 v
= allocate_value (type
);
424 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
425 VALUE_BFD_SECTION (v
) = SYMBOL_BFD_SECTION (var
);
427 len
= TYPE_LENGTH (type
);
430 frame
= selected_frame
;
432 switch (SYMBOL_CLASS (var
))
435 /* Put the constant back in target format. */
436 store_signed_integer (VALUE_CONTENTS_RAW (v
), len
,
437 (LONGEST
) SYMBOL_VALUE (var
));
438 VALUE_LVAL (v
) = not_lval
;
442 /* Put the constant back in target format. */
443 if (overlay_debugging
)
446 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
447 SYMBOL_BFD_SECTION (var
));
448 store_typed_address (VALUE_CONTENTS_RAW (v
), type
, addr
);
451 store_typed_address (VALUE_CONTENTS_RAW (v
), type
,
452 SYMBOL_VALUE_ADDRESS (var
));
453 VALUE_LVAL (v
) = not_lval
;
456 case LOC_CONST_BYTES
:
459 bytes_addr
= SYMBOL_VALUE_BYTES (var
);
460 memcpy (VALUE_CONTENTS_RAW (v
), bytes_addr
, len
);
461 VALUE_LVAL (v
) = not_lval
;
466 if (overlay_debugging
)
467 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
468 SYMBOL_BFD_SECTION (var
));
470 addr
= SYMBOL_VALUE_ADDRESS (var
);
475 /* The import slot does not have a real address in it from the
476 dynamic loader (dld.sl on HP-UX), if the target hasn't
477 begun execution yet, so check for that. */
480 if (!target_has_execution
)
482 Attempt to access variable defined in different shared object or load module when\n\
483 addresses have not been bound by the dynamic loader. Try again when executable is running.");
485 locaddr
= SYMBOL_VALUE_ADDRESS (var
);
486 loc
= value_at (lookup_pointer_type (type
), locaddr
, NULL
);
487 addr
= value_as_address (loc
);
493 addr
= FRAME_ARGS_ADDRESS (frame
);
496 addr
+= SYMBOL_VALUE (var
);
505 argref
= FRAME_ARGS_ADDRESS (frame
);
508 argref
+= SYMBOL_VALUE (var
);
509 ref
= value_at (lookup_pointer_type (type
), argref
, NULL
);
510 addr
= value_as_address (ref
);
518 addr
= FRAME_LOCALS_ADDRESS (frame
);
519 addr
+= SYMBOL_VALUE (var
);
523 case LOC_BASEREG_ARG
:
524 case LOC_THREAD_LOCAL_STATIC
:
528 regval
= value_from_register (lookup_pointer_type (type
),
529 SYMBOL_BASEREG (var
), frame
);
531 error ("Value of base register not available.");
532 addr
= value_as_address (regval
);
533 addr
+= SYMBOL_VALUE (var
);
538 error ("Cannot look up value of a typedef");
542 if (overlay_debugging
)
543 VALUE_ADDRESS (v
) = symbol_overlayed_address
544 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_BFD_SECTION (var
));
546 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
551 case LOC_REGPARM_ADDR
:
554 int regno
= SYMBOL_VALUE (var
);
559 b
= get_frame_block (frame
);
561 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
563 regval
= value_from_register (lookup_pointer_type (type
),
568 error ("Value of register variable not available.");
570 addr
= value_as_address (regval
);
571 VALUE_LVAL (v
) = lval_memory
;
575 regval
= value_from_register (type
, regno
, frame
);
578 error ("Value of register variable not available.");
586 struct minimal_symbol
*msym
;
588 msym
= lookup_minimal_symbol (SYMBOL_NAME (var
), NULL
, NULL
);
591 if (overlay_debugging
)
592 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
593 SYMBOL_BFD_SECTION (msym
));
595 addr
= SYMBOL_VALUE_ADDRESS (msym
);
599 case LOC_OPTIMIZED_OUT
:
600 VALUE_LVAL (v
) = not_lval
;
601 VALUE_OPTIMIZED_OUT (v
) = 1;
605 error ("Cannot look up value of a botched symbol.");
609 VALUE_ADDRESS (v
) = addr
;
614 /* Return a value of type TYPE, stored in register REGNUM, in frame
617 NOTE: returns NULL if register value is not available.
618 Caller will check return value or die! */
621 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
623 char *raw_buffer
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
626 value_ptr v
= allocate_value (type
);
627 char *value_bytes
= 0;
628 int value_bytes_copied
= 0;
629 int num_storage_locs
;
633 CHECK_TYPEDEF (type
);
634 len
= TYPE_LENGTH (type
);
636 VALUE_REGNO (v
) = regnum
;
638 num_storage_locs
= (len
> REGISTER_VIRTUAL_SIZE (regnum
) ?
639 ((len
- 1) / REGISTER_RAW_SIZE (regnum
)) + 1 :
642 if (num_storage_locs
> 1
643 #ifdef GDB_TARGET_IS_H8500
644 || TYPE_CODE (type
) == TYPE_CODE_PTR
648 /* Value spread across multiple storage locations. */
651 int mem_stor
= 0, reg_stor
= 0;
652 int mem_tracking
= 1;
653 CORE_ADDR last_addr
= 0;
654 CORE_ADDR first_addr
= 0;
656 value_bytes
= (char *) alloca (len
+ MAX_REGISTER_RAW_SIZE
);
658 /* Copy all of the data out, whereever it may be. */
660 #ifdef GDB_TARGET_IS_H8500
661 /* This piece of hideosity is required because the H8500 treats registers
662 differently depending upon whether they are used as pointers or not. As a
663 pointer, a register needs to have a page register tacked onto the front.
664 An alternate way to do this would be to have gcc output different register
665 numbers for the pointer & non-pointer form of the register. But, it
666 doesn't, so we're stuck with this. */
668 if (TYPE_CODE (type
) == TYPE_CODE_PTR
679 page_regnum
= SEG_D_REGNUM
;
683 page_regnum
= SEG_E_REGNUM
;
687 page_regnum
= SEG_T_REGNUM
;
692 get_saved_register (value_bytes
+ 1,
699 if (register_cached (page_regnum
) == -1)
700 return NULL
; /* register value not available */
702 if (lval
== lval_register
)
709 get_saved_register (value_bytes
+ 2,
716 if (register_cached (regnum
) == -1)
717 return NULL
; /* register value not available */
719 if (lval
== lval_register
)
724 mem_tracking
= mem_tracking
&& (addr
== last_addr
);
729 #endif /* GDB_TARGET_IS_H8500 */
730 for (local_regnum
= regnum
;
731 value_bytes_copied
< len
;
732 (value_bytes_copied
+= REGISTER_RAW_SIZE (local_regnum
),
735 get_saved_register (value_bytes
+ value_bytes_copied
,
742 if (register_cached (local_regnum
) == -1)
743 return NULL
; /* register value not available */
745 if (regnum
== local_regnum
)
747 if (lval
== lval_register
)
755 && (regnum
== local_regnum
756 || addr
== last_addr
));
761 if ((reg_stor
&& mem_stor
)
762 || (mem_stor
&& !mem_tracking
))
763 /* Mixed storage; all of the hassle we just went through was
764 for some good purpose. */
766 VALUE_LVAL (v
) = lval_reg_frame_relative
;
767 VALUE_FRAME (v
) = FRAME_FP (frame
);
768 VALUE_FRAME_REGNUM (v
) = regnum
;
772 VALUE_LVAL (v
) = lval_memory
;
773 VALUE_ADDRESS (v
) = first_addr
;
777 VALUE_LVAL (v
) = lval_register
;
778 VALUE_ADDRESS (v
) = first_addr
;
781 internal_error (__FILE__
, __LINE__
,
782 "value_from_register: Value not stored anywhere!");
784 VALUE_OPTIMIZED_OUT (v
) = optim
;
786 /* Any structure stored in more than one register will always be
787 an integral number of registers. Otherwise, you'd need to do
788 some fiddling with the last register copied here for little
791 /* Copy into the contents section of the value. */
792 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
, len
);
794 /* Finally do any conversion necessary when extracting this
795 type from more than one register. */
796 #ifdef REGISTER_CONVERT_TO_TYPE
797 REGISTER_CONVERT_TO_TYPE (regnum
, type
, VALUE_CONTENTS_RAW (v
));
802 /* Data is completely contained within a single register. Locate the
803 register's contents in a real register or in core;
804 read the data in raw format. */
806 get_saved_register (raw_buffer
, &optim
, &addr
, frame
, regnum
, &lval
);
808 if (register_cached (regnum
) == -1)
809 return NULL
; /* register value not available */
811 VALUE_OPTIMIZED_OUT (v
) = optim
;
812 VALUE_LVAL (v
) = lval
;
813 VALUE_ADDRESS (v
) = addr
;
815 /* Convert raw data to virtual format if necessary. */
817 if (REGISTER_CONVERTIBLE (regnum
))
819 REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
,
820 raw_buffer
, VALUE_CONTENTS_RAW (v
));
824 /* Raw and virtual formats are the same for this register. */
826 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
&& len
< REGISTER_RAW_SIZE (regnum
))
828 /* Big-endian, and we want less than full size. */
829 VALUE_OFFSET (v
) = REGISTER_RAW_SIZE (regnum
) - len
;
832 memcpy (VALUE_CONTENTS_RAW (v
), raw_buffer
+ VALUE_OFFSET (v
), len
);
838 /* Given a struct symbol for a variable or function,
839 and a stack frame id,
840 return a (pointer to a) struct value containing the properly typed
844 locate_var_value (register struct symbol
*var
, struct frame_info
*frame
)
847 struct type
*type
= SYMBOL_TYPE (var
);
848 value_ptr lazy_value
;
850 /* Evaluate it first; if the result is a memory address, we're fine.
851 Lazy evaluation pays off here. */
853 lazy_value
= read_var_value (var
, frame
);
855 error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
857 if (VALUE_LAZY (lazy_value
)
858 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
862 addr
= VALUE_ADDRESS (lazy_value
);
863 val
= value_from_pointer (lookup_pointer_type (type
), addr
);
864 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (lazy_value
);
868 /* Not a memory address; check what the problem was. */
869 switch (VALUE_LVAL (lazy_value
))
872 case lval_reg_frame_relative
:
873 error ("Address requested for identifier \"%s\" which is in a register.",
874 SYMBOL_SOURCE_NAME (var
));
878 error ("Can't take address of \"%s\" which isn't an lvalue.",
879 SYMBOL_SOURCE_NAME (var
));
882 return 0; /* For lint -- never reached */