9009e6f324be2ae80984546281c665aba35c3ef2
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 /* A default implementation for the "la_read_var_value" hook in
410 the language vector which should work in most situations. */
413 default_read_var_value (struct symbol
*var
, struct frame_info
*frame
)
416 struct type
*type
= SYMBOL_TYPE (var
);
420 /* Call check_typedef on our type to make sure that, if TYPE is
421 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
422 instead of zero. However, we do not replace the typedef type by the
423 target type, because we want to keep the typedef in order to be able to
424 set the returned value type description correctly. */
425 check_typedef (type
);
427 len
= TYPE_LENGTH (type
);
429 if (symbol_read_needs_frame (var
))
432 switch (SYMBOL_CLASS (var
))
435 /* Put the constant back in target format. */
436 v
= allocate_value (type
);
437 store_signed_integer (value_contents_raw (v
), len
,
438 gdbarch_byte_order (get_type_arch (type
)),
439 (LONGEST
) SYMBOL_VALUE (var
));
440 VALUE_LVAL (v
) = not_lval
;
444 /* Put the constant back in target format. */
445 v
= allocate_value (type
);
446 if (overlay_debugging
)
449 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
450 SYMBOL_OBJ_SECTION (var
));
452 store_typed_address (value_contents_raw (v
), type
, addr
);
455 store_typed_address (value_contents_raw (v
), type
,
456 SYMBOL_VALUE_ADDRESS (var
));
457 VALUE_LVAL (v
) = not_lval
;
460 case LOC_CONST_BYTES
:
461 v
= allocate_value (type
);
462 memcpy (value_contents_raw (v
), SYMBOL_VALUE_BYTES (var
), len
);
463 VALUE_LVAL (v
) = not_lval
;
467 v
= allocate_value_lazy (type
);
468 if (overlay_debugging
)
469 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
470 SYMBOL_OBJ_SECTION (var
));
472 addr
= SYMBOL_VALUE_ADDRESS (var
);
476 addr
= get_frame_args_address (frame
);
478 error (_("Unknown argument list address for `%s'."),
479 SYMBOL_PRINT_NAME (var
));
480 addr
+= SYMBOL_VALUE (var
);
481 v
= allocate_value_lazy (type
);
489 argref
= get_frame_args_address (frame
);
491 error (_("Unknown argument list address for `%s'."),
492 SYMBOL_PRINT_NAME (var
));
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 `%s'."),
508 SYMBOL_PRINT_NAME (var
));
512 v
= allocate_value_lazy (type
);
513 if (overlay_debugging
)
514 addr
= symbol_overlayed_address
515 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_OBJ_SECTION (var
));
517 addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
521 case LOC_REGPARM_ADDR
:
523 int regno
= SYMBOL_REGISTER_OPS (var
)
524 ->register_number (var
, get_frame_arch (frame
));
525 struct value
*regval
;
527 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
529 regval
= value_from_register (lookup_pointer_type (type
),
534 error (_("Value of register variable not available for `%s'."),
535 SYMBOL_PRINT_NAME (var
));
537 addr
= value_as_address (regval
);
538 v
= allocate_value_lazy (type
);
542 regval
= value_from_register (type
, regno
, frame
);
545 error (_("Value of register variable not available for `%s'."),
546 SYMBOL_PRINT_NAME (var
));
553 /* FIXME: cagney/2004-01-26: It should be possible to
554 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
555 Unfortunately DWARF 2 stores the frame-base (instead of the
556 function) location in a function's symbol. Oops! For the
557 moment enable this when/where applicable. */
558 return SYMBOL_COMPUTED_OPS (var
)->read_variable (var
, frame
);
562 struct minimal_symbol
*msym
;
563 struct obj_section
*obj_section
;
565 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var
), NULL
, NULL
);
567 error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var
));
568 if (overlay_debugging
)
569 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
570 SYMBOL_OBJ_SECTION (msym
));
572 addr
= SYMBOL_VALUE_ADDRESS (msym
);
574 obj_section
= SYMBOL_OBJ_SECTION (msym
);
576 && (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
577 addr
= target_translate_tls_address (obj_section
->objfile
, addr
);
578 v
= allocate_value_lazy (type
);
582 case LOC_OPTIMIZED_OUT
:
583 return allocate_optimized_out_value (type
);
586 error (_("Cannot look up value of a botched symbol `%s'."),
587 SYMBOL_PRINT_NAME (var
));
591 VALUE_LVAL (v
) = lval_memory
;
592 set_value_address (v
, addr
);
596 /* Calls VAR's language la_read_var_value hook with the given arguments. */
599 read_var_value (struct symbol
*var
, struct frame_info
*frame
)
601 const struct language_defn
*lang
= language_def (SYMBOL_LANGUAGE (var
));
603 gdb_assert (lang
!= NULL
);
604 gdb_assert (lang
->la_read_var_value
!= NULL
);
606 return lang
->la_read_var_value (var
, frame
);
609 /* Install default attributes for register values. */
612 default_value_from_register (struct type
*type
, int regnum
,
613 struct frame_info
*frame
)
615 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
616 int len
= TYPE_LENGTH (type
);
617 struct value
*value
= allocate_value (type
);
619 VALUE_LVAL (value
) = lval_register
;
620 VALUE_FRAME_ID (value
) = get_frame_id (frame
);
621 VALUE_REGNUM (value
) = regnum
;
623 /* Any structure stored in more than one register will always be
624 an integral number of registers. Otherwise, you need to do
625 some fiddling with the last register copied here for little
627 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
628 && len
< register_size (gdbarch
, regnum
))
629 /* Big-endian, and we want less than full size. */
630 set_value_offset (value
, register_size (gdbarch
, regnum
) - len
);
632 set_value_offset (value
, 0);
637 /* VALUE must be an lval_register value. If regnum is the value's
638 associated register number, and len the length of the values type,
639 read one or more registers in FRAME, starting with register REGNUM,
640 until we've read LEN bytes. */
643 read_frame_register_value (struct value
*value
, struct frame_info
*frame
)
645 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
647 int reg_offset
= value_offset (value
);
648 int regnum
= VALUE_REGNUM (value
);
649 int len
= TYPE_LENGTH (check_typedef (value_type (value
)));
651 gdb_assert (VALUE_LVAL (value
) == lval_register
);
653 /* Skip registers wholly inside of REG_OFFSET. */
654 while (reg_offset
>= register_size (gdbarch
, regnum
))
656 reg_offset
-= register_size (gdbarch
, regnum
);
663 struct value
*regval
= get_frame_register_value (frame
, regnum
);
664 int reg_len
= TYPE_LENGTH (value_type (regval
)) - reg_offset
;
666 /* If the register length is larger than the number of bytes
667 remaining to copy, then only copy the appropriate bytes. */
671 value_contents_copy (value
, offset
, regval
, reg_offset
, reg_len
);
680 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
683 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
685 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
686 struct type
*type1
= check_typedef (type
);
689 if (gdbarch_convert_register_p (gdbarch
, regnum
, type1
))
691 int optim
, unavail
, ok
;
693 /* The ISA/ABI need to something weird when obtaining the
694 specified value from this register. It might need to
695 re-order non-adjacent, starting with REGNUM (see MIPS and
696 i386). It might need to convert the [float] register into
697 the corresponding [integer] type (see Alpha). The assumption
698 is that gdbarch_register_to_value populates the entire value
699 including the location. */
700 v
= allocate_value (type
);
701 VALUE_LVAL (v
) = lval_register
;
702 VALUE_FRAME_ID (v
) = get_frame_id (frame
);
703 VALUE_REGNUM (v
) = regnum
;
704 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type1
,
705 value_contents_raw (v
), &optim
,
711 set_value_optimized_out (v
, 1);
713 mark_value_bytes_unavailable (v
, 0, TYPE_LENGTH (type
));
718 /* Construct the value. */
719 v
= gdbarch_value_from_register (gdbarch
, type
, regnum
, frame
);
722 read_frame_register_value (v
, frame
);
728 /* Return contents of register REGNUM in frame FRAME as address,
729 interpreted as value of type TYPE. Will abort if register
730 value is not available. */
733 address_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
738 value
= value_from_register (type
, regnum
, frame
);
741 result
= value_as_address (value
);
742 release_value (value
);
This page took 0.044451 seconds and 4 git commands to generate.