2004-11-15 Andrew Cagney <cagney@gnu.org>
[external/binutils.git] / gdb / findvar.c
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
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
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
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
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
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
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
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 *
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_REGNUM (reg_val) = regnum;
290   VALUE_OPTIMIZED_OUT (reg_val) = optim;
291   VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
292   return reg_val;
293 }
294
295 /* Given a pointer of type TYPE in target form in BUF, return the
296    address it represents.  */
297 CORE_ADDR
298 unsigned_pointer_to_address (struct type *type, const void *buf)
299 {
300   return extract_unsigned_integer (buf, TYPE_LENGTH (type));
301 }
302
303 CORE_ADDR
304 signed_pointer_to_address (struct type *type, const void *buf)
305 {
306   return extract_signed_integer (buf, TYPE_LENGTH (type));
307 }
308
309 /* Given an address, store it as a pointer of type TYPE in target
310    format in BUF.  */
311 void
312 unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
313 {
314   store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
315 }
316
317 void
318 address_to_signed_pointer (struct type *type, void *buf, CORE_ADDR addr)
319 {
320   store_signed_integer (buf, TYPE_LENGTH (type), addr);
321 }
322 \f
323 /* Will calling read_var_value or locate_var_value on SYM end
324    up caring what frame it is being evaluated relative to?  SYM must
325    be non-NULL.  */
326 int
327 symbol_read_needs_frame (struct symbol *sym)
328 {
329   switch (SYMBOL_CLASS (sym))
330     {
331       /* All cases listed explicitly so that gcc -Wall will detect it if
332          we failed to consider one.  */
333     case LOC_COMPUTED:
334     case LOC_COMPUTED_ARG:
335       /* FIXME: cagney/2004-01-26: It should be possible to
336          unconditionally call the SYMBOL_OPS method when available.
337          Unfortunately DWARF 2 stores the frame-base (instead of the
338          function) location in a function's symbol.  Oops!  For the
339          moment enable this when/where applicable.  */
340       return SYMBOL_OPS (sym)->read_needs_frame (sym);
341
342     case LOC_REGISTER:
343     case LOC_ARG:
344     case LOC_REF_ARG:
345     case LOC_REGPARM:
346     case LOC_REGPARM_ADDR:
347     case LOC_LOCAL:
348     case LOC_LOCAL_ARG:
349     case LOC_BASEREG:
350     case LOC_BASEREG_ARG:
351     case LOC_HP_THREAD_LOCAL_STATIC:
352       return 1;
353
354     case LOC_UNDEF:
355     case LOC_CONST:
356     case LOC_STATIC:
357     case LOC_INDIRECT:
358     case LOC_TYPEDEF:
359
360     case LOC_LABEL:
361       /* Getting the address of a label can be done independently of the block,
362          even if some *uses* of that address wouldn't work so well without
363          the right frame.  */
364
365     case LOC_BLOCK:
366     case LOC_CONST_BYTES:
367     case LOC_UNRESOLVED:
368     case LOC_OPTIMIZED_OUT:
369       return 0;
370     }
371   return 1;
372 }
373
374 /* Given a struct symbol for a variable,
375    and a stack frame id, read the value of the variable
376    and return a (pointer to a) struct value containing the value. 
377    If the variable cannot be found, return a zero pointer.
378    If FRAME is NULL, use the deprecated_selected_frame.  */
379
380 struct value *
381 read_var_value (struct symbol *var, struct frame_info *frame)
382 {
383   struct value *v;
384   struct type *type = SYMBOL_TYPE (var);
385   CORE_ADDR addr;
386   int len;
387
388   v = allocate_value (type);
389   VALUE_LVAL (v) = lval_memory; /* The most likely possibility.  */
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);
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);
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 *
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_REGNUM (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_register;
639       VALUE_FRAME_ID (v) = get_frame_id (frame);
640       VALUE_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               /* FIXME: cagney/2004-11-12: I think this is trying to
683                  check that the stored registers are adjacent in
684                  memory.  It isn't doing a good job?  */
685               mem_tracking = (mem_tracking
686                               && (regnum == local_regnum
687                                   || addr == last_addr));
688             }
689           last_addr = addr;
690         }
691       
692       if (mem_tracking && mem_stor && !reg_stor)
693         {
694           VALUE_LVAL (v) = lval_memory;
695           VALUE_ADDRESS (v) = first_addr;
696         }
697       else
698         {
699           VALUE_LVAL (v) = lval_register;
700           VALUE_FRAME_ID (v) = get_frame_id (frame);
701           VALUE_REGNUM (v) = regnum;
702         }
703       
704       VALUE_OPTIMIZED_OUT (v) = optimized;
705       
706       /* Any structure stored in more than one register will always be
707          an integral number of registers.  Otherwise, you need to do
708          some fiddling with the last register copied here for little
709          endian machines.  */
710       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
711           && len < register_size (current_gdbarch, regnum))
712         /* Big-endian, and we want less than full size.  */
713         v->offset = register_size (current_gdbarch, regnum) - len;
714       else
715         v->offset = 0;
716       memcpy (VALUE_CONTENTS_RAW (v), value_bytes + value_offset (v), len);
717     }
718   return v;
719 }
720
721 \f
722 /* Given a struct symbol for a variable or function,
723    and a stack frame id, 
724    return a (pointer to a) struct value containing the properly typed
725    address.  */
726
727 struct value *
728 locate_var_value (struct symbol *var, struct frame_info *frame)
729 {
730   CORE_ADDR addr = 0;
731   struct type *type = SYMBOL_TYPE (var);
732   struct value *lazy_value;
733
734   /* Evaluate it first; if the result is a memory address, we're fine.
735      Lazy evaluation pays off here. */
736
737   lazy_value = read_var_value (var, frame);
738   if (lazy_value == 0)
739     error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var));
740
741   if (VALUE_LAZY (lazy_value)
742       || TYPE_CODE (type) == TYPE_CODE_FUNC)
743     {
744       struct value *val;
745
746       addr = VALUE_ADDRESS (lazy_value);
747       val = value_from_pointer (lookup_pointer_type (type), addr);
748       return val;
749     }
750
751   /* Not a memory address; check what the problem was.  */
752   switch (VALUE_LVAL (lazy_value))
753     {
754     case lval_register:
755       gdb_assert (REGISTER_NAME (VALUE_REGNUM (lazy_value)) != NULL
756                   && *REGISTER_NAME (VALUE_REGNUM (lazy_value)) != '\0');
757       error("Address requested for identifier "
758             "\"%s\" which is in register $%s",
759             SYMBOL_PRINT_NAME (var), 
760             REGISTER_NAME (VALUE_REGNUM (lazy_value)));
761       break;
762
763     default:
764       error ("Can't take address of \"%s\" which isn't an lvalue.",
765              SYMBOL_PRINT_NAME (var));
766       break;
767     }
768   return 0;                     /* For lint -- never reached */
769 }