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"
38 /* Basic byte-swapping routines. All 'extract' functions return a
39 host-format integer from a target-format integer at ADDR which is
42 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
43 /* 8 bit characters are a pretty safe assumption these days, so we
44 assume it throughout all these swapping routines. If we had to deal with
45 9 bit characters, we would need to make len be in bits and would have
46 to re-write these routines... */
51 extract_signed_integer (const gdb_byte
*addr
, int len
,
52 enum bfd_endian byte_order
)
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 (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 gdb_byte
*addr
, int len
,
87 enum bfd_endian byte_order
)
90 const unsigned char *p
;
91 const unsigned char *startaddr
= addr
;
92 const unsigned char *endaddr
= startaddr
+ len
;
94 if (len
> (int) sizeof (ULONGEST
))
96 That operation is not available on integers of more than %d bytes."),
97 (int) sizeof (ULONGEST
));
99 /* Start at the most significant end of the integer, and work towards
100 the least significant. */
102 if (byte_order
== BFD_ENDIAN_BIG
)
104 for (p
= startaddr
; p
< endaddr
; ++p
)
105 retval
= (retval
<< 8) | *p
;
109 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
110 retval
= (retval
<< 8) | *p
;
115 /* Sometimes a long long unsigned integer can be extracted as a
116 LONGEST value. This is done so that we can print these values
117 better. If this integer can be converted to a LONGEST, this
118 function returns 1 and sets *PVAL. Otherwise it returns 0. */
121 extract_long_unsigned_integer (const gdb_byte
*addr
, int orig_len
,
122 enum bfd_endian byte_order
, LONGEST
*pval
)
125 const gdb_byte
*first_addr
;
129 if (byte_order
== BFD_ENDIAN_BIG
)
132 len
> (int) sizeof (LONGEST
) && p
< addr
+ orig_len
;
145 for (p
= addr
+ orig_len
- 1;
146 len
> (int) sizeof (LONGEST
) && p
>= addr
;
156 if (len
<= (int) sizeof (LONGEST
))
158 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
168 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
169 address it represents. */
171 extract_typed_address (const gdb_byte
*buf
, struct type
*type
)
173 if (TYPE_CODE (type
) != TYPE_CODE_PTR
174 && TYPE_CODE (type
) != TYPE_CODE_REF
)
175 internal_error (__FILE__
, __LINE__
,
176 _("extract_typed_address: "
177 "type is not a pointer or reference"));
179 return gdbarch_pointer_to_address (get_type_arch (type
), type
, buf
);
182 /* All 'store' functions accept a host-format integer and store a
183 target-format integer at ADDR which is LEN bytes long. */
186 store_signed_integer (gdb_byte
*addr
, int len
,
187 enum bfd_endian byte_order
, LONGEST val
)
190 gdb_byte
*startaddr
= addr
;
191 gdb_byte
*endaddr
= startaddr
+ len
;
193 /* Start at the least significant end of the integer, and work towards
194 the most significant. */
195 if (byte_order
== BFD_ENDIAN_BIG
)
197 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
205 for (p
= startaddr
; p
< endaddr
; ++p
)
214 store_unsigned_integer (gdb_byte
*addr
, int len
,
215 enum bfd_endian byte_order
, ULONGEST val
)
218 unsigned char *startaddr
= (unsigned char *) addr
;
219 unsigned char *endaddr
= startaddr
+ len
;
221 /* Start at the least significant end of the integer, and work towards
222 the most significant. */
223 if (byte_order
== BFD_ENDIAN_BIG
)
225 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
233 for (p
= startaddr
; p
< endaddr
; ++p
)
241 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
244 store_typed_address (gdb_byte
*buf
, struct type
*type
, CORE_ADDR addr
)
246 if (TYPE_CODE (type
) != TYPE_CODE_PTR
247 && TYPE_CODE (type
) != TYPE_CODE_REF
)
248 internal_error (__FILE__
, __LINE__
,
249 _("store_typed_address: "
250 "type is not a pointer or reference"));
252 gdbarch_address_to_pointer (get_type_arch (type
), type
, buf
, addr
);
257 /* Return a `value' with the contents of (virtual or cooked) register
258 REGNUM as found in the specified FRAME. The register's type is
259 determined by register_type(). */
262 value_of_register (int regnum
, struct frame_info
*frame
)
264 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
268 struct value
*reg_val
;
270 gdb_byte raw_buffer
[MAX_REGISTER_SIZE
];
273 /* User registers lie completely outside of the range of normal
274 registers. Catch them early so that the target never sees them. */
275 if (regnum
>= gdbarch_num_regs (gdbarch
)
276 + gdbarch_num_pseudo_regs (gdbarch
))
277 return value_of_user_reg (regnum
, frame
);
279 frame_register (frame
, regnum
, &optim
, &unavail
,
280 &lval
, &addr
, &realnum
, raw_buffer
);
282 reg_val
= allocate_value (register_type (gdbarch
, regnum
));
284 if (!optim
&& !unavail
)
285 memcpy (value_contents_raw (reg_val
), raw_buffer
,
286 register_size (gdbarch
, regnum
));
288 memset (value_contents_raw (reg_val
), 0,
289 register_size (gdbarch
, regnum
));
291 VALUE_LVAL (reg_val
) = lval
;
292 set_value_address (reg_val
, addr
);
293 VALUE_REGNUM (reg_val
) = regnum
;
294 set_value_optimized_out (reg_val
, optim
);
296 mark_value_bytes_unavailable (reg_val
, 0, register_size (gdbarch
, regnum
));
297 VALUE_FRAME_ID (reg_val
) = get_frame_id (frame
);
301 /* Return a `value' with the contents of (virtual or cooked) register
302 REGNUM as found in the specified FRAME. The register's type is
303 determined by register_type(). The value is not fetched. */
306 value_of_register_lazy (struct frame_info
*frame
, int regnum
)
308 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
309 struct value
*reg_val
;
311 gdb_assert (regnum
< (gdbarch_num_regs (gdbarch
)
312 + gdbarch_num_pseudo_regs (gdbarch
)));
314 /* We should have a valid (i.e. non-sentinel) frame. */
315 gdb_assert (frame_id_p (get_frame_id (frame
)));
317 reg_val
= allocate_value_lazy (register_type (gdbarch
, regnum
));
318 VALUE_LVAL (reg_val
) = lval_register
;
319 VALUE_REGNUM (reg_val
) = regnum
;
320 VALUE_FRAME_ID (reg_val
) = get_frame_id (frame
);
324 /* Given a pointer of type TYPE in target form in BUF, return the
325 address it represents. */
327 unsigned_pointer_to_address (struct gdbarch
*gdbarch
,
328 struct type
*type
, const gdb_byte
*buf
)
330 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
332 return extract_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
);
336 signed_pointer_to_address (struct gdbarch
*gdbarch
,
337 struct type
*type
, const gdb_byte
*buf
)
339 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
341 return extract_signed_integer (buf
, TYPE_LENGTH (type
), byte_order
);
344 /* Given an address, store it as a pointer of type TYPE in target
347 unsigned_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
348 gdb_byte
*buf
, CORE_ADDR addr
)
350 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
352 store_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
356 address_to_signed_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
357 gdb_byte
*buf
, CORE_ADDR addr
)
359 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
361 store_signed_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
364 /* Will calling read_var_value or locate_var_value on SYM end
365 up caring what frame it is being evaluated relative to? SYM must
368 symbol_read_needs_frame (struct symbol
*sym
)
370 switch (SYMBOL_CLASS (sym
))
372 /* All cases listed explicitly so that gcc -Wall will detect it if
373 we failed to consider one. */
375 /* FIXME: cagney/2004-01-26: It should be possible to
376 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
377 Unfortunately DWARF 2 stores the frame-base (instead of the
378 function) location in a function's symbol. Oops! For the
379 moment enable this when/where applicable. */
380 return SYMBOL_COMPUTED_OPS (sym
)->read_needs_frame (sym
);
385 case LOC_REGPARM_ADDR
:
395 /* Getting the address of a label can be done independently of the block,
396 even if some *uses* of that address wouldn't work so well without
400 case LOC_CONST_BYTES
:
402 case LOC_OPTIMIZED_OUT
:
408 /* Given a struct symbol for a variable,
409 and a stack frame id, read the value of the variable
410 and return a (pointer to a) struct value containing the value.
411 If the variable cannot be found, throw error. */
414 read_var_value (struct symbol
*var
, struct frame_info
*frame
)
417 struct type
*type
= SYMBOL_TYPE (var
);
421 /* Call check_typedef on our type to make sure that, if TYPE is
422 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
423 instead of zero. However, we do not replace the typedef type by the
424 target type, because we want to keep the typedef in order to be able to
425 set the returned value type description correctly. */
426 check_typedef (type
);
428 len
= TYPE_LENGTH (type
);
430 if (symbol_read_needs_frame (var
))
433 switch (SYMBOL_CLASS (var
))
436 /* Put the constant back in target format. */
437 v
= allocate_value (type
);
438 store_signed_integer (value_contents_raw (v
), len
,
439 gdbarch_byte_order (get_type_arch (type
)),
440 (LONGEST
) SYMBOL_VALUE (var
));
441 VALUE_LVAL (v
) = not_lval
;
445 /* Put the constant back in target format. */
446 v
= allocate_value (type
);
447 if (overlay_debugging
)
450 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
451 SYMBOL_OBJ_SECTION (var
));
453 store_typed_address (value_contents_raw (v
), type
, addr
);
456 store_typed_address (value_contents_raw (v
), type
,
457 SYMBOL_VALUE_ADDRESS (var
));
458 VALUE_LVAL (v
) = not_lval
;
461 case LOC_CONST_BYTES
:
462 v
= allocate_value (type
);
463 memcpy (value_contents_raw (v
), SYMBOL_VALUE_BYTES (var
), len
);
464 VALUE_LVAL (v
) = not_lval
;
468 v
= allocate_value_lazy (type
);
469 if (overlay_debugging
)
470 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
471 SYMBOL_OBJ_SECTION (var
));
473 addr
= SYMBOL_VALUE_ADDRESS (var
);
477 addr
= get_frame_args_address (frame
);
479 error (_("Unknown argument list address for `%s'."),
480 SYMBOL_PRINT_NAME (var
));
481 addr
+= SYMBOL_VALUE (var
);
482 v
= allocate_value_lazy (type
);
490 argref
= get_frame_args_address (frame
);
492 error (_("Unknown argument list address for `%s'."),
493 SYMBOL_PRINT_NAME (var
));
494 argref
+= SYMBOL_VALUE (var
);
495 ref
= value_at (lookup_pointer_type (type
), argref
);
496 addr
= value_as_address (ref
);
497 v
= allocate_value_lazy (type
);
502 addr
= get_frame_locals_address (frame
);
503 addr
+= SYMBOL_VALUE (var
);
504 v
= allocate_value_lazy (type
);
508 error (_("Cannot look up value of a typedef `%s'."),
509 SYMBOL_PRINT_NAME (var
));
513 v
= allocate_value_lazy (type
);
514 if (overlay_debugging
)
515 addr
= symbol_overlayed_address
516 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_OBJ_SECTION (var
));
518 addr
= BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
522 case LOC_REGPARM_ADDR
:
524 int regno
= SYMBOL_REGISTER_OPS (var
)
525 ->register_number (var
, get_frame_arch (frame
));
526 struct value
*regval
;
528 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
530 regval
= value_from_register (lookup_pointer_type (type
),
535 error (_("Value of register variable not available for `%s'."),
536 SYMBOL_PRINT_NAME (var
));
538 addr
= value_as_address (regval
);
539 v
= allocate_value_lazy (type
);
543 regval
= value_from_register (type
, regno
, frame
);
546 error (_("Value of register variable not available for `%s'."),
547 SYMBOL_PRINT_NAME (var
));
554 /* FIXME: cagney/2004-01-26: It should be possible to
555 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
556 Unfortunately DWARF 2 stores the frame-base (instead of the
557 function) location in a function's symbol. Oops! For the
558 moment enable this when/where applicable. */
559 return SYMBOL_COMPUTED_OPS (var
)->read_variable (var
, frame
);
563 struct minimal_symbol
*msym
;
564 struct obj_section
*obj_section
;
566 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var
), NULL
, NULL
);
568 error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var
));
569 if (overlay_debugging
)
570 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
571 SYMBOL_OBJ_SECTION (msym
));
573 addr
= SYMBOL_VALUE_ADDRESS (msym
);
575 obj_section
= SYMBOL_OBJ_SECTION (msym
);
577 && (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
578 addr
= target_translate_tls_address (obj_section
->objfile
, addr
);
579 v
= allocate_value_lazy (type
);
583 case LOC_OPTIMIZED_OUT
:
584 return allocate_optimized_out_value (type
);
587 error (_("Cannot look up value of a botched symbol `%s'."),
588 SYMBOL_PRINT_NAME (var
));
592 VALUE_LVAL (v
) = lval_memory
;
593 set_value_address (v
, addr
);
597 /* Install default attributes for register values. */
600 default_value_from_register (struct type
*type
, int regnum
,
601 struct frame_info
*frame
)
603 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
604 int len
= TYPE_LENGTH (type
);
605 struct value
*value
= allocate_value (type
);
607 VALUE_LVAL (value
) = lval_register
;
608 VALUE_FRAME_ID (value
) = get_frame_id (frame
);
609 VALUE_REGNUM (value
) = regnum
;
611 /* Any structure stored in more than one register will always be
612 an integral number of registers. Otherwise, you need to do
613 some fiddling with the last register copied here for little
615 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
616 && len
< register_size (gdbarch
, regnum
))
617 /* Big-endian, and we want less than full size. */
618 set_value_offset (value
, register_size (gdbarch
, regnum
) - len
);
620 set_value_offset (value
, 0);
625 /* VALUE must be an lval_register value. If regnum is the value's
626 associated register number, and len the length of the values type,
627 read one or more registers in FRAME, starting with register REGNUM,
628 until we've read LEN bytes. */
631 read_frame_register_value (struct value
*value
, struct frame_info
*frame
)
633 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
635 int reg_offset
= value_offset (value
);
636 int regnum
= VALUE_REGNUM (value
);
637 int len
= TYPE_LENGTH (check_typedef (value_type (value
)));
639 gdb_assert (VALUE_LVAL (value
) == lval_register
);
641 /* Skip registers wholly inside of REG_OFFSET. */
642 while (reg_offset
>= register_size (gdbarch
, regnum
))
644 reg_offset
-= register_size (gdbarch
, regnum
);
651 struct value
*regval
= get_frame_register_value (frame
, regnum
);
652 int reg_len
= TYPE_LENGTH (value_type (regval
)) - reg_offset
;
654 /* If the register length is larger than the number of bytes
655 remaining to copy, then only copy the appropriate bytes. */
659 value_contents_copy (value
, offset
, regval
, reg_offset
, reg_len
);
668 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
671 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
673 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
674 struct type
*type1
= check_typedef (type
);
677 if (gdbarch_convert_register_p (gdbarch
, regnum
, type1
))
679 int optim
, unavail
, ok
;
681 /* The ISA/ABI need to something weird when obtaining the
682 specified value from this register. It might need to
683 re-order non-adjacent, starting with REGNUM (see MIPS and
684 i386). It might need to convert the [float] register into
685 the corresponding [integer] type (see Alpha). The assumption
686 is that gdbarch_register_to_value populates the entire value
687 including the location. */
688 v
= allocate_value (type
);
689 VALUE_LVAL (v
) = lval_register
;
690 VALUE_FRAME_ID (v
) = get_frame_id (frame
);
691 VALUE_REGNUM (v
) = regnum
;
692 ok
= gdbarch_register_to_value (gdbarch
, frame
, regnum
, type1
,
693 value_contents_raw (v
), &optim
,
699 set_value_optimized_out (v
, 1);
701 mark_value_bytes_unavailable (v
, 0, TYPE_LENGTH (type
));
706 /* Construct the value. */
707 v
= gdbarch_value_from_register (gdbarch
, type
, regnum
, frame
);
710 read_frame_register_value (v
, frame
);
716 /* Return contents of register REGNUM in frame FRAME as address,
717 interpreted as value of type TYPE. Will abort if register
718 value is not available. */
721 address_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
726 value
= value_from_register (type
, regnum
, frame
);
729 result
= value_as_address (value
);
730 release_value (value
);
This page took 0.044161 seconds and 4 git commands to generate.