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 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   set_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   if (SYMBOL_CLASS (var) == LOC_COMPUTED
 389       || SYMBOL_CLASS (var) == LOC_COMPUTED_ARG
 390       || SYMBOL_CLASS (var) == LOC_REGISTER
 391       || SYMBOL_CLASS (var) == LOC_REGPARM)
 392     /* These cases do not use V.  */
 393     v = NULL;
 394   else
 395     {
 396       v = allocate_value (type);
 397       VALUE_LVAL (v) = lval_memory;     /* The most likely possibility.  */
 398     }
 399
 400   len = TYPE_LENGTH (type);
 401
 402   /* FIXME drow/2003-09-06: this call to the selected frame should be
 403      pushed upwards to the callers.  */
 404   if (frame == NULL)
 405     frame = deprecated_safe_get_selected_frame ();
 406
 407   switch (SYMBOL_CLASS (var))
 408     {
 409     case LOC_CONST:
 410       /* Put the constant back in target format.  */
 411       store_signed_integer (value_contents_raw (v), len,
 412                             (LONGEST) SYMBOL_VALUE (var));
 413       VALUE_LVAL (v) = not_lval;
 414       return v;
 415
 416     case LOC_LABEL:
 417       /* Put the constant back in target format.  */
 418       if (overlay_debugging)
 419         {
 420           CORE_ADDR addr
 421             = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 422                                         SYMBOL_BFD_SECTION (var));
 423           store_typed_address (value_contents_raw (v), type, addr);
 424         }
 425       else
 426         store_typed_address (value_contents_raw (v), type,
 427                               SYMBOL_VALUE_ADDRESS (var));
 428       VALUE_LVAL (v) = not_lval;
 429       return v;
 430
 431     case LOC_CONST_BYTES:
 432       {
 433         char *bytes_addr;
 434         bytes_addr = SYMBOL_VALUE_BYTES (var);
 435         memcpy (value_contents_raw (v), bytes_addr, len);
 436         VALUE_LVAL (v) = not_lval;
 437         return v;
 438       }
 439
 440     case LOC_STATIC:
 441       if (overlay_debugging)
 442         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 443                                          SYMBOL_BFD_SECTION (var));
 444       else
 445         addr = SYMBOL_VALUE_ADDRESS (var);
 446       break;
 447
 448     case LOC_INDIRECT:
 449       {
 450         /* The import slot does not have a real address in it from the
 451            dynamic loader (dld.sl on HP-UX), if the target hasn't
 452            begun execution yet, so check for that. */
 453         CORE_ADDR locaddr;
 454         struct value *loc;
 455         if (!target_has_execution)
 456           error (_("\
 457 Attempt to access variable defined in different shared object or load module when\n\
 458 addresses have not been bound by the dynamic loader. Try again when executable is running."));
 459
 460         locaddr = SYMBOL_VALUE_ADDRESS (var);
 461         loc = value_at (lookup_pointer_type (type), locaddr);
 462         addr = value_as_address (loc);
 463         break;
 464       }
 465
 466     case LOC_ARG:
 467       if (frame == NULL)
 468         return 0;
 469       addr = get_frame_args_address (frame);
 470       if (!addr)
 471         return 0;
 472       addr += SYMBOL_VALUE (var);
 473       break;
 474
 475     case LOC_REF_ARG:
 476       {
 477         struct value *ref;
 478         CORE_ADDR argref;
 479         if (frame == NULL)
 480           return 0;
 481         argref = get_frame_args_address (frame);
 482         if (!argref)
 483           return 0;
 484         argref += SYMBOL_VALUE (var);
 485         ref = value_at (lookup_pointer_type (type), argref);
 486         addr = value_as_address (ref);
 487         break;
 488       }
 489
 490     case LOC_LOCAL:
 491     case LOC_LOCAL_ARG:
 492       if (frame == NULL)
 493         return 0;
 494       addr = get_frame_locals_address (frame);
 495       addr += SYMBOL_VALUE (var);
 496       break;
 497
 498     case LOC_BASEREG:
 499     case LOC_BASEREG_ARG:
 500     case LOC_HP_THREAD_LOCAL_STATIC:
 501       {
 502         struct value *regval;
 503
 504         regval = value_from_register (lookup_pointer_type (type),
 505                                       SYMBOL_BASEREG (var), frame);
 506         if (regval == NULL)
 507           error (_("Value of base register not available."));
 508         addr = value_as_address (regval);
 509         addr += SYMBOL_VALUE (var);
 510         break;
 511       }
 512
 513     case LOC_TYPEDEF:
 514       error (_("Cannot look up value of a typedef"));
 515       break;
 516
 517     case LOC_BLOCK:
 518       if (overlay_debugging)
 519         VALUE_ADDRESS (v) = symbol_overlayed_address
 520           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
 521       else
 522         VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 523       return v;
 524
 525     case LOC_REGISTER:
 526     case LOC_REGPARM:
 527     case LOC_REGPARM_ADDR:
 528       {
 529         struct block *b;
 530         int regno = SYMBOL_VALUE (var);
 531         struct value *regval;
 532
 533         if (frame == NULL)
 534           return 0;
 535         b = get_frame_block (frame, 0);
 536
 537         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 538           {
 539             regval = value_from_register (lookup_pointer_type (type),
 540                                           regno,
 541                                           frame);
 542
 543             if (regval == NULL)
 544               error (_("Value of register variable not available."));
 545
 546             addr = value_as_address (regval);
 547             VALUE_LVAL (v) = lval_memory;
 548           }
 549         else
 550           {
 551             regval = value_from_register (type, regno, frame);
 552
 553             if (regval == NULL)
 554               error (_("Value of register variable not available."));
 555             return regval;
 556           }
 557       }
 558       break;
 559
 560     case LOC_COMPUTED:
 561     case LOC_COMPUTED_ARG:
 562       /* FIXME: cagney/2004-01-26: It should be possible to
 563          unconditionally call the SYMBOL_OPS method when available.
 564          Unfortunately DWARF 2 stores the frame-base (instead of the
 565          function) location in a function's symbol.  Oops!  For the
 566          moment enable this when/where applicable.  */
 567       if (frame == 0 && SYMBOL_OPS (var)->read_needs_frame (var))
 568         return 0;
 569       return SYMBOL_OPS (var)->read_variable (var, frame);
 570
 571     case LOC_UNRESOLVED:
 572       {
 573         struct minimal_symbol *msym;
 574
 575         msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
 576         if (msym == NULL)
 577           return 0;
 578         if (overlay_debugging)
 579           addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
 580                                            SYMBOL_BFD_SECTION (msym));
 581         else
 582           addr = SYMBOL_VALUE_ADDRESS (msym);
 583       }
 584       break;
 585
 586     case LOC_OPTIMIZED_OUT:
 587       VALUE_LVAL (v) = not_lval;
 588       set_value_optimized_out (v, 1);
 589       return v;
 590
 591     default:
 592       error (_("Cannot look up value of a botched symbol."));
 593       break;
 594     }
 595
 596   VALUE_ADDRESS (v) = addr;
 597   set_value_lazy (v, 1);
 598   return v;
 599 }
 600
 601 /* Return a value of type TYPE, stored in register REGNUM, in frame
 602    FRAME.
 603
 604    NOTE: returns NULL if register value is not available.
 605    Caller will check return value or die!  */
 606
 607 struct value *
 608 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 609 {
 610   struct gdbarch *gdbarch = get_frame_arch (frame);
 611   struct value *v = allocate_value (type);
 612   CHECK_TYPEDEF (type);
 613
 614   if (TYPE_LENGTH (type) == 0)
 615     {
 616       /* It doesn't matter much what we return for this: since the
 617          length is zero, it could be anything.  But if allowed to see
 618          a zero-length type, the register-finding loop below will set
 619          neither mem_stor nor reg_stor, and then report an internal
 620          error.
 621
 622          Zero-length types can legitimately arise from declarations
 623          like 'struct {}' (a GCC extension, not valid ISO C).  GDB may
 624          also create them when it finds bogus debugging information;
 625          for example, in GCC 2.95.4 and binutils 2.11.93.0.2, the
 626          STABS BINCL->EXCL compression process can create bad type
 627          numbers.  GDB reads these as TYPE_CODE_UNDEF types, with zero
 628          length.  (That bug is actually the only known way to get a
 629          zero-length value allocated to a register --- which is what
 630          it takes to make it here.)
 631
 632          We'll just attribute the value to the original register.  */
 633       VALUE_LVAL (v) = lval_register;
 634       VALUE_ADDRESS (v) = regnum;
 635       VALUE_REGNUM (v) = regnum;
 636     }
 637   else if (CONVERT_REGISTER_P (regnum, type))
 638     {
 639       /* The ISA/ABI need to something weird when obtaining the
 640          specified value from this register.  It might need to
 641          re-order non-adjacent, starting with REGNUM (see MIPS and
 642          i386).  It might need to convert the [float] register into
 643          the corresponding [integer] type (see Alpha).  The assumption
 644          is that REGISTER_TO_VALUE populates the entire value
 645          including the location.  */
 646       REGISTER_TO_VALUE (frame, regnum, type, value_contents_raw (v));
 647       VALUE_LVAL (v) = lval_register;
 648       VALUE_FRAME_ID (v) = get_frame_id (frame);
 649       VALUE_REGNUM (v) = regnum;
 650     }
 651   else
 652     {
 653       int local_regnum;
 654       int mem_stor = 0, reg_stor = 0;
 655       int mem_tracking = 1;
 656       CORE_ADDR last_addr = 0;
 657       CORE_ADDR first_addr = 0;
 658       int first_realnum = regnum;
 659       int len = TYPE_LENGTH (type);
 660       int value_bytes_copied;
 661       int optimized = 0;
 662       char *value_bytes = (char *) alloca (len + MAX_REGISTER_SIZE);
 663
 664       /* Copy all of the data out, whereever it may be.  */
 665       for (local_regnum = regnum, value_bytes_copied = 0;
 666            value_bytes_copied < len;
 667            (value_bytes_copied += register_size (current_gdbarch, local_regnum),
 668             ++local_regnum))
 669         {
 670           int realnum;
 671           int optim;
 672           enum lval_type lval;
 673           CORE_ADDR addr;
 674           frame_register (frame, local_regnum, &optim, &lval, &addr,
 675                           &realnum, value_bytes + value_bytes_copied);
 676           optimized += optim;
 677           if (register_cached (local_regnum) == -1)
 678             return NULL;        /* register value not available */
 679
 680           if (regnum == local_regnum)
 681             {
 682               first_addr = addr;
 683               first_realnum = realnum;
 684             }
 685           if (lval == lval_register)
 686             reg_stor++;
 687           else
 688             {
 689               mem_stor++;
 690
 691               /* FIXME: cagney/2004-11-12: I think this is trying to
 692                  check that the stored registers are adjacent in
 693                  memory.  It isn't doing a good job?  */
 694               mem_tracking = (mem_tracking
 695                               && (regnum == local_regnum
 696                                   || addr == last_addr));
 697             }
 698           last_addr = addr;
 699         }
 700
 701       if (mem_tracking && mem_stor && !reg_stor)
 702         {
 703           VALUE_LVAL (v) = lval_memory;
 704           VALUE_ADDRESS (v) = first_addr;
 705         }
 706       else
 707         {
 708           VALUE_LVAL (v) = lval_register;
 709           VALUE_FRAME_ID (v) = get_frame_id (frame);
 710           VALUE_REGNUM (v) = regnum;
 711         }
 712
 713       set_value_optimized_out (v, optimized);
 714
 715       /* Any structure stored in more than one register will always be
 716          an integral number of registers.  Otherwise, you need to do
 717          some fiddling with the last register copied here for little
 718          endian machines.  */
 719       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
 720           && len < register_size (current_gdbarch, regnum))
 721         /* Big-endian, and we want less than full size.  */
 722         set_value_offset (v, register_size (current_gdbarch, regnum) - len);
 723       else
 724         set_value_offset (v, 0);
 725       memcpy (value_contents_raw (v), value_bytes + value_offset (v), len);
 726     }
 727   return v;
 728 }
 729
 730 \f
 731 /* Given a struct symbol for a variable or function,
 732    and a stack frame id,
 733    return a (pointer to a) struct value containing the properly typed
 734    address.  */
 735
 736 struct value *
 737 locate_var_value (struct symbol *var, struct frame_info *frame)
 738 {
 739   CORE_ADDR addr = 0;
 740   struct type *type = SYMBOL_TYPE (var);
 741   struct value *lazy_value;
 742
 743   /* Evaluate it first; if the result is a memory address, we're fine.
 744      Lazy evaluation pays off here. */
 745
 746   lazy_value = read_var_value (var, frame);
 747   if (lazy_value == 0)
 748     error (_("Address of \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
 749
 750   if (value_lazy (lazy_value)
 751       || TYPE_CODE (type) == TYPE_CODE_FUNC)
 752     {
 753       struct value *val;
 754
 755       addr = VALUE_ADDRESS (lazy_value);
 756       val = value_from_pointer (lookup_pointer_type (type), addr);
 757       return val;
 758     }
 759
 760   /* Not a memory address; check what the problem was.  */
 761   switch (VALUE_LVAL (lazy_value))
 762     {
 763     case lval_register:
 764       gdb_assert (REGISTER_NAME (VALUE_REGNUM (lazy_value)) != NULL
 765                   && *REGISTER_NAME (VALUE_REGNUM (lazy_value)) != '\0');
 766       error (_("Address requested for identifier "
 767                "\"%s\" which is in register $%s"),
 768             SYMBOL_PRINT_NAME (var),
 769             REGISTER_NAME (VALUE_REGNUM (lazy_value)));
 770       break;
 771
 772     default:
 773       error (_("Can't take address of \"%s\" which isn't an lvalue."),
 774              SYMBOL_PRINT_NAME (var));
 775       break;
 776     }
 777   return 0;                     /* For lint -- never reached */
 778 }