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 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
);
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
, &lval
, &addr
, &realnum
, raw_buffer
);
281 reg_val
= allocate_value (register_type (gdbarch
, regnum
));
283 memcpy (value_contents_raw (reg_val
), raw_buffer
,
284 register_size (gdbarch
, regnum
));
285 VALUE_LVAL (reg_val
) = lval
;
286 set_value_address (reg_val
, addr
);
287 VALUE_REGNUM (reg_val
) = regnum
;
288 set_value_optimized_out (reg_val
, optim
);
289 VALUE_FRAME_ID (reg_val
) = get_frame_id (frame
);
293 /* Return a `value' with the contents of (virtual or cooked) register
294 REGNUM as found in the specified FRAME. The register's type is
295 determined by register_type(). The value is not fetched. */
298 value_of_register_lazy (struct frame_info
*frame
, int regnum
)
300 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
301 struct value
*reg_val
;
303 gdb_assert (regnum
< (gdbarch_num_regs (gdbarch
)
304 + gdbarch_num_pseudo_regs (gdbarch
)));
306 /* We should have a valid (i.e. non-sentinel) frame. */
307 gdb_assert (frame_id_p (get_frame_id (frame
)));
309 reg_val
= allocate_value (register_type (gdbarch
, regnum
));
310 VALUE_LVAL (reg_val
) = lval_register
;
311 VALUE_REGNUM (reg_val
) = regnum
;
312 VALUE_FRAME_ID (reg_val
) = get_frame_id (frame
);
313 set_value_lazy (reg_val
, 1);
317 /* Given a pointer of type TYPE in target form in BUF, return the
318 address it represents. */
320 unsigned_pointer_to_address (struct gdbarch
*gdbarch
,
321 struct type
*type
, const gdb_byte
*buf
)
323 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
324 return extract_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
);
328 signed_pointer_to_address (struct gdbarch
*gdbarch
,
329 struct type
*type
, const gdb_byte
*buf
)
331 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
332 return extract_signed_integer (buf
, TYPE_LENGTH (type
), byte_order
);
335 /* Given an address, store it as a pointer of type TYPE in target
338 unsigned_address_to_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
339 gdb_byte
*buf
, CORE_ADDR addr
)
341 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
342 store_unsigned_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
346 address_to_signed_pointer (struct gdbarch
*gdbarch
, struct type
*type
,
347 gdb_byte
*buf
, CORE_ADDR addr
)
349 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
350 store_signed_integer (buf
, TYPE_LENGTH (type
), byte_order
, addr
);
353 /* Will calling read_var_value or locate_var_value on SYM end
354 up caring what frame it is being evaluated relative to? SYM must
357 symbol_read_needs_frame (struct symbol
*sym
)
359 switch (SYMBOL_CLASS (sym
))
361 /* All cases listed explicitly so that gcc -Wall will detect it if
362 we failed to consider one. */
364 /* FIXME: cagney/2004-01-26: It should be possible to
365 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
366 Unfortunately DWARF 2 stores the frame-base (instead of the
367 function) location in a function's symbol. Oops! For the
368 moment enable this when/where applicable. */
369 return SYMBOL_COMPUTED_OPS (sym
)->read_needs_frame (sym
);
374 case LOC_REGPARM_ADDR
:
384 /* Getting the address of a label can be done independently of the block,
385 even if some *uses* of that address wouldn't work so well without
389 case LOC_CONST_BYTES
:
391 case LOC_OPTIMIZED_OUT
:
397 /* Given a struct symbol for a variable,
398 and a stack frame id, read the value of the variable
399 and return a (pointer to a) struct value containing the value.
400 If the variable cannot be found, return a zero pointer. */
403 read_var_value (struct symbol
*var
, struct frame_info
*frame
)
406 struct type
*type
= SYMBOL_TYPE (var
);
410 if (SYMBOL_CLASS (var
) == LOC_COMPUTED
411 || SYMBOL_CLASS (var
) == LOC_REGISTER
)
412 /* These cases do not use V. */
416 v
= allocate_value (type
);
417 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
420 len
= TYPE_LENGTH (type
);
422 if (symbol_read_needs_frame (var
))
425 switch (SYMBOL_CLASS (var
))
428 /* Put the constant back in target format. */
429 store_signed_integer (value_contents_raw (v
), len
,
430 gdbarch_byte_order (get_type_arch (type
)),
431 (LONGEST
) SYMBOL_VALUE (var
));
432 VALUE_LVAL (v
) = not_lval
;
436 /* Put the constant back in target format. */
437 if (overlay_debugging
)
440 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
441 SYMBOL_OBJ_SECTION (var
));
442 store_typed_address (value_contents_raw (v
), type
, addr
);
445 store_typed_address (value_contents_raw (v
), type
,
446 SYMBOL_VALUE_ADDRESS (var
));
447 VALUE_LVAL (v
) = not_lval
;
450 case LOC_CONST_BYTES
:
452 memcpy (value_contents_raw (v
), SYMBOL_VALUE_BYTES (var
), len
);
453 VALUE_LVAL (v
) = not_lval
;
458 if (overlay_debugging
)
459 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
460 SYMBOL_OBJ_SECTION (var
));
462 addr
= SYMBOL_VALUE_ADDRESS (var
);
466 addr
= get_frame_args_address (frame
);
469 addr
+= SYMBOL_VALUE (var
);
476 argref
= get_frame_args_address (frame
);
479 argref
+= SYMBOL_VALUE (var
);
480 ref
= value_at (lookup_pointer_type (type
), argref
);
481 addr
= value_as_address (ref
);
486 addr
= get_frame_locals_address (frame
);
487 addr
+= SYMBOL_VALUE (var
);
491 error (_("Cannot look up value of a typedef"));
495 if (overlay_debugging
)
496 set_value_address (v
, symbol_overlayed_address
497 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_OBJ_SECTION (var
)));
499 set_value_address (v
, BLOCK_START (SYMBOL_BLOCK_VALUE (var
)));
503 case LOC_REGPARM_ADDR
:
505 int regno
= SYMBOL_REGISTER_OPS (var
)
506 ->register_number (var
, get_frame_arch (frame
));
507 struct value
*regval
;
509 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
511 regval
= value_from_register (lookup_pointer_type (type
),
516 error (_("Value of register variable not available."));
518 addr
= value_as_address (regval
);
519 VALUE_LVAL (v
) = lval_memory
;
523 regval
= value_from_register (type
, regno
, frame
);
526 error (_("Value of register variable not available."));
533 /* FIXME: cagney/2004-01-26: It should be possible to
534 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
535 Unfortunately DWARF 2 stores the frame-base (instead of the
536 function) location in a function's symbol. Oops! For the
537 moment enable this when/where applicable. */
538 return SYMBOL_COMPUTED_OPS (var
)->read_variable (var
, frame
);
542 struct minimal_symbol
*msym
;
543 struct obj_section
*obj_section
;
545 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var
), NULL
, NULL
);
548 if (overlay_debugging
)
549 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
550 SYMBOL_OBJ_SECTION (msym
));
552 addr
= SYMBOL_VALUE_ADDRESS (msym
);
554 obj_section
= SYMBOL_OBJ_SECTION (msym
);
556 && (obj_section
->the_bfd_section
->flags
& SEC_THREAD_LOCAL
) != 0)
557 addr
= target_translate_tls_address (obj_section
->objfile
, addr
);
561 case LOC_OPTIMIZED_OUT
:
562 VALUE_LVAL (v
) = not_lval
;
563 set_value_optimized_out (v
, 1);
567 error (_("Cannot look up value of a botched symbol."));
571 set_value_address (v
, addr
);
572 set_value_lazy (v
, 1);
576 /* Install default attributes for register values. */
579 default_value_from_register (struct type
*type
, int regnum
,
580 struct frame_info
*frame
)
582 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
583 int len
= TYPE_LENGTH (type
);
584 struct value
*value
= allocate_value (type
);
586 VALUE_LVAL (value
) = lval_register
;
587 VALUE_FRAME_ID (value
) = get_frame_id (frame
);
588 VALUE_REGNUM (value
) = regnum
;
590 /* Any structure stored in more than one register will always be
591 an integral number of registers. Otherwise, you need to do
592 some fiddling with the last register copied here for little
594 if (gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
595 && len
< register_size (gdbarch
, regnum
))
596 /* Big-endian, and we want less than full size. */
597 set_value_offset (value
, register_size (gdbarch
, regnum
) - len
);
599 set_value_offset (value
, 0);
604 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
607 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
609 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
610 struct type
*type1
= check_typedef (type
);
613 if (gdbarch_convert_register_p (gdbarch
, regnum
, type1
))
615 /* The ISA/ABI need to something weird when obtaining the
616 specified value from this register. It might need to
617 re-order non-adjacent, starting with REGNUM (see MIPS and
618 i386). It might need to convert the [float] register into
619 the corresponding [integer] type (see Alpha). The assumption
620 is that gdbarch_register_to_value populates the entire value
621 including the location. */
622 v
= allocate_value (type
);
623 VALUE_LVAL (v
) = lval_register
;
624 VALUE_FRAME_ID (v
) = get_frame_id (frame
);
625 VALUE_REGNUM (v
) = regnum
;
626 gdbarch_register_to_value (gdbarch
,
627 frame
, regnum
, type1
, value_contents_raw (v
));
631 int len
= TYPE_LENGTH (type
);
633 /* Construct the value. */
634 v
= gdbarch_value_from_register (gdbarch
, type
, regnum
, frame
);
637 if (!get_frame_register_bytes (frame
, regnum
, value_offset (v
), len
,
638 value_contents_raw (v
)))
639 set_value_optimized_out (v
, 1);
644 /* Return contents of register REGNUM in frame FRAME as address,
645 interpreted as value of type TYPE. Will abort if register
646 value is not available. */
649 address_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
654 value
= value_from_register (type
, regnum
, frame
);
657 result
= value_as_address (value
);
658 release_value (value
);
This page took 0.042218 seconds and 4 git commands to generate.