1 /* Find a variable's value in memory, for GDB, the GNU debugger.
2 Copyright 1986, 87, 89, 91, 94, 95, 96, 1998, 2001
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
30 #include "gdb_string.h"
31 #include "floatformat.h"
32 #include "symfile.h" /* for overlay functions */
35 /* This is used to indicate that we don't know the format of the floating point
36 number. Typically, this is useful for native ports, where the actual format
37 is irrelevant, since no conversions will be taking place. */
39 const struct floatformat floatformat_unknown
;
41 /* Basic byte-swapping routines. GDB has needed these for a long time...
42 All extract a target-format integer at ADDR which is LEN bytes long. */
44 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
45 /* 8 bit characters are a pretty safe assumption these days, so we
46 assume it throughout all these swapping routines. If we had to deal with
47 9 bit characters, we would need to make len be in bits and would have
48 to re-write these routines... */
53 extract_signed_integer (void *addr
, int len
)
57 unsigned char *startaddr
= (unsigned char *) addr
;
58 unsigned char *endaddr
= startaddr
+ len
;
60 if (len
> (int) sizeof (LONGEST
))
62 That operation is not available on integers of more than %d bytes.",
65 /* Start at the most significant end of the integer, and work towards
66 the least significant. */
67 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
70 /* Do the sign extension once at the start. */
71 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
72 for (++p
; p
< endaddr
; ++p
)
73 retval
= (retval
<< 8) | *p
;
78 /* Do the sign extension once at the start. */
79 retval
= ((LONGEST
) * p
^ 0x80) - 0x80;
80 for (--p
; p
>= startaddr
; --p
)
81 retval
= (retval
<< 8) | *p
;
87 extract_unsigned_integer (void *addr
, int len
)
91 unsigned char *startaddr
= (unsigned char *) addr
;
92 unsigned char *endaddr
= startaddr
+ len
;
94 if (len
> (int) sizeof (ULONGEST
))
96 That operation is not available on integers of more than %d bytes.",
99 /* Start at the most significant end of the integer, and work towards
100 the least significant. */
102 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
104 for (p
= startaddr
; p
< endaddr
; ++p
)
105 retval
= (retval
<< 8) | *p
;
109 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
110 retval
= (retval
<< 8) | *p
;
115 /* Sometimes a long long unsigned integer can be extracted as a
116 LONGEST value. This is done so that we can print these values
117 better. If this integer can be converted to a LONGEST, this
118 function returns 1 and sets *PVAL. Otherwise it returns 0. */
121 extract_long_unsigned_integer (void *addr
, int orig_len
, LONGEST
*pval
)
123 char *p
, *first_addr
;
127 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
129 for (p
= (char *) addr
;
130 len
> (int) sizeof (LONGEST
) && p
< (char *) addr
+ orig_len
;
142 first_addr
= (char *) addr
;
143 for (p
= (char *) addr
+ orig_len
- 1;
144 len
> (int) sizeof (LONGEST
) && p
>= (char *) addr
;
154 if (len
<= (int) sizeof (LONGEST
))
156 *pval
= (LONGEST
) extract_unsigned_integer (first_addr
,
165 /* Treat the LEN bytes at ADDR as a target-format address, and return
166 that address. ADDR is a buffer in the GDB process, not in the
169 This function should only be used by target-specific code. It
170 assumes that a pointer has the same representation as that thing's
171 address represented as an integer. Some machines use word
172 addresses, or similarly munged things, for certain types of
173 pointers, so that assumption doesn't hold everywhere.
175 Common code should use extract_typed_address instead, or something
176 else based on POINTER_TO_ADDRESS. */
179 extract_address (void *addr
, int len
)
181 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
182 whether we want this to be true eventually. */
183 return (CORE_ADDR
) extract_unsigned_integer (addr
, len
);
187 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
188 address it represents. */
190 extract_typed_address (void *buf
, struct type
*type
)
192 if (TYPE_CODE (type
) != TYPE_CODE_PTR
193 && TYPE_CODE (type
) != TYPE_CODE_REF
)
194 internal_error (__FILE__
, __LINE__
,
195 "extract_typed_address: "
196 "type is not a pointer or reference");
198 return POINTER_TO_ADDRESS (type
, buf
);
203 store_signed_integer (void *addr
, int len
, LONGEST val
)
206 unsigned char *startaddr
= (unsigned char *) addr
;
207 unsigned char *endaddr
= startaddr
+ len
;
209 /* Start at the least significant end of the integer, and work towards
210 the most significant. */
211 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
213 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
221 for (p
= startaddr
; p
< endaddr
; ++p
)
230 store_unsigned_integer (void *addr
, int len
, ULONGEST val
)
233 unsigned char *startaddr
= (unsigned char *) addr
;
234 unsigned char *endaddr
= startaddr
+ len
;
236 /* Start at the least significant end of the integer, and work towards
237 the most significant. */
238 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
240 for (p
= endaddr
- 1; p
>= startaddr
; --p
)
248 for (p
= startaddr
; p
< endaddr
; ++p
)
256 /* Store the address VAL as a LEN-byte value in target byte order at
257 ADDR. ADDR is a buffer in the GDB process, not in the inferior.
259 This function should only be used by target-specific code. It
260 assumes that a pointer has the same representation as that thing's
261 address represented as an integer. Some machines use word
262 addresses, or similarly munged things, for certain types of
263 pointers, so that assumption doesn't hold everywhere.
265 Common code should use store_typed_address instead, or something else
266 based on ADDRESS_TO_POINTER. */
268 store_address (void *addr
, int len
, LONGEST val
)
270 store_unsigned_integer (addr
, len
, val
);
274 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
277 store_typed_address (void *buf
, struct type
*type
, CORE_ADDR addr
)
279 if (TYPE_CODE (type
) != TYPE_CODE_PTR
280 && TYPE_CODE (type
) != TYPE_CODE_REF
)
281 internal_error (__FILE__
, __LINE__
,
282 "store_typed_address: "
283 "type is not a pointer or reference");
285 ADDRESS_TO_POINTER (type
, buf
, addr
);
291 /* Extract a floating-point number from a target-order byte-stream at ADDR.
292 Returns the value as type DOUBLEST.
294 If the host and target formats agree, we just copy the raw data into the
295 appropriate type of variable and return, letting the host increase precision
296 as necessary. Otherwise, we call the conversion routine and let it do the
300 extract_floating (void *addr
, int len
)
304 if (len
* TARGET_CHAR_BIT
== TARGET_FLOAT_BIT
)
306 if (HOST_FLOAT_FORMAT
== TARGET_FLOAT_FORMAT
)
310 memcpy (&retval
, addr
, sizeof (retval
));
314 floatformat_to_doublest (TARGET_FLOAT_FORMAT
, addr
, &dretval
);
316 else if (len
* TARGET_CHAR_BIT
== TARGET_DOUBLE_BIT
)
318 if (HOST_DOUBLE_FORMAT
== TARGET_DOUBLE_FORMAT
)
322 memcpy (&retval
, addr
, sizeof (retval
));
326 floatformat_to_doublest (TARGET_DOUBLE_FORMAT
, addr
, &dretval
);
328 else if (len
* TARGET_CHAR_BIT
== TARGET_LONG_DOUBLE_BIT
)
330 if (HOST_LONG_DOUBLE_FORMAT
== TARGET_LONG_DOUBLE_FORMAT
)
334 memcpy (&retval
, addr
, sizeof (retval
));
338 floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT
, addr
, &dretval
);
342 error ("Can't deal with a floating point number of %d bytes.", len
);
349 store_floating (void *addr
, int len
, DOUBLEST val
)
351 if (len
* TARGET_CHAR_BIT
== TARGET_FLOAT_BIT
)
353 if (HOST_FLOAT_FORMAT
== TARGET_FLOAT_FORMAT
)
355 float floatval
= val
;
357 memcpy (addr
, &floatval
, sizeof (floatval
));
360 floatformat_from_doublest (TARGET_FLOAT_FORMAT
, &val
, addr
);
362 else if (len
* TARGET_CHAR_BIT
== TARGET_DOUBLE_BIT
)
364 if (HOST_DOUBLE_FORMAT
== TARGET_DOUBLE_FORMAT
)
366 double doubleval
= val
;
368 memcpy (addr
, &doubleval
, sizeof (doubleval
));
371 floatformat_from_doublest (TARGET_DOUBLE_FORMAT
, &val
, addr
);
373 else if (len
* TARGET_CHAR_BIT
== TARGET_LONG_DOUBLE_BIT
)
375 if (HOST_LONG_DOUBLE_FORMAT
== TARGET_LONG_DOUBLE_FORMAT
)
376 memcpy (addr
, &val
, sizeof (val
));
378 floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT
, &val
, addr
);
382 error ("Can't deal with a floating point number of %d bytes.", len
);
386 /* Return a `value' with the contents of register REGNUM
387 in its virtual format, with the type specified by
388 REGISTER_VIRTUAL_TYPE.
390 NOTE: returns NULL if register value is not available.
391 Caller will check return value or die! */
394 value_of_register (int regnum
)
398 register value_ptr reg_val
;
399 char *raw_buffer
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
402 get_saved_register (raw_buffer
, &optim
, &addr
,
403 selected_frame
, regnum
, &lval
);
405 if (register_cached (regnum
) < 0)
406 return NULL
; /* register value not available */
408 reg_val
= allocate_value (REGISTER_VIRTUAL_TYPE (regnum
));
410 /* Convert raw data to virtual format if necessary. */
412 if (REGISTER_CONVERTIBLE (regnum
))
414 REGISTER_CONVERT_TO_VIRTUAL (regnum
, REGISTER_VIRTUAL_TYPE (regnum
),
415 raw_buffer
, VALUE_CONTENTS_RAW (reg_val
));
417 else if (REGISTER_RAW_SIZE (regnum
) == REGISTER_VIRTUAL_SIZE (regnum
))
418 memcpy (VALUE_CONTENTS_RAW (reg_val
), raw_buffer
,
419 REGISTER_RAW_SIZE (regnum
));
421 internal_error (__FILE__
, __LINE__
,
422 "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
423 REGISTER_NAME (regnum
),
425 REGISTER_RAW_SIZE (regnum
),
426 REGISTER_VIRTUAL_SIZE (regnum
));
427 VALUE_LVAL (reg_val
) = lval
;
428 VALUE_ADDRESS (reg_val
) = addr
;
429 VALUE_REGNO (reg_val
) = regnum
;
430 VALUE_OPTIMIZED_OUT (reg_val
) = optim
;
434 /* Given a pointer of type TYPE in target form in BUF, return the
435 address it represents. */
437 unsigned_pointer_to_address (struct type
*type
, void *buf
)
439 return extract_address (buf
, TYPE_LENGTH (type
));
443 signed_pointer_to_address (struct type
*type
, void *buf
)
445 return extract_signed_integer (buf
, TYPE_LENGTH (type
));
448 /* Given an address, store it as a pointer of type TYPE in target
451 unsigned_address_to_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
453 store_address (buf
, TYPE_LENGTH (type
), addr
);
457 address_to_signed_pointer (struct type
*type
, void *buf
, CORE_ADDR addr
)
459 store_signed_integer (buf
, TYPE_LENGTH (type
), addr
);
462 /* Will calling read_var_value or locate_var_value on SYM end
463 up caring what frame it is being evaluated relative to? SYM must
466 symbol_read_needs_frame (struct symbol
*sym
)
468 switch (SYMBOL_CLASS (sym
))
470 /* All cases listed explicitly so that gcc -Wall will detect it if
471 we failed to consider one. */
476 case LOC_REGPARM_ADDR
:
480 case LOC_BASEREG_ARG
:
481 case LOC_THREAD_LOCAL_STATIC
:
491 /* Getting the address of a label can be done independently of the block,
492 even if some *uses* of that address wouldn't work so well without
496 case LOC_CONST_BYTES
:
498 case LOC_OPTIMIZED_OUT
:
504 /* Given a struct symbol for a variable,
505 and a stack frame id, read the value of the variable
506 and return a (pointer to a) struct value containing the value.
507 If the variable cannot be found, return a zero pointer.
508 If FRAME is NULL, use the selected_frame. */
511 read_var_value (register struct symbol
*var
, struct frame_info
*frame
)
513 register value_ptr v
;
514 struct type
*type
= SYMBOL_TYPE (var
);
518 v
= allocate_value (type
);
519 VALUE_LVAL (v
) = lval_memory
; /* The most likely possibility. */
520 VALUE_BFD_SECTION (v
) = SYMBOL_BFD_SECTION (var
);
522 len
= TYPE_LENGTH (type
);
525 frame
= selected_frame
;
527 switch (SYMBOL_CLASS (var
))
530 /* Put the constant back in target format. */
531 store_signed_integer (VALUE_CONTENTS_RAW (v
), len
,
532 (LONGEST
) SYMBOL_VALUE (var
));
533 VALUE_LVAL (v
) = not_lval
;
537 /* Put the constant back in target format. */
538 if (overlay_debugging
)
541 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
542 SYMBOL_BFD_SECTION (var
));
543 store_typed_address (VALUE_CONTENTS_RAW (v
), type
, addr
);
546 store_typed_address (VALUE_CONTENTS_RAW (v
), type
,
547 SYMBOL_VALUE_ADDRESS (var
));
548 VALUE_LVAL (v
) = not_lval
;
551 case LOC_CONST_BYTES
:
554 bytes_addr
= SYMBOL_VALUE_BYTES (var
);
555 memcpy (VALUE_CONTENTS_RAW (v
), bytes_addr
, len
);
556 VALUE_LVAL (v
) = not_lval
;
561 if (overlay_debugging
)
562 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var
),
563 SYMBOL_BFD_SECTION (var
));
565 addr
= SYMBOL_VALUE_ADDRESS (var
);
569 /* The import slot does not have a real address in it from the
570 dynamic loader (dld.sl on HP-UX), if the target hasn't begun
571 execution yet, so check for that. */
572 if (!target_has_execution
)
574 Attempt to access variable defined in different shared object or load module when\n\
575 addresses have not been bound by the dynamic loader. Try again when executable is running.");
577 addr
= SYMBOL_VALUE_ADDRESS (var
);
578 addr
= read_memory_unsigned_integer
579 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
585 addr
= FRAME_ARGS_ADDRESS (frame
);
588 addr
+= SYMBOL_VALUE (var
);
594 addr
= FRAME_ARGS_ADDRESS (frame
);
597 addr
+= SYMBOL_VALUE (var
);
598 addr
= read_memory_unsigned_integer
599 (addr
, TARGET_PTR_BIT
/ TARGET_CHAR_BIT
);
606 addr
= FRAME_LOCALS_ADDRESS (frame
);
607 addr
+= SYMBOL_VALUE (var
);
611 case LOC_BASEREG_ARG
:
613 char *buf
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
614 get_saved_register (buf
, NULL
, NULL
, frame
, SYMBOL_BASEREG (var
),
616 addr
= extract_address (buf
, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var
)));
617 addr
+= SYMBOL_VALUE (var
);
621 case LOC_THREAD_LOCAL_STATIC
:
623 char *buf
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
625 get_saved_register (buf
, NULL
, NULL
, frame
, SYMBOL_BASEREG (var
),
627 addr
= extract_address (buf
, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var
)));
628 addr
+= SYMBOL_VALUE (var
);
633 error ("Cannot look up value of a typedef");
637 if (overlay_debugging
)
638 VALUE_ADDRESS (v
) = symbol_overlayed_address
639 (BLOCK_START (SYMBOL_BLOCK_VALUE (var
)), SYMBOL_BFD_SECTION (var
));
641 VALUE_ADDRESS (v
) = BLOCK_START (SYMBOL_BLOCK_VALUE (var
));
646 case LOC_REGPARM_ADDR
:
649 int regno
= SYMBOL_VALUE (var
);
654 b
= get_frame_block (frame
);
656 if (SYMBOL_CLASS (var
) == LOC_REGPARM_ADDR
)
658 regval
= value_from_register (lookup_pointer_type (type
),
663 error ("Value of register variable not available.");
665 addr
= value_as_pointer (regval
);
666 VALUE_LVAL (v
) = lval_memory
;
670 regval
= value_from_register (type
, regno
, frame
);
673 error ("Value of register variable not available.");
681 struct minimal_symbol
*msym
;
683 msym
= lookup_minimal_symbol (SYMBOL_NAME (var
), NULL
, NULL
);
686 if (overlay_debugging
)
687 addr
= symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym
),
688 SYMBOL_BFD_SECTION (msym
));
690 addr
= SYMBOL_VALUE_ADDRESS (msym
);
694 case LOC_OPTIMIZED_OUT
:
695 VALUE_LVAL (v
) = not_lval
;
696 VALUE_OPTIMIZED_OUT (v
) = 1;
700 error ("Cannot look up value of a botched symbol.");
704 VALUE_ADDRESS (v
) = addr
;
709 /* Return a value of type TYPE, stored in register REGNUM, in frame
712 NOTE: returns NULL if register value is not available.
713 Caller will check return value or die! */
716 value_from_register (struct type
*type
, int regnum
, struct frame_info
*frame
)
718 char *raw_buffer
= (char*) alloca (MAX_REGISTER_RAW_SIZE
);
721 value_ptr v
= allocate_value (type
);
722 char *value_bytes
= 0;
723 int value_bytes_copied
= 0;
724 int num_storage_locs
;
728 CHECK_TYPEDEF (type
);
729 len
= TYPE_LENGTH (type
);
731 /* Pointers on D10V are really only 16 bits,
732 but we lie to gdb elsewhere... */
733 if (GDB_TARGET_IS_D10V
&& TYPE_CODE (type
) == TYPE_CODE_PTR
)
736 VALUE_REGNO (v
) = regnum
;
738 num_storage_locs
= (len
> REGISTER_VIRTUAL_SIZE (regnum
) ?
739 ((len
- 1) / REGISTER_RAW_SIZE (regnum
)) + 1 :
742 if (num_storage_locs
> 1
743 #ifdef GDB_TARGET_IS_H8500
744 || TYPE_CODE (type
) == TYPE_CODE_PTR
748 /* Value spread across multiple storage locations. */
751 int mem_stor
= 0, reg_stor
= 0;
752 int mem_tracking
= 1;
753 CORE_ADDR last_addr
= 0;
754 CORE_ADDR first_addr
= 0;
756 value_bytes
= (char *) alloca (len
+ MAX_REGISTER_RAW_SIZE
);
758 /* Copy all of the data out, whereever it may be. */
760 #ifdef GDB_TARGET_IS_H8500
761 /* This piece of hideosity is required because the H8500 treats registers
762 differently depending upon whether they are used as pointers or not. As a
763 pointer, a register needs to have a page register tacked onto the front.
764 An alternate way to do this would be to have gcc output different register
765 numbers for the pointer & non-pointer form of the register. But, it
766 doesn't, so we're stuck with this. */
768 if (TYPE_CODE (type
) == TYPE_CODE_PTR
779 page_regnum
= SEG_D_REGNUM
;
783 page_regnum
= SEG_E_REGNUM
;
787 page_regnum
= SEG_T_REGNUM
;
792 get_saved_register (value_bytes
+ 1,
799 if (register_cached (page_regnum
) == -1)
800 return NULL
; /* register value not available */
802 if (lval
== lval_register
)
809 get_saved_register (value_bytes
+ 2,
816 if (register_cached (regnum
) == -1)
817 return NULL
; /* register value not available */
819 if (lval
== lval_register
)
824 mem_tracking
= mem_tracking
&& (addr
== last_addr
);
829 #endif /* GDB_TARGET_IS_H8500 */
830 for (local_regnum
= regnum
;
831 value_bytes_copied
< len
;
832 (value_bytes_copied
+= REGISTER_RAW_SIZE (local_regnum
),
835 get_saved_register (value_bytes
+ value_bytes_copied
,
842 if (register_cached (local_regnum
) == -1)
843 return NULL
; /* register value not available */
845 if (regnum
== local_regnum
)
847 if (lval
== lval_register
)
855 && (regnum
== local_regnum
856 || addr
== last_addr
));
861 if ((reg_stor
&& mem_stor
)
862 || (mem_stor
&& !mem_tracking
))
863 /* Mixed storage; all of the hassle we just went through was
864 for some good purpose. */
866 VALUE_LVAL (v
) = lval_reg_frame_relative
;
867 VALUE_FRAME (v
) = FRAME_FP (frame
);
868 VALUE_FRAME_REGNUM (v
) = regnum
;
872 VALUE_LVAL (v
) = lval_memory
;
873 VALUE_ADDRESS (v
) = first_addr
;
877 VALUE_LVAL (v
) = lval_register
;
878 VALUE_ADDRESS (v
) = first_addr
;
881 internal_error (__FILE__
, __LINE__
,
882 "value_from_register: Value not stored anywhere!");
884 VALUE_OPTIMIZED_OUT (v
) = optim
;
886 /* Any structure stored in more than one register will always be
887 an integral number of registers. Otherwise, you'd need to do
888 some fiddling with the last register copied here for little
891 /* Copy into the contents section of the value. */
892 memcpy (VALUE_CONTENTS_RAW (v
), value_bytes
, len
);
894 /* Finally do any conversion necessary when extracting this
895 type from more than one register. */
896 #ifdef REGISTER_CONVERT_TO_TYPE
897 REGISTER_CONVERT_TO_TYPE (regnum
, type
, VALUE_CONTENTS_RAW (v
));
902 /* Data is completely contained within a single register. Locate the
903 register's contents in a real register or in core;
904 read the data in raw format. */
906 get_saved_register (raw_buffer
, &optim
, &addr
, frame
, regnum
, &lval
);
908 if (register_cached (regnum
) == -1)
909 return NULL
; /* register value not available */
911 VALUE_OPTIMIZED_OUT (v
) = optim
;
912 VALUE_LVAL (v
) = lval
;
913 VALUE_ADDRESS (v
) = addr
;
915 /* Convert raw data to virtual format if necessary. */
917 if (REGISTER_CONVERTIBLE (regnum
))
919 REGISTER_CONVERT_TO_VIRTUAL (regnum
, type
,
920 raw_buffer
, VALUE_CONTENTS_RAW (v
));
924 /* Raw and virtual formats are the same for this register. */
926 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
&& len
< REGISTER_RAW_SIZE (regnum
))
928 /* Big-endian, and we want less than full size. */
929 VALUE_OFFSET (v
) = REGISTER_RAW_SIZE (regnum
) - len
;
932 memcpy (VALUE_CONTENTS_RAW (v
), raw_buffer
+ VALUE_OFFSET (v
), len
);
935 if (GDB_TARGET_IS_D10V
936 && TYPE_CODE (type
) == TYPE_CODE_PTR
)
941 snum
= (unsigned short)
942 extract_unsigned_integer (VALUE_CONTENTS_RAW (v
), 2);
944 if (TYPE_TARGET_TYPE (type
) /* pointer to function */
945 && (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_FUNC
))
946 num
= D10V_MAKE_IADDR (snum
);
947 else /* pointer to data */
948 num
= D10V_MAKE_DADDR (snum
);
950 store_address (VALUE_CONTENTS_RAW (v
), 4, num
);
956 /* Given a struct symbol for a variable or function,
957 and a stack frame id,
958 return a (pointer to a) struct value containing the properly typed
962 locate_var_value (register struct symbol
*var
, struct frame_info
*frame
)
965 struct type
*type
= SYMBOL_TYPE (var
);
966 value_ptr lazy_value
;
968 /* Evaluate it first; if the result is a memory address, we're fine.
969 Lazy evaluation pays off here. */
971 lazy_value
= read_var_value (var
, frame
);
973 error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var
));
975 if (VALUE_LAZY (lazy_value
)
976 || TYPE_CODE (type
) == TYPE_CODE_FUNC
)
980 addr
= VALUE_ADDRESS (lazy_value
);
981 val
= value_from_pointer (lookup_pointer_type (type
), addr
);
982 VALUE_BFD_SECTION (val
) = VALUE_BFD_SECTION (lazy_value
);
986 /* Not a memory address; check what the problem was. */
987 switch (VALUE_LVAL (lazy_value
))
990 case lval_reg_frame_relative
:
991 error ("Address requested for identifier \"%s\" which is in a register.",
992 SYMBOL_SOURCE_NAME (var
));
996 error ("Can't take address of \"%s\" which isn't an lvalue.",
997 SYMBOL_SOURCE_NAME (var
));
1000 return 0; /* For lint -- never reached */