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"
39 /* Basic byte-swapping routines. GDB has needed these for a long time...
40 All extract a target-format integer at ADDR which is LEN bytes long. */
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 void *addr
, int len
)
54 const unsigned char *p
;
55 const unsigned char *startaddr
= addr
;
56 const unsigned char *endaddr
= startaddr
+ len
;
58 if (len
> (int) sizeof (LONGEST
))
60 That operation is not available on integers of more than %d bytes.",
61 (int) sizeof (LONGEST
));
63 /* Start at the most significant end of the integer, and work towards
64 the least significant. */
65 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
68 /* Do the sign extension once at the start. */
69 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
70 for (++p
; p
< endaddr
; ++p
)
71 retval
= (retval
<< 8) | *p
;
76 /* Do the sign extension once at the start. */
77 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
78 for (--p
; p
>= startaddr
; --p
)
79 retval
= (retval
<< 8) | *p
;
85 extract_unsigned_integer (const void *addr
, int len
)
88 const unsigned char *p
;
89 const unsigned char *startaddr
= addr
;
90 const unsigned char *endaddr
= startaddr
+ len
;
92 if (len
> (int) sizeof (ULONGEST
))
94 That operation is not available on integers of more than %d bytes.",
95 (int) sizeof (ULONGEST
));
97 /* Start at the most significant end of the integer, and work towards
98 the least significant. */
100 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
102 for (p
= startaddr
; p
< endaddr
; ++p
)
103 retval
= (retval
<< 8) | *p
;
107 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
108 retval
= (retval
<< 8) | *p
;
113 /* Sometimes a long long unsigned integer can be extracted as a
114 LONGEST value. This is done so that we can print these values
115 better. If this integer can be converted to a LONGEST, this
116 function returns 1 and sets *PVAL. Otherwise it returns 0. */
119 extract_long_unsigned_integer (const void *addr
, int orig_len
, LONGEST
*pval
)
121 char *p
, *first_addr
;
125 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
127 for (p
= (char *) addr
;
128 len
> (int) sizeof (LONGEST
) && p
< (char *) addr
+ orig_len
;
140 first_addr
= (char *) addr
;
141 for (p
= (char *) addr
+ orig_len
- 1;
142 len
> (int) sizeof (LONGEST
) && p
>= (char *) addr
;
152 if (len
<= (int) sizeof (LONGEST
))
154 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
163 /* Treat the LEN bytes at ADDR as a target-format address, and return
164 that address. ADDR is a buffer in the GDB process, not in the
167 This function should only be used by target-specific code. It
168 assumes that a pointer has the same representation as that thing's
169 address represented as an integer. Some machines use word
170 addresses, or similarly munged things, for certain types of
171 pointers, so that assumption doesn't hold everywhere.
173 Common code should use extract_typed_address instead, or something
174 else based on POINTER_TO_ADDRESS. */
177 extract_address (const void *addr
, int len
)
179 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
180 whether we want this to be true eventually. */
181 return (CORE_ADDR
) extract_unsigned_integer (addr
, len
);
185 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
186 address it represents. */
188 extract_typed_address (const void *buf
, struct type
*type
)
190 if (TYPE_CODE (type
) != TYPE_CODE_PTR
191 && TYPE_CODE (type
) != TYPE_CODE_REF
)
192 internal_error (__FILE__
, __LINE__
,
193 "extract_typed_address: "
194 "type is not a pointer or reference");
196 return POINTER_TO_ADDRESS (type
, buf
);
201 store_signed_integer (void *addr
, int len
, LONGEST val
)
204 unsigned char *startaddr
= (unsigned char *) addr
;
205 unsigned char *endaddr
= startaddr
+ len
;
207 /* Start at the least significant end of the integer, and work towards
208 the most significant. */
209 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
211 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
219 for (p
= startaddr
; p
< endaddr
; ++p
)
228 store_unsigned_integer (void *addr
, int len
, ULONGEST val
)
231 unsigned char *startaddr
= (unsigned char *) addr
;
232 unsigned char *endaddr
= startaddr
+ len
;
234 /* Start at the least significant end of the integer, and work towards
235 the most significant. */
236 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
238 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
246 for (p
= startaddr
; p
< endaddr
; ++p
)
254 /* Store the address VAL as a LEN-byte value in target byte order at
255 ADDR. ADDR is a buffer in the GDB process, not in the inferior.
257 This function should only be used by target-specific code. It
258 assumes that a pointer has the same representation as that thing's
259 address represented as an integer. Some machines use word
260 addresses, or similarly munged things, for certain types of
261 pointers, so that assumption doesn't hold everywhere.
263 Common code should use store_typed_address instead, or something else
264 based on ADDRESS_TO_POINTER. */
266 store_address (void *addr
, int len
, LONGEST val
)
268 store_unsigned_integer (addr
, len
, val
);
272 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
275 store_typed_address (void *buf
, struct type
*type
, CORE_ADDR addr
)
277 if (TYPE_CODE (type
) != TYPE_CODE_PTR
278 && TYPE_CODE (type
) != TYPE_CODE_REF
)
279 internal_error (__FILE__
, __LINE__
,
280 "store_typed_address: "
281 "type is not a pointer or reference");
283 ADDRESS_TO_POINTER (type
, buf
, addr
);
288 /* Return a `value' with the contents of (virtual or cooked) register
289 REGNUM as found in the specified FRAME. The register's type is
290 determined by REGISTER_VIRTUAL_TYPE.
292 NOTE: returns NULL if register value is not available. Caller will
293 check return value or die! */
296 value_of_register (int regnum
, struct frame_info
*frame
)
300 struct value
*reg_val
;
301 char *raw_buffer
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
304 /* Builtin registers lie completly outside of the range of normal
305 registers. Catch them early so that the target never sees them. */
306 if (regnum
>= NUM_REGS
+ NUM_PSEUDO_REGS
)
307 return value_of_builtin_reg (regnum
, deprecated_selected_frame
);
309 get_saved_register (raw_buffer
, &optim
, &addr
,
310 frame
, regnum
, &lval
);
312 /* FIXME: cagney/2002-05-15: This test is just bogus.
314 It indicates that the target failed to supply a value for a
315 register because it was "not available" at this time. Problem
316 is, the target still has the register and so get saved_register()
317 may be returning a value saved on the stack. */
319 if (register_cached (regnum
) < 0)
320 return NULL
; /* register value not available */
322 reg_val
= allocate_value (REGISTER_VIRTUAL_TYPE (regnum
));
324 /* Convert raw data to virtual format if necessary. */
326 if (REGISTER_CONVERTIBLE (regnum
))
328 REGISTER_CONVERT_TO_VIRTUAL (regnum
, REGISTER_VIRTUAL_TYPE (regnum
),
329 raw_buffer
, VALUE_CONTENTS_RAW (reg_val
));
331 else if (REGISTER_RAW_SIZE (regnum
) == REGISTER_VIRTUAL_SIZE (regnum
))
332 memcpy (VALUE_CONTENTS_RAW (reg_val
), raw_buffer
,
333 REGISTER_RAW_SIZE (regnum
));
335 internal_error (__FILE__
, __LINE__
,
336 "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
337 REGISTER_NAME (regnum
),
339 REGISTER_RAW_SIZE (regnum
),
340 REGISTER_VIRTUAL_SIZE (regnum
));
341 VALUE_LVAL (reg_val
) = lval
;
342 VALUE_ADDRESS (reg_val
) = addr
;
343 VALUE_REGNO (reg_val
) = regnum
;
344 VALUE_OPTIMIZED_OUT (reg_val
) = optim
;
348 /* Given a pointer of type TYPE in target form in BUF, return the
349 address it represents. */
351 unsigned_pointer_to_address (struct type
*type
, const void *buf
)
353 return extract_address (buf
, TYPE_LENGTH (type
));
357 signed_pointer_to_address (struct type
*type
, const void *buf
)
359 return extract_signed_integer (buf
, TYPE_LENGTH (type
));
362 /* Given an address, store it as a pointer of type TYPE in target
365 unsigned_address_to_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
367 store_address (buf
, TYPE_LENGTH (type
), addr
);
371 address_to_signed_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
373 store_signed_integer (buf
, TYPE_LENGTH (type
), addr
);
376 /* Will calling read_var_value or locate_var_value on SYM end
377 up caring what frame it is being evaluated relative to? SYM must
380 symbol_read_needs_frame (struct symbol
*sym
)
382 switch (SYMBOL_CLASS (sym
))
384 /* All cases listed explicitly so that gcc -Wall will detect it if
385 we failed to consider one. */
390 case LOC_REGPARM_ADDR
:
394 case LOC_BASEREG_ARG
:
395 case LOC_HP_THREAD_LOCAL_STATIC
:
405 /* Getting the address of a label can be done independently of the block,
406 even if some *uses* of that address wouldn't work so well without
410 case LOC_CONST_BYTES
:
412 case LOC_OPTIMIZED_OUT
:
418 /* Given a struct symbol for a variable,
419 and a stack frame id, read the value of the variable
420 and return a (pointer to a) struct value containing the value.
421 If the variable cannot be found, return a zero pointer.
422 If FRAME is NULL, use the deprecated_selected_frame. */
425 read_var_value (register struct symbol
*var
, struct frame_info
*frame
)
427 register struct value
*v
;
428 struct type
*type
= SYMBOL_TYPE (var
);
432 v
= allocate_value (type
);
433 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
434 VALUE_BFD_SECTION (v
) = SYMBOL_BFD_SECTION (var
);
436 len
= TYPE_LENGTH (type
);
439 frame
= deprecated_selected_frame
;
441 switch (SYMBOL_CLASS (var
))
444 /* Put the constant back in target format. */
445 store_signed_integer (VALUE_CONTENTS_RAW (v
), len
,
446 (LONGEST
) SYMBOL_VALUE (var
));
447 VALUE_LVAL (v
) = not_lval
;
451 /* Put the constant back in target format. */
452 if (overlay_debugging
)
455 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
456 SYMBOL_BFD_SECTION (var
));
457 store_typed_address (VALUE_CONTENTS_RAW (v
), type
, addr
);
460 store_typed_address (VALUE_CONTENTS_RAW (v
), type
,
461 SYMBOL_VALUE_ADDRESS (var
));
462 VALUE_LVAL (v
) = not_lval
;
465 case LOC_CONST_BYTES
:
468 bytes_addr
= SYMBOL_VALUE_BYTES (var
);
469 memcpy (VALUE_CONTENTS_RAW (v
), bytes_addr
, len
);
470 VALUE_LVAL (v
) = not_lval
;
475 if (overlay_debugging
)
476 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
477 SYMBOL_BFD_SECTION (var
));
479 addr
= SYMBOL_VALUE_ADDRESS (var
);
484 /* The import slot does not have a real address in it from the
485 dynamic loader (dld.sl on HP-UX), if the target hasn't
486 begun execution yet, so check for that. */
489 if (!target_has_execution
)
491 Attempt to access variable defined in different shared object or load module when\n\
492 addresses have not been bound by the dynamic loader. Try again when executable is running.");
494 locaddr
= SYMBOL_VALUE_ADDRESS (var
);
495 loc
= value_at (lookup_pointer_type (type
), locaddr
, NULL
);
496 addr
= value_as_address (loc
);
502 addr
= FRAME_ARGS_ADDRESS (frame
);
505 addr
+= SYMBOL_VALUE (var
);
514 argref
= FRAME_ARGS_ADDRESS (frame
);
517 argref
+= SYMBOL_VALUE (var
);
518 ref
= value_at (lookup_pointer_type (type
), argref
, NULL
);
519 addr
= value_as_address (ref
);
527 addr
= FRAME_LOCALS_ADDRESS (frame
);
528 addr
+= SYMBOL_VALUE (var
);
532 case LOC_BASEREG_ARG
:
533 case LOC_HP_THREAD_LOCAL_STATIC
:
535 struct value
*regval
;
537 regval
= value_from_register (lookup_pointer_type (type
),
538 SYMBOL_BASEREG (var
), frame
);
540 error ("Value of base register not available.");
541 addr
= value_as_address (regval
);
542 addr
+= SYMBOL_VALUE (var
);
546 case LOC_THREAD_LOCAL_STATIC
:
548 if (target_get_thread_local_address_p ())
549 addr
= target_get_thread_local_address (inferior_ptid
,
550 SYMBOL_OBJFILE (var
),
551 SYMBOL_VALUE_ADDRESS (var
));
552 /* It wouldn't be wrong here to try a gdbarch method, too;
553 finding TLS is an ABI-specific thing. But we don't do that
556 error ("Cannot find thread-local variables on this target");
561 error ("Cannot look up value of a typedef");
565 if (overlay_debugging
)
566 VALUE_ADDRESS (v
) = symbol_overlayed_address
567 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_BFD_SECTION (var
));
569 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
574 case LOC_REGPARM_ADDR
:
577 int regno
= SYMBOL_VALUE (var
);
578 struct value
*regval
;
582 b
= get_frame_block (frame
, 0);
584 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
586 regval
= value_from_register (lookup_pointer_type (type
),
591 error ("Value of register variable not available.");
593 addr
= value_as_address (regval
);
594 VALUE_LVAL (v
) = lval_memory
;
598 regval
= value_from_register (type
, regno
, frame
);
601 error ("Value of register variable not available.");
609 struct minimal_symbol
*msym
;
611 msym
= lookup_minimal_symbol (SYMBOL_NAME (var
), NULL
, NULL
);
614 if (overlay_debugging
)
615 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
616 SYMBOL_BFD_SECTION (msym
));
618 addr
= SYMBOL_VALUE_ADDRESS (msym
);
622 case LOC_OPTIMIZED_OUT
:
623 VALUE_LVAL (v
) = not_lval
;
624 VALUE_OPTIMIZED_OUT (v
) = 1;
628 error ("Cannot look up value of a botched symbol.");
632 VALUE_ADDRESS (v
) = addr
;
637 /* Return a value of type TYPE, stored in register REGNUM, in frame
640 NOTE: returns NULL if register value is not available.
641 Caller will check return value or die! */
644 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
646 char *raw_buffer
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
649 struct value
*v
= allocate_value (type
);
650 char *value_bytes
= 0;
651 int value_bytes_copied
= 0;
652 int num_storage_locs
;
656 CHECK_TYPEDEF (type
);
657 len
= TYPE_LENGTH (type
);
659 VALUE_REGNO (v
) = regnum
;
661 num_storage_locs
= (len
> REGISTER_VIRTUAL_SIZE (regnum
) ?
662 ((len
- 1) / REGISTER_RAW_SIZE (regnum
)) + 1 :
665 if (num_storage_locs
> 1
667 // OBSOLETE #ifdef GDB_TARGET_IS_H8500
668 // OBSOLETE || TYPE_CODE (type) == TYPE_CODE_PTR
673 /* Value spread across multiple storage locations. */
676 int mem_stor
= 0, reg_stor
= 0;
677 int mem_tracking
= 1;
678 CORE_ADDR last_addr
= 0;
679 CORE_ADDR first_addr
= 0;
681 value_bytes
= (char *) alloca (len
+ MAX_REGISTER_RAW_SIZE
);
683 /* Copy all of the data out, whereever it may be. */
686 // OBSOLETE #ifdef GDB_TARGET_IS_H8500
687 // OBSOLETE /* This piece of hideosity is required because the H8500 treats registers
688 // OBSOLETE differently depending upon whether they are used as pointers or not. As a
689 // OBSOLETE pointer, a register needs to have a page register tacked onto the front.
690 // OBSOLETE An alternate way to do this would be to have gcc output different register
691 // OBSOLETE numbers for the pointer & non-pointer form of the register. But, it
692 // OBSOLETE doesn't, so we're stuck with this. */
694 // OBSOLETE if (TYPE_CODE (type) == TYPE_CODE_PTR
695 // OBSOLETE && len > 2)
697 // OBSOLETE int page_regnum;
699 // OBSOLETE switch (regnum)
701 // OBSOLETE case R0_REGNUM:
702 // OBSOLETE case R1_REGNUM:
703 // OBSOLETE case R2_REGNUM:
704 // OBSOLETE case R3_REGNUM:
705 // OBSOLETE page_regnum = SEG_D_REGNUM;
707 // OBSOLETE case R4_REGNUM:
708 // OBSOLETE case R5_REGNUM:
709 // OBSOLETE page_regnum = SEG_E_REGNUM;
711 // OBSOLETE case R6_REGNUM:
712 // OBSOLETE case R7_REGNUM:
713 // OBSOLETE page_regnum = SEG_T_REGNUM;
717 // OBSOLETE value_bytes[0] = 0;
718 // OBSOLETE get_saved_register (value_bytes + 1,
722 // OBSOLETE page_regnum,
725 // OBSOLETE if (register_cached (page_regnum) == -1)
726 // OBSOLETE return NULL; /* register value not available */
728 // OBSOLETE if (lval == lval_register)
729 // OBSOLETE reg_stor++;
731 // OBSOLETE mem_stor++;
732 // OBSOLETE first_addr = addr;
733 // OBSOLETE last_addr = addr;
735 // OBSOLETE get_saved_register (value_bytes + 2,
742 // OBSOLETE if (register_cached (regnum) == -1)
743 // OBSOLETE return NULL; /* register value not available */
745 // OBSOLETE if (lval == lval_register)
746 // OBSOLETE reg_stor++;
749 // OBSOLETE mem_stor++;
750 // OBSOLETE mem_tracking = mem_tracking && (addr == last_addr);
752 // OBSOLETE last_addr = addr;
755 // OBSOLETE #endif /* GDB_TARGET_IS_H8500 */
757 for (local_regnum
= regnum
;
758 value_bytes_copied
< len
;
759 (value_bytes_copied
+= REGISTER_RAW_SIZE (local_regnum
),
762 get_saved_register (value_bytes
+ value_bytes_copied
,
769 if (register_cached (local_regnum
) == -1)
770 return NULL
; /* register value not available */
772 if (regnum
== local_regnum
)
774 if (lval
== lval_register
)
782 && (regnum
== local_regnum
783 || addr
== last_addr
));
788 if ((reg_stor
&& mem_stor
)
789 || (mem_stor
&& !mem_tracking
))
790 /* Mixed storage; all of the hassle we just went through was
791 for some good purpose. */
793 VALUE_LVAL (v
) = lval_reg_frame_relative
;
794 VALUE_FRAME (v
) = get_frame_base (frame
);
795 VALUE_FRAME_REGNUM (v
) = regnum
;
799 VALUE_LVAL (v
) = lval_memory
;
800 VALUE_ADDRESS (v
) = first_addr
;
804 VALUE_LVAL (v
) = lval_register
;
805 VALUE_ADDRESS (v
) = first_addr
;
808 internal_error (__FILE__
, __LINE__
,
809 "value_from_register: Value not stored anywhere!");
811 VALUE_OPTIMIZED_OUT (v
) = optim
;
813 /* Any structure stored in more than one register will always be
814 an integral number of registers. Otherwise, you'd need to do
815 some fiddling with the last register copied here for little
818 /* Copy into the contents section of the value. */
819 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
, len
);
821 /* Finally do any conversion necessary when extracting this
822 type from more than one register. */
823 #ifdef REGISTER_CONVERT_TO_TYPE
824 REGISTER_CONVERT_TO_TYPE (regnum
, type
, VALUE_CONTENTS_RAW (v
));
829 /* Data is completely contained within a single register. Locate the
830 register's contents in a real register or in core;
831 read the data in raw format. */
833 get_saved_register (raw_buffer
, &optim
, &addr
, frame
, regnum
, &lval
);
835 if (register_cached (regnum
) == -1)
836 return NULL
; /* register value not available */
838 VALUE_OPTIMIZED_OUT (v
) = optim
;
839 VALUE_LVAL (v
) = lval
;
840 VALUE_ADDRESS (v
) = addr
;
842 /* Convert the raw register to the corresponding data value's memory
843 format, if necessary. */
845 if (CONVERT_REGISTER_P (regnum
))
847 REGISTER_TO_VALUE (regnum
, type
, raw_buffer
, VALUE_CONTENTS_RAW (v
));
851 /* Raw and virtual formats are the same for this register. */
853 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
&& len
< REGISTER_RAW_SIZE (regnum
))
855 /* Big-endian, and we want less than full size. */
856 VALUE_OFFSET (v
) = REGISTER_RAW_SIZE (regnum
) - len
;
859 memcpy (VALUE_CONTENTS_RAW (v
), raw_buffer
+ VALUE_OFFSET (v
), len
);
865 /* Given a struct symbol for a variable or function,
866 and a stack frame id,
867 return a (pointer to a) struct value containing the properly typed
871 locate_var_value (register struct symbol
*var
, struct frame_info
*frame
)
874 struct type
*type
= SYMBOL_TYPE (var
);
875 struct value
*lazy_value
;
877 /* Evaluate it first; if the result is a memory address, we're fine.
878 Lazy evaluation pays off here. */
880 lazy_value
= read_var_value (var
, frame
);
882 error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
884 if (VALUE_LAZY (lazy_value
)
885 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
889 addr
= VALUE_ADDRESS (lazy_value
);
890 val
= value_from_pointer (lookup_pointer_type (type
), addr
);
891 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (lazy_value
);
895 /* Not a memory address; check what the problem was. */
896 switch (VALUE_LVAL (lazy_value
))
899 gdb_assert (REGISTER_NAME (VALUE_REGNO (lazy_value
)) != NULL
900 && *REGISTER_NAME (VALUE_REGNO (lazy_value
)) != '\0');
901 error("Address requested for identifier "
902 "\"%s\" which is in register $%s",
903 SYMBOL_SOURCE_NAME (var
),
904 REGISTER_NAME (VALUE_REGNO (lazy_value
)));
907 case lval_reg_frame_relative
:
908 gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value
)) != NULL
909 && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value
)) != '\0');
910 error("Address requested for identifier "
911 "\"%s\" which is in frame register $%s",
912 SYMBOL_SOURCE_NAME (var
),
913 REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value
)));
917 error ("Can't take address of \"%s\" which isn't an lvalue.",
918 SYMBOL_SOURCE_NAME (var
));
921 return 0; /* For lint -- never reached */