1 /* Find a variable's value in memory, for GDB, the GNU debugger.
3 Copyright (C) 1986-2013 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/>. */
28 #include "gdb_string.h"
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);
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 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
371 return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym);
373 switch (SYMBOL_CLASS (sym))
375 /* All cases listed explicitly so that gcc -Wall will detect it if
376 we failed to consider one. */
378 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
383 case LOC_REGPARM_ADDR:
393 /* Getting the address of a label can be done independently of the block,
394 even if some *uses* of that address wouldn't work so well without
398 case LOC_CONST_BYTES:
400 case LOC_OPTIMIZED_OUT:
406 /* Private data to be used with minsym_lookup_iterator_cb. */
408 struct minsym_lookup_data
410 /* The name of the minimal symbol we are searching for. */
413 /* The field where the callback should store the minimal symbol
414 if found. It should be initialized to NULL before the search
416 struct minimal_symbol *result;
419 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
420 It searches by name for a minimal symbol within the given OBJFILE.
421 The arguments are passed via CB_DATA, which in reality is a pointer
422 to struct minsym_lookup_data. */
425 minsym_lookup_iterator_cb (struct objfile *objfile, void *cb_data)
427 struct minsym_lookup_data *data = (struct minsym_lookup_data *) cb_data;
429 gdb_assert (data->result == NULL);
431 data->result = lookup_minimal_symbol (data->name, NULL, objfile);
433 /* The iterator should stop iff a match was found. */
434 return (data->result != NULL);
437 /* A default implementation for the "la_read_var_value" hook in
438 the language vector which should work in most situations. */
441 default_read_var_value (struct symbol *var, struct frame_info *frame)
444 struct type *type = SYMBOL_TYPE (var);
447 /* Call check_typedef on our type to make sure that, if TYPE is
448 a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
449 instead of zero. However, we do not replace the typedef type by the
450 target type, because we want to keep the typedef in order to be able to
451 set the returned value type description correctly. */
452 check_typedef (type);
454 if (symbol_read_needs_frame (var))
457 if (SYMBOL_COMPUTED_OPS (var) != NULL)
458 return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
460 switch (SYMBOL_CLASS (var))
463 /* Put the constant back in target format. */
464 v = allocate_value (type);
465 store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type),
466 gdbarch_byte_order (get_type_arch (type)),
467 (LONGEST) SYMBOL_VALUE (var));
468 VALUE_LVAL (v) = not_lval;
472 /* Put the constant back in target format. */
473 v = allocate_value (type);
474 if (overlay_debugging)
477 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
478 SYMBOL_OBJ_SECTION (var));
480 store_typed_address (value_contents_raw (v), type, addr);
483 store_typed_address (value_contents_raw (v), type,
484 SYMBOL_VALUE_ADDRESS (var));
485 VALUE_LVAL (v) = not_lval;
488 case LOC_CONST_BYTES:
489 v = allocate_value (type);
490 memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
492 VALUE_LVAL (v) = not_lval;
496 v = allocate_value_lazy (type);
497 if (overlay_debugging)
498 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
499 SYMBOL_OBJ_SECTION (var));
501 addr = SYMBOL_VALUE_ADDRESS (var);
505 addr = get_frame_args_address (frame);
507 error (_("Unknown argument list address for `%s'."),
508 SYMBOL_PRINT_NAME (var));
509 addr += SYMBOL_VALUE (var);
510 v = allocate_value_lazy (type);
518 argref = get_frame_args_address (frame);
520 error (_("Unknown argument list address for `%s'."),
521 SYMBOL_PRINT_NAME (var));
522 argref += SYMBOL_VALUE (var);
523 ref = value_at (lookup_pointer_type (type), argref);
524 addr = value_as_address (ref);
525 v = allocate_value_lazy (type);
530 addr = get_frame_locals_address (frame);
531 addr += SYMBOL_VALUE (var);
532 v = allocate_value_lazy (type);
536 error (_("Cannot look up value of a typedef `%s'."),
537 SYMBOL_PRINT_NAME (var));
541 v = allocate_value_lazy (type);
542 if (overlay_debugging)
543 addr = symbol_overlayed_address
544 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var));
546 addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
550 case LOC_REGPARM_ADDR:
552 int regno = SYMBOL_REGISTER_OPS (var)
553 ->register_number (var, get_frame_arch (frame));
554 struct value *regval;
556 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
558 regval = value_from_register (lookup_pointer_type (type),
563 error (_("Value of register variable not available for `%s'."),
564 SYMBOL_PRINT_NAME (var));
566 addr = value_as_address (regval);
567 v = allocate_value_lazy (type);
571 regval = value_from_register (type, regno, frame);
574 error (_("Value of register variable not available for `%s'."),
575 SYMBOL_PRINT_NAME (var));
582 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
586 struct minsym_lookup_data lookup_data;
587 struct minimal_symbol *msym;
588 struct obj_section *obj_section;
590 memset (&lookup_data, 0, sizeof (lookup_data));
591 lookup_data.name = SYMBOL_LINKAGE_NAME (var);
593 gdbarch_iterate_over_objfiles_in_search_order
594 (get_objfile_arch (SYMBOL_SYMTAB (var)->objfile),
595 minsym_lookup_iterator_cb, &lookup_data,
596 SYMBOL_SYMTAB (var)->objfile);
597 msym = lookup_data.result;
600 error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var));
601 if (overlay_debugging)
602 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
603 SYMBOL_OBJ_SECTION (msym));
605 addr = SYMBOL_VALUE_ADDRESS (msym);
607 obj_section = SYMBOL_OBJ_SECTION (msym);
609 && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
610 addr = target_translate_tls_address (obj_section->objfile, addr);
611 v = allocate_value_lazy (type);
615 case LOC_OPTIMIZED_OUT:
616 return allocate_optimized_out_value (type);
619 error (_("Cannot look up value of a botched symbol `%s'."),
620 SYMBOL_PRINT_NAME (var));
624 VALUE_LVAL (v) = lval_memory;
625 set_value_address (v, addr);
629 /* Calls VAR's language la_read_var_value hook with the given arguments. */
632 read_var_value (struct symbol *var, struct frame_info *frame)
634 const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var));
636 gdb_assert (lang != NULL);
637 gdb_assert (lang->la_read_var_value != NULL);
639 return lang->la_read_var_value (var, frame);
642 /* Install default attributes for register values. */
645 default_value_from_register (struct type *type, int regnum,
646 struct frame_info *frame)
648 struct gdbarch *gdbarch = get_frame_arch (frame);
649 int len = TYPE_LENGTH (type);
650 struct value *value = allocate_value (type);
652 VALUE_LVAL (value) = lval_register;
653 VALUE_FRAME_ID (value) = get_frame_id (frame);
654 VALUE_REGNUM (value) = regnum;
656 /* Any structure stored in more than one register will always be
657 an integral number of registers. Otherwise, you need to do
658 some fiddling with the last register copied here for little
660 if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
661 && len < register_size (gdbarch, regnum))
662 /* Big-endian, and we want less than full size. */
663 set_value_offset (value, register_size (gdbarch, regnum) - len);
665 set_value_offset (value, 0);
670 /* VALUE must be an lval_register value. If regnum is the value's
671 associated register number, and len the length of the values type,
672 read one or more registers in FRAME, starting with register REGNUM,
673 until we've read LEN bytes.
675 If any of the registers we try to read are optimized out, then mark the
676 complete resulting value as optimized out. */
679 read_frame_register_value (struct value *value, struct frame_info *frame)
681 struct gdbarch *gdbarch = get_frame_arch (frame);
683 int reg_offset = value_offset (value);
684 int regnum = VALUE_REGNUM (value);
685 int len = TYPE_LENGTH (check_typedef (value_type (value)));
687 gdb_assert (VALUE_LVAL (value) == lval_register);
689 /* Skip registers wholly inside of REG_OFFSET. */
690 while (reg_offset >= register_size (gdbarch, regnum))
692 reg_offset -= register_size (gdbarch, regnum);
699 struct value *regval = get_frame_register_value (frame, regnum);
700 int reg_len = TYPE_LENGTH (value_type (regval)) - reg_offset;
702 if (value_optimized_out (regval))
704 set_value_optimized_out (value, 1);
708 /* If the register length is larger than the number of bytes
709 remaining to copy, then only copy the appropriate bytes. */
713 value_contents_copy (value, offset, regval, reg_offset, reg_len);
722 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
725 value_from_register (struct type *type, int regnum, struct frame_info *frame)
727 struct gdbarch *gdbarch = get_frame_arch (frame);
728 struct type *type1 = check_typedef (type);
731 if (gdbarch_convert_register_p (gdbarch, regnum, type1))
733 int optim, unavail, ok;
735 /* The ISA/ABI need to something weird when obtaining the
736 specified value from this register. It might need to
737 re-order non-adjacent, starting with REGNUM (see MIPS and
738 i386). It might need to convert the [float] register into
739 the corresponding [integer] type (see Alpha). The assumption
740 is that gdbarch_register_to_value populates the entire value
741 including the location. */
742 v = allocate_value (type);
743 VALUE_LVAL (v) = lval_register;
744 VALUE_FRAME_ID (v) = get_frame_id (frame);
745 VALUE_REGNUM (v) = regnum;
746 ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
747 value_contents_raw (v), &optim,
753 set_value_optimized_out (v, 1);
755 mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
760 /* Construct the value. */
761 v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
764 read_frame_register_value (v, frame);
770 /* Return contents of register REGNUM in frame FRAME as address,
771 interpreted as value of type TYPE. Will abort if register
772 value is not available. */
775 address_from_register (struct type *type, int regnum, struct frame_info *frame)
780 value = value_from_register (type, regnum, frame);
783 result = value_as_address (value);
784 release_value (value);