1 /* Find a variable's value in memory, for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007, 2008, 2009,
5 2010, 2011 Free 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 3 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, see <http://www.gnu.org/licenses/>. */
30 #include "gdb_string.h"
31 #include "gdb_assert.h"
32 #include "floatformat.h"
33 #include "symfile.h" /* for overlay functions */
35 #include "user-regs.h"
39 /* Basic byte-swapping routines. All 'extract' functions return a
40 host-format integer from a target-format integer at ADDR which is
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 gdb_byte
*addr
, int len
,
53 enum bfd_endian byte_order
)
56 const unsigned char *p
;
57 const unsigned char *startaddr
= addr
;
58 const unsigned char *endaddr
= startaddr
+ len
;
60 if (len
> (int) sizeof (LONGEST
))
62 That operation is not available on integers of more than %d bytes."),
63 (int) sizeof (LONGEST
));
65 /* Start at the most significant end of the integer, and work towards
66 the least significant. */
67 if (byte_order
== BFD_ENDIAN_BIG
)
70 /* Do the sign extension once at the start. */
71 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
72 for (++p
; p
< endaddr
; ++p
)
73 retval
= (retval
<< 8) | *p
;
78 /* Do the sign extension once at the start. */
79 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
80 for (--p
; p
>= startaddr
; --p
)
81 retval
= (retval
<< 8) | *p
;
87 extract_unsigned_integer (const gdb_byte
*addr
, int len
,
88 enum bfd_endian byte_order
)
91 const unsigned char *p
;
92 const unsigned char *startaddr
= addr
;
93 const unsigned char *endaddr
= startaddr
+ len
;
95 if (len
> (int) sizeof (ULONGEST
))
97 That operation is not available on integers of more than %d bytes."),
98 (int) sizeof (ULONGEST
));
100 /* Start at the most significant end of the integer, and work towards
101 the least significant. */
103 if (byte_order
== BFD_ENDIAN_BIG
)
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 (const gdb_byte
*addr
, int orig_len
,
123 enum bfd_endian byte_order
, LONGEST
*pval
)
126 const gdb_byte
*first_addr
;
130 if (byte_order
== BFD_ENDIAN_BIG
)
133 len
> (int) sizeof (LONGEST
) && p
< addr
+ orig_len
;
146 for (p
= addr
+ orig_len
- 1;
147 len
> (int) sizeof (LONGEST
) && p
>= addr
;
157 if (len
<= (int) sizeof (LONGEST
))
159 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
169 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
170 address it represents. */
172 extract_typed_address (const gdb_byte
*buf
, struct type
*type
)
174 if (TYPE_CODE (type
) != TYPE_CODE_PTR
175 && TYPE_CODE (type
) != TYPE_CODE_REF
)
176 internal_error (__FILE__
, __LINE__
,
177 _("extract_typed_address: "
178 "type is not a pointer or reference"));
180 return gdbarch_pointer_to_address (get_type_arch (type
), type
, buf
);
183 /* All 'store' functions accept a host-format integer and store a
184 target-format integer at ADDR which is LEN bytes long. */
187 store_signed_integer (gdb_byte
*addr
, int len
,
188 enum bfd_endian byte_order
, LONGEST val
)
191 gdb_byte
*startaddr
= addr
;
192 gdb_byte
*endaddr
= startaddr
+ len
;
194 /* Start at the least significant end of the integer, and work towards
195 the most significant. */
196 if (byte_order
== BFD_ENDIAN_BIG
)
198 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
206 for (p
= startaddr
; p
< endaddr
; ++p
)
215 store_unsigned_integer (gdb_byte
*addr
, int len
,
216 enum bfd_endian byte_order
, ULONGEST val
)
219 unsigned char *startaddr
= (unsigned char *) addr
;
220 unsigned char *endaddr
= startaddr
+ len
;
222 /* Start at the least significant end of the integer, and work towards
223 the most significant. */
224 if (byte_order
== BFD_ENDIAN_BIG
)
226 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
234 for (p
= startaddr
; p
< endaddr
; ++p
)
242 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
245 store_typed_address (gdb_byte
*buf
, struct type
*type
, CORE_ADDR addr
)
247 if (TYPE_CODE (type
) != TYPE_CODE_PTR
248 && TYPE_CODE (type
) != TYPE_CODE_REF
)
249 internal_error (__FILE__
, __LINE__
,
250 _("store_typed_address: "
251 "type is not a pointer or reference"));
253 gdbarch_address_to_pointer (get_type_arch (type
), type
, buf
, addr
);
258 /* Return a `value' with the contents of (virtual or cooked) register
259 REGNUM as found in the specified FRAME. The register's type is
260 determined by register_type(). */
263 value_of_register (int regnum
, struct frame_info
*frame
)
265 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
269 struct value
*reg_val
;
271 gdb_byte raw_buffer
[MAX_REGISTER_SIZE
];
274 /* User registers lie completely outside of the range of normal
275 registers. Catch them early so that the target never sees them. */
276 if (regnum
>= gdbarch_num_regs (gdbarch
)
277 + gdbarch_num_pseudo_regs (gdbarch
))
278 return value_of_user_reg (regnum
, frame
);
280 frame_register (frame
, regnum
, &optim
, &unavail
,
281 &lval
, &addr
, &realnum
, raw_buffer
);
283 reg_val
= allocate_value (register_type (gdbarch
, regnum
));
285 if (!optim
&& !unavail
)
286 memcpy (value_contents_raw (reg_val
), raw_buffer
,
287 register_size (gdbarch
, regnum
));
289 memset (value_contents_raw (reg_val
), 0,
290 register_size (gdbarch
, regnum
));
292 VALUE_LVAL (reg_val
) = lval
;
293 set_value_address (reg_val
, addr
);
294 VALUE_REGNUM (reg_val
) = regnum
;
295 set_value_optimized_out (reg_val
, optim
);
297 mark_value_bytes_unavailable (reg_val
, 0, register_size (gdbarch
, regnum
));
298 VALUE_FRAME_ID (reg_val
) = get_frame_id (frame
);
302 /* Return a `value' with the contents of (virtual or cooked) register
303 REGNUM as found in the specified FRAME. The register's type is
304 determined by register_type(). The value is not fetched. */
307 value_of_register_lazy (struct frame_info
*frame
, int regnum
)
309 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
310 struct value
*reg_val
;
312 gdb_assert (regnum
< (gdbarch_num_regs (gdbarch
)
313 + gdbarch_num_pseudo_regs (gdbarch
)));
315 /* We should have a valid (i.e. non-sentinel) frame. */
316 gdb_assert (frame_id_p (get_frame_id (frame
)));
318 reg_val
= allocate_value_lazy (register_type (gdbarch
, regnum
));
319 VALUE_LVAL (reg_val
) = lval_register
;
320 VALUE_REGNUM (reg_val
) = regnum
;
321 VALUE_FRAME_ID (reg_val
) = get_frame_id (frame
);
325 /* Given a pointer of type TYPE in target form in BUF, return the
326 address it represents. */
328 unsigned_pointer_to_address (struct gdbarch
*gdbarch
,
329 struct type
*type
, const gdb_byte
*buf
)
331 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
333 return extract_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
);
337 signed_pointer_to_address (struct gdbarch
*gdbarch
,
338 struct type
*type
, const gdb_byte
*buf
)
340 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
342 return extract_signed_integer (buf
, TYPE_LENGTH (type
), byte_order
);
345 /* Given an address, store it as a pointer of type TYPE in target
348 unsigned_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
349 gdb_byte
*buf
, CORE_ADDR addr
)
351 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
353 store_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
357 address_to_signed_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
358 gdb_byte
*buf
, CORE_ADDR addr
)
360 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
362 store_signed_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
365 /* Will calling read_var_value or locate_var_value on SYM end
366 up caring what frame it is being evaluated relative to? SYM must
369 symbol_read_needs_frame (struct symbol
*sym
)
371 switch (SYMBOL_CLASS (sym
))
373 /* All cases listed explicitly so that gcc -Wall will detect it if
374 we failed to consider one. */
376 /* FIXME: cagney/2004-01-26: It should be possible to
377 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
378 Unfortunately DWARF 2 stores the frame-base (instead of the
379 function) location in a function's symbol. Oops! For the
380 moment enable this when/where applicable. */
381 return SYMBOL_COMPUTED_OPS (sym
)->read_needs_frame (sym
);
386 case LOC_REGPARM_ADDR
:
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. */
415 read_var_value (struct symbol
*var
, struct frame_info
*frame
)
418 struct type
*type
= SYMBOL_TYPE (var
);
422 /* Call check_typedef on our type to make sure that, if TYPE is
423 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
424 instead of zero. However, we do not replace the typedef type by the
425 target type, because we want to keep the typedef in order to be able to
426 set the returned value type description correctly. */
427 check_typedef (type
);
429 len
= TYPE_LENGTH (type
);
431 if (symbol_read_needs_frame (var
))
434 switch (SYMBOL_CLASS (var
))
437 /* Put the constant back in target format. */
438 v
= allocate_value (type
);
439 store_signed_integer (value_contents_raw (v
), len
,
440 gdbarch_byte_order (get_type_arch (type
)),
441 (LONGEST
) SYMBOL_VALUE (var
));
442 VALUE_LVAL (v
) = not_lval
;
446 /* Put the constant back in target format. */
447 v
= allocate_value (type
);
448 if (overlay_debugging
)
451 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
452 SYMBOL_OBJ_SECTION (var
));
454 store_typed_address (value_contents_raw (v
), type
, addr
);
457 store_typed_address (value_contents_raw (v
), type
,
458 SYMBOL_VALUE_ADDRESS (var
));
459 VALUE_LVAL (v
) = not_lval
;
462 case LOC_CONST_BYTES
:
463 v
= allocate_value (type
);
464 memcpy (value_contents_raw (v
), SYMBOL_VALUE_BYTES (var
), len
);
465 VALUE_LVAL (v
) = not_lval
;
469 v
= allocate_value_lazy (type
);
470 if (overlay_debugging
)
471 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
472 SYMBOL_OBJ_SECTION (var
));
474 addr
= SYMBOL_VALUE_ADDRESS (var
);
478 addr
= get_frame_args_address (frame
);
481 addr
+= SYMBOL_VALUE (var
);
482 v
= allocate_value_lazy (type
);
490 argref
= get_frame_args_address (frame
);
493 argref
+= SYMBOL_VALUE (var
);
494 ref
= value_at (lookup_pointer_type (type
), argref
);
495 addr
= value_as_address (ref
);
496 v
= allocate_value_lazy (type
);
501 addr
= get_frame_locals_address (frame
);
502 addr
+= SYMBOL_VALUE (var
);
503 v
= allocate_value_lazy (type
);
507 error (_("Cannot look up value of a typedef"));
511 v
= allocate_value_lazy (type
);
512 if (overlay_debugging
)
513 addr
= symbol_overlayed_address
514 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_OBJ_SECTION (var
));
516 addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
520 case LOC_REGPARM_ADDR
:
522 int regno
= SYMBOL_REGISTER_OPS (var
)
523 ->register_number (var
, get_frame_arch (frame
));
524 struct value
*regval
;
526 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
528 regval
= value_from_register (lookup_pointer_type (type
),
533 error (_("Value of register variable not available."));
535 addr
= value_as_address (regval
);
536 v
= allocate_value_lazy (type
);
540 regval
= value_from_register (type
, regno
, frame
);
543 error (_("Value of register variable not available."));
550 /* FIXME: cagney/2004-01-26: It should be possible to
551 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
552 Unfortunately DWARF 2 stores the frame-base (instead of the
553 function) location in a function's symbol. Oops! For the
554 moment enable this when/where applicable. */
555 return SYMBOL_COMPUTED_OPS (var
)->read_variable (var
, frame
);
559 struct minimal_symbol
*msym
;
560 struct obj_section
*obj_section
;
562 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var
), NULL
, NULL
);
565 if (overlay_debugging
)
566 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
567 SYMBOL_OBJ_SECTION (msym
));
569 addr
= SYMBOL_VALUE_ADDRESS (msym
);
571 obj_section
= SYMBOL_OBJ_SECTION (msym
);
573 && (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
574 addr
= target_translate_tls_address (obj_section
->objfile
, addr
);
575 v
= allocate_value_lazy (type
);
579 case LOC_OPTIMIZED_OUT
:
580 v
= allocate_value_lazy (type
);
581 VALUE_LVAL (v
) = not_lval
;
582 set_value_optimized_out (v
, 1);
586 error (_("Cannot look up value of a botched symbol."));
590 VALUE_LVAL (v
) = lval_memory
;
591 set_value_address (v
, addr
);
595 /* Install default attributes for register values. */
598 default_value_from_register (struct type
*type
, int regnum
,
599 struct frame_info
*frame
)
601 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
602 int len
= TYPE_LENGTH (type
);
603 struct value
*value
= allocate_value (type
);
605 VALUE_LVAL (value
) = lval_register
;
606 VALUE_FRAME_ID (value
) = get_frame_id (frame
);
607 VALUE_REGNUM (value
) = regnum
;
609 /* Any structure stored in more than one register will always be
610 an integral number of registers. Otherwise, you need to do
611 some fiddling with the last register copied here for little
613 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
614 && len
< register_size (gdbarch
, regnum
))
615 /* Big-endian, and we want less than full size. */
616 set_value_offset (value
, register_size (gdbarch
, regnum
) - len
);
618 set_value_offset (value
, 0);
623 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
626 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
628 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
629 struct type
*type1
= check_typedef (type
);
631 int optim
, unavail
, ok
;
633 if (gdbarch_convert_register_p (gdbarch
, regnum
, type1
))
635 /* The ISA/ABI need to something weird when obtaining the
636 specified value from this register. It might need to
637 re-order non-adjacent, starting with REGNUM (see MIPS and
638 i386). It might need to convert the [float] register into
639 the corresponding [integer] type (see Alpha). The assumption
640 is that gdbarch_register_to_value populates the entire value
641 including the location. */
642 v
= allocate_value (type
);
643 VALUE_LVAL (v
) = lval_register
;
644 VALUE_FRAME_ID (v
) = get_frame_id (frame
);
645 VALUE_REGNUM (v
) = regnum
;
646 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type1
,
647 value_contents_raw (v
), &optim
,
652 int len
= TYPE_LENGTH (type
);
654 /* Construct the value. */
655 v
= gdbarch_value_from_register (gdbarch
, type
, regnum
, frame
);
658 ok
= get_frame_register_bytes (frame
, regnum
, value_offset (v
), len
,
659 value_contents_raw (v
),
666 set_value_optimized_out (v
, 1);
668 mark_value_bytes_unavailable (v
, 0, TYPE_LENGTH (type
));
674 /* Return contents of register REGNUM in frame FRAME as address,
675 interpreted as value of type TYPE. Will abort if register
676 value is not available. */
679 address_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
684 value
= value_from_register (type
, regnum
, frame
);
687 result
= value_as_address (value
);
688 release_value (value
);
This page took 0.042528 seconds and 4 git commands to generate.