1 /* Find a variable's value in memory, for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004 Free Software
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
32 #include "gdb_string.h"
33 #include "gdb_assert.h"
34 #include "floatformat.h"
35 #include "symfile.h" /* for overlay functions */
37 #include "user-regs.h"
40 /* Basic byte-swapping routines. GDB has needed these for a long time...
41 All extract a target-format integer at ADDR which is LEN bytes long. */
43 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
44 /* 8 bit characters are a pretty safe assumption these days, so we
45 assume it throughout all these swapping routines. If we had to deal with
46 9 bit characters, we would need to make len be in bits and would have
47 to re-write these routines... */
52 extract_signed_integer (const void *addr
, int len
)
55 const unsigned char *p
;
56 const unsigned char *startaddr
= addr
;
57 const unsigned char *endaddr
= startaddr
+ len
;
59 if (len
> (int) sizeof (LONGEST
))
61 That operation is not available on integers of more than %d bytes.",
62 (int) sizeof (LONGEST
));
64 /* Start at the most significant end of the integer, and work towards
65 the least significant. */
66 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
69 /* Do the sign extension once at the start. */
70 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
71 for (++p
; p
< endaddr
; ++p
)
72 retval
= (retval
<< 8) | *p
;
77 /* Do the sign extension once at the start. */
78 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
79 for (--p
; p
>= startaddr
; --p
)
80 retval
= (retval
<< 8) | *p
;
86 extract_unsigned_integer (const void *addr
, int len
)
89 const unsigned char *p
;
90 const unsigned char *startaddr
= addr
;
91 const unsigned char *endaddr
= startaddr
+ len
;
93 if (len
> (int) sizeof (ULONGEST
))
95 That operation is not available on integers of more than %d bytes.",
96 (int) sizeof (ULONGEST
));
98 /* Start at the most significant end of the integer, and work towards
99 the least significant. */
101 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
103 for (p
= startaddr
; p
< endaddr
; ++p
)
104 retval
= (retval
<< 8) | *p
;
108 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
109 retval
= (retval
<< 8) | *p
;
114 /* Sometimes a long long unsigned integer can be extracted as a
115 LONGEST value. This is done so that we can print these values
116 better. If this integer can be converted to a LONGEST, this
117 function returns 1 and sets *PVAL. Otherwise it returns 0. */
120 extract_long_unsigned_integer (const void *addr
, int orig_len
, LONGEST
*pval
)
122 char *p
, *first_addr
;
126 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
128 for (p
= (char *) addr
;
129 len
> (int) sizeof (LONGEST
) && p
< (char *) addr
+ orig_len
;
141 first_addr
= (char *) addr
;
142 for (p
= (char *) addr
+ orig_len
- 1;
143 len
> (int) sizeof (LONGEST
) && p
>= (char *) addr
;
153 if (len
<= (int) sizeof (LONGEST
))
155 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
164 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
165 address it represents. */
167 extract_typed_address (const void *buf
, struct type
*type
)
169 if (TYPE_CODE (type
) != TYPE_CODE_PTR
170 && TYPE_CODE (type
) != TYPE_CODE_REF
)
171 internal_error (__FILE__
, __LINE__
,
172 "extract_typed_address: "
173 "type is not a pointer or reference");
175 return POINTER_TO_ADDRESS (type
, buf
);
180 store_signed_integer (void *addr
, int len
, LONGEST val
)
183 unsigned char *startaddr
= (unsigned char *) addr
;
184 unsigned char *endaddr
= startaddr
+ len
;
186 /* Start at the least significant end of the integer, and work towards
187 the most significant. */
188 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
190 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
198 for (p
= startaddr
; p
< endaddr
; ++p
)
207 store_unsigned_integer (void *addr
, int len
, ULONGEST val
)
210 unsigned char *startaddr
= (unsigned char *) addr
;
211 unsigned char *endaddr
= startaddr
+ len
;
213 /* Start at the least significant end of the integer, and work towards
214 the most significant. */
215 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
217 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
225 for (p
= startaddr
; p
< endaddr
; ++p
)
233 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
236 store_typed_address (void *buf
, struct type
*type
, CORE_ADDR addr
)
238 if (TYPE_CODE (type
) != TYPE_CODE_PTR
239 && TYPE_CODE (type
) != TYPE_CODE_REF
)
240 internal_error (__FILE__
, __LINE__
,
241 "store_typed_address: "
242 "type is not a pointer or reference");
244 ADDRESS_TO_POINTER (type
, buf
, addr
);
249 /* Return a `value' with the contents of (virtual or cooked) register
250 REGNUM as found in the specified FRAME. The register's type is
251 determined by register_type().
253 NOTE: returns NULL if register value is not available. Caller will
254 check return value or die! */
257 value_of_register (int regnum
, struct frame_info
*frame
)
261 struct value
*reg_val
;
263 char raw_buffer
[MAX_REGISTER_SIZE
];
266 /* User registers lie completely outside of the range of normal
267 registers. Catch them early so that the target never sees them. */
268 if (regnum
>= NUM_REGS
+ NUM_PSEUDO_REGS
)
269 return value_of_user_reg (regnum
, frame
);
271 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, raw_buffer
);
273 /* FIXME: cagney/2002-05-15: This test is just bogus.
275 It indicates that the target failed to supply a value for a
276 register because it was "not available" at this time. Problem
277 is, the target still has the register and so get saved_register()
278 may be returning a value saved on the stack. */
280 if (register_cached (regnum
) < 0)
281 return NULL
; /* register value not available */
283 reg_val
= allocate_value (register_type (current_gdbarch
, regnum
));
285 /* Convert raw data to virtual format if necessary. */
287 if (DEPRECATED_REGISTER_CONVERTIBLE_P ()
288 && DEPRECATED_REGISTER_CONVERTIBLE (regnum
))
290 DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum
, register_type (current_gdbarch
, regnum
),
291 raw_buffer
, VALUE_CONTENTS_RAW (reg_val
));
293 else if (DEPRECATED_REGISTER_RAW_SIZE (regnum
) == DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum
))
294 memcpy (VALUE_CONTENTS_RAW (reg_val
), raw_buffer
,
295 DEPRECATED_REGISTER_RAW_SIZE (regnum
));
297 internal_error (__FILE__
, __LINE__
,
298 "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
299 REGISTER_NAME (regnum
),
301 DEPRECATED_REGISTER_RAW_SIZE (regnum
),
302 DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum
));
303 VALUE_LVAL (reg_val
) = lval
;
304 VALUE_ADDRESS (reg_val
) = addr
;
305 VALUE_REGNO (reg_val
) = regnum
;
306 VALUE_OPTIMIZED_OUT (reg_val
) = optim
;
310 /* Given a pointer of type TYPE in target form in BUF, return the
311 address it represents. */
313 unsigned_pointer_to_address (struct type
*type
, const void *buf
)
315 return extract_unsigned_integer (buf
, TYPE_LENGTH (type
));
319 signed_pointer_to_address (struct type
*type
, const void *buf
)
321 return extract_signed_integer (buf
, TYPE_LENGTH (type
));
324 /* Given an address, store it as a pointer of type TYPE in target
327 unsigned_address_to_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
329 store_unsigned_integer (buf
, TYPE_LENGTH (type
), addr
);
333 address_to_signed_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
335 store_signed_integer (buf
, TYPE_LENGTH (type
), addr
);
338 /* Will calling read_var_value or locate_var_value on SYM end
339 up caring what frame it is being evaluated relative to? SYM must
342 symbol_read_needs_frame (struct symbol
*sym
)
344 switch (SYMBOL_CLASS (sym
))
346 /* All cases listed explicitly so that gcc -Wall will detect it if
347 we failed to consider one. */
349 case LOC_COMPUTED_ARG
:
350 /* FIXME: cagney/2004-01-26: It should be possible to
351 unconditionally call the SYMBOL_OPS method when available.
352 Unfortunately DWARF 2 stores the frame-base (instead of the
353 function) location in a function's symbol. Oops! For the
354 moment enable this when/where applicable. */
355 return SYMBOL_OPS (sym
)->read_needs_frame (sym
);
361 case LOC_REGPARM_ADDR
:
365 case LOC_BASEREG_ARG
:
366 case LOC_HP_THREAD_LOCAL_STATIC
:
376 /* Getting the address of a label can be done independently of the block,
377 even if some *uses* of that address wouldn't work so well without
381 case LOC_CONST_BYTES
:
383 case LOC_OPTIMIZED_OUT
:
389 /* Given a struct symbol for a variable,
390 and a stack frame id, read the value of the variable
391 and return a (pointer to a) struct value containing the value.
392 If the variable cannot be found, return a zero pointer.
393 If FRAME is NULL, use the deprecated_selected_frame. */
396 read_var_value (struct symbol
*var
, struct frame_info
*frame
)
399 struct type
*type
= SYMBOL_TYPE (var
);
403 v
= allocate_value (type
);
404 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
405 VALUE_BFD_SECTION (v
) = SYMBOL_BFD_SECTION (var
);
407 len
= TYPE_LENGTH (type
);
410 /* FIXME drow/2003-09-06: this call to the selected frame should be
411 pushed upwards to the callers. */
413 frame
= deprecated_safe_get_selected_frame ();
415 switch (SYMBOL_CLASS (var
))
418 /* Put the constant back in target format. */
419 store_signed_integer (VALUE_CONTENTS_RAW (v
), len
,
420 (LONGEST
) SYMBOL_VALUE (var
));
421 VALUE_LVAL (v
) = not_lval
;
425 /* Put the constant back in target format. */
426 if (overlay_debugging
)
429 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
430 SYMBOL_BFD_SECTION (var
));
431 store_typed_address (VALUE_CONTENTS_RAW (v
), type
, addr
);
434 store_typed_address (VALUE_CONTENTS_RAW (v
), type
,
435 SYMBOL_VALUE_ADDRESS (var
));
436 VALUE_LVAL (v
) = not_lval
;
439 case LOC_CONST_BYTES
:
442 bytes_addr
= SYMBOL_VALUE_BYTES (var
);
443 memcpy (VALUE_CONTENTS_RAW (v
), bytes_addr
, len
);
444 VALUE_LVAL (v
) = not_lval
;
449 if (overlay_debugging
)
450 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
451 SYMBOL_BFD_SECTION (var
));
453 addr
= SYMBOL_VALUE_ADDRESS (var
);
458 /* The import slot does not have a real address in it from the
459 dynamic loader (dld.sl on HP-UX), if the target hasn't
460 begun execution yet, so check for that. */
463 if (!target_has_execution
)
465 Attempt to access variable defined in different shared object or load module when\n\
466 addresses have not been bound by the dynamic loader. Try again when executable is running.");
468 locaddr
= SYMBOL_VALUE_ADDRESS (var
);
469 loc
= value_at (lookup_pointer_type (type
), locaddr
, NULL
);
470 addr
= value_as_address (loc
);
476 addr
= get_frame_args_address (frame
);
479 addr
+= SYMBOL_VALUE (var
);
488 argref
= get_frame_args_address (frame
);
491 argref
+= SYMBOL_VALUE (var
);
492 ref
= value_at (lookup_pointer_type (type
), argref
, NULL
);
493 addr
= value_as_address (ref
);
501 addr
= get_frame_locals_address (frame
);
502 addr
+= SYMBOL_VALUE (var
);
506 case LOC_BASEREG_ARG
:
507 case LOC_HP_THREAD_LOCAL_STATIC
:
509 struct value
*regval
;
511 regval
= value_from_register (lookup_pointer_type (type
),
512 SYMBOL_BASEREG (var
), frame
);
514 error ("Value of base register not available.");
515 addr
= value_as_address (regval
);
516 addr
+= SYMBOL_VALUE (var
);
521 error ("Cannot look up value of a typedef");
525 if (overlay_debugging
)
526 VALUE_ADDRESS (v
) = symbol_overlayed_address
527 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_BFD_SECTION (var
));
529 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
534 case LOC_REGPARM_ADDR
:
537 int regno
= SYMBOL_VALUE (var
);
538 struct value
*regval
;
542 b
= get_frame_block (frame
, 0);
544 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
546 regval
= value_from_register (lookup_pointer_type (type
),
551 error ("Value of register variable not available.");
553 addr
= value_as_address (regval
);
554 VALUE_LVAL (v
) = lval_memory
;
558 regval
= value_from_register (type
, regno
, frame
);
561 error ("Value of register variable not available.");
568 case LOC_COMPUTED_ARG
:
569 /* FIXME: cagney/2004-01-26: It should be possible to
570 unconditionally call the SYMBOL_OPS method when available.
571 Unfortunately DWARF 2 stores the frame-base (instead of the
572 function) location in a function's symbol. Oops! For the
573 moment enable this when/where applicable. */
574 if (frame
== 0 && SYMBOL_OPS (var
)->read_needs_frame (var
))
576 return SYMBOL_OPS (var
)->read_variable (var
, frame
);
580 struct minimal_symbol
*msym
;
582 msym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var
), NULL
, NULL
);
585 if (overlay_debugging
)
586 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
587 SYMBOL_BFD_SECTION (msym
));
589 addr
= SYMBOL_VALUE_ADDRESS (msym
);
593 case LOC_OPTIMIZED_OUT
:
594 VALUE_LVAL (v
) = not_lval
;
595 VALUE_OPTIMIZED_OUT (v
) = 1;
599 error ("Cannot look up value of a botched symbol.");
603 VALUE_ADDRESS (v
) = addr
;
608 /* Return a value of type TYPE, stored in register REGNUM, in frame
611 NOTE: returns NULL if register value is not available.
612 Caller will check return value or die! */
615 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
617 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
618 struct value
*v
= allocate_value (type
);
619 CHECK_TYPEDEF (type
);
621 if (CONVERT_REGISTER_P (regnum
, type
))
623 /* The ISA/ABI need to something weird when obtaining the
624 specified value from this register. It might need to
625 re-order non-adjacent, starting with REGNUM (see MIPS and
626 i386). It might need to convert the [float] register into
627 the corresponding [integer] type (see Alpha). The assumption
628 is that REGISTER_TO_VALUE populates the entire value
629 including the location. */
630 REGISTER_TO_VALUE (frame
, regnum
, type
, VALUE_CONTENTS_RAW (v
));
631 VALUE_LVAL (v
) = lval_reg_frame_relative
;
632 VALUE_FRAME_ID (v
) = get_frame_id (frame
);
633 VALUE_FRAME_REGNUM (v
) = regnum
;
638 int mem_stor
= 0, reg_stor
= 0;
639 int mem_tracking
= 1;
640 CORE_ADDR last_addr
= 0;
641 CORE_ADDR first_addr
= 0;
642 int first_realnum
= regnum
;
643 int len
= TYPE_LENGTH (type
);
644 int value_bytes_copied
;
646 char *value_bytes
= (char *) alloca (len
+ MAX_REGISTER_SIZE
);
648 /* Copy all of the data out, whereever it may be. */
649 for (local_regnum
= regnum
, value_bytes_copied
= 0;
650 value_bytes_copied
< len
;
651 (value_bytes_copied
+= DEPRECATED_REGISTER_RAW_SIZE (local_regnum
),
658 frame_register (frame
, local_regnum
, &optim
, &lval
, &addr
,
659 &realnum
, value_bytes
+ value_bytes_copied
);
661 if (register_cached (local_regnum
) == -1)
662 return NULL
; /* register value not available */
664 if (regnum
== local_regnum
)
667 first_realnum
= realnum
;
669 if (lval
== lval_register
)
675 mem_tracking
= (mem_tracking
676 && (regnum
== local_regnum
677 || addr
== last_addr
));
682 /* FIXME: cagney/2003-06-04: Shouldn't this always use
683 lval_reg_frame_relative? If it doesn't and the register's
684 location changes (say after a resume) then this value is
685 going to have wrong information. */
686 if ((reg_stor
&& mem_stor
)
687 || (mem_stor
&& !mem_tracking
))
688 /* Mixed storage; all of the hassle we just went through was
689 for some good purpose. */
691 VALUE_LVAL (v
) = lval_reg_frame_relative
;
692 VALUE_FRAME_ID (v
) = get_frame_id (frame
);
693 VALUE_FRAME_REGNUM (v
) = regnum
;
697 VALUE_LVAL (v
) = lval_memory
;
698 VALUE_ADDRESS (v
) = first_addr
;
702 VALUE_LVAL (v
) = lval_register
;
703 VALUE_ADDRESS (v
) = first_addr
;
704 VALUE_REGNO (v
) = first_realnum
;
707 internal_error (__FILE__
, __LINE__
,
708 "value_from_register: Value not stored anywhere!");
710 VALUE_OPTIMIZED_OUT (v
) = optimized
;
712 /* Any structure stored in more than one register will always be
713 an integral number of registers. Otherwise, you need to do
714 some fiddling with the last register copied here for little
716 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
717 && len
< DEPRECATED_REGISTER_RAW_SIZE (regnum
))
718 /* Big-endian, and we want less than full size. */
719 VALUE_OFFSET (v
) = DEPRECATED_REGISTER_RAW_SIZE (regnum
) - len
;
721 VALUE_OFFSET (v
) = 0;
722 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
+ VALUE_OFFSET (v
), len
);
728 /* Given a struct symbol for a variable or function,
729 and a stack frame id,
730 return a (pointer to a) struct value containing the properly typed
734 locate_var_value (struct symbol
*var
, struct frame_info
*frame
)
737 struct type
*type
= SYMBOL_TYPE (var
);
738 struct value
*lazy_value
;
740 /* Evaluate it first; if the result is a memory address, we're fine.
741 Lazy evaluation pays off here. */
743 lazy_value
= read_var_value (var
, frame
);
745 error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var
));
747 if (VALUE_LAZY (lazy_value
)
748 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
752 addr
= VALUE_ADDRESS (lazy_value
);
753 val
= value_from_pointer (lookup_pointer_type (type
), addr
);
754 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (lazy_value
);
758 /* Not a memory address; check what the problem was. */
759 switch (VALUE_LVAL (lazy_value
))
762 gdb_assert (REGISTER_NAME (VALUE_REGNO (lazy_value
)) != NULL
763 && *REGISTER_NAME (VALUE_REGNO (lazy_value
)) != '\0');
764 error("Address requested for identifier "
765 "\"%s\" which is in register $%s",
766 SYMBOL_PRINT_NAME (var
),
767 REGISTER_NAME (VALUE_REGNO (lazy_value
)));
770 case lval_reg_frame_relative
:
771 gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value
)) != NULL
772 && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value
)) != '\0');
773 error("Address requested for identifier "
774 "\"%s\" which is in frame register $%s",
775 SYMBOL_PRINT_NAME (var
),
776 REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value
)));
780 error ("Can't take address of \"%s\" which isn't an lvalue.",
781 SYMBOL_PRINT_NAME (var
));
784 return 0; /* For lint -- never reached */