1 /* Find a variable's value in memory, for GDB, the GNU debugger.
3 Copyright (C) 1986-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
29 #include "floatformat.h"
30 #include "symfile.h" /* for overlay functions */
32 #include "user-regs.h"
37 /* Basic byte-swapping routines. All 'extract' functions return a
38 host-format integer from a target-format integer at ADDR which is
41 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
42 /* 8 bit characters are a pretty safe assumption these days, so we
43 assume it throughout all these swapping routines. If we had to deal with
44 9 bit characters, we would need to make len be in bits and would have
45 to re-write these routines... */
50 extract_signed_integer (const gdb_byte
*addr
, int len
,
51 enum bfd_endian byte_order
)
54 const unsigned char *p
;
55 const unsigned char *startaddr
= addr
;
56 const unsigned char *endaddr
= startaddr
+ len
;
58 if (len
> (int) sizeof (LONGEST
))
60 That operation is not available on integers of more than %d bytes."),
61 (int) sizeof (LONGEST
));
63 /* Start at the most significant end of the integer, and work towards
64 the least significant. */
65 if (byte_order
== BFD_ENDIAN_BIG
)
68 /* Do the sign extension once at the start. */
69 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
70 for (++p
; p
< endaddr
; ++p
)
71 retval
= (retval
<< 8) | *p
;
76 /* Do the sign extension once at the start. */
77 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
78 for (--p
; p
>= startaddr
; --p
)
79 retval
= (retval
<< 8) | *p
;
85 extract_unsigned_integer (const gdb_byte
*addr
, int len
,
86 enum bfd_endian byte_order
)
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 (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 gdb_byte
*addr
, int orig_len
,
121 enum bfd_endian byte_order
, LONGEST
*pval
)
124 const gdb_byte
*first_addr
;
128 if (byte_order
== BFD_ENDIAN_BIG
)
131 len
> (int) sizeof (LONGEST
) && p
< addr
+ orig_len
;
144 for (p
= addr
+ orig_len
- 1;
145 len
> (int) sizeof (LONGEST
) && p
>= addr
;
155 if (len
<= (int) sizeof (LONGEST
))
157 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
167 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
168 address it represents. */
170 extract_typed_address (const gdb_byte
*buf
, struct type
*type
)
172 if (TYPE_CODE (type
) != TYPE_CODE_PTR
173 && TYPE_CODE (type
) != TYPE_CODE_REF
)
174 internal_error (__FILE__
, __LINE__
,
175 _("extract_typed_address: "
176 "type is not a pointer or reference"));
178 return gdbarch_pointer_to_address (get_type_arch (type
), type
, buf
);
181 /* All 'store' functions accept a host-format integer and store a
182 target-format integer at ADDR which is LEN bytes long. */
185 store_signed_integer (gdb_byte
*addr
, int len
,
186 enum bfd_endian byte_order
, LONGEST val
)
189 gdb_byte
*startaddr
= addr
;
190 gdb_byte
*endaddr
= startaddr
+ len
;
192 /* Start at the least significant end of the integer, and work towards
193 the most significant. */
194 if (byte_order
== BFD_ENDIAN_BIG
)
196 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
204 for (p
= startaddr
; p
< endaddr
; ++p
)
213 store_unsigned_integer (gdb_byte
*addr
, int len
,
214 enum bfd_endian byte_order
, ULONGEST val
)
217 unsigned char *startaddr
= (unsigned char *) addr
;
218 unsigned char *endaddr
= startaddr
+ len
;
220 /* Start at the least significant end of the integer, and work towards
221 the most significant. */
222 if (byte_order
== BFD_ENDIAN_BIG
)
224 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
232 for (p
= startaddr
; p
< endaddr
; ++p
)
240 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
243 store_typed_address (gdb_byte
*buf
, struct type
*type
, CORE_ADDR addr
)
245 if (TYPE_CODE (type
) != TYPE_CODE_PTR
246 && TYPE_CODE (type
) != TYPE_CODE_REF
)
247 internal_error (__FILE__
, __LINE__
,
248 _("store_typed_address: "
249 "type is not a pointer or reference"));
251 gdbarch_address_to_pointer (get_type_arch (type
), type
, buf
, addr
);
256 /* Return a `value' with the contents of (virtual or cooked) register
257 REGNUM as found in the specified FRAME. The register's type is
258 determined by register_type(). */
261 value_of_register (int regnum
, struct frame_info
*frame
)
263 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
264 struct value
*reg_val
;
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
>= gdbarch_num_regs (gdbarch
)
269 + gdbarch_num_pseudo_regs (gdbarch
))
270 return value_of_user_reg (regnum
, frame
);
272 reg_val
= value_of_register_lazy (frame
, regnum
);
273 value_fetch_lazy (reg_val
);
277 /* Return a `value' with the contents of (virtual or cooked) register
278 REGNUM as found in the specified FRAME. The register's type is
279 determined by register_type(). The value is not fetched. */
282 value_of_register_lazy (struct frame_info
*frame
, int regnum
)
284 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
285 struct value
*reg_val
;
287 gdb_assert (regnum
< (gdbarch_num_regs (gdbarch
)
288 + gdbarch_num_pseudo_regs (gdbarch
)));
290 /* We should have a valid (i.e. non-sentinel) frame. */
291 gdb_assert (frame_id_p (get_frame_id (frame
)));
293 reg_val
= allocate_value_lazy (register_type (gdbarch
, regnum
));
294 VALUE_LVAL (reg_val
) = lval_register
;
295 VALUE_REGNUM (reg_val
) = regnum
;
296 VALUE_FRAME_ID (reg_val
) = get_frame_id (frame
);
300 /* Given a pointer of type TYPE in target form in BUF, return the
301 address it represents. */
303 unsigned_pointer_to_address (struct gdbarch
*gdbarch
,
304 struct type
*type
, const gdb_byte
*buf
)
306 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
308 return extract_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
);
312 signed_pointer_to_address (struct gdbarch
*gdbarch
,
313 struct type
*type
, const gdb_byte
*buf
)
315 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
317 return extract_signed_integer (buf
, TYPE_LENGTH (type
), byte_order
);
320 /* Given an address, store it as a pointer of type TYPE in target
323 unsigned_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
324 gdb_byte
*buf
, CORE_ADDR addr
)
326 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
328 store_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
332 address_to_signed_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
333 gdb_byte
*buf
, CORE_ADDR addr
)
335 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
337 store_signed_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
340 /* Will calling read_var_value or locate_var_value on SYM end
341 up caring what frame it is being evaluated relative to? SYM must
344 symbol_read_needs_frame (struct symbol
*sym
)
346 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
347 return SYMBOL_COMPUTED_OPS (sym
)->read_needs_frame (sym
);
349 switch (SYMBOL_CLASS (sym
))
351 /* All cases listed explicitly so that gcc -Wall will detect it if
352 we failed to consider one. */
354 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
359 case LOC_REGPARM_ADDR
:
369 /* Getting the address of a label can be done independently of the block,
370 even if some *uses* of that address wouldn't work so well without
374 case LOC_CONST_BYTES
:
376 case LOC_OPTIMIZED_OUT
:
382 /* Private data to be used with minsym_lookup_iterator_cb. */
384 struct minsym_lookup_data
386 /* The name of the minimal symbol we are searching for. */
389 /* The field where the callback should store the minimal symbol
390 if found. It should be initialized to NULL before the search
392 struct bound_minimal_symbol result
;
395 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
396 It searches by name for a minimal symbol within the given OBJFILE.
397 The arguments are passed via CB_DATA, which in reality is a pointer
398 to struct minsym_lookup_data. */
401 minsym_lookup_iterator_cb (struct objfile
*objfile
, void *cb_data
)
403 struct minsym_lookup_data
*data
= (struct minsym_lookup_data
*) cb_data
;
405 gdb_assert (data
->result
.minsym
== NULL
);
407 data
->result
= lookup_minimal_symbol (data
->name
, NULL
, objfile
);
409 /* The iterator should stop iff a match was found. */
410 return (data
->result
.minsym
!= NULL
);
413 /* A default implementation for the "la_read_var_value" hook in
414 the language vector which should work in most situations. */
417 default_read_var_value (struct symbol
*var
, struct frame_info
*frame
)
420 struct type
*type
= SYMBOL_TYPE (var
);
423 /* Call check_typedef on our type to make sure that, if TYPE is
424 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
425 instead of zero. However, we do not replace the typedef type by the
426 target type, because we want to keep the typedef in order to be able to
427 set the returned value type description correctly. */
428 check_typedef (type
);
430 if (symbol_read_needs_frame (var
))
433 if (SYMBOL_COMPUTED_OPS (var
) != NULL
)
434 return SYMBOL_COMPUTED_OPS (var
)->read_variable (var
, frame
);
436 switch (SYMBOL_CLASS (var
))
439 if (is_dynamic_type (type
))
441 /* Value is a constant byte-sequence and needs no memory access. */
442 type
= resolve_dynamic_type (type
, /* Unused address. */ 0);
444 /* Put the constant back in target format. */
445 v
= allocate_value (type
);
446 store_signed_integer (value_contents_raw (v
), TYPE_LENGTH (type
),
447 gdbarch_byte_order (get_type_arch (type
)),
448 (LONGEST
) SYMBOL_VALUE (var
));
449 VALUE_LVAL (v
) = not_lval
;
453 /* Put the constant back in target format. */
454 v
= allocate_value (type
);
455 if (overlay_debugging
)
458 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
459 SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var
),
462 store_typed_address (value_contents_raw (v
), type
, addr
);
465 store_typed_address (value_contents_raw (v
), type
,
466 SYMBOL_VALUE_ADDRESS (var
));
467 VALUE_LVAL (v
) = not_lval
;
470 case LOC_CONST_BYTES
:
471 if (is_dynamic_type (type
))
473 /* Value is a constant byte-sequence and needs no memory access. */
474 type
= resolve_dynamic_type (type
, /* Unused address. */ 0);
476 v
= allocate_value (type
);
477 memcpy (value_contents_raw (v
), SYMBOL_VALUE_BYTES (var
),
479 VALUE_LVAL (v
) = not_lval
;
483 if (overlay_debugging
)
484 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
485 SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var
),
488 addr
= SYMBOL_VALUE_ADDRESS (var
);
492 addr
= get_frame_args_address (frame
);
494 error (_("Unknown argument list address for `%s'."),
495 SYMBOL_PRINT_NAME (var
));
496 addr
+= SYMBOL_VALUE (var
);
504 argref
= get_frame_args_address (frame
);
506 error (_("Unknown argument list address for `%s'."),
507 SYMBOL_PRINT_NAME (var
));
508 argref
+= SYMBOL_VALUE (var
);
509 ref
= value_at (lookup_pointer_type (type
), argref
);
510 addr
= value_as_address (ref
);
515 addr
= get_frame_locals_address (frame
);
516 addr
+= SYMBOL_VALUE (var
);
520 error (_("Cannot look up value of a typedef `%s'."),
521 SYMBOL_PRINT_NAME (var
));
525 if (overlay_debugging
)
526 addr
= symbol_overlayed_address
527 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var
),
530 addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
534 case LOC_REGPARM_ADDR
:
536 int regno
= SYMBOL_REGISTER_OPS (var
)
537 ->register_number (var
, get_frame_arch (frame
));
538 struct value
*regval
;
540 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
542 regval
= value_from_register (lookup_pointer_type (type
),
547 error (_("Value of register variable not available for `%s'."),
548 SYMBOL_PRINT_NAME (var
));
550 addr
= value_as_address (regval
);
554 regval
= value_from_register (type
, regno
, frame
);
557 error (_("Value of register variable not available for `%s'."),
558 SYMBOL_PRINT_NAME (var
));
565 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
569 struct minsym_lookup_data lookup_data
;
570 struct minimal_symbol
*msym
;
571 struct obj_section
*obj_section
;
573 memset (&lookup_data
, 0, sizeof (lookup_data
));
574 lookup_data
.name
= SYMBOL_LINKAGE_NAME (var
);
576 gdbarch_iterate_over_objfiles_in_search_order
577 (get_objfile_arch (SYMBOL_SYMTAB (var
)->objfile
),
578 minsym_lookup_iterator_cb
, &lookup_data
,
579 SYMBOL_SYMTAB (var
)->objfile
);
580 msym
= lookup_data
.result
.minsym
;
583 error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var
));
584 if (overlay_debugging
)
585 addr
= symbol_overlayed_address (BMSYMBOL_VALUE_ADDRESS (lookup_data
.result
),
586 MSYMBOL_OBJ_SECTION (lookup_data
.result
.objfile
,
589 addr
= BMSYMBOL_VALUE_ADDRESS (lookup_data
.result
);
591 obj_section
= MSYMBOL_OBJ_SECTION (lookup_data
.result
.objfile
, msym
);
593 && (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
594 addr
= target_translate_tls_address (obj_section
->objfile
, addr
);
598 case LOC_OPTIMIZED_OUT
:
599 return allocate_optimized_out_value (type
);
602 error (_("Cannot look up value of a botched symbol `%s'."),
603 SYMBOL_PRINT_NAME (var
));
607 v
= value_at_lazy (type
, addr
);
611 /* Calls VAR's language la_read_var_value hook with the given arguments. */
614 read_var_value (struct symbol
*var
, struct frame_info
*frame
)
616 const struct language_defn
*lang
= language_def (SYMBOL_LANGUAGE (var
));
618 gdb_assert (lang
!= NULL
);
619 gdb_assert (lang
->la_read_var_value
!= NULL
);
621 return lang
->la_read_var_value (var
, frame
);
624 /* Install default attributes for register values. */
627 default_value_from_register (struct gdbarch
*gdbarch
, struct type
*type
,
628 int regnum
, struct frame_id frame_id
)
630 int len
= TYPE_LENGTH (type
);
631 struct value
*value
= allocate_value (type
);
633 VALUE_LVAL (value
) = lval_register
;
634 VALUE_FRAME_ID (value
) = frame_id
;
635 VALUE_REGNUM (value
) = regnum
;
637 /* Any structure stored in more than one register will always be
638 an integral number of registers. Otherwise, you need to do
639 some fiddling with the last register copied here for little
641 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
642 && len
< register_size (gdbarch
, regnum
))
643 /* Big-endian, and we want less than full size. */
644 set_value_offset (value
, register_size (gdbarch
, regnum
) - len
);
646 set_value_offset (value
, 0);
651 /* VALUE must be an lval_register value. If regnum is the value's
652 associated register number, and len the length of the values type,
653 read one or more registers in FRAME, starting with register REGNUM,
654 until we've read LEN bytes.
656 If any of the registers we try to read are optimized out, then mark the
657 complete resulting value as optimized out. */
660 read_frame_register_value (struct value
*value
, struct frame_info
*frame
)
662 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
664 int reg_offset
= value_offset (value
);
665 int regnum
= VALUE_REGNUM (value
);
666 int len
= TYPE_LENGTH (check_typedef (value_type (value
)));
668 gdb_assert (VALUE_LVAL (value
) == lval_register
);
670 /* Skip registers wholly inside of REG_OFFSET. */
671 while (reg_offset
>= register_size (gdbarch
, regnum
))
673 reg_offset
-= register_size (gdbarch
, regnum
);
680 struct value
*regval
= get_frame_register_value (frame
, regnum
);
681 int reg_len
= TYPE_LENGTH (value_type (regval
)) - reg_offset
;
683 if (value_optimized_out (regval
))
685 set_value_optimized_out (value
, 1);
689 /* If the register length is larger than the number of bytes
690 remaining to copy, then only copy the appropriate bytes. */
694 value_contents_copy (value
, offset
, regval
, reg_offset
, reg_len
);
703 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
706 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
708 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
709 struct type
*type1
= check_typedef (type
);
712 if (gdbarch_convert_register_p (gdbarch
, regnum
, type1
))
714 int optim
, unavail
, ok
;
716 /* The ISA/ABI need to something weird when obtaining the
717 specified value from this register. It might need to
718 re-order non-adjacent, starting with REGNUM (see MIPS and
719 i386). It might need to convert the [float] register into
720 the corresponding [integer] type (see Alpha). The assumption
721 is that gdbarch_register_to_value populates the entire value
722 including the location. */
723 v
= allocate_value (type
);
724 VALUE_LVAL (v
) = lval_register
;
725 VALUE_FRAME_ID (v
) = get_frame_id (frame
);
726 VALUE_REGNUM (v
) = regnum
;
727 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type1
,
728 value_contents_raw (v
), &optim
,
734 set_value_optimized_out (v
, 1);
736 mark_value_bytes_unavailable (v
, 0, TYPE_LENGTH (type
));
741 /* Construct the value. */
742 v
= gdbarch_value_from_register (gdbarch
, type
,
743 regnum
, get_frame_id (frame
));
746 read_frame_register_value (v
, frame
);
752 /* Return contents of register REGNUM in frame FRAME as address.
753 Will abort if register value is not available. */
756 address_from_register (int regnum
, struct frame_info
*frame
)
758 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
759 struct type
*type
= builtin_type (gdbarch
)->builtin_data_ptr
;
763 /* This routine may be called during early unwinding, at a time
764 where the ID of FRAME is not yet known. Calling value_from_register
765 would therefore abort in get_frame_id. However, since we only need
766 a temporary value that is never used as lvalue, we actually do not
767 really need to set its VALUE_FRAME_ID. Therefore, we re-implement
768 the core of value_from_register, but use the null_frame_id.
770 This works only if we do not require a special conversion routine,
771 which is true for plain pointer types for all current targets. */
772 gdb_assert (!gdbarch_convert_register_p (gdbarch
, regnum
, type
));
774 value
= gdbarch_value_from_register (gdbarch
, type
, regnum
, null_frame_id
);
775 read_frame_register_value (value
, frame
);
777 if (value_optimized_out (value
))
779 /* This function is used while computing a location expression.
780 Complain about the value being optimized out, rather than
781 letting value_as_address complain about some random register
782 the expression depends on not being saved. */
783 error_value_optimized_out ();
786 result
= value_as_address (value
);
787 release_value (value
);