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, 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
  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   char 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         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 *
 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       char *value_bytes = (char *) 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 \f
 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 *
 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 }