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 (TYPE_LENGTH (type
) == 0)
623 /* It doesn't matter much what we return for this: since the
624 length is zero, it could be anything. But if allowed to see
625 a zero-length type, the register-finding loop below will set
626 neither mem_stor nor reg_stor, and then report an internal
629 Zero-length types can legitimately arise from declarations
630 like 'struct {}'. GDB may also create them when it finds
631 bogus debugging information; for example, in GCC 2.94.4 and
632 binutils 2.11.93.0.2, the STABS BINCL->EXCL compression
633 process can create bad type numbers. GDB reads these as
634 TYPE_CODE_UNDEF types, with zero length. (That bug is
635 actually the only known way to get a zero-length value
636 allocated to a register --- which is what it takes to make it
639 We'll just attribute the value to the original register. */
640 VALUE_LVAL (v
) = lval_register
;
641 VALUE_ADDRESS (v
) = regnum
;
642 VALUE_REGNO (v
) = regnum
;
644 else if (CONVERT_REGISTER_P (regnum
, type
))
646 /* The ISA/ABI need to something weird when obtaining the
647 specified value from this register. It might need to
648 re-order non-adjacent, starting with REGNUM (see MIPS and
649 i386). It might need to convert the [float] register into
650 the corresponding [integer] type (see Alpha). The assumption
651 is that REGISTER_TO_VALUE populates the entire value
652 including the location. */
653 REGISTER_TO_VALUE (frame
, regnum
, type
, VALUE_CONTENTS_RAW (v
));
654 VALUE_LVAL (v
) = lval_reg_frame_relative
;
655 VALUE_FRAME_ID (v
) = get_frame_id (frame
);
656 VALUE_FRAME_REGNUM (v
) = regnum
;
661 int mem_stor
= 0, reg_stor
= 0;
662 int mem_tracking
= 1;
663 CORE_ADDR last_addr
= 0;
664 CORE_ADDR first_addr
= 0;
665 int first_realnum
= regnum
;
666 int len
= TYPE_LENGTH (type
);
667 int value_bytes_copied
;
669 char *value_bytes
= (char *) alloca (len
+ MAX_REGISTER_SIZE
);
671 /* Copy all of the data out, whereever it may be. */
672 for (local_regnum
= regnum
, value_bytes_copied
= 0;
673 value_bytes_copied
< len
;
674 (value_bytes_copied
+= DEPRECATED_REGISTER_RAW_SIZE (local_regnum
),
681 frame_register (frame
, local_regnum
, &optim
, &lval
, &addr
,
682 &realnum
, value_bytes
+ value_bytes_copied
);
684 if (register_cached (local_regnum
) == -1)
685 return NULL
; /* register value not available */
687 if (regnum
== local_regnum
)
690 first_realnum
= realnum
;
692 if (lval
== lval_register
)
698 mem_tracking
= (mem_tracking
699 && (regnum
== local_regnum
700 || addr
== last_addr
));
705 /* FIXME: cagney/2003-06-04: Shouldn't this always use
706 lval_reg_frame_relative? If it doesn't and the register's
707 location changes (say after a resume) then this value is
708 going to have wrong information. */
709 if ((reg_stor
&& mem_stor
)
710 || (mem_stor
&& !mem_tracking
))
711 /* Mixed storage; all of the hassle we just went through was
712 for some good purpose. */
714 VALUE_LVAL (v
) = lval_reg_frame_relative
;
715 VALUE_FRAME_ID (v
) = get_frame_id (frame
);
716 VALUE_FRAME_REGNUM (v
) = regnum
;
720 VALUE_LVAL (v
) = lval_memory
;
721 VALUE_ADDRESS (v
) = first_addr
;
725 VALUE_LVAL (v
) = lval_register
;
726 VALUE_ADDRESS (v
) = first_addr
;
727 VALUE_REGNO (v
) = first_realnum
;
730 internal_error (__FILE__
, __LINE__
,
731 "value_from_register: Value not stored anywhere!");
733 VALUE_OPTIMIZED_OUT (v
) = optimized
;
735 /* Any structure stored in more than one register will always be
736 an integral number of registers. Otherwise, you need to do
737 some fiddling with the last register copied here for little
739 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
740 && len
< DEPRECATED_REGISTER_RAW_SIZE (regnum
))
741 /* Big-endian, and we want less than full size. */
742 VALUE_OFFSET (v
) = DEPRECATED_REGISTER_RAW_SIZE (regnum
) - len
;
744 VALUE_OFFSET (v
) = 0;
745 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
+ VALUE_OFFSET (v
), len
);
751 /* Given a struct symbol for a variable or function,
752 and a stack frame id,
753 return a (pointer to a) struct value containing the properly typed
757 locate_var_value (struct symbol
*var
, struct frame_info
*frame
)
760 struct type
*type
= SYMBOL_TYPE (var
);
761 struct value
*lazy_value
;
763 /* Evaluate it first; if the result is a memory address, we're fine.
764 Lazy evaluation pays off here. */
766 lazy_value
= read_var_value (var
, frame
);
768 error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var
));
770 if (VALUE_LAZY (lazy_value
)
771 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
775 addr
= VALUE_ADDRESS (lazy_value
);
776 val
= value_from_pointer (lookup_pointer_type (type
), addr
);
777 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (lazy_value
);
781 /* Not a memory address; check what the problem was. */
782 switch (VALUE_LVAL (lazy_value
))
785 gdb_assert (REGISTER_NAME (VALUE_REGNO (lazy_value
)) != NULL
786 && *REGISTER_NAME (VALUE_REGNO (lazy_value
)) != '\0');
787 error("Address requested for identifier "
788 "\"%s\" which is in register $%s",
789 SYMBOL_PRINT_NAME (var
),
790 REGISTER_NAME (VALUE_REGNO (lazy_value
)));
793 case lval_reg_frame_relative
:
794 gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value
)) != NULL
795 && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value
)) != '\0');
796 error("Address requested for identifier "
797 "\"%s\" which is in frame register $%s",
798 SYMBOL_PRINT_NAME (var
),
799 REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value
)));
803 error ("Can't take address of \"%s\" which isn't an lvalue.",
804 SYMBOL_PRINT_NAME (var
));
807 return 0; /* For lint -- never reached */