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
   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 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., 51 Franklin Street, Fifth Floor,
  22    Boston, MA 02110-1301, 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 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
  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
 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
 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
 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
 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
 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 *
 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
 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
 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
 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
 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 \f
 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
 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 *
 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         memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len);
 437         VALUE_LVAL (v) = not_lval;
 438         return v;
 439       }
 440
 441     case LOC_STATIC:
 442       if (overlay_debugging)
 443         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 444                                          SYMBOL_BFD_SECTION (var));
 445       else
 446         addr = SYMBOL_VALUE_ADDRESS (var);
 447       break;
 448
 449     case LOC_INDIRECT:
 450       {
 451         /* The import slot does not have a real address in it from the
 452            dynamic loader (dld.sl on HP-UX), if the target hasn't
 453            begun execution yet, so check for that. */
 454         CORE_ADDR locaddr;
 455         struct value *loc;
 456         if (!target_has_execution)
 457           error (_("\
 458 Attempt to access variable defined in different shared object or load module when\n\
 459 addresses have not been bound by the dynamic loader. Try again when executable is running."));
 460
 461         locaddr = SYMBOL_VALUE_ADDRESS (var);
 462         loc = value_at (lookup_pointer_type (type), locaddr);
 463         addr = value_as_address (loc);
 464         break;
 465       }
 466
 467     case LOC_ARG:
 468       if (frame == NULL)
 469         return 0;
 470       addr = get_frame_args_address (frame);
 471       if (!addr)
 472         return 0;
 473       addr += SYMBOL_VALUE (var);
 474       break;
 475
 476     case LOC_REF_ARG:
 477       {
 478         struct value *ref;
 479         CORE_ADDR argref;
 480         if (frame == NULL)
 481           return 0;
 482         argref = get_frame_args_address (frame);
 483         if (!argref)
 484           return 0;
 485         argref += SYMBOL_VALUE (var);
 486         ref = value_at (lookup_pointer_type (type), argref);
 487         addr = value_as_address (ref);
 488         break;
 489       }
 490
 491     case LOC_LOCAL:
 492     case LOC_LOCAL_ARG:
 493       if (frame == NULL)
 494         return 0;
 495       addr = get_frame_locals_address (frame);
 496       addr += SYMBOL_VALUE (var);
 497       break;
 498
 499     case LOC_BASEREG:
 500     case LOC_BASEREG_ARG:
 501     case LOC_HP_THREAD_LOCAL_STATIC:
 502       {
 503         struct value *regval;
 504
 505         regval = value_from_register (lookup_pointer_type (type),
 506                                       SYMBOL_BASEREG (var), frame);
 507         if (regval == NULL)
 508           error (_("Value of base register not available."));
 509         addr = value_as_address (regval);
 510         addr += SYMBOL_VALUE (var);
 511         break;
 512       }
 513
 514     case LOC_TYPEDEF:
 515       error (_("Cannot look up value of a typedef"));
 516       break;
 517
 518     case LOC_BLOCK:
 519       if (overlay_debugging)
 520         VALUE_ADDRESS (v) = symbol_overlayed_address
 521           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
 522       else
 523         VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 524       return v;
 525
 526     case LOC_REGISTER:
 527     case LOC_REGPARM:
 528     case LOC_REGPARM_ADDR:
 529       {
 530         struct block *b;
 531         int regno = SYMBOL_VALUE (var);
 532         struct value *regval;
 533
 534         if (frame == NULL)
 535           return 0;
 536         b = get_frame_block (frame, 0);
 537
 538         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 539           {
 540             regval = value_from_register (lookup_pointer_type (type),
 541                                           regno,
 542                                           frame);
 543
 544             if (regval == NULL)
 545               error (_("Value of register variable not available."));
 546
 547             addr = value_as_address (regval);
 548             VALUE_LVAL (v) = lval_memory;
 549           }
 550         else
 551           {
 552             regval = value_from_register (type, regno, frame);
 553
 554             if (regval == NULL)
 555               error (_("Value of register variable not available."));
 556             return regval;
 557           }
 558       }
 559       break;
 560
 561     case LOC_COMPUTED:
 562     case LOC_COMPUTED_ARG:
 563       /* FIXME: cagney/2004-01-26: It should be possible to
 564          unconditionally call the SYMBOL_OPS method when available.
 565          Unfortunately DWARF 2 stores the frame-base (instead of the
 566          function) location in a function's symbol.  Oops!  For the
 567          moment enable this when/where applicable.  */
 568       if (frame == 0 && SYMBOL_OPS (var)->read_needs_frame (var))
 569         return 0;
 570       return SYMBOL_OPS (var)->read_variable (var, frame);
 571
 572     case LOC_UNRESOLVED:
 573       {
 574         struct minimal_symbol *msym;
 575
 576         msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
 577         if (msym == NULL)
 578           return 0;
 579         if (overlay_debugging)
 580           addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
 581                                            SYMBOL_BFD_SECTION (msym));
 582         else
 583           addr = SYMBOL_VALUE_ADDRESS (msym);
 584       }
 585       break;
 586
 587     case LOC_OPTIMIZED_OUT:
 588       VALUE_LVAL (v) = not_lval;
 589       set_value_optimized_out (v, 1);
 590       return v;
 591
 592     default:
 593       error (_("Cannot look up value of a botched symbol."));
 594       break;
 595     }
 596
 597   VALUE_ADDRESS (v) = addr;
 598   set_value_lazy (v, 1);
 599   return v;
 600 }
 601
 602 /* Install default attributes for register values.  */
 603
 604 struct value *
 605 default_value_from_register (struct type *type, int regnum,
 606                              struct frame_info *frame)
 607 {
 608   struct gdbarch *gdbarch = get_frame_arch (frame);
 609   int len = TYPE_LENGTH (type);
 610   struct value *value = allocate_value (type);
 611
 612   VALUE_LVAL (value) = lval_register;
 613   VALUE_FRAME_ID (value) = get_frame_id (frame);
 614   VALUE_REGNUM (value) = regnum;
 615
 616   /* Any structure stored in more than one register will always be
 617      an integral number of registers.  Otherwise, you need to do
 618      some fiddling with the last register copied here for little
 619      endian machines.  */
 620   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
 621       && len < register_size (gdbarch, regnum))
 622     /* Big-endian, and we want less than full size.  */
 623     set_value_offset (value, register_size (gdbarch, regnum) - len);
 624   else
 625     set_value_offset (value, 0);
 626
 627   return value;
 628 }
 629
 630 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME.  */
 631
 632 struct value *
 633 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 634 {
 635   struct gdbarch *gdbarch = get_frame_arch (frame);
 636   struct type *type1 = check_typedef (type);
 637   struct value *v;
 638
 639   if (CONVERT_REGISTER_P (regnum, type1))
 640     {
 641       /* The ISA/ABI need to something weird when obtaining the
 642          specified value from this register.  It might need to
 643          re-order non-adjacent, starting with REGNUM (see MIPS and
 644          i386).  It might need to convert the [float] register into
 645          the corresponding [integer] type (see Alpha).  The assumption
 646          is that REGISTER_TO_VALUE populates the entire value
 647          including the location.  */
 648       v = allocate_value (type);
 649       VALUE_LVAL (v) = lval_register;
 650       VALUE_FRAME_ID (v) = get_frame_id (frame);
 651       VALUE_REGNUM (v) = regnum;
 652       REGISTER_TO_VALUE (frame, regnum, type1, value_contents_raw (v));
 653     }
 654   else
 655     {
 656       int len = TYPE_LENGTH (type);
 657
 658       /* Construct the value.  */
 659       v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
 660
 661       /* Get the data.  */
 662       if (!get_frame_register_bytes (frame, regnum, value_offset (v), len,
 663                                      value_contents_raw (v)))
 664         set_value_optimized_out (v, 1);
 665     }
 666   return v;
 667 }
 668
 669 /* Return contents of register REGNUM in frame FRAME as address,
 670    interpreted as value of type TYPE.   Will abort if register
 671    value is not available.  */
 672
 673 CORE_ADDR
 674 address_from_register (struct type *type, int regnum, struct frame_info *frame)
 675 {
 676   struct value *value;
 677   CORE_ADDR result;
 678
 679   value = value_from_register (type, regnum, frame);
 680   gdb_assert (value);
 681
 682   result = value_as_address (value);
 683   release_value (value);
 684   value_free (value);
 685
 686   return result;
 687 }
 688
 689 \f
 690 /* Given a struct symbol for a variable or function,
 691    and a stack frame id,
 692    return a (pointer to a) struct value containing the properly typed
 693    address.  */
 694
 695 struct value *
 696 locate_var_value (struct symbol *var, struct frame_info *frame)
 697 {
 698   CORE_ADDR addr = 0;
 699   struct type *type = SYMBOL_TYPE (var);
 700   struct value *lazy_value;
 701
 702   /* Evaluate it first; if the result is a memory address, we're fine.
 703      Lazy evaluation pays off here. */
 704
 705   lazy_value = read_var_value (var, frame);
 706   if (lazy_value == 0)
 707     error (_("Address of \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
 708
 709   if (value_lazy (lazy_value)
 710       || TYPE_CODE (type) == TYPE_CODE_FUNC)
 711     {
 712       struct value *val;
 713
 714       addr = VALUE_ADDRESS (lazy_value);
 715       val = value_from_pointer (lookup_pointer_type (type), addr);
 716       return val;
 717     }
 718
 719   /* Not a memory address; check what the problem was.  */
 720   switch (VALUE_LVAL (lazy_value))
 721     {
 722     case lval_register:
 723       gdb_assert (REGISTER_NAME (VALUE_REGNUM (lazy_value)) != NULL
 724                   && *REGISTER_NAME (VALUE_REGNUM (lazy_value)) != '\0');
 725       error (_("Address requested for identifier "
 726                "\"%s\" which is in register $%s"),
 727             SYMBOL_PRINT_NAME (var),
 728             REGISTER_NAME (VALUE_REGNUM (lazy_value)));
 729       break;
 730
 731     default:
 732       error (_("Can't take address of \"%s\" which isn't an lvalue."),
 733              SYMBOL_PRINT_NAME (var));
 734       break;
 735     }
 736   return 0;                     /* For lint -- never reached */
 737 }