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 LEN bytes at ADDR as a target-format address, and return
165 that address. ADDR is a buffer in the GDB process, not in the
168 This function should only be used by target-specific code. It
169 assumes that a pointer has the same representation as that thing's
170 address represented as an integer. Some machines use word
171 addresses, or similarly munged things, for certain types of
172 pointers, so that assumption doesn't hold everywhere.
174 Common code should use extract_typed_address instead, or something
175 else based on POINTER_TO_ADDRESS. */
178 extract_address (const void *addr
, int len
)
180 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
181 whether we want this to be true eventually. */
182 return (CORE_ADDR
) extract_unsigned_integer (addr
, len
);
186 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
187 address it represents. */
189 extract_typed_address (const void *buf
, struct type
*type
)
191 if (TYPE_CODE (type
) != TYPE_CODE_PTR
192 && TYPE_CODE (type
) != TYPE_CODE_REF
)
193 internal_error (__FILE__
, __LINE__
,
194 "extract_typed_address: "
195 "type is not a pointer or reference");
197 return POINTER_TO_ADDRESS (type
, buf
);
202 store_signed_integer (void *addr
, int len
, LONGEST val
)
205 unsigned char *startaddr
= (unsigned char *) addr
;
206 unsigned char *endaddr
= startaddr
+ len
;
208 /* Start at the least significant end of the integer, and work towards
209 the most significant. */
210 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
212 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
220 for (p
= startaddr
; p
< endaddr
; ++p
)
229 store_unsigned_integer (void *addr
, int len
, ULONGEST val
)
232 unsigned char *startaddr
= (unsigned char *) addr
;
233 unsigned char *endaddr
= startaddr
+ len
;
235 /* Start at the least significant end of the integer, and work towards
236 the most significant. */
237 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
239 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
247 for (p
= startaddr
; p
< endaddr
; ++p
)
255 /* Store the address VAL as a LEN-byte value in target byte order at
256 ADDR. ADDR is a buffer in the GDB process, not in the inferior.
258 This function should only be used by target-specific code. It
259 assumes that a pointer has the same representation as that thing's
260 address represented as an integer. Some machines use word
261 addresses, or similarly munged things, for certain types of
262 pointers, so that assumption doesn't hold everywhere.
264 Common code should use store_typed_address instead, or something else
265 based on ADDRESS_TO_POINTER. */
267 store_address (void *addr
, int len
, LONGEST val
)
269 store_unsigned_integer (addr
, len
, val
);
273 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
276 store_typed_address (void *buf
, struct type
*type
, CORE_ADDR addr
)
278 if (TYPE_CODE (type
) != TYPE_CODE_PTR
279 && TYPE_CODE (type
) != TYPE_CODE_REF
)
280 internal_error (__FILE__
, __LINE__
,
281 "store_typed_address: "
282 "type is not a pointer or reference");
284 ADDRESS_TO_POINTER (type
, buf
, addr
);
289 /* Return a `value' with the contents of (virtual or cooked) register
290 REGNUM as found in the specified FRAME. The register's type is
291 determined by register_type().
293 NOTE: returns NULL if register value is not available. Caller will
294 check return value or die! */
297 value_of_register (int regnum
, struct frame_info
*frame
)
301 struct value
*reg_val
;
303 char *raw_buffer
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
306 /* Builtin registers lie completly outside of the range of normal
307 registers. Catch them early so that the target never sees them. */
308 if (regnum
>= NUM_REGS
+ NUM_PSEUDO_REGS
)
309 return value_of_builtin_reg (regnum
, frame
);
311 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, raw_buffer
);
313 /* FIXME: cagney/2002-05-15: This test is just bogus.
315 It indicates that the target failed to supply a value for a
316 register because it was "not available" at this time. Problem
317 is, the target still has the register and so get saved_register()
318 may be returning a value saved on the stack. */
320 if (register_cached (regnum
) < 0)
321 return NULL
; /* register value not available */
323 reg_val
= allocate_value (register_type (current_gdbarch
, regnum
));
325 /* Convert raw data to virtual format if necessary. */
327 if (REGISTER_CONVERTIBLE (regnum
))
329 REGISTER_CONVERT_TO_VIRTUAL (regnum
, register_type (current_gdbarch
, regnum
),
330 raw_buffer
, VALUE_CONTENTS_RAW (reg_val
));
332 else if (REGISTER_RAW_SIZE (regnum
) == REGISTER_VIRTUAL_SIZE (regnum
))
333 memcpy (VALUE_CONTENTS_RAW (reg_val
), raw_buffer
,
334 REGISTER_RAW_SIZE (regnum
));
336 internal_error (__FILE__
, __LINE__
,
337 "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
338 REGISTER_NAME (regnum
),
340 REGISTER_RAW_SIZE (regnum
),
341 REGISTER_VIRTUAL_SIZE (regnum
));
342 VALUE_LVAL (reg_val
) = lval
;
343 VALUE_ADDRESS (reg_val
) = addr
;
344 VALUE_REGNO (reg_val
) = regnum
;
345 VALUE_OPTIMIZED_OUT (reg_val
) = optim
;
349 /* Given a pointer of type TYPE in target form in BUF, return the
350 address it represents. */
352 unsigned_pointer_to_address (struct type
*type
, const void *buf
)
354 return extract_address (buf
, TYPE_LENGTH (type
));
358 signed_pointer_to_address (struct type
*type
, const void *buf
)
360 return extract_signed_integer (buf
, TYPE_LENGTH (type
));
363 /* Given an address, store it as a pointer of type TYPE in target
366 unsigned_address_to_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
368 store_address (buf
, TYPE_LENGTH (type
), addr
);
372 address_to_signed_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
374 store_signed_integer (buf
, TYPE_LENGTH (type
), addr
);
377 /* Will calling read_var_value or locate_var_value on SYM end
378 up caring what frame it is being evaluated relative to? SYM must
381 symbol_read_needs_frame (struct symbol
*sym
)
383 switch (SYMBOL_CLASS (sym
))
385 /* All cases listed explicitly so that gcc -Wall will detect it if
386 we failed to consider one. */
388 case LOC_COMPUTED_ARG
:
390 struct location_funcs
*symfuncs
= SYMBOL_LOCATION_FUNCS (sym
);
391 return (symfuncs
->read_needs_frame
) (sym
);
399 case LOC_REGPARM_ADDR
:
403 case LOC_BASEREG_ARG
:
404 case LOC_HP_THREAD_LOCAL_STATIC
:
414 /* Getting the address of a label can be done independently of the block,
415 even if some *uses* of that address wouldn't work so well without
419 case LOC_CONST_BYTES
:
421 case LOC_OPTIMIZED_OUT
:
427 /* Given a struct symbol for a variable,
428 and a stack frame id, read the value of the variable
429 and return a (pointer to a) struct value containing the value.
430 If the variable cannot be found, return a zero pointer.
431 If FRAME is NULL, use the deprecated_selected_frame. */
434 read_var_value (register struct symbol
*var
, struct frame_info
*frame
)
436 register struct value
*v
;
437 struct type
*type
= SYMBOL_TYPE (var
);
441 v
= allocate_value (type
);
442 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
443 VALUE_BFD_SECTION (v
) = SYMBOL_BFD_SECTION (var
);
445 len
= TYPE_LENGTH (type
);
448 frame
= deprecated_selected_frame
;
450 switch (SYMBOL_CLASS (var
))
453 /* Put the constant back in target format. */
454 store_signed_integer (VALUE_CONTENTS_RAW (v
), len
,
455 (LONGEST
) SYMBOL_VALUE (var
));
456 VALUE_LVAL (v
) = not_lval
;
460 /* Put the constant back in target format. */
461 if (overlay_debugging
)
464 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
465 SYMBOL_BFD_SECTION (var
));
466 store_typed_address (VALUE_CONTENTS_RAW (v
), type
, addr
);
469 store_typed_address (VALUE_CONTENTS_RAW (v
), type
,
470 SYMBOL_VALUE_ADDRESS (var
));
471 VALUE_LVAL (v
) = not_lval
;
474 case LOC_CONST_BYTES
:
477 bytes_addr
= SYMBOL_VALUE_BYTES (var
);
478 memcpy (VALUE_CONTENTS_RAW (v
), bytes_addr
, len
);
479 VALUE_LVAL (v
) = not_lval
;
484 if (overlay_debugging
)
485 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
486 SYMBOL_BFD_SECTION (var
));
488 addr
= SYMBOL_VALUE_ADDRESS (var
);
493 /* The import slot does not have a real address in it from the
494 dynamic loader (dld.sl on HP-UX), if the target hasn't
495 begun execution yet, so check for that. */
498 if (!target_has_execution
)
500 Attempt to access variable defined in different shared object or load module when\n\
501 addresses have not been bound by the dynamic loader. Try again when executable is running.");
503 locaddr
= SYMBOL_VALUE_ADDRESS (var
);
504 loc
= value_at (lookup_pointer_type (type
), locaddr
, NULL
);
505 addr
= value_as_address (loc
);
511 addr
= FRAME_ARGS_ADDRESS (frame
);
514 addr
+= SYMBOL_VALUE (var
);
523 argref
= FRAME_ARGS_ADDRESS (frame
);
526 argref
+= SYMBOL_VALUE (var
);
527 ref
= value_at (lookup_pointer_type (type
), argref
, NULL
);
528 addr
= value_as_address (ref
);
536 addr
= FRAME_LOCALS_ADDRESS (frame
);
537 addr
+= SYMBOL_VALUE (var
);
541 case LOC_BASEREG_ARG
:
542 case LOC_HP_THREAD_LOCAL_STATIC
:
544 struct value
*regval
;
546 regval
= value_from_register (lookup_pointer_type (type
),
547 SYMBOL_BASEREG (var
), frame
);
549 error ("Value of base register not available.");
550 addr
= value_as_address (regval
);
551 addr
+= SYMBOL_VALUE (var
);
555 case LOC_THREAD_LOCAL_STATIC
:
557 if (target_get_thread_local_address_p ())
558 addr
= target_get_thread_local_address (inferior_ptid
,
559 SYMBOL_OBJFILE (var
),
560 SYMBOL_VALUE_ADDRESS (var
));
561 /* It wouldn't be wrong here to try a gdbarch method, too;
562 finding TLS is an ABI-specific thing. But we don't do that
565 error ("Cannot find thread-local variables on this target");
570 error ("Cannot look up value of a typedef");
574 if (overlay_debugging
)
575 VALUE_ADDRESS (v
) = symbol_overlayed_address
576 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_BFD_SECTION (var
));
578 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
583 case LOC_REGPARM_ADDR
:
586 int regno
= SYMBOL_VALUE (var
);
587 struct value
*regval
;
591 b
= get_frame_block (frame
, 0);
593 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
595 regval
= value_from_register (lookup_pointer_type (type
),
600 error ("Value of register variable not available.");
602 addr
= value_as_address (regval
);
603 VALUE_LVAL (v
) = lval_memory
;
607 regval
= value_from_register (type
, regno
, frame
);
610 error ("Value of register variable not available.");
617 case LOC_COMPUTED_ARG
:
619 struct location_funcs
*funcs
= SYMBOL_LOCATION_FUNCS (var
);
621 if (frame
== 0 && (funcs
->read_needs_frame
) (var
))
623 return (funcs
->read_variable
) (var
, frame
);
630 struct minimal_symbol
*msym
;
632 msym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var
), NULL
, NULL
);
635 if (overlay_debugging
)
636 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
637 SYMBOL_BFD_SECTION (msym
));
639 addr
= SYMBOL_VALUE_ADDRESS (msym
);
643 case LOC_OPTIMIZED_OUT
:
644 VALUE_LVAL (v
) = not_lval
;
645 VALUE_OPTIMIZED_OUT (v
) = 1;
649 error ("Cannot look up value of a botched symbol.");
653 VALUE_ADDRESS (v
) = addr
;
658 /* Return a value of type TYPE, stored in register REGNUM, in frame
661 NOTE: returns NULL if register value is not available.
662 Caller will check return value or die! */
665 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
667 char *raw_buffer
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
670 struct value
*v
= allocate_value (type
);
671 char *value_bytes
= 0;
672 int value_bytes_copied
= 0;
673 int num_storage_locs
;
677 CHECK_TYPEDEF (type
);
678 len
= TYPE_LENGTH (type
);
680 VALUE_REGNO (v
) = regnum
;
682 num_storage_locs
= (len
> REGISTER_VIRTUAL_SIZE (regnum
) ?
683 ((len
- 1) / REGISTER_RAW_SIZE (regnum
)) + 1 :
686 if (num_storage_locs
> 1
688 // OBSOLETE #ifdef GDB_TARGET_IS_H8500
689 // OBSOLETE || TYPE_CODE (type) == TYPE_CODE_PTR
694 /* Value spread across multiple storage locations. */
697 int mem_stor
= 0, reg_stor
= 0;
698 int mem_tracking
= 1;
699 CORE_ADDR last_addr
= 0;
700 CORE_ADDR first_addr
= 0;
702 value_bytes
= (char *) alloca (len
+ MAX_REGISTER_RAW_SIZE
);
704 /* Copy all of the data out, whereever it may be. */
707 // OBSOLETE #ifdef GDB_TARGET_IS_H8500
708 // OBSOLETE /* This piece of hideosity is required because the H8500 treats registers
709 // OBSOLETE differently depending upon whether they are used as pointers or not. As a
710 // OBSOLETE pointer, a register needs to have a page register tacked onto the front.
711 // OBSOLETE An alternate way to do this would be to have gcc output different register
712 // OBSOLETE numbers for the pointer & non-pointer form of the register. But, it
713 // OBSOLETE doesn't, so we're stuck with this. */
715 // OBSOLETE if (TYPE_CODE (type) == TYPE_CODE_PTR
716 // OBSOLETE && len > 2)
718 // OBSOLETE int page_regnum;
720 // OBSOLETE switch (regnum)
722 // OBSOLETE case R0_REGNUM:
723 // OBSOLETE case R1_REGNUM:
724 // OBSOLETE case R2_REGNUM:
725 // OBSOLETE case R3_REGNUM:
726 // OBSOLETE page_regnum = SEG_D_REGNUM;
728 // OBSOLETE case R4_REGNUM:
729 // OBSOLETE case R5_REGNUM:
730 // OBSOLETE page_regnum = SEG_E_REGNUM;
732 // OBSOLETE case R6_REGNUM:
733 // OBSOLETE case R7_REGNUM:
734 // OBSOLETE page_regnum = SEG_T_REGNUM;
738 // OBSOLETE value_bytes[0] = 0;
739 // OBSOLETE get_saved_register (value_bytes + 1,
743 // OBSOLETE page_regnum,
746 // OBSOLETE if (register_cached (page_regnum) == -1)
747 // OBSOLETE return NULL; /* register value not available */
749 // OBSOLETE if (lval == lval_register)
750 // OBSOLETE reg_stor++;
752 // OBSOLETE mem_stor++;
753 // OBSOLETE first_addr = addr;
754 // OBSOLETE last_addr = addr;
756 // OBSOLETE get_saved_register (value_bytes + 2,
763 // OBSOLETE if (register_cached (regnum) == -1)
764 // OBSOLETE return NULL; /* register value not available */
766 // OBSOLETE if (lval == lval_register)
767 // OBSOLETE reg_stor++;
770 // OBSOLETE mem_stor++;
771 // OBSOLETE mem_tracking = mem_tracking && (addr == last_addr);
773 // OBSOLETE last_addr = addr;
776 // OBSOLETE #endif /* GDB_TARGET_IS_H8500 */
778 for (local_regnum
= regnum
;
779 value_bytes_copied
< len
;
780 (value_bytes_copied
+= REGISTER_RAW_SIZE (local_regnum
),
784 frame_register (frame
, local_regnum
, &optim
, &lval
, &addr
,
785 &realnum
, value_bytes
+ value_bytes_copied
);
787 if (register_cached (local_regnum
) == -1)
788 return NULL
; /* register value not available */
790 if (regnum
== local_regnum
)
792 if (lval
== lval_register
)
800 && (regnum
== local_regnum
801 || addr
== last_addr
));
806 if ((reg_stor
&& mem_stor
)
807 || (mem_stor
&& !mem_tracking
))
808 /* Mixed storage; all of the hassle we just went through was
809 for some good purpose. */
811 VALUE_LVAL (v
) = lval_reg_frame_relative
;
812 VALUE_FRAME (v
) = get_frame_base (frame
);
813 VALUE_FRAME_REGNUM (v
) = regnum
;
817 VALUE_LVAL (v
) = lval_memory
;
818 VALUE_ADDRESS (v
) = first_addr
;
822 VALUE_LVAL (v
) = lval_register
;
823 VALUE_ADDRESS (v
) = first_addr
;
826 internal_error (__FILE__
, __LINE__
,
827 "value_from_register: Value not stored anywhere!");
829 VALUE_OPTIMIZED_OUT (v
) = optim
;
831 /* Any structure stored in more than one register will always be
832 an integral number of registers. Otherwise, you'd need to do
833 some fiddling with the last register copied here for little
836 /* Copy into the contents section of the value. */
837 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
, len
);
839 /* Finally do any conversion necessary when extracting this
840 type from more than one register. */
841 #ifdef REGISTER_CONVERT_TO_TYPE
842 REGISTER_CONVERT_TO_TYPE (regnum
, type
, VALUE_CONTENTS_RAW (v
));
847 /* Data is completely contained within a single register. Locate the
848 register's contents in a real register or in core;
849 read the data in raw format. */
853 frame_register (frame
, regnum
, &optim
, &lval
, &addr
, &realnum
, raw_buffer
);
856 if (register_cached (regnum
) == -1)
857 return NULL
; /* register value not available */
859 VALUE_OPTIMIZED_OUT (v
) = optim
;
860 VALUE_LVAL (v
) = lval
;
861 VALUE_ADDRESS (v
) = addr
;
863 /* Convert the raw register to the corresponding data value's memory
864 format, if necessary. */
866 if (CONVERT_REGISTER_P (regnum
))
868 REGISTER_TO_VALUE (regnum
, type
, raw_buffer
, VALUE_CONTENTS_RAW (v
));
872 /* Raw and virtual formats are the same for this register. */
874 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
&& len
< REGISTER_RAW_SIZE (regnum
))
876 /* Big-endian, and we want less than full size. */
877 VALUE_OFFSET (v
) = REGISTER_RAW_SIZE (regnum
) - len
;
880 memcpy (VALUE_CONTENTS_RAW (v
), raw_buffer
+ VALUE_OFFSET (v
), len
);
886 /* Given a struct symbol for a variable or function,
887 and a stack frame id,
888 return a (pointer to a) struct value containing the properly typed
892 locate_var_value (register struct symbol
*var
, struct frame_info
*frame
)
895 struct type
*type
= SYMBOL_TYPE (var
);
896 struct value
*lazy_value
;
898 /* Evaluate it first; if the result is a memory address, we're fine.
899 Lazy evaluation pays off here. */
901 lazy_value
= read_var_value (var
, frame
);
903 error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var
));
905 if (VALUE_LAZY (lazy_value
)
906 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
910 addr
= VALUE_ADDRESS (lazy_value
);
911 val
= value_from_pointer (lookup_pointer_type (type
), addr
);
912 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (lazy_value
);
916 /* Not a memory address; check what the problem was. */
917 switch (VALUE_LVAL (lazy_value
))
920 gdb_assert (REGISTER_NAME (VALUE_REGNO (lazy_value
)) != NULL
921 && *REGISTER_NAME (VALUE_REGNO (lazy_value
)) != '\0');
922 error("Address requested for identifier "
923 "\"%s\" which is in register $%s",
924 SYMBOL_PRINT_NAME (var
),
925 REGISTER_NAME (VALUE_REGNO (lazy_value
)));
928 case lval_reg_frame_relative
:
929 gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value
)) != NULL
930 && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value
)) != '\0');
931 error("Address requested for identifier "
932 "\"%s\" which is in frame register $%s",
933 SYMBOL_PRINT_NAME (var
),
934 REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value
)));
938 error ("Can't take address of \"%s\" which isn't an lvalue.",
939 SYMBOL_PRINT_NAME (var
));
942 return 0; /* For lint -- never reached */