gdb/findvar.c

   1 /* Find a variable's value in memory, for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
   4    1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007, 2008
   5    Free 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 3 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, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "frame.h"
  26 #include "value.h"
  27 #include "gdbcore.h"
  28 #include "inferior.h"
  29 #include "target.h"
  30 #include "gdb_string.h"
  31 #include "gdb_assert.h"
  32 #include "floatformat.h"
  33 #include "symfile.h"            /* for overlay functions */
  34 #include "regcache.h"
  35 #include "user-regs.h"
  36 #include "block.h"
  37
  38 /* Basic byte-swapping routines.  GDB has needed these for a long time...
  39    All extract a target-format integer at ADDR which is LEN bytes long.  */
  40
  41 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
  42   /* 8 bit characters are a pretty safe assumption these days, so we
  43      assume it throughout all these swapping routines.  If we had to deal with
  44      9 bit characters, we would need to make len be in bits and would have
  45      to re-write these routines...  */
  46 you lose
  47 #endif
  48
  49 LONGEST
  50 extract_signed_integer (const gdb_byte *addr, int len)
  51 {
  52   LONGEST retval;
  53   const unsigned char *p;
  54   const unsigned char *startaddr = addr;
  55   const unsigned char *endaddr = startaddr + len;
  56
  57   if (len > (int) sizeof (LONGEST))
  58     error (_("\
  59 That operation is not available on integers of more than %d bytes."),
  60            (int) sizeof (LONGEST));
  61
  62   /* Start at the most significant end of the integer, and work towards
  63      the least significant.  */
  64   if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
  65     {
  66       p = startaddr;
  67       /* Do the sign extension once at the start.  */
  68       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  69       for (++p; p < endaddr; ++p)
  70         retval = (retval << 8) | *p;
  71     }
  72   else
  73     {
  74       p = endaddr - 1;
  75       /* Do the sign extension once at the start.  */
  76       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  77       for (--p; p >= startaddr; --p)
  78         retval = (retval << 8) | *p;
  79     }
  80   return retval;
  81 }
  82
  83 ULONGEST
  84 extract_unsigned_integer (const gdb_byte *addr, int len)
  85 {
  86   ULONGEST retval;
  87   const unsigned char *p;
  88   const unsigned char *startaddr = addr;
  89   const unsigned char *endaddr = startaddr + len;
  90
  91   if (len > (int) sizeof (ULONGEST))
  92     error (_("\
  93 That operation is not available on integers of more than %d bytes."),
  94            (int) sizeof (ULONGEST));
  95
  96   /* Start at the most significant end of the integer, and work towards
  97      the least significant.  */
  98   retval = 0;
  99   if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
 100     {
 101       for (p = startaddr; p < endaddr; ++p)
 102         retval = (retval << 8) | *p;
 103     }
 104   else
 105     {
 106       for (p = endaddr - 1; p >= startaddr; --p)
 107         retval = (retval << 8) | *p;
 108     }
 109   return retval;
 110 }
 111
 112 /* Sometimes a long long unsigned integer can be extracted as a
 113    LONGEST value.  This is done so that we can print these values
 114    better.  If this integer can be converted to a LONGEST, this
 115    function returns 1 and sets *PVAL.  Otherwise it returns 0.  */
 116
 117 int
 118 extract_long_unsigned_integer (const gdb_byte *addr, int orig_len,
 119                                LONGEST *pval)
 120 {
 121   const gdb_byte *p;
 122   const gdb_byte *first_addr;
 123   int len;
 124
 125   len = orig_len;
 126   if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_BIG)
 127     {
 128       for (p = addr;
 129            len > (int) sizeof (LONGEST) && p < 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 = addr;
 142       for (p = addr + orig_len - 1;
 143            len > (int) sizeof (LONGEST) && p >= 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 gdb_byte *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 gdbarch_pointer_to_address (current_gdbarch, type, buf);
 176 }
 177
 178
 179 void
 180 store_signed_integer (gdb_byte *addr, int len, LONGEST val)
 181 {
 182   gdb_byte *p;
 183   gdb_byte *startaddr = addr;
 184   gdb_byte *endaddr = startaddr + len;
 185
 186   /* Start at the least significant end of the integer, and work towards
 187      the most significant.  */
 188   if (gdbarch_byte_order (current_gdbarch) == 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 (gdb_byte *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 (gdbarch_byte_order (current_gdbarch) == 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 (gdb_byte *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   gdbarch_address_to_pointer (current_gdbarch, 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 struct value *
 254 value_of_register (int regnum, struct frame_info *frame)
 255 {
 256   struct gdbarch *gdbarch = get_frame_arch (frame);
 257   CORE_ADDR addr;
 258   int optim;
 259   struct value *reg_val;
 260   int realnum;
 261   gdb_byte raw_buffer[MAX_REGISTER_SIZE];
 262   enum lval_type lval;
 263
 264   /* User registers lie completely outside of the range of normal
 265      registers.  Catch them early so that the target never sees them.  */
 266   if (regnum >= gdbarch_num_regs (gdbarch)
 267                 + gdbarch_num_pseudo_regs (gdbarch))
 268     return value_of_user_reg (regnum, frame);
 269
 270   frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
 271
 272   reg_val = allocate_value (register_type (gdbarch, regnum));
 273
 274   memcpy (value_contents_raw (reg_val), raw_buffer,
 275           register_size (gdbarch, regnum));
 276   VALUE_LVAL (reg_val) = lval;
 277   VALUE_ADDRESS (reg_val) = addr;
 278   VALUE_REGNUM (reg_val) = regnum;
 279   set_value_optimized_out (reg_val, optim);
 280   VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
 281   return reg_val;
 282 }
 283
 284 /* Return a `value' with the contents of (virtual or cooked) register
 285    REGNUM as found in the specified FRAME.  The register's type is
 286    determined by register_type().  The value is not fetched.  */
 287
 288 struct value *
 289 value_of_register_lazy (struct frame_info *frame, int regnum)
 290 {
 291   struct gdbarch *gdbarch = get_frame_arch (frame);
 292   struct value *reg_val;
 293
 294   gdb_assert (regnum < (gdbarch_num_regs (gdbarch)
 295                         + gdbarch_num_pseudo_regs (gdbarch)));
 296
 297   /* We should have a valid (i.e. non-sentinel) frame.  */
 298   gdb_assert (frame_id_p (get_frame_id (frame)));
 299
 300   reg_val = allocate_value (register_type (gdbarch, regnum));
 301   VALUE_LVAL (reg_val) = lval_register;
 302   VALUE_REGNUM (reg_val) = regnum;
 303   VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
 304   set_value_lazy (reg_val, 1);
 305   return reg_val;
 306 }
 307
 308 /* Given a pointer of type TYPE in target form in BUF, return the
 309    address it represents.  */
 310 CORE_ADDR
 311 unsigned_pointer_to_address (struct type *type, const gdb_byte *buf)
 312 {
 313   return extract_unsigned_integer (buf, TYPE_LENGTH (type));
 314 }
 315
 316 CORE_ADDR
 317 signed_pointer_to_address (struct type *type, const gdb_byte *buf)
 318 {
 319   return extract_signed_integer (buf, TYPE_LENGTH (type));
 320 }
 321
 322 /* Given an address, store it as a pointer of type TYPE in target
 323    format in BUF.  */
 324 void
 325 unsigned_address_to_pointer (struct type *type, gdb_byte *buf,
 326                              CORE_ADDR addr)
 327 {
 328   store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
 329 }
 330
 331 void
 332 address_to_signed_pointer (struct type *type, gdb_byte *buf, CORE_ADDR addr)
 333 {
 334   store_signed_integer (buf, TYPE_LENGTH (type), addr);
 335 }
 336 \f
 337 /* Will calling read_var_value or locate_var_value on SYM end
 338    up caring what frame it is being evaluated relative to?  SYM must
 339    be non-NULL.  */
 340 int
 341 symbol_read_needs_frame (struct symbol *sym)
 342 {
 343   switch (SYMBOL_CLASS (sym))
 344     {
 345       /* All cases listed explicitly so that gcc -Wall will detect it if
 346          we failed to consider one.  */
 347     case LOC_COMPUTED:
 348     case LOC_COMPUTED_ARG:
 349       /* FIXME: cagney/2004-01-26: It should be possible to
 350          unconditionally call the SYMBOL_OPS method when available.
 351          Unfortunately DWARF 2 stores the frame-base (instead of the
 352          function) location in a function's symbol.  Oops!  For the
 353          moment enable this when/where applicable.  */
 354       return SYMBOL_OPS (sym)->read_needs_frame (sym);
 355
 356     case LOC_REGISTER:
 357     case LOC_ARG:
 358     case LOC_REF_ARG:
 359     case LOC_REGPARM:
 360     case LOC_REGPARM_ADDR:
 361     case LOC_LOCAL:
 362     case LOC_LOCAL_ARG:
 363     case LOC_BASEREG:
 364     case LOC_BASEREG_ARG:
 365       return 1;
 366
 367     case LOC_UNDEF:
 368     case LOC_CONST:
 369     case LOC_STATIC:
 370     case LOC_TYPEDEF:
 371
 372     case LOC_LABEL:
 373       /* Getting the address of a label can be done independently of the block,
 374          even if some *uses* of that address wouldn't work so well without
 375          the right frame.  */
 376
 377     case LOC_BLOCK:
 378     case LOC_CONST_BYTES:
 379     case LOC_UNRESOLVED:
 380     case LOC_OPTIMIZED_OUT:
 381       return 0;
 382     }
 383   return 1;
 384 }
 385
 386 /* Given a struct symbol for a variable,
 387    and a stack frame id, read the value of the variable
 388    and return a (pointer to a) struct value containing the value.
 389    If the variable cannot be found, return a zero pointer.
 390    If FRAME is NULL, use the selected frame.  */
 391
 392 struct value *
 393 read_var_value (struct symbol *var, struct frame_info *frame)
 394 {
 395   struct value *v;
 396   struct type *type = SYMBOL_TYPE (var);
 397   CORE_ADDR addr;
 398   int len;
 399
 400   if (SYMBOL_CLASS (var) == LOC_COMPUTED
 401       || SYMBOL_CLASS (var) == LOC_COMPUTED_ARG
 402       || SYMBOL_CLASS (var) == LOC_REGISTER
 403       || SYMBOL_CLASS (var) == LOC_REGPARM)
 404     /* These cases do not use V.  */
 405     v = NULL;
 406   else
 407     {
 408       v = allocate_value (type);
 409       VALUE_LVAL (v) = lval_memory;     /* The most likely possibility.  */
 410     }
 411
 412   len = TYPE_LENGTH (type);
 413
 414   /* FIXME drow/2003-09-06: this call to the selected frame should be
 415      pushed upwards to the callers.  */
 416   if (frame == NULL)
 417     frame = deprecated_safe_get_selected_frame ();
 418
 419   switch (SYMBOL_CLASS (var))
 420     {
 421     case LOC_CONST:
 422       /* Put the constant back in target format.  */
 423       store_signed_integer (value_contents_raw (v), len,
 424                             (LONGEST) SYMBOL_VALUE (var));
 425       VALUE_LVAL (v) = not_lval;
 426       return v;
 427
 428     case LOC_LABEL:
 429       /* Put the constant back in target format.  */
 430       if (overlay_debugging)
 431         {
 432           CORE_ADDR addr
 433             = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 434                                         SYMBOL_BFD_SECTION (var));
 435           store_typed_address (value_contents_raw (v), type, addr);
 436         }
 437       else
 438         store_typed_address (value_contents_raw (v), type,
 439                               SYMBOL_VALUE_ADDRESS (var));
 440       VALUE_LVAL (v) = not_lval;
 441       return v;
 442
 443     case LOC_CONST_BYTES:
 444       {
 445         memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len);
 446         VALUE_LVAL (v) = not_lval;
 447         return v;
 448       }
 449
 450     case LOC_STATIC:
 451       if (overlay_debugging)
 452         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 453                                          SYMBOL_BFD_SECTION (var));
 454       else
 455         addr = SYMBOL_VALUE_ADDRESS (var);
 456       break;
 457
 458     case LOC_ARG:
 459       if (frame == NULL)
 460         return 0;
 461       addr = get_frame_args_address (frame);
 462       if (!addr)
 463         return 0;
 464       addr += SYMBOL_VALUE (var);
 465       break;
 466
 467     case LOC_REF_ARG:
 468       {
 469         struct value *ref;
 470         CORE_ADDR argref;
 471         if (frame == NULL)
 472           return 0;
 473         argref = get_frame_args_address (frame);
 474         if (!argref)
 475           return 0;
 476         argref += SYMBOL_VALUE (var);
 477         ref = value_at (lookup_pointer_type (type), argref);
 478         addr = value_as_address (ref);
 479         break;
 480       }
 481
 482     case LOC_LOCAL:
 483     case LOC_LOCAL_ARG:
 484       if (frame == NULL)
 485         return 0;
 486       addr = get_frame_locals_address (frame);
 487       addr += SYMBOL_VALUE (var);
 488       break;
 489
 490     case LOC_BASEREG:
 491     case LOC_BASEREG_ARG:
 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       set_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   set_value_lazy (v, 1);
 589   return v;
 590 }
 591
 592 /* Install default attributes for register values.  */
 593
 594 struct value *
 595 default_value_from_register (struct type *type, int regnum,
 596                              struct frame_info *frame)
 597 {
 598   struct gdbarch *gdbarch = get_frame_arch (frame);
 599   int len = TYPE_LENGTH (type);
 600   struct value *value = allocate_value (type);
 601
 602   VALUE_LVAL (value) = lval_register;
 603   VALUE_FRAME_ID (value) = get_frame_id (frame);
 604   VALUE_REGNUM (value) = regnum;
 605
 606   /* Any structure stored in more than one register will always be
 607      an integral number of registers.  Otherwise, you need to do
 608      some fiddling with the last register copied here for little
 609      endian machines.  */
 610   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
 611       && len < register_size (gdbarch, regnum))
 612     /* Big-endian, and we want less than full size.  */
 613     set_value_offset (value, register_size (gdbarch, regnum) - len);
 614   else
 615     set_value_offset (value, 0);
 616
 617   return value;
 618 }
 619
 620 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME.  */
 621
 622 struct value *
 623 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 624 {
 625   struct gdbarch *gdbarch = get_frame_arch (frame);
 626   struct type *type1 = check_typedef (type);
 627   struct value *v;
 628
 629   if (gdbarch_convert_register_p (gdbarch, regnum, type1))
 630     {
 631       /* The ISA/ABI need to something weird when obtaining the
 632          specified value from this register.  It might need to
 633          re-order non-adjacent, starting with REGNUM (see MIPS and
 634          i386).  It might need to convert the [float] register into
 635          the corresponding [integer] type (see Alpha).  The assumption
 636          is that gdbarch_register_to_value populates the entire value
 637          including the location.  */
 638       v = allocate_value (type);
 639       VALUE_LVAL (v) = lval_register;
 640       VALUE_FRAME_ID (v) = get_frame_id (frame);
 641       VALUE_REGNUM (v) = regnum;
 642       gdbarch_register_to_value (gdbarch,
 643                                  frame, regnum, type1, value_contents_raw (v));
 644     }
 645   else
 646     {
 647       int len = TYPE_LENGTH (type);
 648
 649       /* Construct the value.  */
 650       v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
 651
 652       /* Get the data.  */
 653       if (!get_frame_register_bytes (frame, regnum, value_offset (v), len,
 654                                      value_contents_raw (v)))
 655         set_value_optimized_out (v, 1);
 656     }
 657   return v;
 658 }
 659
 660 /* Return contents of register REGNUM in frame FRAME as address,
 661    interpreted as value of type TYPE.   Will abort if register
 662    value is not available.  */
 663
 664 CORE_ADDR
 665 address_from_register (struct type *type, int regnum, struct frame_info *frame)
 666 {
 667   struct value *value;
 668   CORE_ADDR result;
 669
 670   value = value_from_register (type, regnum, frame);
 671   gdb_assert (value);
 672
 673   result = value_as_address (value);
 674   release_value (value);
 675   value_free (value);
 676
 677   return result;
 678 }
 679
 680 \f
 681 /* Given a struct symbol for a variable or function,
 682    and a stack frame id,
 683    return a (pointer to a) struct value containing the properly typed
 684    address.  */
 685
 686 struct value *
 687 locate_var_value (struct symbol *var, struct frame_info *frame)
 688 {
 689   struct gdbarch *gdbarch = get_frame_arch (frame);
 690   CORE_ADDR addr = 0;
 691   struct type *type = SYMBOL_TYPE (var);
 692   struct value *lazy_value;
 693
 694   /* Evaluate it first; if the result is a memory address, we're fine.
 695      Lazy evaluation pays off here. */
 696
 697   lazy_value = read_var_value (var, frame);
 698   if (lazy_value == 0)
 699     error (_("Address of \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
 700
 701   if ((VALUE_LVAL (lazy_value) == lval_memory && value_lazy (lazy_value))
 702       || TYPE_CODE (type) == TYPE_CODE_FUNC)
 703     {
 704       struct value *val;
 705
 706       addr = VALUE_ADDRESS (lazy_value);
 707       val = value_from_pointer (lookup_pointer_type (type), addr);
 708       return val;
 709     }
 710
 711   /* Not a memory address; check what the problem was.  */
 712   switch (VALUE_LVAL (lazy_value))
 713     {
 714     case lval_register:
 715       gdb_assert (gdbarch_register_name
 716                    (gdbarch, VALUE_REGNUM (lazy_value)) != NULL
 717                   && *gdbarch_register_name
 718                     (gdbarch, VALUE_REGNUM (lazy_value)) != '\0');
 719       error (_("Address requested for identifier "
 720                "\"%s\" which is in register $%s"),
 721             SYMBOL_PRINT_NAME (var),
 722             gdbarch_register_name (gdbarch, VALUE_REGNUM (lazy_value)));
 723       break;
 724
 725     default:
 726       error (_("Can't take address of \"%s\" which isn't an lvalue."),
 727              SYMBOL_PRINT_NAME (var));
 728       break;
 729     }
 730   return 0;                     /* For lint -- never reached */
 731 }