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