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