1 /* Find a variable's value in memory, for GDB, the GNU debugger.
3 Copyright (C) 1986-2001, 2003-2005, 2007-2012 Free Software
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 3 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, see <http://www.gnu.org/licenses/>. */
29 #include "gdb_string.h"
30 #include "gdb_assert.h"
31 #include "floatformat.h"
32 #include "symfile.h" /* for overlay functions */
34 #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 /* Private data to be used with minsym_lookup_iterator_cb. */
411 struct minsym_lookup_data
413 /* The name of the minimal symbol we are searching for. */
416 /* The field where the callback should store the minimal symbol
417 if found. It should be initialized to NULL before the search
419 struct minimal_symbol
*result
;
422 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
423 It searches by name for a minimal symbol within the given OBJFILE.
424 The arguments are passed via CB_DATA, which in reality is a pointer
425 to struct minsym_lookup_data. */
428 minsym_lookup_iterator_cb (struct objfile
*objfile
, void *cb_data
)
430 struct minsym_lookup_data
*data
= (struct minsym_lookup_data
*) cb_data
;
432 gdb_assert (data
->result
== NULL
);
434 data
->result
= lookup_minimal_symbol (data
->name
, NULL
, objfile
);
436 /* The iterator should stop iff a match was found. */
437 return (data
->result
!= NULL
);
440 /* A default implementation for the "la_read_var_value" hook in
441 the language vector which should work in most situations. */
444 default_read_var_value (struct symbol
*var
, struct frame_info
*frame
)
447 struct type
*type
= SYMBOL_TYPE (var
);
450 /* Call check_typedef on our type to make sure that, if TYPE is
451 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
452 instead of zero. However, we do not replace the typedef type by the
453 target type, because we want to keep the typedef in order to be able to
454 set the returned value type description correctly. */
455 check_typedef (type
);
457 if (symbol_read_needs_frame (var
))
460 switch (SYMBOL_CLASS (var
))
463 /* Put the constant back in target format. */
464 v
= allocate_value (type
);
465 store_signed_integer (value_contents_raw (v
), TYPE_LENGTH (type
),
466 gdbarch_byte_order (get_type_arch (type
)),
467 (LONGEST
) SYMBOL_VALUE (var
));
468 VALUE_LVAL (v
) = not_lval
;
472 /* Put the constant back in target format. */
473 v
= allocate_value (type
);
474 if (overlay_debugging
)
477 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
478 SYMBOL_OBJ_SECTION (var
));
480 store_typed_address (value_contents_raw (v
), type
, addr
);
483 store_typed_address (value_contents_raw (v
), type
,
484 SYMBOL_VALUE_ADDRESS (var
));
485 VALUE_LVAL (v
) = not_lval
;
488 case LOC_CONST_BYTES
:
489 v
= allocate_value (type
);
490 memcpy (value_contents_raw (v
), SYMBOL_VALUE_BYTES (var
),
492 VALUE_LVAL (v
) = not_lval
;
496 v
= allocate_value_lazy (type
);
497 if (overlay_debugging
)
498 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
499 SYMBOL_OBJ_SECTION (var
));
501 addr
= SYMBOL_VALUE_ADDRESS (var
);
505 addr
= get_frame_args_address (frame
);
507 error (_("Unknown argument list address for `%s'."),
508 SYMBOL_PRINT_NAME (var
));
509 addr
+= SYMBOL_VALUE (var
);
510 v
= allocate_value_lazy (type
);
518 argref
= get_frame_args_address (frame
);
520 error (_("Unknown argument list address for `%s'."),
521 SYMBOL_PRINT_NAME (var
));
522 argref
+= SYMBOL_VALUE (var
);
523 ref
= value_at (lookup_pointer_type (type
), argref
);
524 addr
= value_as_address (ref
);
525 v
= allocate_value_lazy (type
);
530 addr
= get_frame_locals_address (frame
);
531 addr
+= SYMBOL_VALUE (var
);
532 v
= allocate_value_lazy (type
);
536 error (_("Cannot look up value of a typedef `%s'."),
537 SYMBOL_PRINT_NAME (var
));
541 v
= allocate_value_lazy (type
);
542 if (overlay_debugging
)
543 addr
= symbol_overlayed_address
544 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_OBJ_SECTION (var
));
546 addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
550 case LOC_REGPARM_ADDR
:
552 int regno
= SYMBOL_REGISTER_OPS (var
)
553 ->register_number (var
, get_frame_arch (frame
));
554 struct value
*regval
;
556 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
558 regval
= value_from_register (lookup_pointer_type (type
),
563 error (_("Value of register variable not available for `%s'."),
564 SYMBOL_PRINT_NAME (var
));
566 addr
= value_as_address (regval
);
567 v
= allocate_value_lazy (type
);
571 regval
= value_from_register (type
, regno
, frame
);
574 error (_("Value of register variable not available for `%s'."),
575 SYMBOL_PRINT_NAME (var
));
582 /* FIXME: cagney/2004-01-26: It should be possible to
583 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
584 Unfortunately DWARF 2 stores the frame-base (instead of the
585 function) location in a function's symbol. Oops! For the
586 moment enable this when/where applicable. */
587 return SYMBOL_COMPUTED_OPS (var
)->read_variable (var
, frame
);
591 struct minsym_lookup_data lookup_data
;
592 struct minimal_symbol
*msym
;
593 struct obj_section
*obj_section
;
595 memset (&lookup_data
, 0, sizeof (lookup_data
));
596 lookup_data
.name
= SYMBOL_LINKAGE_NAME (var
);
598 gdbarch_iterate_over_objfiles_in_search_order
599 (get_objfile_arch (SYMBOL_SYMTAB (var
)->objfile
),
600 minsym_lookup_iterator_cb
, &lookup_data
,
601 SYMBOL_SYMTAB (var
)->objfile
);
602 msym
= lookup_data
.result
;
605 error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var
));
606 if (overlay_debugging
)
607 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
608 SYMBOL_OBJ_SECTION (msym
));
610 addr
= SYMBOL_VALUE_ADDRESS (msym
);
612 obj_section
= SYMBOL_OBJ_SECTION (msym
);
614 && (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
615 addr
= target_translate_tls_address (obj_section
->objfile
, addr
);
616 v
= allocate_value_lazy (type
);
620 case LOC_OPTIMIZED_OUT
:
621 return allocate_optimized_out_value (type
);
624 error (_("Cannot look up value of a botched symbol `%s'."),
625 SYMBOL_PRINT_NAME (var
));
629 VALUE_LVAL (v
) = lval_memory
;
630 set_value_address (v
, addr
);
634 /* Calls VAR's language la_read_var_value hook with the given arguments. */
637 read_var_value (struct symbol
*var
, struct frame_info
*frame
)
639 const struct language_defn
*lang
= language_def (SYMBOL_LANGUAGE (var
));
641 gdb_assert (lang
!= NULL
);
642 gdb_assert (lang
->la_read_var_value
!= NULL
);
644 return lang
->la_read_var_value (var
, frame
);
647 /* Install default attributes for register values. */
650 default_value_from_register (struct type
*type
, int regnum
,
651 struct frame_info
*frame
)
653 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
654 int len
= TYPE_LENGTH (type
);
655 struct value
*value
= allocate_value (type
);
657 VALUE_LVAL (value
) = lval_register
;
658 VALUE_FRAME_ID (value
) = get_frame_id (frame
);
659 VALUE_REGNUM (value
) = regnum
;
661 /* Any structure stored in more than one register will always be
662 an integral number of registers. Otherwise, you need to do
663 some fiddling with the last register copied here for little
665 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
666 && len
< register_size (gdbarch
, regnum
))
667 /* Big-endian, and we want less than full size. */
668 set_value_offset (value
, register_size (gdbarch
, regnum
) - len
);
670 set_value_offset (value
, 0);
675 /* VALUE must be an lval_register value. If regnum is the value's
676 associated register number, and len the length of the values type,
677 read one or more registers in FRAME, starting with register REGNUM,
678 until we've read LEN bytes.
680 If any of the registers we try to read are optimized out, then mark the
681 complete resulting value as optimized out. */
684 read_frame_register_value (struct value
*value
, struct frame_info
*frame
)
686 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
688 int reg_offset
= value_offset (value
);
689 int regnum
= VALUE_REGNUM (value
);
690 int len
= TYPE_LENGTH (check_typedef (value_type (value
)));
692 gdb_assert (VALUE_LVAL (value
) == lval_register
);
694 /* Skip registers wholly inside of REG_OFFSET. */
695 while (reg_offset
>= register_size (gdbarch
, regnum
))
697 reg_offset
-= register_size (gdbarch
, regnum
);
704 struct value
*regval
= get_frame_register_value (frame
, regnum
);
705 int reg_len
= TYPE_LENGTH (value_type (regval
)) - reg_offset
;
707 if (value_optimized_out (regval
))
709 set_value_optimized_out (value
, 1);
713 /* If the register length is larger than the number of bytes
714 remaining to copy, then only copy the appropriate bytes. */
718 value_contents_copy (value
, offset
, regval
, reg_offset
, reg_len
);
727 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
730 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
732 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
733 struct type
*type1
= check_typedef (type
);
736 if (gdbarch_convert_register_p (gdbarch
, regnum
, type1
))
738 int optim
, unavail
, ok
;
740 /* The ISA/ABI need to something weird when obtaining the
741 specified value from this register. It might need to
742 re-order non-adjacent, starting with REGNUM (see MIPS and
743 i386). It might need to convert the [float] register into
744 the corresponding [integer] type (see Alpha). The assumption
745 is that gdbarch_register_to_value populates the entire value
746 including the location. */
747 v
= allocate_value (type
);
748 VALUE_LVAL (v
) = lval_register
;
749 VALUE_FRAME_ID (v
) = get_frame_id (frame
);
750 VALUE_REGNUM (v
) = regnum
;
751 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type1
,
752 value_contents_raw (v
), &optim
,
758 set_value_optimized_out (v
, 1);
760 mark_value_bytes_unavailable (v
, 0, TYPE_LENGTH (type
));
765 /* Construct the value. */
766 v
= gdbarch_value_from_register (gdbarch
, type
, regnum
, frame
);
769 read_frame_register_value (v
, frame
);
775 /* Return contents of register REGNUM in frame FRAME as address,
776 interpreted as value of type TYPE. Will abort if register
777 value is not available. */
780 address_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
785 value
= value_from_register (type
, regnum
, frame
);
788 result
= value_as_address (value
);
789 release_value (value
);