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, 2011 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);
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 /* Given a struct symbol for a variable,
410 and a stack frame id, read the value of the variable
411 and return a (pointer to a) struct value containing the value.
412 If the variable cannot be found, throw error. */
415 read_var_value (struct symbol *var, struct frame_info *frame)
418 struct type *type = SYMBOL_TYPE (var);
422 /* Call check_typedef on our type to make sure that, if TYPE is
423 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
424 instead of zero. However, we do not replace the typedef type by the
425 target type, because we want to keep the typedef in order to be able to
426 set the returned value type description correctly. */
427 check_typedef (type);
429 len = TYPE_LENGTH (type);
431 if (symbol_read_needs_frame (var))
434 switch (SYMBOL_CLASS (var))
437 /* Put the constant back in target format. */
438 v = allocate_value (type);
439 store_signed_integer (value_contents_raw (v), len,
440 gdbarch_byte_order (get_type_arch (type)),
441 (LONGEST) SYMBOL_VALUE (var));
442 VALUE_LVAL (v) = not_lval;
446 /* Put the constant back in target format. */
447 v = allocate_value (type);
448 if (overlay_debugging)
451 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
452 SYMBOL_OBJ_SECTION (var));
454 store_typed_address (value_contents_raw (v), type, addr);
457 store_typed_address (value_contents_raw (v), type,
458 SYMBOL_VALUE_ADDRESS (var));
459 VALUE_LVAL (v) = not_lval;
462 case LOC_CONST_BYTES:
463 v = allocate_value (type);
464 memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len);
465 VALUE_LVAL (v) = not_lval;
469 v = allocate_value_lazy (type);
470 if (overlay_debugging)
471 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
472 SYMBOL_OBJ_SECTION (var));
474 addr = SYMBOL_VALUE_ADDRESS (var);
478 addr = get_frame_args_address (frame);
480 error (_("Unknown argument list address for `%s'."),
481 SYMBOL_PRINT_NAME (var));
482 addr += SYMBOL_VALUE (var);
483 v = allocate_value_lazy (type);
491 argref = get_frame_args_address (frame);
493 error (_("Unknown argument list address for `%s'."),
494 SYMBOL_PRINT_NAME (var));
495 argref += SYMBOL_VALUE (var);
496 ref = value_at (lookup_pointer_type (type), argref);
497 addr = value_as_address (ref);
498 v = allocate_value_lazy (type);
503 addr = get_frame_locals_address (frame);
504 addr += SYMBOL_VALUE (var);
505 v = allocate_value_lazy (type);
509 error (_("Cannot look up value of a typedef `%s'."),
510 SYMBOL_PRINT_NAME (var));
514 v = allocate_value_lazy (type);
515 if (overlay_debugging)
516 addr = symbol_overlayed_address
517 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var));
519 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
523 case LOC_REGPARM_ADDR:
525 int regno = SYMBOL_REGISTER_OPS (var)
526 ->register_number (var, get_frame_arch (frame));
527 struct value *regval;
529 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
531 regval = value_from_register (lookup_pointer_type (type),
536 error (_("Value of register variable not available for `%s'."),
537 SYMBOL_PRINT_NAME (var));
539 addr = value_as_address (regval);
540 v = allocate_value_lazy (type);
544 regval = value_from_register (type, regno, frame);
547 error (_("Value of register variable not available for `%s'."),
548 SYMBOL_PRINT_NAME (var));
555 /* FIXME: cagney/2004-01-26: It should be possible to
556 unconditionally call the SYMBOL_COMPUTED_OPS method when available.
557 Unfortunately DWARF 2 stores the frame-base (instead of the
558 function) location in a function's symbol. Oops! For the
559 moment enable this when/where applicable. */
560 return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
564 struct minimal_symbol *msym;
565 struct obj_section *obj_section;
567 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
569 error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var));
570 if (overlay_debugging)
571 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
572 SYMBOL_OBJ_SECTION (msym));
574 addr = SYMBOL_VALUE_ADDRESS (msym);
576 obj_section = SYMBOL_OBJ_SECTION (msym);
578 && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
579 addr = target_translate_tls_address (obj_section->objfile, addr);
580 v = allocate_value_lazy (type);
584 case LOC_OPTIMIZED_OUT:
585 return allocate_optimized_out_value (type);
588 error (_("Cannot look up value of a botched symbol `%s'."),
589 SYMBOL_PRINT_NAME (var));
593 VALUE_LVAL (v) = lval_memory;
594 set_value_address (v, addr);
598 /* Install default attributes for register values. */
601 default_value_from_register (struct type *type, int regnum,
602 struct frame_info *frame)
604 struct gdbarch *gdbarch = get_frame_arch (frame);
605 int len = TYPE_LENGTH (type);
606 struct value *value = allocate_value (type);
608 VALUE_LVAL (value) = lval_register;
609 VALUE_FRAME_ID (value) = get_frame_id (frame);
610 VALUE_REGNUM (value) = regnum;
612 /* Any structure stored in more than one register will always be
613 an integral number of registers. Otherwise, you need to do
614 some fiddling with the last register copied here for little
616 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
617 && len < register_size (gdbarch, regnum))
618 /* Big-endian, and we want less than full size. */
619 set_value_offset (value, register_size (gdbarch, regnum) - len);
621 set_value_offset (value, 0);
626 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
629 value_from_register (struct type *type, int regnum, struct frame_info *frame)
631 struct gdbarch *gdbarch = get_frame_arch (frame);
632 struct type *type1 = check_typedef (type);
635 if (gdbarch_convert_register_p (gdbarch, regnum, type1))
637 int optim, unavail, ok;
639 /* The ISA/ABI need to something weird when obtaining the
640 specified value from this register. It might need to
641 re-order non-adjacent, starting with REGNUM (see MIPS and
642 i386). It might need to convert the [float] register into
643 the corresponding [integer] type (see Alpha). The assumption
644 is that gdbarch_register_to_value populates the entire value
645 including the location. */
646 v = allocate_value (type);
647 VALUE_LVAL (v) = lval_register;
648 VALUE_FRAME_ID (v) = get_frame_id (frame);
649 VALUE_REGNUM (v) = regnum;
650 ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
651 value_contents_raw (v), &optim,
657 set_value_optimized_out (v, 1);
659 mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
664 int len = TYPE_LENGTH (type);
667 /* Construct the value. */
668 v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
671 v2 = get_frame_register_value (frame, regnum);
673 value_contents_copy (v, 0, v2, value_offset (v), len);
679 /* Return contents of register REGNUM in frame FRAME as address,
680 interpreted as value of type TYPE. Will abort if register
681 value is not available. */
684 address_from_register (struct type *type, int regnum, struct frame_info *frame)
689 value = value_from_register (type, regnum, frame);
692 result = value_as_address (value);
693 release_value (value);