* defs.h (HOST_FLOAT_FORMAT, HOST_DOUBLE_FORMAT)
[deliverable/binutils-gdb.git] / gdb / findvar.c
CommitLineData
c906108c 1/* Find a variable's value in memory, for GDB, the GNU debugger.
b6ba6518
KB
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000, 2001
c906108c
SS
4 Free Software Foundation, Inc.
5
c5aa993b 6 This file is part of GDB.
c906108c 7
c5aa993b
JM
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.
c906108c 12
c5aa993b
JM
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.
c906108c 17
c5aa993b
JM
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. */
c906108c
SS
22
23#include "defs.h"
24#include "symtab.h"
25#include "gdbtypes.h"
26#include "frame.h"
27#include "value.h"
28#include "gdbcore.h"
29#include "inferior.h"
30#include "target.h"
31#include "gdb_string.h"
32#include "floatformat.h"
c5aa993b 33#include "symfile.h" /* for overlay functions */
4e052eda 34#include "regcache.h"
c906108c
SS
35
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. */
39
40const struct floatformat floatformat_unknown;
41
c906108c
SS
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. */
44
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... */
c5aa993b 50you lose
c906108c
SS
51#endif
52
a9ac8f51
AC
53LONGEST
54extract_signed_integer (void *addr, int len)
c906108c
SS
55{
56 LONGEST retval;
57 unsigned char *p;
c5aa993b 58 unsigned char *startaddr = (unsigned char *) addr;
c906108c
SS
59 unsigned char *endaddr = startaddr + len;
60
61 if (len > (int) sizeof (LONGEST))
62 error ("\
63That operation is not available on integers of more than %d bytes.",
64 sizeof (LONGEST));
65
66 /* Start at the most significant end of the integer, and work towards
67 the least significant. */
68 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
69 {
70 p = startaddr;
71 /* Do the sign extension once at the start. */
c5aa993b 72 retval = ((LONGEST) * p ^ 0x80) - 0x80;
c906108c
SS
73 for (++p; p < endaddr; ++p)
74 retval = (retval << 8) | *p;
75 }
76 else
77 {
78 p = endaddr - 1;
79 /* Do the sign extension once at the start. */
c5aa993b 80 retval = ((LONGEST) * p ^ 0x80) - 0x80;
c906108c
SS
81 for (--p; p >= startaddr; --p)
82 retval = (retval << 8) | *p;
83 }
84 return retval;
85}
86
87ULONGEST
a9ac8f51 88extract_unsigned_integer (void *addr, int len)
c906108c
SS
89{
90 ULONGEST retval;
91 unsigned char *p;
c5aa993b 92 unsigned char *startaddr = (unsigned char *) addr;
c906108c
SS
93 unsigned char *endaddr = startaddr + len;
94
95 if (len > (int) sizeof (ULONGEST))
96 error ("\
97That operation is not available on integers of more than %d bytes.",
98 sizeof (ULONGEST));
99
100 /* Start at the most significant end of the integer, and work towards
101 the least significant. */
102 retval = 0;
103 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
104 {
105 for (p = startaddr; p < endaddr; ++p)
106 retval = (retval << 8) | *p;
107 }
108 else
109 {
110 for (p = endaddr - 1; p >= startaddr; --p)
111 retval = (retval << 8) | *p;
112 }
113 return retval;
114}
115
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. */
120
121int
a9ac8f51 122extract_long_unsigned_integer (void *addr, int orig_len, LONGEST *pval)
c906108c
SS
123{
124 char *p, *first_addr;
125 int len;
126
127 len = orig_len;
128 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
129 {
130 for (p = (char *) addr;
131 len > (int) sizeof (LONGEST) && p < (char *) addr + orig_len;
132 p++)
133 {
134 if (*p == 0)
135 len--;
136 else
137 break;
138 }
139 first_addr = p;
140 }
141 else
142 {
143 first_addr = (char *) addr;
144 for (p = (char *) addr + orig_len - 1;
145 len > (int) sizeof (LONGEST) && p >= (char *) addr;
146 p--)
147 {
148 if (*p == 0)
149 len--;
150 else
151 break;
152 }
153 }
154
155 if (len <= (int) sizeof (LONGEST))
156 {
157 *pval = (LONGEST) extract_unsigned_integer (first_addr,
158 sizeof (LONGEST));
159 return 1;
160 }
161
162 return 0;
163}
164
4478b372
JB
165
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
168 inferior.
169
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.
175
176 Common code should use extract_typed_address instead, or something
177 else based on POINTER_TO_ADDRESS. */
178
c906108c 179CORE_ADDR
a9ac8f51 180extract_address (void *addr, int len)
c906108c
SS
181{
182 /* Assume a CORE_ADDR can fit in a LONGEST (for now). Not sure
183 whether we want this to be true eventually. */
c5aa993b 184 return (CORE_ADDR) extract_unsigned_integer (addr, len);
c906108c
SS
185}
186
4478b372 187
4478b372
JB
188/* Treat the bytes at BUF as a pointer of type TYPE, and return the
189 address it represents. */
190CORE_ADDR
191extract_typed_address (void *buf, struct type *type)
192{
193 if (TYPE_CODE (type) != TYPE_CODE_PTR
194 && TYPE_CODE (type) != TYPE_CODE_REF)
8e65ff28
AC
195 internal_error (__FILE__, __LINE__,
196 "extract_typed_address: "
4478b372
JB
197 "type is not a pointer or reference");
198
199 return POINTER_TO_ADDRESS (type, buf);
200}
201
202
c906108c 203void
a9ac8f51 204store_signed_integer (void *addr, int len, LONGEST val)
c906108c
SS
205{
206 unsigned char *p;
c5aa993b 207 unsigned char *startaddr = (unsigned char *) addr;
c906108c
SS
208 unsigned char *endaddr = startaddr + len;
209
210 /* Start at the least significant end of the integer, and work towards
211 the most significant. */
212 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
213 {
214 for (p = endaddr - 1; p >= startaddr; --p)
215 {
216 *p = val & 0xff;
217 val >>= 8;
218 }
219 }
220 else
221 {
222 for (p = startaddr; p < endaddr; ++p)
223 {
224 *p = val & 0xff;
225 val >>= 8;
226 }
227 }
228}
229
230void
a9ac8f51 231store_unsigned_integer (void *addr, int len, ULONGEST val)
c906108c
SS
232{
233 unsigned char *p;
c5aa993b 234 unsigned char *startaddr = (unsigned char *) addr;
c906108c
SS
235 unsigned char *endaddr = startaddr + len;
236
237 /* Start at the least significant end of the integer, and work towards
238 the most significant. */
239 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
240 {
241 for (p = endaddr - 1; p >= startaddr; --p)
242 {
243 *p = val & 0xff;
244 val >>= 8;
245 }
246 }
247 else
248 {
249 for (p = startaddr; p < endaddr; ++p)
250 {
251 *p = val & 0xff;
252 val >>= 8;
253 }
254 }
255}
256
4478b372
JB
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.
259
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.
265
266 Common code should use store_typed_address instead, or something else
267 based on ADDRESS_TO_POINTER. */
c906108c 268void
a9ac8f51 269store_address (void *addr, int len, LONGEST val)
c906108c 270{
c906108c
SS
271 store_unsigned_integer (addr, len, val);
272}
4478b372
JB
273
274
4478b372
JB
275/* Store the address ADDR as a pointer of type TYPE at BUF, in target
276 form. */
277void
278store_typed_address (void *buf, struct type *type, CORE_ADDR addr)
279{
280 if (TYPE_CODE (type) != TYPE_CODE_PTR
281 && TYPE_CODE (type) != TYPE_CODE_REF)
8e65ff28
AC
282 internal_error (__FILE__, __LINE__,
283 "store_typed_address: "
4478b372
JB
284 "type is not a pointer or reference");
285
286 ADDRESS_TO_POINTER (type, buf, addr);
287}
288
289
290
c906108c
SS
291/* Return a `value' with the contents of register REGNUM
292 in its virtual format, with the type specified by
293 REGISTER_VIRTUAL_TYPE.
294
295 NOTE: returns NULL if register value is not available.
296 Caller will check return value or die! */
297
298value_ptr
fba45db2 299value_of_register (int regnum)
c906108c
SS
300{
301 CORE_ADDR addr;
302 int optim;
303 register value_ptr reg_val;
e6cbd02a 304 char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
c906108c
SS
305 enum lval_type lval;
306
307 get_saved_register (raw_buffer, &optim, &addr,
308 selected_frame, regnum, &lval);
309
32178cab 310 if (register_cached (regnum) < 0)
c5aa993b 311 return NULL; /* register value not available */
c906108c
SS
312
313 reg_val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
314
315 /* Convert raw data to virtual format if necessary. */
316
c906108c
SS
317 if (REGISTER_CONVERTIBLE (regnum))
318 {
319 REGISTER_CONVERT_TO_VIRTUAL (regnum, REGISTER_VIRTUAL_TYPE (regnum),
320 raw_buffer, VALUE_CONTENTS_RAW (reg_val));
321 }
392a587b
JM
322 else if (REGISTER_RAW_SIZE (regnum) == REGISTER_VIRTUAL_SIZE (regnum))
323 memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
324 REGISTER_RAW_SIZE (regnum));
c906108c 325 else
8e65ff28
AC
326 internal_error (__FILE__, __LINE__,
327 "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
96baa820
JM
328 REGISTER_NAME (regnum),
329 regnum,
330 REGISTER_RAW_SIZE (regnum),
331 REGISTER_VIRTUAL_SIZE (regnum));
c906108c
SS
332 VALUE_LVAL (reg_val) = lval;
333 VALUE_ADDRESS (reg_val) = addr;
334 VALUE_REGNO (reg_val) = regnum;
335 VALUE_OPTIMIZED_OUT (reg_val) = optim;
336 return reg_val;
337}
4478b372
JB
338
339/* Given a pointer of type TYPE in target form in BUF, return the
340 address it represents. */
341CORE_ADDR
ac2e2ef7 342unsigned_pointer_to_address (struct type *type, void *buf)
4478b372
JB
343{
344 return extract_address (buf, TYPE_LENGTH (type));
345}
346
ac2e2ef7
AC
347CORE_ADDR
348signed_pointer_to_address (struct type *type, void *buf)
349{
350 return extract_signed_integer (buf, TYPE_LENGTH (type));
351}
4478b372
JB
352
353/* Given an address, store it as a pointer of type TYPE in target
354 format in BUF. */
355void
ac2e2ef7 356unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
4478b372
JB
357{
358 store_address (buf, TYPE_LENGTH (type), addr);
359}
360
ac2e2ef7
AC
361void
362address_to_signed_pointer (struct type *type, void *buf, CORE_ADDR addr)
363{
364 store_signed_integer (buf, TYPE_LENGTH (type), addr);
365}
c906108c
SS
366\f
367/* Will calling read_var_value or locate_var_value on SYM end
368 up caring what frame it is being evaluated relative to? SYM must
369 be non-NULL. */
370int
fba45db2 371symbol_read_needs_frame (struct symbol *sym)
c906108c
SS
372{
373 switch (SYMBOL_CLASS (sym))
374 {
375 /* All cases listed explicitly so that gcc -Wall will detect it if
c5aa993b 376 we failed to consider one. */
c906108c
SS
377 case LOC_REGISTER:
378 case LOC_ARG:
379 case LOC_REF_ARG:
380 case LOC_REGPARM:
381 case LOC_REGPARM_ADDR:
382 case LOC_LOCAL:
383 case LOC_LOCAL_ARG:
384 case LOC_BASEREG:
385 case LOC_BASEREG_ARG:
386 case LOC_THREAD_LOCAL_STATIC:
387 return 1;
388
389 case LOC_UNDEF:
390 case LOC_CONST:
391 case LOC_STATIC:
392 case LOC_INDIRECT:
393 case LOC_TYPEDEF:
394
395 case LOC_LABEL:
396 /* Getting the address of a label can be done independently of the block,
c5aa993b
JM
397 even if some *uses* of that address wouldn't work so well without
398 the right frame. */
c906108c
SS
399
400 case LOC_BLOCK:
401 case LOC_CONST_BYTES:
402 case LOC_UNRESOLVED:
403 case LOC_OPTIMIZED_OUT:
404 return 0;
405 }
406 return 1;
407}
408
409/* Given a struct symbol for a variable,
410 and a stack frame id, read the value of the variable
411 and return a (pointer to a) struct value containing the value.
412 If the variable cannot be found, return a zero pointer.
413 If FRAME is NULL, use the selected_frame. */
414
415value_ptr
fba45db2 416read_var_value (register struct symbol *var, struct frame_info *frame)
c906108c
SS
417{
418 register value_ptr v;
419 struct type *type = SYMBOL_TYPE (var);
420 CORE_ADDR addr;
421 register int len;
422
423 v = allocate_value (type);
424 VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */
425 VALUE_BFD_SECTION (v) = SYMBOL_BFD_SECTION (var);
426
427 len = TYPE_LENGTH (type);
428
c5aa993b
JM
429 if (frame == NULL)
430 frame = selected_frame;
c906108c
SS
431
432 switch (SYMBOL_CLASS (var))
433 {
434 case LOC_CONST:
435 /* Put the constant back in target format. */
436 store_signed_integer (VALUE_CONTENTS_RAW (v), len,
437 (LONGEST) SYMBOL_VALUE (var));
438 VALUE_LVAL (v) = not_lval;
439 return v;
440
441 case LOC_LABEL:
442 /* Put the constant back in target format. */
443 if (overlay_debugging)
4478b372
JB
444 {
445 CORE_ADDR addr
446 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
447 SYMBOL_BFD_SECTION (var));
448 store_typed_address (VALUE_CONTENTS_RAW (v), type, addr);
449 }
c906108c 450 else
4478b372
JB
451 store_typed_address (VALUE_CONTENTS_RAW (v), type,
452 SYMBOL_VALUE_ADDRESS (var));
c906108c
SS
453 VALUE_LVAL (v) = not_lval;
454 return v;
455
456 case LOC_CONST_BYTES:
457 {
458 char *bytes_addr;
459 bytes_addr = SYMBOL_VALUE_BYTES (var);
460 memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
461 VALUE_LVAL (v) = not_lval;
462 return v;
463 }
464
465 case LOC_STATIC:
466 if (overlay_debugging)
467 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
468 SYMBOL_BFD_SECTION (var));
469 else
470 addr = SYMBOL_VALUE_ADDRESS (var);
471 break;
472
473 case LOC_INDIRECT:
474 /* The import slot does not have a real address in it from the
475 dynamic loader (dld.sl on HP-UX), if the target hasn't begun
c5aa993b 476 execution yet, so check for that. */
c906108c 477 if (!target_has_execution)
c5aa993b 478 error ("\
c906108c
SS
479Attempt to access variable defined in different shared object or load module when\n\
480addresses have not been bound by the dynamic loader. Try again when executable is running.");
c5aa993b 481
c906108c
SS
482 addr = SYMBOL_VALUE_ADDRESS (var);
483 addr = read_memory_unsigned_integer
484 (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
485 break;
486
487 case LOC_ARG:
488 if (frame == NULL)
489 return 0;
490 addr = FRAME_ARGS_ADDRESS (frame);
491 if (!addr)
492 return 0;
493 addr += SYMBOL_VALUE (var);
494 break;
495
496 case LOC_REF_ARG:
497 if (frame == NULL)
498 return 0;
499 addr = FRAME_ARGS_ADDRESS (frame);
500 if (!addr)
501 return 0;
502 addr += SYMBOL_VALUE (var);
503 addr = read_memory_unsigned_integer
504 (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
505 break;
506
507 case LOC_LOCAL:
508 case LOC_LOCAL_ARG:
509 if (frame == NULL)
510 return 0;
511 addr = FRAME_LOCALS_ADDRESS (frame);
512 addr += SYMBOL_VALUE (var);
513 break;
514
515 case LOC_BASEREG:
516 case LOC_BASEREG_ARG:
c906108c
SS
517 case LOC_THREAD_LOCAL_STATIC:
518 {
9ed10b08 519 value_ptr regval;
c5aa993b 520
9ed10b08
ND
521 regval = value_from_register (lookup_pointer_type (type),
522 SYMBOL_BASEREG (var), frame);
523 if (regval == NULL)
524 error ("Value of base register not available.");
525 addr = value_as_pointer (regval);
c5aa993b
JM
526 addr += SYMBOL_VALUE (var);
527 break;
c906108c 528 }
c5aa993b 529
c906108c
SS
530 case LOC_TYPEDEF:
531 error ("Cannot look up value of a typedef");
532 break;
533
534 case LOC_BLOCK:
535 if (overlay_debugging)
c5aa993b 536 VALUE_ADDRESS (v) = symbol_overlayed_address
c906108c
SS
537 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
538 else
539 VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
540 return v;
541
542 case LOC_REGISTER:
543 case LOC_REGPARM:
544 case LOC_REGPARM_ADDR:
545 {
546 struct block *b;
547 int regno = SYMBOL_VALUE (var);
548 value_ptr regval;
549
550 if (frame == NULL)
551 return 0;
552 b = get_frame_block (frame);
553
554 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
555 {
556 regval = value_from_register (lookup_pointer_type (type),
c5aa993b 557 regno,
c906108c
SS
558 frame);
559
560 if (regval == NULL)
561 error ("Value of register variable not available.");
562
c5aa993b 563 addr = value_as_pointer (regval);
c906108c
SS
564 VALUE_LVAL (v) = lval_memory;
565 }
566 else
567 {
568 regval = value_from_register (type, regno, frame);
569
570 if (regval == NULL)
571 error ("Value of register variable not available.");
572 return regval;
573 }
574 }
575 break;
576
577 case LOC_UNRESOLVED:
578 {
579 struct minimal_symbol *msym;
580
581 msym = lookup_minimal_symbol (SYMBOL_NAME (var), NULL, NULL);
582 if (msym == NULL)
583 return 0;
584 if (overlay_debugging)
585 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
586 SYMBOL_BFD_SECTION (msym));
587 else
588 addr = SYMBOL_VALUE_ADDRESS (msym);
589 }
590 break;
591
592 case LOC_OPTIMIZED_OUT:
593 VALUE_LVAL (v) = not_lval;
594 VALUE_OPTIMIZED_OUT (v) = 1;
595 return v;
596
597 default:
598 error ("Cannot look up value of a botched symbol.");
599 break;
600 }
601
602 VALUE_ADDRESS (v) = addr;
603 VALUE_LAZY (v) = 1;
604 return v;
605}
606
607/* Return a value of type TYPE, stored in register REGNUM, in frame
0f2c5ba5 608 FRAME.
c906108c
SS
609
610 NOTE: returns NULL if register value is not available.
611 Caller will check return value or die! */
612
613value_ptr
fba45db2 614value_from_register (struct type *type, int regnum, struct frame_info *frame)
c906108c 615{
e6cbd02a 616 char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
c906108c
SS
617 CORE_ADDR addr;
618 int optim;
619 value_ptr v = allocate_value (type);
620 char *value_bytes = 0;
621 int value_bytes_copied = 0;
622 int num_storage_locs;
623 enum lval_type lval;
624 int len;
625
626 CHECK_TYPEDEF (type);
627 len = TYPE_LENGTH (type);
628
629 VALUE_REGNO (v) = regnum;
630
631 num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
632 ((len - 1) / REGISTER_RAW_SIZE (regnum)) + 1 :
633 1);
634
635 if (num_storage_locs > 1
636#ifdef GDB_TARGET_IS_H8500
637 || TYPE_CODE (type) == TYPE_CODE_PTR
638#endif
c5aa993b 639 )
c906108c
SS
640 {
641 /* Value spread across multiple storage locations. */
c5aa993b 642
c906108c
SS
643 int local_regnum;
644 int mem_stor = 0, reg_stor = 0;
645 int mem_tracking = 1;
646 CORE_ADDR last_addr = 0;
647 CORE_ADDR first_addr = 0;
648
649 value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE);
650
651 /* Copy all of the data out, whereever it may be. */
652
653#ifdef GDB_TARGET_IS_H8500
654/* This piece of hideosity is required because the H8500 treats registers
655 differently depending upon whether they are used as pointers or not. As a
656 pointer, a register needs to have a page register tacked onto the front.
657 An alternate way to do this would be to have gcc output different register
658 numbers for the pointer & non-pointer form of the register. But, it
659 doesn't, so we're stuck with this. */
660
661 if (TYPE_CODE (type) == TYPE_CODE_PTR
662 && len > 2)
663 {
664 int page_regnum;
665
666 switch (regnum)
667 {
c5aa993b
JM
668 case R0_REGNUM:
669 case R1_REGNUM:
670 case R2_REGNUM:
671 case R3_REGNUM:
c906108c
SS
672 page_regnum = SEG_D_REGNUM;
673 break;
c5aa993b
JM
674 case R4_REGNUM:
675 case R5_REGNUM:
c906108c
SS
676 page_regnum = SEG_E_REGNUM;
677 break;
c5aa993b
JM
678 case R6_REGNUM:
679 case R7_REGNUM:
c906108c
SS
680 page_regnum = SEG_T_REGNUM;
681 break;
682 }
683
684 value_bytes[0] = 0;
685 get_saved_register (value_bytes + 1,
686 &optim,
687 &addr,
688 frame,
689 page_regnum,
690 &lval);
691
32178cab 692 if (register_cached (page_regnum) == -1)
c906108c
SS
693 return NULL; /* register value not available */
694
695 if (lval == lval_register)
696 reg_stor++;
697 else
698 mem_stor++;
699 first_addr = addr;
700 last_addr = addr;
701
702 get_saved_register (value_bytes + 2,
703 &optim,
704 &addr,
705 frame,
706 regnum,
707 &lval);
708
32178cab 709 if (register_cached (regnum) == -1)
c906108c
SS
710 return NULL; /* register value not available */
711
712 if (lval == lval_register)
713 reg_stor++;
714 else
715 {
716 mem_stor++;
717 mem_tracking = mem_tracking && (addr == last_addr);
718 }
719 last_addr = addr;
720 }
721 else
c5aa993b 722#endif /* GDB_TARGET_IS_H8500 */
c906108c
SS
723 for (local_regnum = regnum;
724 value_bytes_copied < len;
725 (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
726 ++local_regnum))
727 {
728 get_saved_register (value_bytes + value_bytes_copied,
729 &optim,
730 &addr,
731 frame,
732 local_regnum,
733 &lval);
734
32178cab 735 if (register_cached (local_regnum) == -1)
c5aa993b 736 return NULL; /* register value not available */
c906108c
SS
737
738 if (regnum == local_regnum)
739 first_addr = addr;
740 if (lval == lval_register)
741 reg_stor++;
742 else
743 {
744 mem_stor++;
c5aa993b 745
c906108c
SS
746 mem_tracking =
747 (mem_tracking
748 && (regnum == local_regnum
749 || addr == last_addr));
750 }
751 last_addr = addr;
752 }
753
754 if ((reg_stor && mem_stor)
755 || (mem_stor && !mem_tracking))
756 /* Mixed storage; all of the hassle we just went through was
757 for some good purpose. */
758 {
759 VALUE_LVAL (v) = lval_reg_frame_relative;
760 VALUE_FRAME (v) = FRAME_FP (frame);
761 VALUE_FRAME_REGNUM (v) = regnum;
762 }
763 else if (mem_stor)
764 {
765 VALUE_LVAL (v) = lval_memory;
766 VALUE_ADDRESS (v) = first_addr;
767 }
768 else if (reg_stor)
769 {
770 VALUE_LVAL (v) = lval_register;
771 VALUE_ADDRESS (v) = first_addr;
772 }
773 else
8e65ff28
AC
774 internal_error (__FILE__, __LINE__,
775 "value_from_register: Value not stored anywhere!");
c906108c
SS
776
777 VALUE_OPTIMIZED_OUT (v) = optim;
778
779 /* Any structure stored in more than one register will always be
c5aa993b
JM
780 an integral number of registers. Otherwise, you'd need to do
781 some fiddling with the last register copied here for little
782 endian machines. */
c906108c
SS
783
784 /* Copy into the contents section of the value. */
785 memcpy (VALUE_CONTENTS_RAW (v), value_bytes, len);
786
787 /* Finally do any conversion necessary when extracting this
788 type from more than one register. */
789#ifdef REGISTER_CONVERT_TO_TYPE
c5aa993b 790 REGISTER_CONVERT_TO_TYPE (regnum, type, VALUE_CONTENTS_RAW (v));
c906108c
SS
791#endif
792 return v;
793 }
794
795 /* Data is completely contained within a single register. Locate the
796 register's contents in a real register or in core;
797 read the data in raw format. */
798
799 get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
800
32178cab 801 if (register_cached (regnum) == -1)
c5aa993b 802 return NULL; /* register value not available */
c906108c
SS
803
804 VALUE_OPTIMIZED_OUT (v) = optim;
805 VALUE_LVAL (v) = lval;
806 VALUE_ADDRESS (v) = addr;
807
808 /* Convert raw data to virtual format if necessary. */
c5aa993b 809
c906108c
SS
810 if (REGISTER_CONVERTIBLE (regnum))
811 {
812 REGISTER_CONVERT_TO_VIRTUAL (regnum, type,
813 raw_buffer, VALUE_CONTENTS_RAW (v));
814 }
815 else
c906108c
SS
816 {
817 /* Raw and virtual formats are the same for this register. */
818
819 if (TARGET_BYTE_ORDER == BIG_ENDIAN && len < REGISTER_RAW_SIZE (regnum))
820 {
c5aa993b 821 /* Big-endian, and we want less than full size. */
c906108c
SS
822 VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
823 }
824
825 memcpy (VALUE_CONTENTS_RAW (v), raw_buffer + VALUE_OFFSET (v), len);
826 }
c5aa993b 827
c906108c
SS
828 return v;
829}
830\f
831/* Given a struct symbol for a variable or function,
832 and a stack frame id,
833 return a (pointer to a) struct value containing the properly typed
834 address. */
835
836value_ptr
fba45db2 837locate_var_value (register struct symbol *var, struct frame_info *frame)
c906108c
SS
838{
839 CORE_ADDR addr = 0;
840 struct type *type = SYMBOL_TYPE (var);
841 value_ptr lazy_value;
842
843 /* Evaluate it first; if the result is a memory address, we're fine.
844 Lazy evaluation pays off here. */
845
846 lazy_value = read_var_value (var, frame);
847 if (lazy_value == 0)
848 error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
849
850 if (VALUE_LAZY (lazy_value)
851 || TYPE_CODE (type) == TYPE_CODE_FUNC)
852 {
853 value_ptr val;
854
855 addr = VALUE_ADDRESS (lazy_value);
4478b372 856 val = value_from_pointer (lookup_pointer_type (type), addr);
c906108c
SS
857 VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value);
858 return val;
859 }
860
861 /* Not a memory address; check what the problem was. */
c5aa993b 862 switch (VALUE_LVAL (lazy_value))
c906108c
SS
863 {
864 case lval_register:
865 case lval_reg_frame_relative:
866 error ("Address requested for identifier \"%s\" which is in a register.",
867 SYMBOL_SOURCE_NAME (var));
868 break;
869
870 default:
871 error ("Can't take address of \"%s\" which isn't an lvalue.",
872 SYMBOL_SOURCE_NAME (var));
873 break;
874 }
c5aa993b 875 return 0; /* For lint -- never reached */
c906108c 876}
This page took 0.144983 seconds and 4 git commands to generate.