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 "gdb_assert.h"
30 #include "floatformat.h"
31 #include "symfile.h" /* for overlay functions */
33 #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);
265 struct value *reg_val;
267 /* User registers lie completely outside of the range of normal
268 registers. Catch them early so that the target never sees them. */
269 if (regnum >= gdbarch_num_regs (gdbarch)
270 + gdbarch_num_pseudo_regs (gdbarch))
271 return value_of_user_reg (regnum, frame);
273 reg_val = value_of_register_lazy (frame, regnum);
274 value_fetch_lazy (reg_val);
278 /* Return a `value' with the contents of (virtual or cooked) register
279 REGNUM as found in the specified FRAME. The register's type is
280 determined by register_type(). The value is not fetched. */
283 value_of_register_lazy (struct frame_info *frame, int regnum)
285 struct gdbarch *gdbarch = get_frame_arch (frame);
286 struct value *reg_val;
288 gdb_assert (regnum < (gdbarch_num_regs (gdbarch)
289 + gdbarch_num_pseudo_regs (gdbarch)));
291 /* We should have a valid (i.e. non-sentinel) frame. */
292 gdb_assert (frame_id_p (get_frame_id (frame)));
294 reg_val = allocate_value_lazy (register_type (gdbarch, regnum));
295 VALUE_LVAL (reg_val) = lval_register;
296 VALUE_REGNUM (reg_val) = regnum;
297 VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
301 /* Given a pointer of type TYPE in target form in BUF, return the
302 address it represents. */
304 unsigned_pointer_to_address (struct gdbarch *gdbarch,
305 struct type *type, const gdb_byte *buf)
307 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
309 return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
313 signed_pointer_to_address (struct gdbarch *gdbarch,
314 struct type *type, const gdb_byte *buf)
316 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
318 return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
321 /* Given an address, store it as a pointer of type TYPE in target
324 unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type,
325 gdb_byte *buf, CORE_ADDR addr)
327 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
329 store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
333 address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type,
334 gdb_byte *buf, CORE_ADDR addr)
336 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
338 store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr);
341 /* Will calling read_var_value or locate_var_value on SYM end
342 up caring what frame it is being evaluated relative to? SYM must
345 symbol_read_needs_frame (struct symbol *sym)
347 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
348 return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym);
350 switch (SYMBOL_CLASS (sym))
352 /* All cases listed explicitly so that gcc -Wall will detect it if
353 we failed to consider one. */
355 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
360 case LOC_REGPARM_ADDR:
370 /* Getting the address of a label can be done independently of the block,
371 even if some *uses* of that address wouldn't work so well without
375 case LOC_CONST_BYTES:
377 case LOC_OPTIMIZED_OUT:
383 /* Private data to be used with minsym_lookup_iterator_cb. */
385 struct minsym_lookup_data
387 /* The name of the minimal symbol we are searching for. */
390 /* The field where the callback should store the minimal symbol
391 if found. It should be initialized to NULL before the search
393 struct bound_minimal_symbol result;
396 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
397 It searches by name for a minimal symbol within the given OBJFILE.
398 The arguments are passed via CB_DATA, which in reality is a pointer
399 to struct minsym_lookup_data. */
402 minsym_lookup_iterator_cb (struct objfile *objfile, void *cb_data)
404 struct minsym_lookup_data *data = (struct minsym_lookup_data *) cb_data;
406 gdb_assert (data->result.minsym == NULL);
408 data->result = lookup_minimal_symbol (data->name, NULL, objfile);
410 /* The iterator should stop iff a match was found. */
411 return (data->result.minsym != NULL);
414 /* A default implementation for the "la_read_var_value" hook in
415 the language vector which should work in most situations. */
418 default_read_var_value (struct symbol *var, struct frame_info *frame)
421 struct type *type = SYMBOL_TYPE (var);
424 /* Call check_typedef on our type to make sure that, if TYPE is
425 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
426 instead of zero. However, we do not replace the typedef type by the
427 target type, because we want to keep the typedef in order to be able to
428 set the returned value type description correctly. */
429 check_typedef (type);
431 if (symbol_read_needs_frame (var))
434 if (SYMBOL_COMPUTED_OPS (var) != NULL)
435 return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
437 switch (SYMBOL_CLASS (var))
440 /* Put the constant back in target format. */
441 v = allocate_value (type);
442 store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type),
443 gdbarch_byte_order (get_type_arch (type)),
444 (LONGEST) SYMBOL_VALUE (var));
445 VALUE_LVAL (v) = not_lval;
449 /* Put the constant back in target format. */
450 v = allocate_value (type);
451 if (overlay_debugging)
454 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
455 SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
458 store_typed_address (value_contents_raw (v), type, addr);
461 store_typed_address (value_contents_raw (v), type,
462 SYMBOL_VALUE_ADDRESS (var));
463 VALUE_LVAL (v) = not_lval;
466 case LOC_CONST_BYTES:
467 v = allocate_value (type);
468 memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
470 VALUE_LVAL (v) = not_lval;
474 if (overlay_debugging)
475 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
476 SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
479 addr = SYMBOL_VALUE_ADDRESS (var);
483 addr = get_frame_args_address (frame);
485 error (_("Unknown argument list address for `%s'."),
486 SYMBOL_PRINT_NAME (var));
487 addr += SYMBOL_VALUE (var);
495 argref = get_frame_args_address (frame);
497 error (_("Unknown argument list address for `%s'."),
498 SYMBOL_PRINT_NAME (var));
499 argref += SYMBOL_VALUE (var);
500 ref = value_at (lookup_pointer_type (type), argref);
501 addr = value_as_address (ref);
506 addr = get_frame_locals_address (frame);
507 addr += SYMBOL_VALUE (var);
511 error (_("Cannot look up value of a typedef `%s'."),
512 SYMBOL_PRINT_NAME (var));
516 if (overlay_debugging)
517 addr = symbol_overlayed_address
518 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
521 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
525 case LOC_REGPARM_ADDR:
527 int regno = SYMBOL_REGISTER_OPS (var)
528 ->register_number (var, get_frame_arch (frame));
529 struct value *regval;
531 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
533 regval = value_from_register (lookup_pointer_type (type),
538 error (_("Value of register variable not available for `%s'."),
539 SYMBOL_PRINT_NAME (var));
541 addr = value_as_address (regval);
545 regval = value_from_register (type, regno, frame);
548 error (_("Value of register variable not available for `%s'."),
549 SYMBOL_PRINT_NAME (var));
556 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
560 struct minsym_lookup_data lookup_data;
561 struct minimal_symbol *msym;
562 struct obj_section *obj_section;
564 memset (&lookup_data, 0, sizeof (lookup_data));
565 lookup_data.name = SYMBOL_LINKAGE_NAME (var);
567 gdbarch_iterate_over_objfiles_in_search_order
568 (get_objfile_arch (SYMBOL_SYMTAB (var)->objfile),
569 minsym_lookup_iterator_cb, &lookup_data,
570 SYMBOL_SYMTAB (var)->objfile);
571 msym = lookup_data.result.minsym;
574 error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var));
575 if (overlay_debugging)
576 addr = symbol_overlayed_address (BMSYMBOL_VALUE_ADDRESS (lookup_data.result),
577 MSYMBOL_OBJ_SECTION (lookup_data.result.objfile,
580 addr = BMSYMBOL_VALUE_ADDRESS (lookup_data.result);
582 obj_section = MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, msym);
584 && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
585 addr = target_translate_tls_address (obj_section->objfile, addr);
589 case LOC_OPTIMIZED_OUT:
590 return allocate_optimized_out_value (type);
593 error (_("Cannot look up value of a botched symbol `%s'."),
594 SYMBOL_PRINT_NAME (var));
598 v = value_at_lazy (type, addr);
602 /* Calls VAR's language la_read_var_value hook with the given arguments. */
605 read_var_value (struct symbol *var, struct frame_info *frame)
607 const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var));
609 gdb_assert (lang != NULL);
610 gdb_assert (lang->la_read_var_value != NULL);
612 return lang->la_read_var_value (var, frame);
615 /* Install default attributes for register values. */
618 default_value_from_register (struct type *type, int regnum,
619 struct frame_info *frame)
621 struct gdbarch *gdbarch = get_frame_arch (frame);
622 int len = TYPE_LENGTH (type);
623 struct value *value = allocate_value (type);
625 VALUE_LVAL (value) = lval_register;
626 VALUE_FRAME_ID (value) = get_frame_id (frame);
627 VALUE_REGNUM (value) = regnum;
629 /* Any structure stored in more than one register will always be
630 an integral number of registers. Otherwise, you need to do
631 some fiddling with the last register copied here for little
633 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
634 && len < register_size (gdbarch, regnum))
635 /* Big-endian, and we want less than full size. */
636 set_value_offset (value, register_size (gdbarch, regnum) - len);
638 set_value_offset (value, 0);
643 /* VALUE must be an lval_register value. If regnum is the value's
644 associated register number, and len the length of the values type,
645 read one or more registers in FRAME, starting with register REGNUM,
646 until we've read LEN bytes.
648 If any of the registers we try to read are optimized out, then mark the
649 complete resulting value as optimized out. */
652 read_frame_register_value (struct value *value, struct frame_info *frame)
654 struct gdbarch *gdbarch = get_frame_arch (frame);
656 int reg_offset = value_offset (value);
657 int regnum = VALUE_REGNUM (value);
658 int len = TYPE_LENGTH (check_typedef (value_type (value)));
660 gdb_assert (VALUE_LVAL (value) == lval_register);
662 /* Skip registers wholly inside of REG_OFFSET. */
663 while (reg_offset >= register_size (gdbarch, regnum))
665 reg_offset -= register_size (gdbarch, regnum);
672 struct value *regval = get_frame_register_value (frame, regnum);
673 int reg_len = TYPE_LENGTH (value_type (regval)) - reg_offset;
675 if (value_optimized_out (regval))
677 set_value_optimized_out (value, 1);
681 /* If the register length is larger than the number of bytes
682 remaining to copy, then only copy the appropriate bytes. */
686 value_contents_copy (value, offset, regval, reg_offset, reg_len);
695 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
698 value_from_register (struct type *type, int regnum, struct frame_info *frame)
700 struct gdbarch *gdbarch = get_frame_arch (frame);
701 struct type *type1 = check_typedef (type);
704 if (gdbarch_convert_register_p (gdbarch, regnum, type1))
706 int optim, unavail, ok;
708 /* The ISA/ABI need to something weird when obtaining the
709 specified value from this register. It might need to
710 re-order non-adjacent, starting with REGNUM (see MIPS and
711 i386). It might need to convert the [float] register into
712 the corresponding [integer] type (see Alpha). The assumption
713 is that gdbarch_register_to_value populates the entire value
714 including the location. */
715 v = allocate_value (type);
716 VALUE_LVAL (v) = lval_register;
717 VALUE_FRAME_ID (v) = get_frame_id (frame);
718 VALUE_REGNUM (v) = regnum;
719 ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
720 value_contents_raw (v), &optim,
726 set_value_optimized_out (v, 1);
728 mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
733 /* Construct the value. */
734 v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
737 read_frame_register_value (v, frame);
743 /* Return contents of register REGNUM in frame FRAME as address,
744 interpreted as value of type TYPE. Will abort if register
745 value is not available. */
748 address_from_register (struct type *type, int regnum, struct frame_info *frame)
753 value = value_from_register (type, regnum, frame);
756 if (value_optimized_out (value))
758 /* This function is used while computing a location expression.
759 Complain about the value being optimized out, rather than
760 letting value_as_address complain about some random register
761 the expression depends on not being saved. */
762 error_value_optimized_out ();
765 result = value_as_address (value);
766 release_value (value);