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
5 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 2 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, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor,
22 Boston, MA 02110-1301, USA. */
32 #include "gdb_string.h"
33 #include "gdb_assert.h"
34 #include "floatformat.h"
35 #include "symfile.h" /* for overlay functions */
37 #include "user-regs.h"
40 /* Basic byte-swapping routines. GDB has needed these for a long time...
41 All extract a target-format integer at ADDR which is LEN bytes long. */
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)
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 (TARGET_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)
89 const unsigned char *p;
90 const unsigned char *startaddr = addr;
91 const unsigned char *endaddr = startaddr + len;
93 if (len > (int) sizeof (ULONGEST))
95 That operation is not available on integers of more than %d bytes."),
96 (int) sizeof (ULONGEST));
98 /* Start at the most significant end of the integer, and work towards
99 the least significant. */
101 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
103 for (p = startaddr; p < endaddr; ++p)
104 retval = (retval << 8) | *p;
108 for (p = endaddr - 1; p >= startaddr; --p)
109 retval = (retval << 8) | *p;
114 /* Sometimes a long long unsigned integer can be extracted as a
115 LONGEST value. This is done so that we can print these values
116 better. If this integer can be converted to a LONGEST, this
117 function returns 1 and sets *PVAL. Otherwise it returns 0. */
120 extract_long_unsigned_integer (const gdb_byte *addr, int orig_len,
124 const gdb_byte *first_addr;
128 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
131 len > (int) sizeof (LONGEST) && p < addr + orig_len;
144 for (p = addr + orig_len - 1;
145 len > (int) sizeof (LONGEST) && p >= addr;
155 if (len <= (int) sizeof (LONGEST))
157 *pval = (LONGEST) extract_unsigned_integer (first_addr,
166 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
167 address it represents. */
169 extract_typed_address (const gdb_byte *buf, struct type *type)
171 if (TYPE_CODE (type) != TYPE_CODE_PTR
172 && TYPE_CODE (type) != TYPE_CODE_REF)
173 internal_error (__FILE__, __LINE__,
174 _("extract_typed_address: "
175 "type is not a pointer or reference"));
177 return POINTER_TO_ADDRESS (type, buf);
182 store_signed_integer (gdb_byte *addr, int len, LONGEST val)
185 gdb_byte *startaddr = addr;
186 gdb_byte *endaddr = startaddr + len;
188 /* Start at the least significant end of the integer, and work towards
189 the most significant. */
190 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
192 for (p = endaddr - 1; p >= startaddr; --p)
200 for (p = startaddr; p < endaddr; ++p)
209 store_unsigned_integer (gdb_byte *addr, int len, ULONGEST val)
212 unsigned char *startaddr = (unsigned char *) addr;
213 unsigned char *endaddr = startaddr + len;
215 /* Start at the least significant end of the integer, and work towards
216 the most significant. */
217 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
219 for (p = endaddr - 1; p >= startaddr; --p)
227 for (p = startaddr; p < endaddr; ++p)
235 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
238 store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
240 if (TYPE_CODE (type) != TYPE_CODE_PTR
241 && TYPE_CODE (type) != TYPE_CODE_REF)
242 internal_error (__FILE__, __LINE__,
243 _("store_typed_address: "
244 "type is not a pointer or reference"));
246 ADDRESS_TO_POINTER (type, buf, addr);
251 /* Return a `value' with the contents of (virtual or cooked) register
252 REGNUM as found in the specified FRAME. The register's type is
253 determined by register_type(). */
256 value_of_register (int regnum, struct frame_info *frame)
260 struct value *reg_val;
262 gdb_byte raw_buffer[MAX_REGISTER_SIZE];
265 /* User registers lie completely outside of the range of normal
266 registers. Catch them early so that the target never sees them. */
267 if (regnum >= NUM_REGS + NUM_PSEUDO_REGS)
268 return value_of_user_reg (regnum, frame);
270 frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
272 reg_val = allocate_value (register_type (current_gdbarch, regnum));
274 memcpy (value_contents_raw (reg_val), raw_buffer,
275 register_size (current_gdbarch, regnum));
276 VALUE_LVAL (reg_val) = lval;
277 VALUE_ADDRESS (reg_val) = addr;
278 VALUE_REGNUM (reg_val) = regnum;
279 set_value_optimized_out (reg_val, optim);
280 VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
284 /* Given a pointer of type TYPE in target form in BUF, return the
285 address it represents. */
287 unsigned_pointer_to_address (struct type *type, const gdb_byte *buf)
289 return extract_unsigned_integer (buf, TYPE_LENGTH (type));
293 signed_pointer_to_address (struct type *type, const gdb_byte *buf)
295 return extract_signed_integer (buf, TYPE_LENGTH (type));
298 /* Given an address, store it as a pointer of type TYPE in target
301 unsigned_address_to_pointer (struct type *type, gdb_byte *buf,
304 store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
308 address_to_signed_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
310 store_signed_integer (buf, TYPE_LENGTH (type), addr);
313 /* Will calling read_var_value or locate_var_value on SYM end
314 up caring what frame it is being evaluated relative to? SYM must
317 symbol_read_needs_frame (struct symbol *sym)
319 switch (SYMBOL_CLASS (sym))
321 /* All cases listed explicitly so that gcc -Wall will detect it if
322 we failed to consider one. */
324 case LOC_COMPUTED_ARG:
325 /* FIXME: cagney/2004-01-26: It should be possible to
326 unconditionally call the SYMBOL_OPS method when available.
327 Unfortunately DWARF 2 stores the frame-base (instead of the
328 function) location in a function's symbol. Oops! For the
329 moment enable this when/where applicable. */
330 return SYMBOL_OPS (sym)->read_needs_frame (sym);
336 case LOC_REGPARM_ADDR:
340 case LOC_BASEREG_ARG:
341 case LOC_HP_THREAD_LOCAL_STATIC:
351 /* Getting the address of a label can be done independently of the block,
352 even if some *uses* of that address wouldn't work so well without
356 case LOC_CONST_BYTES:
358 case LOC_OPTIMIZED_OUT:
364 /* Given a struct symbol for a variable,
365 and a stack frame id, read the value of the variable
366 and return a (pointer to a) struct value containing the value.
367 If the variable cannot be found, return a zero pointer.
368 If FRAME is NULL, use the selected frame. */
371 read_var_value (struct symbol *var, struct frame_info *frame)
374 struct type *type = SYMBOL_TYPE (var);
378 if (SYMBOL_CLASS (var) == LOC_COMPUTED
379 || SYMBOL_CLASS (var) == LOC_COMPUTED_ARG
380 || SYMBOL_CLASS (var) == LOC_REGISTER
381 || SYMBOL_CLASS (var) == LOC_REGPARM)
382 /* These cases do not use V. */
386 v = allocate_value (type);
387 VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */
390 len = TYPE_LENGTH (type);
392 /* FIXME drow/2003-09-06: this call to the selected frame should be
393 pushed upwards to the callers. */
395 frame = deprecated_safe_get_selected_frame ();
397 switch (SYMBOL_CLASS (var))
400 /* Put the constant back in target format. */
401 store_signed_integer (value_contents_raw (v), len,
402 (LONGEST) SYMBOL_VALUE (var));
403 VALUE_LVAL (v) = not_lval;
407 /* Put the constant back in target format. */
408 if (overlay_debugging)
411 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
412 SYMBOL_BFD_SECTION (var));
413 store_typed_address (value_contents_raw (v), type, addr);
416 store_typed_address (value_contents_raw (v), type,
417 SYMBOL_VALUE_ADDRESS (var));
418 VALUE_LVAL (v) = not_lval;
421 case LOC_CONST_BYTES:
423 memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len);
424 VALUE_LVAL (v) = not_lval;
429 if (overlay_debugging)
430 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
431 SYMBOL_BFD_SECTION (var));
433 addr = SYMBOL_VALUE_ADDRESS (var);
438 /* The import slot does not have a real address in it from the
439 dynamic loader (dld.sl on HP-UX), if the target hasn't
440 begun execution yet, so check for that. */
443 if (!target_has_execution)
445 Attempt to access variable defined in different shared object or load module when\n\
446 addresses have not been bound by the dynamic loader. Try again when executable is running."));
448 locaddr = SYMBOL_VALUE_ADDRESS (var);
449 loc = value_at (lookup_pointer_type (type), locaddr);
450 addr = value_as_address (loc);
457 addr = get_frame_args_address (frame);
460 addr += SYMBOL_VALUE (var);
469 argref = get_frame_args_address (frame);
472 argref += SYMBOL_VALUE (var);
473 ref = value_at (lookup_pointer_type (type), argref);
474 addr = value_as_address (ref);
482 addr = get_frame_locals_address (frame);
483 addr += SYMBOL_VALUE (var);
487 case LOC_BASEREG_ARG:
488 case LOC_HP_THREAD_LOCAL_STATIC:
490 struct value *regval;
492 regval = value_from_register (lookup_pointer_type (type),
493 SYMBOL_BASEREG (var), frame);
495 error (_("Value of base register not available."));
496 addr = value_as_address (regval);
497 addr += SYMBOL_VALUE (var);
502 error (_("Cannot look up value of a typedef"));
506 if (overlay_debugging)
507 VALUE_ADDRESS (v) = symbol_overlayed_address
508 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
510 VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
515 case LOC_REGPARM_ADDR:
518 int regno = SYMBOL_VALUE (var);
519 struct value *regval;
523 b = get_frame_block (frame, 0);
525 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
527 regval = value_from_register (lookup_pointer_type (type),
532 error (_("Value of register variable not available."));
534 addr = value_as_address (regval);
535 VALUE_LVAL (v) = lval_memory;
539 regval = value_from_register (type, regno, frame);
542 error (_("Value of register variable not available."));
549 case LOC_COMPUTED_ARG:
550 /* FIXME: cagney/2004-01-26: It should be possible to
551 unconditionally call the SYMBOL_OPS method when available.
552 Unfortunately DWARF 2 stores the frame-base (instead of the
553 function) location in a function's symbol. Oops! For the
554 moment enable this when/where applicable. */
555 if (frame == 0 && SYMBOL_OPS (var)->read_needs_frame (var))
557 return SYMBOL_OPS (var)->read_variable (var, frame);
561 struct minimal_symbol *msym;
563 msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
566 if (overlay_debugging)
567 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
568 SYMBOL_BFD_SECTION (msym));
570 addr = SYMBOL_VALUE_ADDRESS (msym);
574 case LOC_OPTIMIZED_OUT:
575 VALUE_LVAL (v) = not_lval;
576 set_value_optimized_out (v, 1);
580 error (_("Cannot look up value of a botched symbol."));
584 VALUE_ADDRESS (v) = addr;
585 set_value_lazy (v, 1);
589 /* Install default attributes for register values. */
592 default_value_from_register (struct type *type, int regnum,
593 struct frame_info *frame)
595 struct gdbarch *gdbarch = get_frame_arch (frame);
596 int len = TYPE_LENGTH (type);
597 struct value *value = allocate_value (type);
599 VALUE_LVAL (value) = lval_register;
600 VALUE_FRAME_ID (value) = get_frame_id (frame);
601 VALUE_REGNUM (value) = regnum;
603 /* Any structure stored in more than one register will always be
604 an integral number of registers. Otherwise, you need to do
605 some fiddling with the last register copied here for little
607 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
608 && len < register_size (gdbarch, regnum))
609 /* Big-endian, and we want less than full size. */
610 set_value_offset (value, register_size (gdbarch, regnum) - len);
612 set_value_offset (value, 0);
617 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME. */
620 value_from_register (struct type *type, int regnum, struct frame_info *frame)
622 struct gdbarch *gdbarch = get_frame_arch (frame);
623 struct type *type1 = check_typedef (type);
626 if (CONVERT_REGISTER_P (regnum, type1))
628 /* The ISA/ABI need to something weird when obtaining the
629 specified value from this register. It might need to
630 re-order non-adjacent, starting with REGNUM (see MIPS and
631 i386). It might need to convert the [float] register into
632 the corresponding [integer] type (see Alpha). The assumption
633 is that REGISTER_TO_VALUE populates the entire value
634 including the location. */
635 v = allocate_value (type);
636 VALUE_LVAL (v) = lval_register;
637 VALUE_FRAME_ID (v) = get_frame_id (frame);
638 VALUE_REGNUM (v) = regnum;
639 REGISTER_TO_VALUE (frame, regnum, type1, value_contents_raw (v));
643 int len = TYPE_LENGTH (type);
645 /* Construct the value. */
646 v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
649 if (!get_frame_register_bytes (frame, regnum, value_offset (v), len,
650 value_contents_raw (v)))
651 set_value_optimized_out (v, 1);
656 /* Return contents of register REGNUM in frame FRAME as address,
657 interpreted as value of type TYPE. Will abort if register
658 value is not available. */
661 address_from_register (struct type *type, int regnum, struct frame_info *frame)
666 value = value_from_register (type, regnum, frame);
669 result = value_as_address (value);
670 release_value (value);
677 /* Given a struct symbol for a variable or function,
678 and a stack frame id,
679 return a (pointer to a) struct value containing the properly typed
683 locate_var_value (struct symbol *var, struct frame_info *frame)
686 struct type *type = SYMBOL_TYPE (var);
687 struct value *lazy_value;
689 /* Evaluate it first; if the result is a memory address, we're fine.
690 Lazy evaluation pays off here. */
692 lazy_value = read_var_value (var, frame);
694 error (_("Address of \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
696 if (value_lazy (lazy_value)
697 || TYPE_CODE (type) == TYPE_CODE_FUNC)
701 addr = VALUE_ADDRESS (lazy_value);
702 val = value_from_pointer (lookup_pointer_type (type), addr);
706 /* Not a memory address; check what the problem was. */
707 switch (VALUE_LVAL (lazy_value))
710 gdb_assert (REGISTER_NAME (VALUE_REGNUM (lazy_value)) != NULL
711 && *REGISTER_NAME (VALUE_REGNUM (lazy_value)) != '\0');
712 error (_("Address requested for identifier "
713 "\"%s\" which is in register $%s"),
714 SYMBOL_PRINT_NAME (var),
715 REGISTER_NAME (VALUE_REGNUM (lazy_value)));
719 error (_("Can't take address of \"%s\" which isn't an lvalue."),
720 SYMBOL_PRINT_NAME (var));
723 return 0; /* For lint -- never reached */