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 memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
286 register_size (current_gdbarch, regnum));
287 VALUE_LVAL (reg_val) = lval;
288 VALUE_ADDRESS (reg_val) = addr;
289 VALUE_REGNO (reg_val) = regnum;
290 VALUE_OPTIMIZED_OUT (reg_val) = optim;
291 return reg_val;
292 }
293
294 /* Given a pointer of type TYPE in target form in BUF, return the
295 address it represents. */
296 CORE_ADDR
unsigned_pointer_to_address(struct type * type,const void * buf)297 unsigned_pointer_to_address (struct type *type, const void *buf)
298 {
299 return extract_unsigned_integer (buf, TYPE_LENGTH (type));
300 }
301
302 CORE_ADDR
signed_pointer_to_address(struct type * type,const void * buf)303 signed_pointer_to_address (struct type *type, const void *buf)
304 {
305 return extract_signed_integer (buf, TYPE_LENGTH (type));
306 }
307
308 /* Given an address, store it as a pointer of type TYPE in target
309 format in BUF. */
310 void
unsigned_address_to_pointer(struct type * type,void * buf,CORE_ADDR addr)311 unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
312 {
313 store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
314 }
315
316 void
address_to_signed_pointer(struct type * type,void * buf,CORE_ADDR addr)317 address_to_signed_pointer (struct type *type, void *buf, CORE_ADDR addr)
318 {
319 store_signed_integer (buf, TYPE_LENGTH (type), addr);
320 }
321
322 /* Will calling read_var_value or locate_var_value on SYM end
323 up caring what frame it is being evaluated relative to? SYM must
324 be non-NULL. */
325 int
symbol_read_needs_frame(struct symbol * sym)326 symbol_read_needs_frame (struct symbol *sym)
327 {
328 switch (SYMBOL_CLASS (sym))
329 {
330 /* All cases listed explicitly so that gcc -Wall will detect it if
331 we failed to consider one. */
332 case LOC_COMPUTED:
333 case LOC_COMPUTED_ARG:
334 /* FIXME: cagney/2004-01-26: It should be possible to
335 unconditionally call the SYMBOL_OPS method when available.
336 Unfortunately DWARF 2 stores the frame-base (instead of the
337 function) location in a function's symbol. Oops! For the
338 moment enable this when/where applicable. */
339 return SYMBOL_OPS (sym)->read_needs_frame (sym);
340
341 case LOC_REGISTER:
342 case LOC_ARG:
343 case LOC_REF_ARG:
344 case LOC_REGPARM:
345 case LOC_REGPARM_ADDR:
346 case LOC_LOCAL:
347 case LOC_LOCAL_ARG:
348 case LOC_BASEREG:
349 case LOC_BASEREG_ARG:
350 case LOC_HP_THREAD_LOCAL_STATIC:
351 return 1;
352
353 case LOC_UNDEF:
354 case LOC_CONST:
355 case LOC_STATIC:
356 case LOC_INDIRECT:
357 case LOC_TYPEDEF:
358
359 case LOC_LABEL:
360 /* Getting the address of a label can be done independently of the block,
361 even if some *uses* of that address wouldn't work so well without
362 the right frame. */
363
364 case LOC_BLOCK:
365 case LOC_CONST_BYTES:
366 case LOC_UNRESOLVED:
367 case LOC_OPTIMIZED_OUT:
368 return 0;
369 }
370 return 1;
371 }
372
373 /* Given a struct symbol for a variable,
374 and a stack frame id, read the value of the variable
375 and return a (pointer to a) struct value containing the value.
376 If the variable cannot be found, return a zero pointer.
377 If FRAME is NULL, use the deprecated_selected_frame. */
378
379 struct value *
read_var_value(struct symbol * var,struct frame_info * frame)380 read_var_value (struct symbol *var, struct frame_info *frame)
381 {
382 struct value *v;
383 struct type *type = SYMBOL_TYPE (var);
384 CORE_ADDR addr;
385 int len;
386
387 v = allocate_value (type);
388 VALUE_LVAL (v) = lval_memory; /* The most likely possibility. */
389 VALUE_BFD_SECTION (v) = SYMBOL_BFD_SECTION (var);
390
391 len = TYPE_LENGTH (type);
392
393
394 /* FIXME drow/2003-09-06: this call to the selected frame should be
395 pushed upwards to the callers. */
396 if (frame == NULL)
397 frame = deprecated_safe_get_selected_frame ();
398
399 switch (SYMBOL_CLASS (var))
400 {
401 case LOC_CONST:
402 /* Put the constant back in target format. */
403 store_signed_integer (VALUE_CONTENTS_RAW (v), len,
404 (LONGEST) SYMBOL_VALUE (var));
405 VALUE_LVAL (v) = not_lval;
406 return v;
407
408 case LOC_LABEL:
409 /* Put the constant back in target format. */
410 if (overlay_debugging)
411 {
412 CORE_ADDR addr
413 = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
414 SYMBOL_BFD_SECTION (var));
415 store_typed_address (VALUE_CONTENTS_RAW (v), type, addr);
416 }
417 else
418 store_typed_address (VALUE_CONTENTS_RAW (v), type,
419 SYMBOL_VALUE_ADDRESS (var));
420 VALUE_LVAL (v) = not_lval;
421 return v;
422
423 case LOC_CONST_BYTES:
424 {
425 char *bytes_addr;
426 bytes_addr = SYMBOL_VALUE_BYTES (var);
427 memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
428 VALUE_LVAL (v) = not_lval;
429 return v;
430 }
431
432 case LOC_STATIC:
433 if (overlay_debugging)
434 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
435 SYMBOL_BFD_SECTION (var));
436 else
437 addr = SYMBOL_VALUE_ADDRESS (var);
438 break;
439
440 case LOC_INDIRECT:
441 {
442 /* The import slot does not have a real address in it from the
443 dynamic loader (dld.sl on HP-UX), if the target hasn't
444 begun execution yet, so check for that. */
445 CORE_ADDR locaddr;
446 struct value *loc;
447 if (!target_has_execution)
448 error ("\
449 Attempt to access variable defined in different shared object or load module when\n\
450 addresses have not been bound by the dynamic loader. Try again when executable is running.");
451
452 locaddr = SYMBOL_VALUE_ADDRESS (var);
453 loc = value_at (lookup_pointer_type (type), locaddr, NULL);
454 addr = value_as_address (loc);
455 }
456
457 case LOC_ARG:
458 if (frame == NULL)
459 return 0;
460 addr = get_frame_args_address (frame);
461 if (!addr)
462 return 0;
463 addr += SYMBOL_VALUE (var);
464 break;
465
466 case LOC_REF_ARG:
467 {
468 struct value *ref;
469 CORE_ADDR argref;
470 if (frame == NULL)
471 return 0;
472 argref = get_frame_args_address (frame);
473 if (!argref)
474 return 0;
475 argref += SYMBOL_VALUE (var);
476 ref = value_at (lookup_pointer_type (type), argref, NULL);
477 addr = value_as_address (ref);
478 break;
479 }
480
481 case LOC_LOCAL:
482 case LOC_LOCAL_ARG:
483 if (frame == NULL)
484 return 0;
485 addr = get_frame_locals_address (frame);
486 addr += SYMBOL_VALUE (var);
487 break;
488
489 case LOC_BASEREG:
490 case LOC_BASEREG_ARG:
491 case LOC_HP_THREAD_LOCAL_STATIC:
492 {
493 struct value *regval;
494
495 regval = value_from_register (lookup_pointer_type (type),
496 SYMBOL_BASEREG (var), frame);
497 if (regval == NULL)
498 error ("Value of base register not available.");
499 addr = value_as_address (regval);
500 addr += SYMBOL_VALUE (var);
501 break;
502 }
503
504 case LOC_TYPEDEF:
505 error ("Cannot look up value of a typedef");
506 break;
507
508 case LOC_BLOCK:
509 if (overlay_debugging)
510 VALUE_ADDRESS (v) = symbol_overlayed_address
511 (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
512 else
513 VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
514 return v;
515
516 case LOC_REGISTER:
517 case LOC_REGPARM:
518 case LOC_REGPARM_ADDR:
519 {
520 struct block *b;
521 int regno = SYMBOL_VALUE (var);
522 struct value *regval;
523
524 if (frame == NULL)
525 return 0;
526 b = get_frame_block (frame, 0);
527
528 if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
529 {
530 regval = value_from_register (lookup_pointer_type (type),
531 regno,
532 frame);
533
534 if (regval == NULL)
535 error ("Value of register variable not available.");
536
537 addr = value_as_address (regval);
538 VALUE_LVAL (v) = lval_memory;
539 }
540 else
541 {
542 regval = value_from_register (type, regno, frame);
543
544 if (regval == NULL)
545 error ("Value of register variable not available.");
546 return regval;
547 }
548 }
549 break;
550
551 case LOC_COMPUTED:
552 case LOC_COMPUTED_ARG:
553 /* FIXME: cagney/2004-01-26: It should be possible to
554 unconditionally call the SYMBOL_OPS method when available.
555 Unfortunately DWARF 2 stores the frame-base (instead of the
556 function) location in a function's symbol. Oops! For the
557 moment enable this when/where applicable. */
558 if (frame == 0 && SYMBOL_OPS (var)->read_needs_frame (var))
559 return 0;
560 return SYMBOL_OPS (var)->read_variable (var, frame);
561
562 case LOC_UNRESOLVED:
563 {
564 struct minimal_symbol *msym;
565
566 msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
567 if (msym == NULL)
568 return 0;
569 if (overlay_debugging)
570 addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
571 SYMBOL_BFD_SECTION (msym));
572 else
573 addr = SYMBOL_VALUE_ADDRESS (msym);
574 }
575 break;
576
577 case LOC_OPTIMIZED_OUT:
578 VALUE_LVAL (v) = not_lval;
579 VALUE_OPTIMIZED_OUT (v) = 1;
580 return v;
581
582 default:
583 error ("Cannot look up value of a botched symbol.");
584 break;
585 }
586
587 VALUE_ADDRESS (v) = addr;
588 VALUE_LAZY (v) = 1;
589 return v;
590 }
591
592 /* Return a value of type TYPE, stored in register REGNUM, in frame
593 FRAME.
594
595 NOTE: returns NULL if register value is not available.
596 Caller will check return value or die! */
597
598 struct value *
value_from_register(struct type * type,int regnum,struct frame_info * frame)599 value_from_register (struct type *type, int regnum, struct frame_info *frame)
600 {
601 struct gdbarch *gdbarch = get_frame_arch (frame);
602 struct value *v = allocate_value (type);
603 CHECK_TYPEDEF (type);
604
605 if (TYPE_LENGTH (type) == 0)
606 {
607 /* It doesn't matter much what we return for this: since the
608 length is zero, it could be anything. But if allowed to see
609 a zero-length type, the register-finding loop below will set
610 neither mem_stor nor reg_stor, and then report an internal
611 error.
612
613 Zero-length types can legitimately arise from declarations
614 like 'struct {}' (a GCC extension, not valid ISO C). GDB may
615 also create them when it finds bogus debugging information;
616 for example, in GCC 2.95.4 and binutils 2.11.93.0.2, the
617 STABS BINCL->EXCL compression process can create bad type
618 numbers. GDB reads these as TYPE_CODE_UNDEF types, with zero
619 length. (That bug is actually the only known way to get a
620 zero-length value allocated to a register --- which is what
621 it takes to make it here.)
622
623 We'll just attribute the value to the original register. */
624 VALUE_LVAL (v) = lval_register;
625 VALUE_ADDRESS (v) = regnum;
626 VALUE_REGNO (v) = regnum;
627 }
628 else if (CONVERT_REGISTER_P (regnum, type))
629 {
630 /* The ISA/ABI need to something weird when obtaining the
631 specified value from this register. It might need to
632 re-order non-adjacent, starting with REGNUM (see MIPS and
633 i386). It might need to convert the [float] register into
634 the corresponding [integer] type (see Alpha). The assumption
635 is that REGISTER_TO_VALUE populates the entire value
636 including the location. */
637 REGISTER_TO_VALUE (frame, regnum, type, VALUE_CONTENTS_RAW (v));
638 VALUE_LVAL (v) = lval_reg_frame_relative;
639 VALUE_FRAME_ID (v) = get_frame_id (frame);
640 VALUE_FRAME_REGNUM (v) = regnum;
641 }
642 else
643 {
644 int local_regnum;
645 int mem_stor = 0, reg_stor = 0;
646 int mem_tracking = 1;
647 CORE_ADDR last_addr = 0;
648 CORE_ADDR first_addr = 0;
649 int first_realnum = regnum;
650 int len = TYPE_LENGTH (type);
651 int value_bytes_copied;
652 int optimized = 0;
653 char *value_bytes = (char *) alloca (len + MAX_REGISTER_SIZE);
654
655 /* Copy all of the data out, whereever it may be. */
656 for (local_regnum = regnum, value_bytes_copied = 0;
657 value_bytes_copied < len;
658 (value_bytes_copied += register_size (current_gdbarch, local_regnum),
659 ++local_regnum))
660 {
661 int realnum;
662 int optim;
663 enum lval_type lval;
664 CORE_ADDR addr;
665 frame_register (frame, local_regnum, &optim, &lval, &addr,
666 &realnum, value_bytes + value_bytes_copied);
667 optimized += optim;
668 if (register_cached (local_regnum) == -1)
669 return NULL; /* register value not available */
670
671 if (regnum == local_regnum)
672 {
673 first_addr = addr;
674 first_realnum = realnum;
675 }
676 if (lval == lval_register)
677 reg_stor++;
678 else
679 {
680 mem_stor++;
681
682 mem_tracking = (mem_tracking
683 && (regnum == local_regnum
684 || addr == last_addr));
685 }
686 last_addr = addr;
687 }
688
689 /* FIXME: cagney/2003-06-04: Shouldn't this always use
690 lval_reg_frame_relative? If it doesn't and the register's
691 location changes (say after a resume) then this value is
692 going to have wrong information. */
693 if ((reg_stor && mem_stor)
694 || (mem_stor && !mem_tracking))
695 /* Mixed storage; all of the hassle we just went through was
696 for some good purpose. */
697 {
698 VALUE_LVAL (v) = lval_reg_frame_relative;
699 VALUE_FRAME_ID (v) = get_frame_id (frame);
700 VALUE_FRAME_REGNUM (v) = regnum;
701 }
702 else if (mem_stor)
703 {
704 VALUE_LVAL (v) = lval_memory;
705 VALUE_ADDRESS (v) = first_addr;
706 }
707 else if (reg_stor)
708 {
709 VALUE_LVAL (v) = lval_register;
710 VALUE_ADDRESS (v) = first_addr;
711 VALUE_REGNO (v) = first_realnum;
712 }
713 else
714 internal_error (__FILE__, __LINE__,
715 "value_from_register: Value not stored anywhere!");
716
717 VALUE_OPTIMIZED_OUT (v) = optimized;
718
719 /* Any structure stored in more than one register will always be
720 an integral number of registers. Otherwise, you need to do
721 some fiddling with the last register copied here for little
722 endian machines. */
723 if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
724 && len < register_size (current_gdbarch, regnum))
725 /* Big-endian, and we want less than full size. */
726 VALUE_OFFSET (v) = register_size (current_gdbarch, regnum) - len;
727 else
728 VALUE_OFFSET (v) = 0;
729 memcpy (VALUE_CONTENTS_RAW (v), value_bytes + VALUE_OFFSET (v), len);
730 }
731 return v;
732 }
733
734
735 /* Given a struct symbol for a variable or function,
736 and a stack frame id,
737 return a (pointer to a) struct value containing the properly typed
738 address. */
739
740 struct value *
locate_var_value(struct symbol * var,struct frame_info * frame)741 locate_var_value (struct symbol *var, struct frame_info *frame)
742 {
743 CORE_ADDR addr = 0;
744 struct type *type = SYMBOL_TYPE (var);
745 struct value *lazy_value;
746
747 /* Evaluate it first; if the result is a memory address, we're fine.
748 Lazy evaluation pays off here. */
749
750 lazy_value = read_var_value (var, frame);
751 if (lazy_value == 0)
752 error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var));
753
754 if (VALUE_LAZY (lazy_value)
755 || TYPE_CODE (type) == TYPE_CODE_FUNC)
756 {
757 struct value *val;
758
759 addr = VALUE_ADDRESS (lazy_value);
760 val = value_from_pointer (lookup_pointer_type (type), addr);
761 VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value);
762 return val;
763 }
764
765 /* Not a memory address; check what the problem was. */
766 switch (VALUE_LVAL (lazy_value))
767 {
768 case lval_register:
769 gdb_assert (REGISTER_NAME (VALUE_REGNO (lazy_value)) != NULL
770 && *REGISTER_NAME (VALUE_REGNO (lazy_value)) != '\0');
771 error("Address requested for identifier "
772 "\"%s\" which is in register $%s",
773 SYMBOL_PRINT_NAME (var),
774 REGISTER_NAME (VALUE_REGNO (lazy_value)));
775 break;
776
777 case lval_reg_frame_relative:
778 gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != NULL
779 && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != '\0');
780 error("Address requested for identifier "
781 "\"%s\" which is in frame register $%s",
782 SYMBOL_PRINT_NAME (var),
783 REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)));
784 break;
785
786 default:
787 error ("Can't take address of \"%s\" which isn't an lvalue.",
788 SYMBOL_PRINT_NAME (var));
789 break;
790 }
791 return 0; /* For lint -- never reached */
792 }
793