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
);
474 /* The import slot does not have a real address in it from the
475 dynamic loader (dld.sl on HP-UX), if the target hasn't begun
476 execution yet, so check for that. */
477 if (!target_has_execution
)
479 Attempt to access variable defined in different shared object or load module when\n\
480 addresses have not been bound by the dynamic loader. Try again when executable is running.");
482 addr
= SYMBOL_VALUE_ADDRESS (var
);
483 addr
= read_memory_unsigned_integer
484 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
490 addr
= FRAME_ARGS_ADDRESS (frame
);
493 addr
+= SYMBOL_VALUE (var
);
499 addr
= FRAME_ARGS_ADDRESS (frame
);
502 addr
+= SYMBOL_VALUE (var
);
503 addr
= read_memory_unsigned_integer
504 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
511 addr
= FRAME_LOCALS_ADDRESS (frame
);
512 addr
+= SYMBOL_VALUE (var
);
516 case LOC_BASEREG_ARG
:
517 case LOC_THREAD_LOCAL_STATIC
:
521 regval
= value_from_register (lookup_pointer_type (type
),
522 SYMBOL_BASEREG (var
), frame
);
524 error ("Value of base register not available.");
525 addr
= value_as_pointer (regval
);
526 addr
+= SYMBOL_VALUE (var
);
531 error ("Cannot look up value of a typedef");
535 if (overlay_debugging
)
536 VALUE_ADDRESS (v
) = symbol_overlayed_address
537 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_BFD_SECTION (var
));
539 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
544 case LOC_REGPARM_ADDR
:
547 int regno
= SYMBOL_VALUE (var
);
552 b
= get_frame_block (frame
);
554 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
556 regval
= value_from_register (lookup_pointer_type (type
),
561 error ("Value of register variable not available.");
563 addr
= value_as_pointer (regval
);
564 VALUE_LVAL (v
) = lval_memory
;
568 regval
= value_from_register (type
, regno
, frame
);
571 error ("Value of register variable not available.");
579 struct minimal_symbol
*msym
;
581 msym
= lookup_minimal_symbol (SYMBOL_NAME (var
), NULL
, NULL
);
584 if (overlay_debugging
)
585 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
586 SYMBOL_BFD_SECTION (msym
));
588 addr
= SYMBOL_VALUE_ADDRESS (msym
);
592 case LOC_OPTIMIZED_OUT
:
593 VALUE_LVAL (v
) = not_lval
;
594 VALUE_OPTIMIZED_OUT (v
) = 1;
598 error ("Cannot look up value of a botched symbol.");
602 VALUE_ADDRESS (v
) = addr
;
607 /* Return a value of type TYPE, stored in register REGNUM, in frame
610 NOTE: returns NULL if register value is not available.
611 Caller will check return value or die! */
614 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
616 char *raw_buffer
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
619 value_ptr v
= allocate_value (type
);
620 char *value_bytes
= 0;
621 int value_bytes_copied
= 0;
622 int num_storage_locs
;
626 CHECK_TYPEDEF (type
);
627 len
= TYPE_LENGTH (type
);
629 VALUE_REGNO (v
) = regnum
;
631 num_storage_locs
= (len
> REGISTER_VIRTUAL_SIZE (regnum
) ?
632 ((len
- 1) / REGISTER_RAW_SIZE (regnum
)) + 1 :
635 if (num_storage_locs
> 1
636 #ifdef GDB_TARGET_IS_H8500
637 || TYPE_CODE (type
) == TYPE_CODE_PTR
641 /* Value spread across multiple storage locations. */
644 int mem_stor
= 0, reg_stor
= 0;
645 int mem_tracking
= 1;
646 CORE_ADDR last_addr
= 0;
647 CORE_ADDR first_addr
= 0;
649 value_bytes
= (char *) alloca (len
+ MAX_REGISTER_RAW_SIZE
);
651 /* Copy all of the data out, whereever it may be. */
653 #ifdef GDB_TARGET_IS_H8500
654 /* This piece of hideosity is required because the H8500 treats registers
655 differently depending upon whether they are used as pointers or not. As a
656 pointer, a register needs to have a page register tacked onto the front.
657 An alternate way to do this would be to have gcc output different register
658 numbers for the pointer & non-pointer form of the register. But, it
659 doesn't, so we're stuck with this. */
661 if (TYPE_CODE (type
) == TYPE_CODE_PTR
672 page_regnum
= SEG_D_REGNUM
;
676 page_regnum
= SEG_E_REGNUM
;
680 page_regnum
= SEG_T_REGNUM
;
685 get_saved_register (value_bytes
+ 1,
692 if (register_cached (page_regnum
) == -1)
693 return NULL
; /* register value not available */
695 if (lval
== lval_register
)
702 get_saved_register (value_bytes
+ 2,
709 if (register_cached (regnum
) == -1)
710 return NULL
; /* register value not available */
712 if (lval
== lval_register
)
717 mem_tracking
= mem_tracking
&& (addr
== last_addr
);
722 #endif /* GDB_TARGET_IS_H8500 */
723 for (local_regnum
= regnum
;
724 value_bytes_copied
< len
;
725 (value_bytes_copied
+= REGISTER_RAW_SIZE (local_regnum
),
728 get_saved_register (value_bytes
+ value_bytes_copied
,
735 if (register_cached (local_regnum
) == -1)
736 return NULL
; /* register value not available */
738 if (regnum
== local_regnum
)
740 if (lval
== lval_register
)
748 && (regnum
== local_regnum
749 || addr
== last_addr
));
754 if ((reg_stor
&& mem_stor
)
755 || (mem_stor
&& !mem_tracking
))
756 /* Mixed storage; all of the hassle we just went through was
757 for some good purpose. */
759 VALUE_LVAL (v
) = lval_reg_frame_relative
;
760 VALUE_FRAME (v
) = FRAME_FP (frame
);
761 VALUE_FRAME_REGNUM (v
) = regnum
;
765 VALUE_LVAL (v
) = lval_memory
;
766 VALUE_ADDRESS (v
) = first_addr
;
770 VALUE_LVAL (v
) = lval_register
;
771 VALUE_ADDRESS (v
) = first_addr
;
774 internal_error (__FILE__
, __LINE__
,
775 "value_from_register: Value not stored anywhere!");
777 VALUE_OPTIMIZED_OUT (v
) = optim
;
779 /* Any structure stored in more than one register will always be
780 an integral number of registers. Otherwise, you'd need to do
781 some fiddling with the last register copied here for little
784 /* Copy into the contents section of the value. */
785 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
, len
);
787 /* Finally do any conversion necessary when extracting this
788 type from more than one register. */
789 #ifdef REGISTER_CONVERT_TO_TYPE
790 REGISTER_CONVERT_TO_TYPE (regnum
, type
, VALUE_CONTENTS_RAW (v
));
795 /* Data is completely contained within a single register. Locate the
796 register's contents in a real register or in core;
797 read the data in raw format. */
799 get_saved_register (raw_buffer
, &optim
, &addr
, frame
, regnum
, &lval
);
801 if (register_cached (regnum
) == -1)
802 return NULL
; /* register value not available */
804 VALUE_OPTIMIZED_OUT (v
) = optim
;
805 VALUE_LVAL (v
) = lval
;
806 VALUE_ADDRESS (v
) = addr
;
808 /* Convert raw data to virtual format if necessary. */
810 if (REGISTER_CONVERTIBLE (regnum
))
812 REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
,
813 raw_buffer
, VALUE_CONTENTS_RAW (v
));
817 /* Raw and virtual formats are the same for this register. */
819 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
&& len
< REGISTER_RAW_SIZE (regnum
))
821 /* Big-endian, and we want less than full size. */
822 VALUE_OFFSET (v
) = REGISTER_RAW_SIZE (regnum
) - len
;
825 memcpy (VALUE_CONTENTS_RAW (v
), raw_buffer
+ VALUE_OFFSET (v
), len
);
831 /* Given a struct symbol for a variable or function,
832 and a stack frame id,
833 return a (pointer to a) struct value containing the properly typed
837 locate_var_value (register struct symbol
*var
, struct frame_info
*frame
)
840 struct type
*type
= SYMBOL_TYPE (var
);
841 value_ptr lazy_value
;
843 /* Evaluate it first; if the result is a memory address, we're fine.
844 Lazy evaluation pays off here. */
846 lazy_value
= read_var_value (var
, frame
);
848 error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
850 if (VALUE_LAZY (lazy_value
)
851 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
855 addr
= VALUE_ADDRESS (lazy_value
);
856 val
= value_from_pointer (lookup_pointer_type (type
), addr
);
857 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (lazy_value
);
861 /* Not a memory address; check what the problem was. */
862 switch (VALUE_LVAL (lazy_value
))
865 case lval_reg_frame_relative
:
866 error ("Address requested for identifier \"%s\" which is in a register.",
867 SYMBOL_SOURCE_NAME (var
));
871 error ("Can't take address of \"%s\" which isn't an lvalue.",
872 SYMBOL_SOURCE_NAME (var
));
875 return 0; /* For lint -- never reached */