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, 2005 Free
5 Software Foundation, Inc.
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 memcpy (value_contents_raw (reg_val
), raw_buffer
,
286 register_size (current_gdbarch
, regnum
));
287 VALUE_LVAL (reg_val
) = lval
;
288 VALUE_ADDRESS (reg_val
) = addr
;
289 VALUE_REGNUM (reg_val
) = regnum
;
290 set_value_optimized_out (reg_val
, optim
);
291 VALUE_FRAME_ID (reg_val
) = get_frame_id (frame
);
295 /* Given a pointer of type TYPE in target form in BUF, return the
296 address it represents. */
298 unsigned_pointer_to_address (struct type
*type
, const gdb_byte
*buf
)
300 return extract_unsigned_integer (buf
, TYPE_LENGTH (type
));
304 signed_pointer_to_address (struct type
*type
, const gdb_byte
*buf
)
306 return extract_signed_integer (buf
, TYPE_LENGTH (type
));
309 /* Given an address, store it as a pointer of type TYPE in target
312 unsigned_address_to_pointer (struct type
*type
, gdb_byte
*buf
,
315 store_unsigned_integer (buf
, TYPE_LENGTH (type
), addr
);
319 address_to_signed_pointer (struct type
*type
, gdb_byte
*buf
, CORE_ADDR addr
)
321 store_signed_integer (buf
, TYPE_LENGTH (type
), addr
);
324 /* Will calling read_var_value or locate_var_value on SYM end
325 up caring what frame it is being evaluated relative to? SYM must
328 symbol_read_needs_frame (struct symbol
*sym
)
330 switch (SYMBOL_CLASS (sym
))
332 /* All cases listed explicitly so that gcc -Wall will detect it if
333 we failed to consider one. */
335 case LOC_COMPUTED_ARG
:
336 /* FIXME: cagney/2004-01-26: It should be possible to
337 unconditionally call the SYMBOL_OPS method when available.
338 Unfortunately DWARF 2 stores the frame-base (instead of the
339 function) location in a function's symbol. Oops! For the
340 moment enable this when/where applicable. */
341 return SYMBOL_OPS (sym
)->read_needs_frame (sym
);
347 case LOC_REGPARM_ADDR
:
351 case LOC_BASEREG_ARG
:
352 case LOC_HP_THREAD_LOCAL_STATIC
:
362 /* Getting the address of a label can be done independently of the block,
363 even if some *uses* of that address wouldn't work so well without
367 case LOC_CONST_BYTES
:
369 case LOC_OPTIMIZED_OUT
:
375 /* Given a struct symbol for a variable,
376 and a stack frame id, read the value of the variable
377 and return a (pointer to a) struct value containing the value.
378 If the variable cannot be found, return a zero pointer.
379 If FRAME is NULL, use the deprecated_selected_frame. */
382 read_var_value (struct symbol
*var
, struct frame_info
*frame
)
385 struct type
*type
= SYMBOL_TYPE (var
);
389 if (SYMBOL_CLASS (var
) == LOC_COMPUTED
390 || SYMBOL_CLASS (var
) == LOC_COMPUTED_ARG
391 || SYMBOL_CLASS (var
) == LOC_REGISTER
392 || SYMBOL_CLASS (var
) == LOC_REGPARM
)
393 /* These cases do not use V. */
397 v
= allocate_value (type
);
398 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
401 len
= TYPE_LENGTH (type
);
403 /* FIXME drow/2003-09-06: this call to the selected frame should be
404 pushed upwards to the callers. */
406 frame
= deprecated_safe_get_selected_frame ();
408 switch (SYMBOL_CLASS (var
))
411 /* Put the constant back in target format. */
412 store_signed_integer (value_contents_raw (v
), len
,
413 (LONGEST
) SYMBOL_VALUE (var
));
414 VALUE_LVAL (v
) = not_lval
;
418 /* Put the constant back in target format. */
419 if (overlay_debugging
)
422 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
423 SYMBOL_BFD_SECTION (var
));
424 store_typed_address (value_contents_raw (v
), type
, addr
);
427 store_typed_address (value_contents_raw (v
), type
,
428 SYMBOL_VALUE_ADDRESS (var
));
429 VALUE_LVAL (v
) = not_lval
;
432 case LOC_CONST_BYTES
:
435 bytes_addr
= SYMBOL_VALUE_BYTES (var
);
436 memcpy (value_contents_raw (v
), bytes_addr
, len
);
437 VALUE_LVAL (v
) = not_lval
;
442 if (overlay_debugging
)
443 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
444 SYMBOL_BFD_SECTION (var
));
446 addr
= SYMBOL_VALUE_ADDRESS (var
);
451 /* The import slot does not have a real address in it from the
452 dynamic loader (dld.sl on HP-UX), if the target hasn't
453 begun execution yet, so check for that. */
456 if (!target_has_execution
)
458 Attempt to access variable defined in different shared object or load module when\n\
459 addresses have not been bound by the dynamic loader. Try again when executable is running."));
461 locaddr
= SYMBOL_VALUE_ADDRESS (var
);
462 loc
= value_at (lookup_pointer_type (type
), locaddr
);
463 addr
= value_as_address (loc
);
470 addr
= get_frame_args_address (frame
);
473 addr
+= SYMBOL_VALUE (var
);
482 argref
= get_frame_args_address (frame
);
485 argref
+= SYMBOL_VALUE (var
);
486 ref
= value_at (lookup_pointer_type (type
), argref
);
487 addr
= value_as_address (ref
);
495 addr
= get_frame_locals_address (frame
);
496 addr
+= SYMBOL_VALUE (var
);
500 case LOC_BASEREG_ARG
:
501 case LOC_HP_THREAD_LOCAL_STATIC
:
503 struct value
*regval
;
505 regval
= value_from_register (lookup_pointer_type (type
),
506 SYMBOL_BASEREG (var
), frame
);
508 error (_("Value of base register not available."));
509 addr
= value_as_address (regval
);
510 addr
+= SYMBOL_VALUE (var
);
515 error (_("Cannot look up value of a typedef"));
519 if (overlay_debugging
)
520 VALUE_ADDRESS (v
) = symbol_overlayed_address
521 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_BFD_SECTION (var
));
523 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
528 case LOC_REGPARM_ADDR
:
531 int regno
= SYMBOL_VALUE (var
);
532 struct value
*regval
;
536 b
= get_frame_block (frame
, 0);
538 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
540 regval
= value_from_register (lookup_pointer_type (type
),
545 error (_("Value of register variable not available."));
547 addr
= value_as_address (regval
);
548 VALUE_LVAL (v
) = lval_memory
;
552 regval
= value_from_register (type
, regno
, frame
);
555 error (_("Value of register variable not available."));
562 case LOC_COMPUTED_ARG
:
563 /* FIXME: cagney/2004-01-26: It should be possible to
564 unconditionally call the SYMBOL_OPS method when available.
565 Unfortunately DWARF 2 stores the frame-base (instead of the
566 function) location in a function's symbol. Oops! For the
567 moment enable this when/where applicable. */
568 if (frame
== 0 && SYMBOL_OPS (var
)->read_needs_frame (var
))
570 return SYMBOL_OPS (var
)->read_variable (var
, frame
);
574 struct minimal_symbol
*msym
;
576 msym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var
), NULL
, NULL
);
579 if (overlay_debugging
)
580 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
581 SYMBOL_BFD_SECTION (msym
));
583 addr
= SYMBOL_VALUE_ADDRESS (msym
);
587 case LOC_OPTIMIZED_OUT
:
588 VALUE_LVAL (v
) = not_lval
;
589 set_value_optimized_out (v
, 1);
593 error (_("Cannot look up value of a botched symbol."));
597 VALUE_ADDRESS (v
) = addr
;
598 set_value_lazy (v
, 1);
602 /* Return a value of type TYPE, stored in register REGNUM, in frame
605 NOTE: returns NULL if register value is not available.
606 Caller will check return value or die! */
609 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
611 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
612 struct value
*v
= allocate_value (type
);
613 CHECK_TYPEDEF (type
);
615 if (TYPE_LENGTH (type
) == 0)
617 /* It doesn't matter much what we return for this: since the
618 length is zero, it could be anything. But if allowed to see
619 a zero-length type, the register-finding loop below will set
620 neither mem_stor nor reg_stor, and then report an internal
623 Zero-length types can legitimately arise from declarations
624 like 'struct {}' (a GCC extension, not valid ISO C). GDB may
625 also create them when it finds bogus debugging information;
626 for example, in GCC 2.95.4 and binutils 2.11.93.0.2, the
627 STABS BINCL->EXCL compression process can create bad type
628 numbers. GDB reads these as TYPE_CODE_UNDEF types, with zero
629 length. (That bug is actually the only known way to get a
630 zero-length value allocated to a register --- which is what
631 it takes to make it here.)
633 We'll just attribute the value to the original register. */
634 VALUE_LVAL (v
) = lval_register
;
635 VALUE_ADDRESS (v
) = regnum
;
636 VALUE_REGNUM (v
) = regnum
;
638 else if (CONVERT_REGISTER_P (regnum
, type
))
640 /* The ISA/ABI need to something weird when obtaining the
641 specified value from this register. It might need to
642 re-order non-adjacent, starting with REGNUM (see MIPS and
643 i386). It might need to convert the [float] register into
644 the corresponding [integer] type (see Alpha). The assumption
645 is that REGISTER_TO_VALUE populates the entire value
646 including the location. */
647 REGISTER_TO_VALUE (frame
, regnum
, type
, value_contents_raw (v
));
648 VALUE_LVAL (v
) = lval_register
;
649 VALUE_FRAME_ID (v
) = get_frame_id (frame
);
650 VALUE_REGNUM (v
) = regnum
;
655 int mem_stor
= 0, reg_stor
= 0;
656 int mem_tracking
= 1;
657 CORE_ADDR last_addr
= 0;
658 CORE_ADDR first_addr
= 0;
659 int first_realnum
= regnum
;
660 int len
= TYPE_LENGTH (type
);
661 int value_bytes_copied
;
663 char *value_bytes
= (char *) alloca (len
+ MAX_REGISTER_SIZE
);
665 /* Copy all of the data out, whereever it may be. */
666 for (local_regnum
= regnum
, value_bytes_copied
= 0;
667 value_bytes_copied
< len
;
668 (value_bytes_copied
+= register_size (current_gdbarch
, local_regnum
),
675 frame_register (frame
, local_regnum
, &optim
, &lval
, &addr
,
676 &realnum
, value_bytes
+ value_bytes_copied
);
678 if (register_cached (local_regnum
) == -1)
679 return NULL
; /* register value not available */
681 if (regnum
== local_regnum
)
684 first_realnum
= realnum
;
686 if (lval
== lval_register
)
692 /* FIXME: cagney/2004-11-12: I think this is trying to
693 check that the stored registers are adjacent in
694 memory. It isn't doing a good job? */
695 mem_tracking
= (mem_tracking
696 && (regnum
== local_regnum
697 || addr
== last_addr
));
702 if (mem_tracking
&& mem_stor
&& !reg_stor
)
704 VALUE_LVAL (v
) = lval_memory
;
705 VALUE_ADDRESS (v
) = first_addr
;
709 VALUE_LVAL (v
) = lval_register
;
710 VALUE_FRAME_ID (v
) = get_frame_id (frame
);
711 VALUE_REGNUM (v
) = regnum
;
714 set_value_optimized_out (v
, optimized
);
716 /* Any structure stored in more than one register will always be
717 an integral number of registers. Otherwise, you need to do
718 some fiddling with the last register copied here for little
720 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
721 && len
< register_size (current_gdbarch
, regnum
))
722 /* Big-endian, and we want less than full size. */
723 set_value_offset (v
, register_size (current_gdbarch
, regnum
) - len
);
725 set_value_offset (v
, 0);
726 memcpy (value_contents_raw (v
), value_bytes
+ value_offset (v
), len
);
732 /* Given a struct symbol for a variable or function,
733 and a stack frame id,
734 return a (pointer to a) struct value containing the properly typed
738 locate_var_value (struct symbol
*var
, struct frame_info
*frame
)
741 struct type
*type
= SYMBOL_TYPE (var
);
742 struct value
*lazy_value
;
744 /* Evaluate it first; if the result is a memory address, we're fine.
745 Lazy evaluation pays off here. */
747 lazy_value
= read_var_value (var
, frame
);
749 error (_("Address of \"%s\" is unknown."), SYMBOL_PRINT_NAME (var
));
751 if (value_lazy (lazy_value
)
752 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
756 addr
= VALUE_ADDRESS (lazy_value
);
757 val
= value_from_pointer (lookup_pointer_type (type
), addr
);
761 /* Not a memory address; check what the problem was. */
762 switch (VALUE_LVAL (lazy_value
))
765 gdb_assert (REGISTER_NAME (VALUE_REGNUM (lazy_value
)) != NULL
766 && *REGISTER_NAME (VALUE_REGNUM (lazy_value
)) != '\0');
767 error (_("Address requested for identifier "
768 "\"%s\" which is in register $%s"),
769 SYMBOL_PRINT_NAME (var
),
770 REGISTER_NAME (VALUE_REGNUM (lazy_value
)));
774 error (_("Can't take address of \"%s\" which isn't an lvalue."),
775 SYMBOL_PRINT_NAME (var
));
778 return 0; /* For lint -- never reached */