1 /* Find a variable's value in memory, for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2003 Free Software
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., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
32 #include "gdb_string.h"
33 #include "gdb_assert.h"
34 #include "floatformat.h"
35 #include "symfile.h" /* for overlay functions */
37 #include "builtin-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 void *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 void *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 void *addr, int orig_len, LONGEST *pval)
122 char *p, *first_addr;
126 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
128 for (p = (char *) addr;
129 len > (int) sizeof (LONGEST) && p < (char *) addr + orig_len;
141 first_addr = (char *) addr;
142 for (p = (char *) addr + orig_len - 1;
143 len > (int) sizeof (LONGEST) && p >= (char *) addr;
153 if (len <= (int) sizeof (LONGEST))
155 *pval = (LONGEST) extract_unsigned_integer (first_addr,
164 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
165 address it represents. */
167 extract_typed_address (const void *buf, struct type *type)
169 if (TYPE_CODE (type) != TYPE_CODE_PTR
170 && TYPE_CODE (type) != TYPE_CODE_REF)
171 internal_error (__FILE__, __LINE__,
172 "extract_typed_address: "
173 "type is not a pointer or reference");
175 return POINTER_TO_ADDRESS (type, buf);
180 store_signed_integer (void *addr, int len, LONGEST val)
183 unsigned char *startaddr = (unsigned char *) addr;
184 unsigned char *endaddr = startaddr + len;
186 /* Start at the least significant end of the integer, and work towards
187 the most significant. */
188 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
190 for (p = endaddr - 1; p >= startaddr; --p)
198 for (p = startaddr; p < endaddr; ++p)
207 store_unsigned_integer (void *addr, int len, ULONGEST val)
210 unsigned char *startaddr = (unsigned char *) addr;
211 unsigned char *endaddr = startaddr + len;
213 /* Start at the least significant end of the integer, and work towards
214 the most significant. */
215 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
217 for (p = endaddr - 1; p >= startaddr; --p)
225 for (p = startaddr; p < endaddr; ++p)
233 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
236 store_typed_address (void *buf, struct type *type, CORE_ADDR addr)
238 if (TYPE_CODE (type) != TYPE_CODE_PTR
239 && TYPE_CODE (type) != TYPE_CODE_REF)
240 internal_error (__FILE__, __LINE__,
241 "store_typed_address: "
242 "type is not a pointer or reference");
244 ADDRESS_TO_POINTER (type, buf, addr);
249 /* Return a `value' with the contents of (virtual or cooked) register
250 REGNUM as found in the specified FRAME. The register's type is
251 determined by register_type().
253 NOTE: returns NULL if register value is not available. Caller will
254 check return value or die! */
257 value_of_register (int regnum, struct frame_info *frame)
261 struct value *reg_val;
263 char raw_buffer[MAX_REGISTER_SIZE];
266 /* Builtin registers lie completly outside of the range of normal
267 registers. Catch them early so that the target never sees them. */
268 if (regnum >= NUM_REGS + NUM_PSEUDO_REGS)
269 return value_of_builtin_reg (regnum, frame);
271 frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
273 /* FIXME: cagney/2002-05-15: This test is just bogus.
275 It indicates that the target failed to supply a value for a
276 register because it was "not available" at this time. Problem
277 is, the target still has the register and so get saved_register()
278 may be returning a value saved on the stack. */
280 if (register_cached (regnum) < 0)
281 return NULL; /* register value not available */
283 reg_val = allocate_value (register_type (current_gdbarch, regnum));
285 /* Convert raw data to virtual format if necessary. */
287 if (REGISTER_CONVERTIBLE (regnum))
289 REGISTER_CONVERT_TO_VIRTUAL (regnum, register_type (current_gdbarch, regnum),
290 raw_buffer, VALUE_CONTENTS_RAW (reg_val));
292 else if (REGISTER_RAW_SIZE (regnum) == REGISTER_VIRTUAL_SIZE (regnum))
293 memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
294 REGISTER_RAW_SIZE (regnum));
296 internal_error (__FILE__, __LINE__,
297 "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
298 REGISTER_NAME (regnum),
300 REGISTER_RAW_SIZE (regnum),
301 REGISTER_VIRTUAL_SIZE (regnum));
302 VALUE_LVAL (reg_val) = lval;
303 VALUE_ADDRESS (reg_val) = addr;
304 VALUE_REGNO (reg_val) = regnum;
305 VALUE_OPTIMIZED_OUT (reg_val) = optim;
309 /* Given a pointer of type TYPE in target form in BUF, return the
310 address it represents. */
312 unsigned_pointer_to_address (struct type *type, const void *buf)
314 return extract_unsigned_integer (buf, TYPE_LENGTH (type));
318 signed_pointer_to_address (struct type *type, const void *buf)
320 return extract_signed_integer (buf, TYPE_LENGTH (type));
323 /* Given an address, store it as a pointer of type TYPE in target
326 unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
328 store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
332 address_to_signed_pointer (struct type *type, void *buf, CORE_ADDR addr)
334 store_signed_integer (buf, TYPE_LENGTH (type), addr);
337 /* Will calling read_var_value or locate_var_value on SYM end
338 up caring what frame it is being evaluated relative to? SYM must
341 symbol_read_needs_frame (struct symbol *sym)
343 switch (SYMBOL_CLASS (sym))
345 /* All cases listed explicitly so that gcc -Wall will detect it if
346 we failed to consider one. */
348 case LOC_COMPUTED_ARG:
350 struct location_funcs *symfuncs = SYMBOL_LOCATION_FUNCS (sym);
351 return (symfuncs->read_needs_frame) (sym);
359 case LOC_REGPARM_ADDR:
363 case LOC_BASEREG_ARG:
364 case LOC_HP_THREAD_LOCAL_STATIC:
374 /* Getting the address of a label can be done independently of the block,
375 even if some *uses* of that address wouldn't work so well without
379 case LOC_CONST_BYTES:
381 case LOC_OPTIMIZED_OUT:
387 /* Given a struct symbol for a variable,
388 and a stack frame id, read the value of the variable
389 and return a (pointer to a) struct value containing the value.
390 If the variable cannot be found, return a zero pointer.
391 If FRAME is NULL, use the deprecated_selected_frame. */
394 read_var_value (register struct symbol *var, struct frame_info *frame)
396 register struct value *v;
397 struct type *type = SYMBOL_TYPE (var);
401 v = allocate_value (type);
402 VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */
403 VALUE_BFD_SECTION (v) = SYMBOL_BFD_SECTION (var);
405 len = TYPE_LENGTH (type);
408 frame = deprecated_selected_frame;
410 switch (SYMBOL_CLASS (var))
413 /* Put the constant back in target format. */
414 store_signed_integer (VALUE_CONTENTS_RAW (v), len,
415 (LONGEST) SYMBOL_VALUE (var));
416 VALUE_LVAL (v) = not_lval;
420 /* Put the constant back in target format. */
421 if (overlay_debugging)
424 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
425 SYMBOL_BFD_SECTION (var));
426 store_typed_address (VALUE_CONTENTS_RAW (v), type, addr);
429 store_typed_address (VALUE_CONTENTS_RAW (v), type,
430 SYMBOL_VALUE_ADDRESS (var));
431 VALUE_LVAL (v) = not_lval;
434 case LOC_CONST_BYTES:
437 bytes_addr = SYMBOL_VALUE_BYTES (var);
438 memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
439 VALUE_LVAL (v) = not_lval;
444 if (overlay_debugging)
445 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
446 SYMBOL_BFD_SECTION (var));
448 addr = SYMBOL_VALUE_ADDRESS (var);
453 /* The import slot does not have a real address in it from the
454 dynamic loader (dld.sl on HP-UX), if the target hasn't
455 begun execution yet, so check for that. */
458 if (!target_has_execution)
460 Attempt to access variable defined in different shared object or load module when\n\
461 addresses have not been bound by the dynamic loader. Try again when executable is running.");
463 locaddr = SYMBOL_VALUE_ADDRESS (var);
464 loc = value_at (lookup_pointer_type (type), locaddr, NULL);
465 addr = value_as_address (loc);
471 addr = get_frame_args_address (frame);
474 addr += SYMBOL_VALUE (var);
483 argref = get_frame_args_address (frame);
486 argref += SYMBOL_VALUE (var);
487 ref = value_at (lookup_pointer_type (type), argref, NULL);
488 addr = value_as_address (ref);
496 addr = get_frame_locals_address (frame);
497 addr += SYMBOL_VALUE (var);
501 case LOC_BASEREG_ARG:
502 case LOC_HP_THREAD_LOCAL_STATIC:
504 struct value *regval;
506 regval = value_from_register (lookup_pointer_type (type),
507 SYMBOL_BASEREG (var), frame);
509 error ("Value of base register not available.");
510 addr = value_as_address (regval);
511 addr += SYMBOL_VALUE (var);
515 case LOC_THREAD_LOCAL_STATIC:
517 if (target_get_thread_local_address_p ())
518 addr = target_get_thread_local_address (inferior_ptid,
519 SYMBOL_OBJFILE (var),
520 SYMBOL_VALUE_ADDRESS (var));
521 /* It wouldn't be wrong here to try a gdbarch method, too;
522 finding TLS is an ABI-specific thing. But we don't do that
525 error ("Cannot find thread-local variables on this target");
530 error ("Cannot look up value of a typedef");
534 if (overlay_debugging)
535 VALUE_ADDRESS (v) = symbol_overlayed_address
536 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
538 VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
543 case LOC_REGPARM_ADDR:
546 int regno = SYMBOL_VALUE (var);
547 struct value *regval;
551 b = get_frame_block (frame, 0);
553 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
555 regval = value_from_register (lookup_pointer_type (type),
560 error ("Value of register variable not available.");
562 addr = value_as_address (regval);
563 VALUE_LVAL (v) = lval_memory;
567 regval = value_from_register (type, regno, frame);
570 error ("Value of register variable not available.");
577 case LOC_COMPUTED_ARG:
579 struct location_funcs *funcs = SYMBOL_LOCATION_FUNCS (var);
581 if (frame == 0 && (funcs->read_needs_frame) (var))
583 return (funcs->read_variable) (var, frame);
590 struct minimal_symbol *msym;
592 msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
595 if (overlay_debugging)
596 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
597 SYMBOL_BFD_SECTION (msym));
599 addr = SYMBOL_VALUE_ADDRESS (msym);
603 case LOC_OPTIMIZED_OUT:
604 VALUE_LVAL (v) = not_lval;
605 VALUE_OPTIMIZED_OUT (v) = 1;
609 error ("Cannot look up value of a botched symbol.");
613 VALUE_ADDRESS (v) = addr;
618 /* Return a value of type TYPE, stored in register REGNUM, in frame
621 NOTE: returns NULL if register value is not available.
622 Caller will check return value or die! */
625 value_from_register (struct type *type, int regnum, struct frame_info *frame)
627 char raw_buffer[MAX_REGISTER_SIZE];
630 struct value *v = allocate_value (type);
631 char *value_bytes = 0;
632 int value_bytes_copied = 0;
633 int num_storage_locs;
637 CHECK_TYPEDEF (type);
638 len = TYPE_LENGTH (type);
640 VALUE_REGNO (v) = regnum;
642 num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
643 ((len - 1) / REGISTER_RAW_SIZE (regnum)) + 1 :
646 if (num_storage_locs > 1
648 // OBSOLETE #ifdef GDB_TARGET_IS_H8500
649 // OBSOLETE || TYPE_CODE (type) == TYPE_CODE_PTR
654 /* Value spread across multiple storage locations. */
657 int mem_stor = 0, reg_stor = 0;
658 int mem_tracking = 1;
659 CORE_ADDR last_addr = 0;
660 CORE_ADDR first_addr = 0;
662 value_bytes = (char *) alloca (len + MAX_REGISTER_SIZE);
664 /* Copy all of the data out, whereever it may be. */
667 // OBSOLETE #ifdef GDB_TARGET_IS_H8500
668 // OBSOLETE /* This piece of hideosity is required because the H8500 treats registers
669 // OBSOLETE differently depending upon whether they are used as pointers or not. As a
670 // OBSOLETE pointer, a register needs to have a page register tacked onto the front.
671 // OBSOLETE An alternate way to do this would be to have gcc output different register
672 // OBSOLETE numbers for the pointer & non-pointer form of the register. But, it
673 // OBSOLETE doesn't, so we're stuck with this. */
675 // OBSOLETE if (TYPE_CODE (type) == TYPE_CODE_PTR
676 // OBSOLETE && len > 2)
678 // OBSOLETE int page_regnum;
680 // OBSOLETE switch (regnum)
682 // OBSOLETE case R0_REGNUM:
683 // OBSOLETE case R1_REGNUM:
684 // OBSOLETE case R2_REGNUM:
685 // OBSOLETE case R3_REGNUM:
686 // OBSOLETE page_regnum = SEG_D_REGNUM;
688 // OBSOLETE case R4_REGNUM:
689 // OBSOLETE case R5_REGNUM:
690 // OBSOLETE page_regnum = SEG_E_REGNUM;
692 // OBSOLETE case R6_REGNUM:
693 // OBSOLETE case R7_REGNUM:
694 // OBSOLETE page_regnum = SEG_T_REGNUM;
698 // OBSOLETE value_bytes[0] = 0;
699 // OBSOLETE get_saved_register (value_bytes + 1,
703 // OBSOLETE page_regnum,
706 // OBSOLETE if (register_cached (page_regnum) == -1)
707 // OBSOLETE return NULL; /* register value not available */
709 // OBSOLETE if (lval == lval_register)
710 // OBSOLETE reg_stor++;
712 // OBSOLETE mem_stor++;
713 // OBSOLETE first_addr = addr;
714 // OBSOLETE last_addr = addr;
716 // OBSOLETE get_saved_register (value_bytes + 2,
723 // OBSOLETE if (register_cached (regnum) == -1)
724 // OBSOLETE return NULL; /* register value not available */
726 // OBSOLETE if (lval == lval_register)
727 // OBSOLETE reg_stor++;
730 // OBSOLETE mem_stor++;
731 // OBSOLETE mem_tracking = mem_tracking && (addr == last_addr);
733 // OBSOLETE last_addr = addr;
736 // OBSOLETE #endif /* GDB_TARGET_IS_H8500 */
738 for (local_regnum = regnum;
739 value_bytes_copied < len;
740 (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
744 frame_register (frame, local_regnum, &optim, &lval, &addr,
745 &realnum, value_bytes + value_bytes_copied);
747 if (register_cached (local_regnum) == -1)
748 return NULL; /* register value not available */
750 if (regnum == local_regnum)
752 if (lval == lval_register)
760 && (regnum == local_regnum
761 || addr == last_addr));
766 if ((reg_stor && mem_stor)
767 || (mem_stor && !mem_tracking))
768 /* Mixed storage; all of the hassle we just went through was
769 for some good purpose. */
771 VALUE_LVAL (v) = lval_reg_frame_relative;
772 VALUE_FRAME (v) = get_frame_base (frame);
773 VALUE_FRAME_REGNUM (v) = regnum;
777 VALUE_LVAL (v) = lval_memory;
778 VALUE_ADDRESS (v) = first_addr;
782 VALUE_LVAL (v) = lval_register;
783 VALUE_ADDRESS (v) = first_addr;
786 internal_error (__FILE__, __LINE__,
787 "value_from_register: Value not stored anywhere!");
789 VALUE_OPTIMIZED_OUT (v) = optim;
791 /* Any structure stored in more than one register will always be
792 an integral number of registers. Otherwise, you'd need to do
793 some fiddling with the last register copied here for little
796 /* Copy into the contents section of the value. */
797 memcpy (VALUE_CONTENTS_RAW (v), value_bytes, len);
799 /* Finally do any conversion necessary when extracting this
800 type from more than one register. */
801 #ifdef REGISTER_CONVERT_TO_TYPE
802 REGISTER_CONVERT_TO_TYPE (regnum, type, VALUE_CONTENTS_RAW (v));
807 /* Data is completely contained within a single register. Locate the
808 register's contents in a real register or in core;
809 read the data in raw format. */
813 frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
816 if (register_cached (regnum) == -1)
817 return NULL; /* register value not available */
819 VALUE_OPTIMIZED_OUT (v) = optim;
820 VALUE_LVAL (v) = lval;
821 VALUE_ADDRESS (v) = addr;
823 /* Convert the raw register to the corresponding data value's memory
824 format, if necessary. */
826 if (CONVERT_REGISTER_P (regnum))
828 REGISTER_TO_VALUE (regnum, type, raw_buffer, VALUE_CONTENTS_RAW (v));
832 /* Raw and virtual formats are the same for this register. */
834 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG && len < REGISTER_RAW_SIZE (regnum))
836 /* Big-endian, and we want less than full size. */
837 VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
840 memcpy (VALUE_CONTENTS_RAW (v), raw_buffer + VALUE_OFFSET (v), len);
846 /* Given a struct symbol for a variable or function,
847 and a stack frame id,
848 return a (pointer to a) struct value containing the properly typed
852 locate_var_value (register struct symbol *var, struct frame_info *frame)
855 struct type *type = SYMBOL_TYPE (var);
856 struct value *lazy_value;
858 /* Evaluate it first; if the result is a memory address, we're fine.
859 Lazy evaluation pays off here. */
861 lazy_value = read_var_value (var, frame);
863 error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var));
865 if (VALUE_LAZY (lazy_value)
866 || TYPE_CODE (type) == TYPE_CODE_FUNC)
870 addr = VALUE_ADDRESS (lazy_value);
871 val = value_from_pointer (lookup_pointer_type (type), addr);
872 VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value);
876 /* Not a memory address; check what the problem was. */
877 switch (VALUE_LVAL (lazy_value))
880 gdb_assert (REGISTER_NAME (VALUE_REGNO (lazy_value)) != NULL
881 && *REGISTER_NAME (VALUE_REGNO (lazy_value)) != '\0');
882 error("Address requested for identifier "
883 "\"%s\" which is in register $%s",
884 SYMBOL_PRINT_NAME (var),
885 REGISTER_NAME (VALUE_REGNO (lazy_value)));
888 case lval_reg_frame_relative:
889 gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != NULL
890 && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != '\0');
891 error("Address requested for identifier "
892 "\"%s\" which is in frame register $%s",
893 SYMBOL_PRINT_NAME (var),
894 REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)));
898 error ("Can't take address of \"%s\" which isn't an lvalue.",
899 SYMBOL_PRINT_NAME (var));
902 return 0; /* For lint -- never reached */