1 /* Find a variable's value in memory, for GDB, the GNU debugger.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000, 2001
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
31 #include "gdb_string.h"
32 #include "floatformat.h"
33 #include "symfile.h" /* for overlay functions */
36 /* This is used to indicate that we don't know the format of the floating point
37 number. Typically, this is useful for native ports, where the actual format
38 is irrelevant, since no conversions will be taking place. */
40 const struct floatformat floatformat_unknown
;
42 /* Basic byte-swapping routines. GDB has needed these for a long time...
43 All extract a target-format integer at ADDR which is LEN bytes long. */
45 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
46 /* 8 bit characters are a pretty safe assumption these days, so we
47 assume it throughout all these swapping routines. If we had to deal with
48 9 bit characters, we would need to make len be in bits and would have
49 to re-write these routines... */
54 extract_signed_integer (void *addr
, int len
)
58 unsigned char *startaddr
= (unsigned char *) addr
;
59 unsigned char *endaddr
= startaddr
+ len
;
61 if (len
> (int) sizeof (LONGEST
))
63 That operation is not available on integers of more than %d bytes.",
66 /* Start at the most significant end of the integer, and work towards
67 the least significant. */
68 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
71 /* Do the sign extension once at the start. */
72 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
73 for (++p
; p
< endaddr
; ++p
)
74 retval
= (retval
<< 8) | *p
;
79 /* Do the sign extension once at the start. */
80 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
81 for (--p
; p
>= startaddr
; --p
)
82 retval
= (retval
<< 8) | *p
;
88 extract_unsigned_integer (void *addr
, int len
)
92 unsigned char *startaddr
= (unsigned char *) addr
;
93 unsigned char *endaddr
= startaddr
+ len
;
95 if (len
> (int) sizeof (ULONGEST
))
97 That operation is not available on integers of more than %d bytes.",
100 /* Start at the most significant end of the integer, and work towards
101 the least significant. */
103 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
105 for (p
= startaddr
; p
< endaddr
; ++p
)
106 retval
= (retval
<< 8) | *p
;
110 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
111 retval
= (retval
<< 8) | *p
;
116 /* Sometimes a long long unsigned integer can be extracted as a
117 LONGEST value. This is done so that we can print these values
118 better. If this integer can be converted to a LONGEST, this
119 function returns 1 and sets *PVAL. Otherwise it returns 0. */
122 extract_long_unsigned_integer (void *addr
, int orig_len
, LONGEST
*pval
)
124 char *p
, *first_addr
;
128 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
130 for (p
= (char *) addr
;
131 len
> (int) sizeof (LONGEST
) && p
< (char *) addr
+ orig_len
;
143 first_addr
= (char *) addr
;
144 for (p
= (char *) addr
+ orig_len
- 1;
145 len
> (int) sizeof (LONGEST
) && p
>= (char *) addr
;
155 if (len
<= (int) sizeof (LONGEST
))
157 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
166 /* Treat the LEN bytes at ADDR as a target-format address, and return
167 that address. ADDR is a buffer in the GDB process, not in the
170 This function should only be used by target-specific code. It
171 assumes that a pointer has the same representation as that thing's
172 address represented as an integer. Some machines use word
173 addresses, or similarly munged things, for certain types of
174 pointers, so that assumption doesn't hold everywhere.
176 Common code should use extract_typed_address instead, or something
177 else based on POINTER_TO_ADDRESS. */
180 extract_address (void *addr
, int len
)
182 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
183 whether we want this to be true eventually. */
184 return (CORE_ADDR
) extract_unsigned_integer (addr
, len
);
188 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
189 address it represents. */
191 extract_typed_address (void *buf
, struct type
*type
)
193 if (TYPE_CODE (type
) != TYPE_CODE_PTR
194 && TYPE_CODE (type
) != TYPE_CODE_REF
)
195 internal_error (__FILE__
, __LINE__
,
196 "extract_typed_address: "
197 "type is not a pointer or reference");
199 return POINTER_TO_ADDRESS (type
, buf
);
204 store_signed_integer (void *addr
, int len
, LONGEST val
)
207 unsigned char *startaddr
= (unsigned char *) addr
;
208 unsigned char *endaddr
= startaddr
+ len
;
210 /* Start at the least significant end of the integer, and work towards
211 the most significant. */
212 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
214 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
222 for (p
= startaddr
; p
< endaddr
; ++p
)
231 store_unsigned_integer (void *addr
, int len
, ULONGEST val
)
234 unsigned char *startaddr
= (unsigned char *) addr
;
235 unsigned char *endaddr
= startaddr
+ len
;
237 /* Start at the least significant end of the integer, and work towards
238 the most significant. */
239 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
241 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
249 for (p
= startaddr
; p
< endaddr
; ++p
)
257 /* Store the address VAL as a LEN-byte value in target byte order at
258 ADDR. ADDR is a buffer in the GDB process, not in the inferior.
260 This function should only be used by target-specific code. It
261 assumes that a pointer has the same representation as that thing's
262 address represented as an integer. Some machines use word
263 addresses, or similarly munged things, for certain types of
264 pointers, so that assumption doesn't hold everywhere.
266 Common code should use store_typed_address instead, or something else
267 based on ADDRESS_TO_POINTER. */
269 store_address (void *addr
, int len
, LONGEST val
)
271 store_unsigned_integer (addr
, len
, val
);
275 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
278 store_typed_address (void *buf
, struct type
*type
, CORE_ADDR addr
)
280 if (TYPE_CODE (type
) != TYPE_CODE_PTR
281 && TYPE_CODE (type
) != TYPE_CODE_REF
)
282 internal_error (__FILE__
, __LINE__
,
283 "store_typed_address: "
284 "type is not a pointer or reference");
286 ADDRESS_TO_POINTER (type
, buf
, addr
);
292 /* Extract a floating-point number from a target-order byte-stream at ADDR.
293 Returns the value as type DOUBLEST.
295 If the host and target formats agree, we just copy the raw data into the
296 appropriate type of variable and return, letting the host increase precision
297 as necessary. Otherwise, we call the conversion routine and let it do the
301 extract_floating (void *addr
, int len
)
305 if (len
* TARGET_CHAR_BIT
== TARGET_FLOAT_BIT
)
307 if (HOST_FLOAT_FORMAT
== TARGET_FLOAT_FORMAT
)
311 memcpy (&retval
, addr
, sizeof (retval
));
315 floatformat_to_doublest (TARGET_FLOAT_FORMAT
, addr
, &dretval
);
317 else if (len
* TARGET_CHAR_BIT
== TARGET_DOUBLE_BIT
)
319 if (HOST_DOUBLE_FORMAT
== TARGET_DOUBLE_FORMAT
)
323 memcpy (&retval
, addr
, sizeof (retval
));
327 floatformat_to_doublest (TARGET_DOUBLE_FORMAT
, addr
, &dretval
);
329 else if (len
* TARGET_CHAR_BIT
== TARGET_LONG_DOUBLE_BIT
)
331 if (HOST_LONG_DOUBLE_FORMAT
== TARGET_LONG_DOUBLE_FORMAT
)
335 memcpy (&retval
, addr
, sizeof (retval
));
339 floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT
, addr
, &dretval
);
343 error ("Can't deal with a floating point number of %d bytes.", len
);
350 store_floating (void *addr
, int len
, DOUBLEST val
)
352 if (len
* TARGET_CHAR_BIT
== TARGET_FLOAT_BIT
)
354 if (HOST_FLOAT_FORMAT
== TARGET_FLOAT_FORMAT
)
356 float floatval
= val
;
358 memcpy (addr
, &floatval
, sizeof (floatval
));
361 floatformat_from_doublest (TARGET_FLOAT_FORMAT
, &val
, addr
);
363 else if (len
* TARGET_CHAR_BIT
== TARGET_DOUBLE_BIT
)
365 if (HOST_DOUBLE_FORMAT
== TARGET_DOUBLE_FORMAT
)
367 double doubleval
= val
;
369 memcpy (addr
, &doubleval
, sizeof (doubleval
));
372 floatformat_from_doublest (TARGET_DOUBLE_FORMAT
, &val
, addr
);
374 else if (len
* TARGET_CHAR_BIT
== TARGET_LONG_DOUBLE_BIT
)
376 if (HOST_LONG_DOUBLE_FORMAT
== TARGET_LONG_DOUBLE_FORMAT
)
377 memcpy (addr
, &val
, sizeof (val
));
379 floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT
, &val
, addr
);
383 error ("Can't deal with a floating point number of %d bytes.", len
);
387 /* Return a `value' with the contents of register REGNUM
388 in its virtual format, with the type specified by
389 REGISTER_VIRTUAL_TYPE.
391 NOTE: returns NULL if register value is not available.
392 Caller will check return value or die! */
395 value_of_register (int regnum
)
399 register value_ptr reg_val
;
400 char *raw_buffer
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
403 get_saved_register (raw_buffer
, &optim
, &addr
,
404 selected_frame
, regnum
, &lval
);
406 if (register_cached (regnum
) < 0)
407 return NULL
; /* register value not available */
409 reg_val
= allocate_value (REGISTER_VIRTUAL_TYPE (regnum
));
411 /* Convert raw data to virtual format if necessary. */
413 if (REGISTER_CONVERTIBLE (regnum
))
415 REGISTER_CONVERT_TO_VIRTUAL (regnum
, REGISTER_VIRTUAL_TYPE (regnum
),
416 raw_buffer
, VALUE_CONTENTS_RAW (reg_val
));
418 else if (REGISTER_RAW_SIZE (regnum
) == REGISTER_VIRTUAL_SIZE (regnum
))
419 memcpy (VALUE_CONTENTS_RAW (reg_val
), raw_buffer
,
420 REGISTER_RAW_SIZE (regnum
));
422 internal_error (__FILE__
, __LINE__
,
423 "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
424 REGISTER_NAME (regnum
),
426 REGISTER_RAW_SIZE (regnum
),
427 REGISTER_VIRTUAL_SIZE (regnum
));
428 VALUE_LVAL (reg_val
) = lval
;
429 VALUE_ADDRESS (reg_val
) = addr
;
430 VALUE_REGNO (reg_val
) = regnum
;
431 VALUE_OPTIMIZED_OUT (reg_val
) = optim
;
435 /* Given a pointer of type TYPE in target form in BUF, return the
436 address it represents. */
438 unsigned_pointer_to_address (struct type
*type
, void *buf
)
440 return extract_address (buf
, TYPE_LENGTH (type
));
444 signed_pointer_to_address (struct type
*type
, void *buf
)
446 return extract_signed_integer (buf
, TYPE_LENGTH (type
));
449 /* Given an address, store it as a pointer of type TYPE in target
452 unsigned_address_to_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
454 store_address (buf
, TYPE_LENGTH (type
), addr
);
458 address_to_signed_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
460 store_signed_integer (buf
, TYPE_LENGTH (type
), addr
);
463 /* Will calling read_var_value or locate_var_value on SYM end
464 up caring what frame it is being evaluated relative to? SYM must
467 symbol_read_needs_frame (struct symbol
*sym
)
469 switch (SYMBOL_CLASS (sym
))
471 /* All cases listed explicitly so that gcc -Wall will detect it if
472 we failed to consider one. */
477 case LOC_REGPARM_ADDR
:
481 case LOC_BASEREG_ARG
:
482 case LOC_THREAD_LOCAL_STATIC
:
492 /* Getting the address of a label can be done independently of the block,
493 even if some *uses* of that address wouldn't work so well without
497 case LOC_CONST_BYTES
:
499 case LOC_OPTIMIZED_OUT
:
505 /* Given a struct symbol for a variable,
506 and a stack frame id, read the value of the variable
507 and return a (pointer to a) struct value containing the value.
508 If the variable cannot be found, return a zero pointer.
509 If FRAME is NULL, use the selected_frame. */
512 read_var_value (register struct symbol
*var
, struct frame_info
*frame
)
514 register value_ptr v
;
515 struct type
*type
= SYMBOL_TYPE (var
);
519 v
= allocate_value (type
);
520 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
521 VALUE_BFD_SECTION (v
) = SYMBOL_BFD_SECTION (var
);
523 len
= TYPE_LENGTH (type
);
526 frame
= selected_frame
;
528 switch (SYMBOL_CLASS (var
))
531 /* Put the constant back in target format. */
532 store_signed_integer (VALUE_CONTENTS_RAW (v
), len
,
533 (LONGEST
) SYMBOL_VALUE (var
));
534 VALUE_LVAL (v
) = not_lval
;
538 /* Put the constant back in target format. */
539 if (overlay_debugging
)
542 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
543 SYMBOL_BFD_SECTION (var
));
544 store_typed_address (VALUE_CONTENTS_RAW (v
), type
, addr
);
547 store_typed_address (VALUE_CONTENTS_RAW (v
), type
,
548 SYMBOL_VALUE_ADDRESS (var
));
549 VALUE_LVAL (v
) = not_lval
;
552 case LOC_CONST_BYTES
:
555 bytes_addr
= SYMBOL_VALUE_BYTES (var
);
556 memcpy (VALUE_CONTENTS_RAW (v
), bytes_addr
, len
);
557 VALUE_LVAL (v
) = not_lval
;
562 if (overlay_debugging
)
563 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
564 SYMBOL_BFD_SECTION (var
));
566 addr
= SYMBOL_VALUE_ADDRESS (var
);
570 /* The import slot does not have a real address in it from the
571 dynamic loader (dld.sl on HP-UX), if the target hasn't begun
572 execution yet, so check for that. */
573 if (!target_has_execution
)
575 Attempt to access variable defined in different shared object or load module when\n\
576 addresses have not been bound by the dynamic loader. Try again when executable is running.");
578 addr
= SYMBOL_VALUE_ADDRESS (var
);
579 addr
= read_memory_unsigned_integer
580 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
586 addr
= FRAME_ARGS_ADDRESS (frame
);
589 addr
+= SYMBOL_VALUE (var
);
595 addr
= FRAME_ARGS_ADDRESS (frame
);
598 addr
+= SYMBOL_VALUE (var
);
599 addr
= read_memory_unsigned_integer
600 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
607 addr
= FRAME_LOCALS_ADDRESS (frame
);
608 addr
+= SYMBOL_VALUE (var
);
612 case LOC_BASEREG_ARG
:
613 case LOC_THREAD_LOCAL_STATIC
:
617 regval
= value_from_register (lookup_pointer_type (type
),
618 SYMBOL_BASEREG (var
), frame
);
620 error ("Value of base register not available.");
621 addr
= value_as_pointer (regval
);
622 addr
+= SYMBOL_VALUE (var
);
627 error ("Cannot look up value of a typedef");
631 if (overlay_debugging
)
632 VALUE_ADDRESS (v
) = symbol_overlayed_address
633 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_BFD_SECTION (var
));
635 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
640 case LOC_REGPARM_ADDR
:
643 int regno
= SYMBOL_VALUE (var
);
648 b
= get_frame_block (frame
);
650 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
652 regval
= value_from_register (lookup_pointer_type (type
),
657 error ("Value of register variable not available.");
659 addr
= value_as_pointer (regval
);
660 VALUE_LVAL (v
) = lval_memory
;
664 regval
= value_from_register (type
, regno
, frame
);
667 error ("Value of register variable not available.");
675 struct minimal_symbol
*msym
;
677 msym
= lookup_minimal_symbol (SYMBOL_NAME (var
), NULL
, NULL
);
680 if (overlay_debugging
)
681 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
682 SYMBOL_BFD_SECTION (msym
));
684 addr
= SYMBOL_VALUE_ADDRESS (msym
);
688 case LOC_OPTIMIZED_OUT
:
689 VALUE_LVAL (v
) = not_lval
;
690 VALUE_OPTIMIZED_OUT (v
) = 1;
694 error ("Cannot look up value of a botched symbol.");
698 VALUE_ADDRESS (v
) = addr
;
703 /* Return a value of type TYPE, stored in register REGNUM, in frame
706 NOTE: returns NULL if register value is not available.
707 Caller will check return value or die! */
710 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
712 char *raw_buffer
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
715 value_ptr v
= allocate_value (type
);
716 char *value_bytes
= 0;
717 int value_bytes_copied
= 0;
718 int num_storage_locs
;
722 CHECK_TYPEDEF (type
);
723 len
= TYPE_LENGTH (type
);
725 VALUE_REGNO (v
) = regnum
;
727 num_storage_locs
= (len
> REGISTER_VIRTUAL_SIZE (regnum
) ?
728 ((len
- 1) / REGISTER_RAW_SIZE (regnum
)) + 1 :
731 if (num_storage_locs
> 1
732 #ifdef GDB_TARGET_IS_H8500
733 || TYPE_CODE (type
) == TYPE_CODE_PTR
737 /* Value spread across multiple storage locations. */
740 int mem_stor
= 0, reg_stor
= 0;
741 int mem_tracking
= 1;
742 CORE_ADDR last_addr
= 0;
743 CORE_ADDR first_addr
= 0;
745 value_bytes
= (char *) alloca (len
+ MAX_REGISTER_RAW_SIZE
);
747 /* Copy all of the data out, whereever it may be. */
749 #ifdef GDB_TARGET_IS_H8500
750 /* This piece of hideosity is required because the H8500 treats registers
751 differently depending upon whether they are used as pointers or not. As a
752 pointer, a register needs to have a page register tacked onto the front.
753 An alternate way to do this would be to have gcc output different register
754 numbers for the pointer & non-pointer form of the register. But, it
755 doesn't, so we're stuck with this. */
757 if (TYPE_CODE (type
) == TYPE_CODE_PTR
768 page_regnum
= SEG_D_REGNUM
;
772 page_regnum
= SEG_E_REGNUM
;
776 page_regnum
= SEG_T_REGNUM
;
781 get_saved_register (value_bytes
+ 1,
788 if (register_cached (page_regnum
) == -1)
789 return NULL
; /* register value not available */
791 if (lval
== lval_register
)
798 get_saved_register (value_bytes
+ 2,
805 if (register_cached (regnum
) == -1)
806 return NULL
; /* register value not available */
808 if (lval
== lval_register
)
813 mem_tracking
= mem_tracking
&& (addr
== last_addr
);
818 #endif /* GDB_TARGET_IS_H8500 */
819 for (local_regnum
= regnum
;
820 value_bytes_copied
< len
;
821 (value_bytes_copied
+= REGISTER_RAW_SIZE (local_regnum
),
824 get_saved_register (value_bytes
+ value_bytes_copied
,
831 if (register_cached (local_regnum
) == -1)
832 return NULL
; /* register value not available */
834 if (regnum
== local_regnum
)
836 if (lval
== lval_register
)
844 && (regnum
== local_regnum
845 || addr
== last_addr
));
850 if ((reg_stor
&& mem_stor
)
851 || (mem_stor
&& !mem_tracking
))
852 /* Mixed storage; all of the hassle we just went through was
853 for some good purpose. */
855 VALUE_LVAL (v
) = lval_reg_frame_relative
;
856 VALUE_FRAME (v
) = FRAME_FP (frame
);
857 VALUE_FRAME_REGNUM (v
) = regnum
;
861 VALUE_LVAL (v
) = lval_memory
;
862 VALUE_ADDRESS (v
) = first_addr
;
866 VALUE_LVAL (v
) = lval_register
;
867 VALUE_ADDRESS (v
) = first_addr
;
870 internal_error (__FILE__
, __LINE__
,
871 "value_from_register: Value not stored anywhere!");
873 VALUE_OPTIMIZED_OUT (v
) = optim
;
875 /* Any structure stored in more than one register will always be
876 an integral number of registers. Otherwise, you'd need to do
877 some fiddling with the last register copied here for little
880 /* Copy into the contents section of the value. */
881 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
, len
);
883 /* Finally do any conversion necessary when extracting this
884 type from more than one register. */
885 #ifdef REGISTER_CONVERT_TO_TYPE
886 REGISTER_CONVERT_TO_TYPE (regnum
, type
, VALUE_CONTENTS_RAW (v
));
891 /* Data is completely contained within a single register. Locate the
892 register's contents in a real register or in core;
893 read the data in raw format. */
895 get_saved_register (raw_buffer
, &optim
, &addr
, frame
, regnum
, &lval
);
897 if (register_cached (regnum
) == -1)
898 return NULL
; /* register value not available */
900 VALUE_OPTIMIZED_OUT (v
) = optim
;
901 VALUE_LVAL (v
) = lval
;
902 VALUE_ADDRESS (v
) = addr
;
904 /* Convert raw data to virtual format if necessary. */
906 if (REGISTER_CONVERTIBLE (regnum
))
908 REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
,
909 raw_buffer
, VALUE_CONTENTS_RAW (v
));
913 /* Raw and virtual formats are the same for this register. */
915 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
&& len
< REGISTER_RAW_SIZE (regnum
))
917 /* Big-endian, and we want less than full size. */
918 VALUE_OFFSET (v
) = REGISTER_RAW_SIZE (regnum
) - len
;
921 memcpy (VALUE_CONTENTS_RAW (v
), raw_buffer
+ VALUE_OFFSET (v
), len
);
927 /* Given a struct symbol for a variable or function,
928 and a stack frame id,
929 return a (pointer to a) struct value containing the properly typed
933 locate_var_value (register struct symbol
*var
, struct frame_info
*frame
)
936 struct type
*type
= SYMBOL_TYPE (var
);
937 value_ptr lazy_value
;
939 /* Evaluate it first; if the result is a memory address, we're fine.
940 Lazy evaluation pays off here. */
942 lazy_value
= read_var_value (var
, frame
);
944 error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
946 if (VALUE_LAZY (lazy_value
)
947 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
951 addr
= VALUE_ADDRESS (lazy_value
);
952 val
= value_from_pointer (lookup_pointer_type (type
), addr
);
953 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (lazy_value
);
957 /* Not a memory address; check what the problem was. */
958 switch (VALUE_LVAL (lazy_value
))
961 case lval_reg_frame_relative
:
962 error ("Address requested for identifier \"%s\" which is in a register.",
963 SYMBOL_SOURCE_NAME (var
));
967 error ("Can't take address of \"%s\" which isn't an lvalue.",
968 SYMBOL_SOURCE_NAME (var
));
971 return 0; /* For lint -- never reached */