1 /* Find a variable's value in memory, for GDB, the GNU debugger.
2
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004 Free Software
5 Foundation, Inc.
6
7 This file is part of GDB.
8
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.
13
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.
18
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. */
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"
33 #include "gdb_assert.h"
34 #include "floatformat.h"
35 #include "symfile.h" /* for overlay functions */
36 #include "regcache.h"
37 #include "user-regs.h"
38 #include "block.h"
39
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... */
48 you lose
49 #endif
50
51 LONGEST
extract_signed_integer(const void * addr,int len)52 extract_signed_integer (const void *addr, int len)
53 {
54 LONGEST retval;
55 const unsigned char *p;
56 const unsigned char *startaddr = addr;
57 const unsigned char *endaddr = startaddr + len;
58
59 if (len > (int) sizeof (LONGEST))
60 error ("\
61 That operation is not available on integers of more than %d bytes.",
62 (int) sizeof (LONGEST));
63
64 /* Start at the most significant end of the integer, and work towards
65 the least significant. */
66 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
67 {
68 p = startaddr;
69 /* Do the sign extension once at the start. */
70 retval = ((LONGEST) * p ^ 0x80) - 0x80;
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. */
78 retval = ((LONGEST) * p ^ 0x80) - 0x80;
79 for (--p; p >= startaddr; --p)
80 retval = (retval << 8) | *p;
81 }
82 return retval;
83 }
84
85 ULONGEST
extract_unsigned_integer(const void * addr,int len)86 extract_unsigned_integer (const void *addr, int len)
87 {
88 ULONGEST retval;
89 const unsigned char *p;
90 const unsigned char *startaddr = addr;
91 const unsigned char *endaddr = startaddr + len;
92
93 if (len > (int) sizeof (ULONGEST))
94 error ("\
95 That operation is not available on integers of more than %d bytes.",
96 (int) sizeof (ULONGEST));
97
98 /* Start at the most significant end of the integer, and work towards
99 the least significant. */
100 retval = 0;
101 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
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
119 int
extract_long_unsigned_integer(const void * addr,int orig_len,LONGEST * pval)120 extract_long_unsigned_integer (const void *addr, int orig_len, LONGEST *pval)
121 {
122 char *p, *first_addr;
123 int len;
124
125 len = orig_len;
126 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
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
163
164 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
165 address it represents. */
166 CORE_ADDR
extract_typed_address(const void * buf,struct type * type)167 extract_typed_address (const void *buf, struct type *type)
168 {
169 if (TYPE_CODE (type) != TYPE_CODE_PTR
170 && TYPE_CODE (type) != TYPE_CODE_REF)
171 internal_error (__FILE__, __LINE__,
172 "extract_typed_address: "
173 "type is not a pointer or reference");
174
175 return POINTER_TO_ADDRESS (type, buf);
176 }
177
178
179 void
store_signed_integer(void * addr,int len,LONGEST val)180 store_signed_integer (void *addr, int len, LONGEST val)
181 {
182 unsigned char *p;
183 unsigned char *startaddr = (unsigned char *) addr;
184 unsigned char *endaddr = startaddr + len;
185
186 /* Start at the least significant end of the integer, and work towards
187 the most significant. */
188 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
189 {
190 for (p = endaddr - 1; p >= startaddr; --p)
191 {
192 *p = val & 0xff;
193 val >>= 8;
194 }
195 }
196 else
197 {
198 for (p = startaddr; p < endaddr; ++p)
199 {
200 *p = val & 0xff;
201 val >>= 8;
202 }
203 }
204 }
205
206 void
store_unsigned_integer(void * addr,int len,ULONGEST val)207 store_unsigned_integer (void *addr, int len, ULONGEST val)
208 {
209 unsigned char *p;
210 unsigned char *startaddr = (unsigned char *) addr;
211 unsigned char *endaddr = startaddr + len;
212
213 /* Start at the least significant end of the integer, and work towards
214 the most significant. */
215 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
216 {
217 for (p = endaddr - 1; p >= startaddr; --p)
218 {
219 *p = val & 0xff;
220 val >>= 8;
221 }
222 }
223 else
224 {
225 for (p = startaddr; p < endaddr; ++p)
226 {
227 *p = val & 0xff;
228 val >>= 8;
229 }
230 }
231 }
232
233 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
234 form. */
235 void
store_typed_address(void * buf,struct type * type,CORE_ADDR addr)236 store_typed_address (void *buf, struct type *type, CORE_ADDR addr)
237 {
238 if (TYPE_CODE (type) != TYPE_CODE_PTR
239 && TYPE_CODE (type) != TYPE_CODE_REF)
240 internal_error (__FILE__, __LINE__,
241 "store_typed_address: "
242 "type is not a pointer or reference");
243
244 ADDRESS_TO_POINTER (type, buf, addr);
245 }
246
247
248
249 /* Return a `value' with the contents of (virtual or cooked) register
250 REGNUM as found in the specified FRAME. The register's type is
251 determined by register_type().
252
253 NOTE: returns NULL if register value is not available. Caller will
254 check return value or die! */
255
256 struct value *
value_of_register(int regnum,struct frame_info * frame)257 value_of_register (int regnum, struct frame_info *frame)
258 {
259 CORE_ADDR addr;
260 int optim;
261 struct value *reg_val;
262 int realnum;
263 char raw_buffer[MAX_REGISTER_SIZE];
264 enum lval_type lval;
265
266 /* User registers lie completely outside of the range of normal
267 registers. Catch them early so that the target never sees them. */
268 if (regnum >= NUM_REGS + NUM_PSEUDO_REGS)
269 return value_of_user_reg (regnum, frame);
270
271 frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
272
273 /* FIXME: cagney/2002-05-15: This test is just bogus.
274
275 It indicates that the target failed to supply a value for a
276 register because it was "not available" at this time. Problem
277 is, the target still has the register and so get saved_register()
278 may be returning a value saved on the stack. */
279
280 if (register_cached (regnum) < 0)
281 return NULL; /* register value not available */
282
283 reg_val = allocate_value (register_type (current_gdbarch, regnum));
284
285 /* Convert raw data to virtual format if necessary. */
286
287 if (DEPRECATED_REGISTER_CONVERTIBLE_P ()
288 && DEPRECATED_REGISTER_CONVERTIBLE (regnum))
289 {
290 DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (regnum, register_type (current_gdbarch, regnum),
291 raw_buffer, VALUE_CONTENTS_RAW (reg_val));
292 }
293 else if (DEPRECATED_REGISTER_RAW_SIZE (regnum) == DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum))
294 memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
295 DEPRECATED_REGISTER_RAW_SIZE (regnum));
296 else
297 internal_error (__FILE__, __LINE__,
298 "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
299 REGISTER_NAME (regnum),
300 regnum,
301 DEPRECATED_REGISTER_RAW_SIZE (regnum),
302 DEPRECATED_REGISTER_VIRTUAL_SIZE (regnum));
303 VALUE_LVAL (reg_val) = lval;
304 VALUE_ADDRESS (reg_val) = addr;
305 VALUE_REGNO (reg_val) = regnum;
306 VALUE_OPTIMIZED_OUT (reg_val) = optim;
307 return reg_val;
308 }
309
310 /* Given a pointer of type TYPE in target form in BUF, return the
311 address it represents. */
312 CORE_ADDR
unsigned_pointer_to_address(struct type * type,const void * buf)313 unsigned_pointer_to_address (struct type *type, const void *buf)
314 {
315 return extract_unsigned_integer (buf, TYPE_LENGTH (type));
316 }
317
318 CORE_ADDR
signed_pointer_to_address(struct type * type,const void * buf)319 signed_pointer_to_address (struct type *type, const void *buf)
320 {
321 return extract_signed_integer (buf, TYPE_LENGTH (type));
322 }
323
324 /* Given an address, store it as a pointer of type TYPE in target
325 format in BUF. */
326 void
unsigned_address_to_pointer(struct type * type,void * buf,CORE_ADDR addr)327 unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
328 {
329 store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
330 }
331
332 void
address_to_signed_pointer(struct type * type,void * buf,CORE_ADDR addr)333 address_to_signed_pointer (struct type *type, void *buf, CORE_ADDR addr)
334 {
335 store_signed_integer (buf, TYPE_LENGTH (type), addr);
336 }
337
338 /* Will calling read_var_value or locate_var_value on SYM end
339 up caring what frame it is being evaluated relative to? SYM must
340 be non-NULL. */
341 int
symbol_read_needs_frame(struct symbol * sym)342 symbol_read_needs_frame (struct symbol *sym)
343 {
344 switch (SYMBOL_CLASS (sym))
345 {
346 /* All cases listed explicitly so that gcc -Wall will detect it if
347 we failed to consider one. */
348 case LOC_COMPUTED:
349 case LOC_COMPUTED_ARG:
350 /* FIXME: cagney/2004-01-26: It should be possible to
351 unconditionally call the SYMBOL_OPS method when available.
352 Unfortunately DWARF 2 stores the frame-base (instead of the
353 function) location in a function's symbol. Oops! For the
354 moment enable this when/where applicable. */
355 return SYMBOL_OPS (sym)->read_needs_frame (sym);
356
357 case LOC_REGISTER:
358 case LOC_ARG:
359 case LOC_REF_ARG:
360 case LOC_REGPARM:
361 case LOC_REGPARM_ADDR:
362 case LOC_LOCAL:
363 case LOC_LOCAL_ARG:
364 case LOC_BASEREG:
365 case LOC_BASEREG_ARG:
366 case LOC_HP_THREAD_LOCAL_STATIC:
367 return 1;
368
369 case LOC_UNDEF:
370 case LOC_CONST:
371 case LOC_STATIC:
372 case LOC_INDIRECT:
373 case LOC_TYPEDEF:
374
375 case LOC_LABEL:
376 /* Getting the address of a label can be done independently of the block,
377 even if some *uses* of that address wouldn't work so well without
378 the right frame. */
379
380 case LOC_BLOCK:
381 case LOC_CONST_BYTES:
382 case LOC_UNRESOLVED:
383 case LOC_OPTIMIZED_OUT:
384 return 0;
385 }
386 return 1;
387 }
388
389 /* Given a struct symbol for a variable,
390 and a stack frame id, read the value of the variable
391 and return a (pointer to a) struct value containing the value.
392 If the variable cannot be found, return a zero pointer.
393 If FRAME is NULL, use the deprecated_selected_frame. */
394
395 struct value *
read_var_value(struct symbol * var,struct frame_info * frame)396 read_var_value (struct symbol *var, struct frame_info *frame)
397 {
398 struct value *v;
399 struct type *type = SYMBOL_TYPE (var);
400 CORE_ADDR addr;
401 int len;
402
403 v = allocate_value (type);
404 VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */
405 VALUE_BFD_SECTION (v) = SYMBOL_BFD_SECTION (var);
406
407 len = TYPE_LENGTH (type);
408
409
410 /* FIXME drow/2003-09-06: this call to the selected frame should be
411 pushed upwards to the callers. */
412 if (frame == NULL)
413 frame = deprecated_safe_get_selected_frame ();
414
415 switch (SYMBOL_CLASS (var))
416 {
417 case LOC_CONST:
418 /* Put the constant back in target format. */
419 store_signed_integer (VALUE_CONTENTS_RAW (v), len,
420 (LONGEST) SYMBOL_VALUE (var));
421 VALUE_LVAL (v) = not_lval;
422 return v;
423
424 case LOC_LABEL:
425 /* Put the constant back in target format. */
426 if (overlay_debugging)
427 {
428 CORE_ADDR addr
429 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
430 SYMBOL_BFD_SECTION (var));
431 store_typed_address (VALUE_CONTENTS_RAW (v), type, addr);
432 }
433 else
434 store_typed_address (VALUE_CONTENTS_RAW (v), type,
435 SYMBOL_VALUE_ADDRESS (var));
436 VALUE_LVAL (v) = not_lval;
437 return v;
438
439 case LOC_CONST_BYTES:
440 {
441 char *bytes_addr;
442 bytes_addr = SYMBOL_VALUE_BYTES (var);
443 memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
444 VALUE_LVAL (v) = not_lval;
445 return v;
446 }
447
448 case LOC_STATIC:
449 if (overlay_debugging)
450 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
451 SYMBOL_BFD_SECTION (var));
452 else
453 addr = SYMBOL_VALUE_ADDRESS (var);
454 break;
455
456 case LOC_INDIRECT:
457 {
458 /* The import slot does not have a real address in it from the
459 dynamic loader (dld.sl on HP-UX), if the target hasn't
460 begun execution yet, so check for that. */
461 CORE_ADDR locaddr;
462 struct value *loc;
463 if (!target_has_execution)
464 error ("\
465 Attempt to access variable defined in different shared object or load module when\n\
466 addresses have not been bound by the dynamic loader. Try again when executable is running.");
467
468 locaddr = SYMBOL_VALUE_ADDRESS (var);
469 loc = value_at (lookup_pointer_type (type), locaddr, NULL);
470 addr = value_as_address (loc);
471 }
472
473 case LOC_ARG:
474 if (frame == NULL)
475 return 0;
476 addr = get_frame_args_address (frame);
477 if (!addr)
478 return 0;
479 addr += SYMBOL_VALUE (var);
480 break;
481
482 case LOC_REF_ARG:
483 {
484 struct value *ref;
485 CORE_ADDR argref;
486 if (frame == NULL)
487 return 0;
488 argref = get_frame_args_address (frame);
489 if (!argref)
490 return 0;
491 argref += SYMBOL_VALUE (var);
492 ref = value_at (lookup_pointer_type (type), argref, NULL);
493 addr = value_as_address (ref);
494 break;
495 }
496
497 case LOC_LOCAL:
498 case LOC_LOCAL_ARG:
499 if (frame == NULL)
500 return 0;
501 addr = get_frame_locals_address (frame);
502 addr += SYMBOL_VALUE (var);
503 break;
504
505 case LOC_BASEREG:
506 case LOC_BASEREG_ARG:
507 case LOC_HP_THREAD_LOCAL_STATIC:
508 {
509 struct value *regval;
510
511 regval = value_from_register (lookup_pointer_type (type),
512 SYMBOL_BASEREG (var), frame);
513 if (regval == NULL)
514 error ("Value of base register not available.");
515 addr = value_as_address (regval);
516 addr += SYMBOL_VALUE (var);
517 break;
518 }
519
520 case LOC_TYPEDEF:
521 error ("Cannot look up value of a typedef");
522 break;
523
524 case LOC_BLOCK:
525 if (overlay_debugging)
526 VALUE_ADDRESS (v) = symbol_overlayed_address
527 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
528 else
529 VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
530 return v;
531
532 case LOC_REGISTER:
533 case LOC_REGPARM:
534 case LOC_REGPARM_ADDR:
535 {
536 struct block *b;
537 int regno = SYMBOL_VALUE (var);
538 struct value *regval;
539
540 if (frame == NULL)
541 return 0;
542 b = get_frame_block (frame, 0);
543
544 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
545 {
546 regval = value_from_register (lookup_pointer_type (type),
547 regno,
548 frame);
549
550 if (regval == NULL)
551 error ("Value of register variable not available.");
552
553 addr = value_as_address (regval);
554 VALUE_LVAL (v) = lval_memory;
555 }
556 else
557 {
558 regval = value_from_register (type, regno, frame);
559
560 if (regval == NULL)
561 error ("Value of register variable not available.");
562 return regval;
563 }
564 }
565 break;
566
567 case LOC_COMPUTED:
568 case LOC_COMPUTED_ARG:
569 /* FIXME: cagney/2004-01-26: It should be possible to
570 unconditionally call the SYMBOL_OPS method when available.
571 Unfortunately DWARF 2 stores the frame-base (instead of the
572 function) location in a function's symbol. Oops! For the
573 moment enable this when/where applicable. */
574 if (frame == 0 && SYMBOL_OPS (var)->read_needs_frame (var))
575 return 0;
576 return SYMBOL_OPS (var)->read_variable (var, frame);
577
578 case LOC_UNRESOLVED:
579 {
580 struct minimal_symbol *msym;
581
582 msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
583 if (msym == NULL)
584 return 0;
585 if (overlay_debugging)
586 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
587 SYMBOL_BFD_SECTION (msym));
588 else
589 addr = SYMBOL_VALUE_ADDRESS (msym);
590 }
591 break;
592
593 case LOC_OPTIMIZED_OUT:
594 VALUE_LVAL (v) = not_lval;
595 VALUE_OPTIMIZED_OUT (v) = 1;
596 return v;
597
598 default:
599 error ("Cannot look up value of a botched symbol.");
600 break;
601 }
602
603 VALUE_ADDRESS (v) = addr;
604 VALUE_LAZY (v) = 1;
605 return v;
606 }
607
608 /* Return a value of type TYPE, stored in register REGNUM, in frame
609 FRAME.
610
611 NOTE: returns NULL if register value is not available.
612 Caller will check return value or die! */
613
614 struct value *
value_from_register(struct type * type,int regnum,struct frame_info * frame)615 value_from_register (struct type *type, int regnum, struct frame_info *frame)
616 {
617 struct gdbarch *gdbarch = get_frame_arch (frame);
618 struct value *v = allocate_value (type);
619 CHECK_TYPEDEF (type);
620
621 if (TYPE_LENGTH (type) == 0)
622 {
623 /* It doesn't matter much what we return for this: since the
624 length is zero, it could be anything. But if allowed to see
625 a zero-length type, the register-finding loop below will set
626 neither mem_stor nor reg_stor, and then report an internal
627 error.
628
629 Zero-length types can legitimately arise from declarations
630 like 'struct {}' (a GCC extension, not valid ISO C). GDB may
631 also create them when it finds bogus debugging information;
632 for example, in GCC 2.95.4 and binutils 2.11.93.0.2, the
633 STABS BINCL->EXCL compression process can create bad type
634 numbers. GDB reads these as TYPE_CODE_UNDEF types, with zero
635 length. (That bug is actually the only known way to get a
636 zero-length value allocated to a register --- which is what
637 it takes to make it here.)
638
639 We'll just attribute the value to the original register. */
640 VALUE_LVAL (v) = lval_register;
641 VALUE_ADDRESS (v) = regnum;
642 VALUE_REGNO (v) = regnum;
643 }
644 else if (CONVERT_REGISTER_P (regnum, type))
645 {
646 /* The ISA/ABI need to something weird when obtaining the
647 specified value from this register. It might need to
648 re-order non-adjacent, starting with REGNUM (see MIPS and
649 i386). It might need to convert the [float] register into
650 the corresponding [integer] type (see Alpha). The assumption
651 is that REGISTER_TO_VALUE populates the entire value
652 including the location. */
653 REGISTER_TO_VALUE (frame, regnum, type, VALUE_CONTENTS_RAW (v));
654 VALUE_LVAL (v) = lval_reg_frame_relative;
655 VALUE_FRAME_ID (v) = get_frame_id (frame);
656 VALUE_FRAME_REGNUM (v) = regnum;
657 }
658 else
659 {
660 int local_regnum;
661 int mem_stor = 0, reg_stor = 0;
662 int mem_tracking = 1;
663 CORE_ADDR last_addr = 0;
664 CORE_ADDR first_addr = 0;
665 int first_realnum = regnum;
666 int len = TYPE_LENGTH (type);
667 int value_bytes_copied;
668 int optimized = 0;
669 char *value_bytes = (char *) alloca (len + MAX_REGISTER_SIZE);
670
671 /* Copy all of the data out, whereever it may be. */
672 for (local_regnum = regnum, value_bytes_copied = 0;
673 value_bytes_copied < len;
674 (value_bytes_copied += DEPRECATED_REGISTER_RAW_SIZE (local_regnum),
675 ++local_regnum))
676 {
677 int realnum;
678 int optim;
679 enum lval_type lval;
680 CORE_ADDR addr;
681 frame_register (frame, local_regnum, &optim, &lval, &addr,
682 &realnum, value_bytes + value_bytes_copied);
683 optimized += optim;
684 if (register_cached (local_regnum) == -1)
685 return NULL; /* register value not available */
686
687 if (regnum == local_regnum)
688 {
689 first_addr = addr;
690 first_realnum = realnum;
691 }
692 if (lval == lval_register)
693 reg_stor++;
694 else
695 {
696 mem_stor++;
697
698 mem_tracking = (mem_tracking
699 && (regnum == local_regnum
700 || addr == last_addr));
701 }
702 last_addr = addr;
703 }
704
705 /* FIXME: cagney/2003-06-04: Shouldn't this always use
706 lval_reg_frame_relative? If it doesn't and the register's
707 location changes (say after a resume) then this value is
708 going to have wrong information. */
709 if ((reg_stor && mem_stor)
710 || (mem_stor && !mem_tracking))
711 /* Mixed storage; all of the hassle we just went through was
712 for some good purpose. */
713 {
714 VALUE_LVAL (v) = lval_reg_frame_relative;
715 VALUE_FRAME_ID (v) = get_frame_id (frame);
716 VALUE_FRAME_REGNUM (v) = regnum;
717 }
718 else if (mem_stor)
719 {
720 VALUE_LVAL (v) = lval_memory;
721 VALUE_ADDRESS (v) = first_addr;
722 }
723 else if (reg_stor)
724 {
725 VALUE_LVAL (v) = lval_register;
726 VALUE_ADDRESS (v) = first_addr;
727 VALUE_REGNO (v) = first_realnum;
728 }
729 else
730 internal_error (__FILE__, __LINE__,
731 "value_from_register: Value not stored anywhere!");
732
733 VALUE_OPTIMIZED_OUT (v) = optimized;
734
735 /* Any structure stored in more than one register will always be
736 an integral number of registers. Otherwise, you need to do
737 some fiddling with the last register copied here for little
738 endian machines. */
739 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
740 && len < DEPRECATED_REGISTER_RAW_SIZE (regnum))
741 /* Big-endian, and we want less than full size. */
742 VALUE_OFFSET (v) = DEPRECATED_REGISTER_RAW_SIZE (regnum) - len;
743 else
744 VALUE_OFFSET (v) = 0;
745 memcpy (VALUE_CONTENTS_RAW (v), value_bytes + VALUE_OFFSET (v), len);
746 }
747 return v;
748 }
749
750
751 /* Given a struct symbol for a variable or function,
752 and a stack frame id,
753 return a (pointer to a) struct value containing the properly typed
754 address. */
755
756 struct value *
locate_var_value(struct symbol * var,struct frame_info * frame)757 locate_var_value (struct symbol *var, struct frame_info *frame)
758 {
759 CORE_ADDR addr = 0;
760 struct type *type = SYMBOL_TYPE (var);
761 struct value *lazy_value;
762
763 /* Evaluate it first; if the result is a memory address, we're fine.
764 Lazy evaluation pays off here. */
765
766 lazy_value = read_var_value (var, frame);
767 if (lazy_value == 0)
768 error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var));
769
770 if (VALUE_LAZY (lazy_value)
771 || TYPE_CODE (type) == TYPE_CODE_FUNC)
772 {
773 struct value *val;
774
775 addr = VALUE_ADDRESS (lazy_value);
776 val = value_from_pointer (lookup_pointer_type (type), addr);
777 VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value);
778 return val;
779 }
780
781 /* Not a memory address; check what the problem was. */
782 switch (VALUE_LVAL (lazy_value))
783 {
784 case lval_register:
785 gdb_assert (REGISTER_NAME (VALUE_REGNO (lazy_value)) != NULL
786 && *REGISTER_NAME (VALUE_REGNO (lazy_value)) != '\0');
787 error("Address requested for identifier "
788 "\"%s\" which is in register $%s",
789 SYMBOL_PRINT_NAME (var),
790 REGISTER_NAME (VALUE_REGNO (lazy_value)));
791 break;
792
793 case lval_reg_frame_relative:
794 gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != NULL
795 && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != '\0');
796 error("Address requested for identifier "
797 "\"%s\" which is in frame register $%s",
798 SYMBOL_PRINT_NAME (var),
799 REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)));
800 break;
801
802 default:
803 error ("Can't take address of \"%s\" which isn't an lvalue.",
804 SYMBOL_PRINT_NAME (var));
805 break;
806 }
807 return 0; /* For lint -- never reached */
808 }
809