gdb/findvar.c

   1 /* Find a variable's value in memory, for GDB, the GNU debugger.
   2
   3    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
   4    1995, 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004 Free Software
   5    Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 #include "defs.h"
  25 #include "symtab.h"
  26 #include "gdbtypes.h"
  27 #include "frame.h"
  28 #include "value.h"
  29 #include "gdbcore.h"
  30 #include "inferior.h"
  31 #include "target.h"
  32 #include "gdb_string.h"
  33 #include "gdb_assert.h"
  34 #include "floatformat.h"
  35 #include "symfile.h"            /* for overlay functions */
  36 #include "regcache.h"
  37 #include "user-regs.h"
  38 #include "block.h"
  39
  40 /* Basic byte-swapping routines.  GDB has needed these for a long time...
  41    All extract a target-format integer at ADDR which is LEN bytes long.  */
  42
  43 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
  44   /* 8 bit characters are a pretty safe assumption these days, so we
  45      assume it throughout all these swapping routines.  If we had to deal with
  46      9 bit characters, we would need to make len be in bits and would have
  47      to re-write these routines...  */
  48 you lose
  49 #endif
  50
  51 LONGEST
  52 extract_signed_integer (const void *addr, int len)
  53 {
  54   LONGEST retval;
  55   const unsigned char *p;
  56   const unsigned char *startaddr = addr;
  57   const unsigned char *endaddr = startaddr + len;
  58
  59   if (len > (int) sizeof (LONGEST))
  60     error ("\
  61 That operation is not available on integers of more than %d bytes.",
  62            (int) sizeof (LONGEST));
  63
  64   /* Start at the most significant end of the integer, and work towards
  65      the least significant.  */
  66   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
  67     {
  68       p = startaddr;
  69       /* Do the sign extension once at the start.  */
  70       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  71       for (++p; p < endaddr; ++p)
  72         retval = (retval << 8) | *p;
  73     }
  74   else
  75     {
  76       p = endaddr - 1;
  77       /* Do the sign extension once at the start.  */
  78       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  79       for (--p; p >= startaddr; --p)
  80         retval = (retval << 8) | *p;
  81     }
  82   return retval;
  83 }
  84
  85 ULONGEST
  86 extract_unsigned_integer (const void *addr, int len)
  87 {
  88   ULONGEST retval;
  89   const unsigned char *p;
  90   const unsigned char *startaddr = addr;
  91   const unsigned char *endaddr = startaddr + len;
  92
  93   if (len > (int) sizeof (ULONGEST))
  94     error ("\
  95 That operation is not available on integers of more than %d bytes.",
  96            (int) sizeof (ULONGEST));
  97
  98   /* Start at the most significant end of the integer, and work towards
  99      the least significant.  */
 100   retval = 0;
 101   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 102     {
 103       for (p = startaddr; p < endaddr; ++p)
 104         retval = (retval << 8) | *p;
 105     }
 106   else
 107     {
 108       for (p = endaddr - 1; p >= startaddr; --p)
 109         retval = (retval << 8) | *p;
 110     }
 111   return retval;
 112 }
 113
 114 /* Sometimes a long long unsigned integer can be extracted as a
 115    LONGEST value.  This is done so that we can print these values
 116    better.  If this integer can be converted to a LONGEST, this
 117    function returns 1 and sets *PVAL.  Otherwise it returns 0.  */
 118
 119 int
 120 extract_long_unsigned_integer (const void *addr, int orig_len, LONGEST *pval)
 121 {
 122   char *p, *first_addr;
 123   int len;
 124
 125   len = orig_len;
 126   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 127     {
 128       for (p = (char *) addr;
 129            len > (int) sizeof (LONGEST) && p < (char *) addr + orig_len;
 130            p++)
 131         {
 132           if (*p == 0)
 133             len--;
 134           else
 135             break;
 136         }
 137       first_addr = p;
 138     }
 139   else
 140     {
 141       first_addr = (char *) addr;
 142       for (p = (char *) addr + orig_len - 1;
 143            len > (int) sizeof (LONGEST) && p >= (char *) addr;
 144            p--)
 145         {
 146           if (*p == 0)
 147             len--;
 148           else
 149             break;
 150         }
 151     }
 152
 153   if (len <= (int) sizeof (LONGEST))
 154     {
 155       *pval = (LONGEST) extract_unsigned_integer (first_addr,
 156                                                   sizeof (LONGEST));
 157       return 1;
 158     }
 159
 160   return 0;
 161 }
 162
 163
 164 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
 165    address it represents.  */
 166 CORE_ADDR
 167 extract_typed_address (const void *buf, struct type *type)
 168 {
 169   if (TYPE_CODE (type) != TYPE_CODE_PTR
 170       && TYPE_CODE (type) != TYPE_CODE_REF)
 171     internal_error (__FILE__, __LINE__,
 172                     "extract_typed_address: "
 173                     "type is not a pointer or reference");
 174
 175   return POINTER_TO_ADDRESS (type, buf);
 176 }
 177
 178
 179 void
 180 store_signed_integer (void *addr, int len, LONGEST val)
 181 {
 182   unsigned char *p;
 183   unsigned char *startaddr = (unsigned char *) addr;
 184   unsigned char *endaddr = startaddr + len;
 185
 186   /* Start at the least significant end of the integer, and work towards
 187      the most significant.  */
 188   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 189     {
 190       for (p = endaddr - 1; p >= startaddr; --p)
 191         {
 192           *p = val & 0xff;
 193           val >>= 8;
 194         }
 195     }
 196   else
 197     {
 198       for (p = startaddr; p < endaddr; ++p)
 199         {
 200           *p = val & 0xff;
 201           val >>= 8;
 202         }
 203     }
 204 }
 205
 206 void
 207 store_unsigned_integer (void *addr, int len, ULONGEST val)
 208 {
 209   unsigned char *p;
 210   unsigned char *startaddr = (unsigned char *) addr;
 211   unsigned char *endaddr = startaddr + len;
 212
 213   /* Start at the least significant end of the integer, and work towards
 214      the most significant.  */
 215   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 216     {
 217       for (p = endaddr - 1; p >= startaddr; --p)
 218         {
 219           *p = val & 0xff;
 220           val >>= 8;
 221         }
 222     }
 223   else
 224     {
 225       for (p = startaddr; p < endaddr; ++p)
 226         {
 227           *p = val & 0xff;
 228           val >>= 8;
 229         }
 230     }
 231 }
 232
 233 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
 234    form.  */
 235 void
 236 store_typed_address (void *buf, struct type *type, CORE_ADDR addr)
 237 {
 238   if (TYPE_CODE (type) != TYPE_CODE_PTR
 239       && TYPE_CODE (type) != TYPE_CODE_REF)
 240     internal_error (__FILE__, __LINE__,
 241                     "store_typed_address: "
 242                     "type is not a pointer or reference");
 243
 244   ADDRESS_TO_POINTER (type, buf, addr);
 245 }
 246
 247
 248
 249 /* Return a `value' with the contents of (virtual or cooked) register
 250    REGNUM as found in the specified FRAME.  The register's type is
 251    determined by register_type().
 252
 253    NOTE: returns NULL if register value is not available.  Caller will
 254    check return value or die!  */
 255
 256 struct value *
 257 value_of_register (int regnum, struct frame_info *frame)
 258 {
 259   CORE_ADDR addr;
 260   int optim;
 261   struct value *reg_val;
 262   int realnum;
 263   char raw_buffer[MAX_REGISTER_SIZE];
 264   enum lval_type lval;
 265
 266   /* User registers lie completely outside of the range of normal
 267      registers.  Catch them early so that the target never sees them.  */
 268   if (regnum >= NUM_REGS + NUM_PSEUDO_REGS)
 269     return value_of_user_reg (regnum, frame);
 270
 271   frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
 272
 273   /* FIXME: cagney/2002-05-15: This test is just bogus.
 274
 275      It indicates that the target failed to supply a value for a
 276      register because it was "not available" at this time.  Problem
 277      is, the target still has the register and so get saved_register()
 278      may be returning a value saved on the stack.  */
 279
 280   if (register_cached (regnum) < 0)
 281     return NULL;                /* register value not available */
 282
 283   reg_val = allocate_value (register_type (current_gdbarch, regnum));
 284
 285   memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
 286           register_size (current_gdbarch, regnum));
 287   VALUE_LVAL (reg_val) = lval;
 288   VALUE_ADDRESS (reg_val) = addr;
 289   VALUE_REGNUM (reg_val) = regnum;
 290   VALUE_OPTIMIZED_OUT (reg_val) = optim;
 291   VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
 292   return reg_val;
 293 }
 294
 295 /* Given a pointer of type TYPE in target form in BUF, return the
 296    address it represents.  */
 297 CORE_ADDR
 298 unsigned_pointer_to_address (struct type *type, const void *buf)
 299 {
 300   return extract_unsigned_integer (buf, TYPE_LENGTH (type));
 301 }
 302
 303 CORE_ADDR
 304 signed_pointer_to_address (struct type *type, const void *buf)
 305 {
 306   return extract_signed_integer (buf, TYPE_LENGTH (type));
 307 }
 308
 309 /* Given an address, store it as a pointer of type TYPE in target
 310    format in BUF.  */
 311 void
 312 unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
 313 {
 314   store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
 315 }
 316
 317 void
 318 address_to_signed_pointer (struct type *type, void *buf, CORE_ADDR addr)
 319 {
 320   store_signed_integer (buf, TYPE_LENGTH (type), addr);
 321 }
 322 \f
 323 /* Will calling read_var_value or locate_var_value on SYM end
 324    up caring what frame it is being evaluated relative to?  SYM must
 325    be non-NULL.  */
 326 int
 327 symbol_read_needs_frame (struct symbol *sym)
 328 {
 329   switch (SYMBOL_CLASS (sym))
 330     {
 331       /* All cases listed explicitly so that gcc -Wall will detect it if
 332          we failed to consider one.  */
 333     case LOC_COMPUTED:
 334     case LOC_COMPUTED_ARG:
 335       /* FIXME: cagney/2004-01-26: It should be possible to
 336          unconditionally call the SYMBOL_OPS method when available.
 337          Unfortunately DWARF 2 stores the frame-base (instead of the
 338          function) location in a function's symbol.  Oops!  For the
 339          moment enable this when/where applicable.  */
 340       return SYMBOL_OPS (sym)->read_needs_frame (sym);
 341
 342     case LOC_REGISTER:
 343     case LOC_ARG:
 344     case LOC_REF_ARG:
 345     case LOC_REGPARM:
 346     case LOC_REGPARM_ADDR:
 347     case LOC_LOCAL:
 348     case LOC_LOCAL_ARG:
 349     case LOC_BASEREG:
 350     case LOC_BASEREG_ARG:
 351     case LOC_HP_THREAD_LOCAL_STATIC:
 352       return 1;
 353
 354     case LOC_UNDEF:
 355     case LOC_CONST:
 356     case LOC_STATIC:
 357     case LOC_INDIRECT:
 358     case LOC_TYPEDEF:
 359
 360     case LOC_LABEL:
 361       /* Getting the address of a label can be done independently of the block,
 362          even if some *uses* of that address wouldn't work so well without
 363          the right frame.  */
 364
 365     case LOC_BLOCK:
 366     case LOC_CONST_BYTES:
 367     case LOC_UNRESOLVED:
 368     case LOC_OPTIMIZED_OUT:
 369       return 0;
 370     }
 371   return 1;
 372 }
 373
 374 /* Given a struct symbol for a variable,
 375    and a stack frame id, read the value of the variable
 376    and return a (pointer to a) struct value containing the value.
 377    If the variable cannot be found, return a zero pointer.
 378    If FRAME is NULL, use the deprecated_selected_frame.  */
 379
 380 struct value *
 381 read_var_value (struct symbol *var, struct frame_info *frame)
 382 {
 383   struct value *v;
 384   struct type *type = SYMBOL_TYPE (var);
 385   CORE_ADDR addr;
 386   int len;
 387
 388   v = allocate_value (type);
 389   VALUE_LVAL (v) = lval_memory; /* The most likely possibility.  */
 390
 391   len = TYPE_LENGTH (type);
 392
 393
 394   /* FIXME drow/2003-09-06: this call to the selected frame should be
 395      pushed upwards to the callers.  */
 396   if (frame == NULL)
 397     frame = deprecated_safe_get_selected_frame ();
 398
 399   switch (SYMBOL_CLASS (var))
 400     {
 401     case LOC_CONST:
 402       /* Put the constant back in target format.  */
 403       store_signed_integer (VALUE_CONTENTS_RAW (v), len,
 404                             (LONGEST) SYMBOL_VALUE (var));
 405       VALUE_LVAL (v) = not_lval;
 406       return v;
 407
 408     case LOC_LABEL:
 409       /* Put the constant back in target format.  */
 410       if (overlay_debugging)
 411         {
 412           CORE_ADDR addr
 413             = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 414                                         SYMBOL_BFD_SECTION (var));
 415           store_typed_address (VALUE_CONTENTS_RAW (v), type, addr);
 416         }
 417       else
 418         store_typed_address (VALUE_CONTENTS_RAW (v), type,
 419                               SYMBOL_VALUE_ADDRESS (var));
 420       VALUE_LVAL (v) = not_lval;
 421       return v;
 422
 423     case LOC_CONST_BYTES:
 424       {
 425         char *bytes_addr;
 426         bytes_addr = SYMBOL_VALUE_BYTES (var);
 427         memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
 428         VALUE_LVAL (v) = not_lval;
 429         return v;
 430       }
 431
 432     case LOC_STATIC:
 433       if (overlay_debugging)
 434         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 435                                          SYMBOL_BFD_SECTION (var));
 436       else
 437         addr = SYMBOL_VALUE_ADDRESS (var);
 438       break;
 439
 440     case LOC_INDIRECT:
 441       {
 442         /* The import slot does not have a real address in it from the
 443            dynamic loader (dld.sl on HP-UX), if the target hasn't
 444            begun execution yet, so check for that. */
 445         CORE_ADDR locaddr;
 446         struct value *loc;
 447         if (!target_has_execution)
 448           error ("\
 449 Attempt to access variable defined in different shared object or load module when\n\
 450 addresses have not been bound by the dynamic loader. Try again when executable is running.");
 451
 452         locaddr = SYMBOL_VALUE_ADDRESS (var);
 453         loc = value_at (lookup_pointer_type (type), locaddr);
 454         addr = value_as_address (loc);
 455       }
 456
 457     case LOC_ARG:
 458       if (frame == NULL)
 459         return 0;
 460       addr = get_frame_args_address (frame);
 461       if (!addr)
 462         return 0;
 463       addr += SYMBOL_VALUE (var);
 464       break;
 465
 466     case LOC_REF_ARG:
 467       {
 468         struct value *ref;
 469         CORE_ADDR argref;
 470         if (frame == NULL)
 471           return 0;
 472         argref = get_frame_args_address (frame);
 473         if (!argref)
 474           return 0;
 475         argref += SYMBOL_VALUE (var);
 476         ref = value_at (lookup_pointer_type (type), argref);
 477         addr = value_as_address (ref);
 478         break;
 479       }
 480
 481     case LOC_LOCAL:
 482     case LOC_LOCAL_ARG:
 483       if (frame == NULL)
 484         return 0;
 485       addr = get_frame_locals_address (frame);
 486       addr += SYMBOL_VALUE (var);
 487       break;
 488
 489     case LOC_BASEREG:
 490     case LOC_BASEREG_ARG:
 491     case LOC_HP_THREAD_LOCAL_STATIC:
 492       {
 493         struct value *regval;
 494
 495         regval = value_from_register (lookup_pointer_type (type),
 496                                       SYMBOL_BASEREG (var), frame);
 497         if (regval == NULL)
 498           error ("Value of base register not available.");
 499         addr = value_as_address (regval);
 500         addr += SYMBOL_VALUE (var);
 501         break;
 502       }
 503
 504     case LOC_TYPEDEF:
 505       error ("Cannot look up value of a typedef");
 506       break;
 507
 508     case LOC_BLOCK:
 509       if (overlay_debugging)
 510         VALUE_ADDRESS (v) = symbol_overlayed_address
 511           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
 512       else
 513         VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 514       return v;
 515
 516     case LOC_REGISTER:
 517     case LOC_REGPARM:
 518     case LOC_REGPARM_ADDR:
 519       {
 520         struct block *b;
 521         int regno = SYMBOL_VALUE (var);
 522         struct value *regval;
 523
 524         if (frame == NULL)
 525           return 0;
 526         b = get_frame_block (frame, 0);
 527
 528         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 529           {
 530             regval = value_from_register (lookup_pointer_type (type),
 531                                           regno,
 532                                           frame);
 533
 534             if (regval == NULL)
 535               error ("Value of register variable not available.");
 536
 537             addr = value_as_address (regval);
 538             VALUE_LVAL (v) = lval_memory;
 539           }
 540         else
 541           {
 542             regval = value_from_register (type, regno, frame);
 543
 544             if (regval == NULL)
 545               error ("Value of register variable not available.");
 546             return regval;
 547           }
 548       }
 549       break;
 550
 551     case LOC_COMPUTED:
 552     case LOC_COMPUTED_ARG:
 553       /* FIXME: cagney/2004-01-26: It should be possible to
 554          unconditionally call the SYMBOL_OPS method when available.
 555          Unfortunately DWARF 2 stores the frame-base (instead of the
 556          function) location in a function's symbol.  Oops!  For the
 557          moment enable this when/where applicable.  */
 558       if (frame == 0 && SYMBOL_OPS (var)->read_needs_frame (var))
 559         return 0;
 560       return SYMBOL_OPS (var)->read_variable (var, frame);
 561
 562     case LOC_UNRESOLVED:
 563       {
 564         struct minimal_symbol *msym;
 565
 566         msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
 567         if (msym == NULL)
 568           return 0;
 569         if (overlay_debugging)
 570           addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
 571                                            SYMBOL_BFD_SECTION (msym));
 572         else
 573           addr = SYMBOL_VALUE_ADDRESS (msym);
 574       }
 575       break;
 576
 577     case LOC_OPTIMIZED_OUT:
 578       VALUE_LVAL (v) = not_lval;
 579       VALUE_OPTIMIZED_OUT (v) = 1;
 580       return v;
 581
 582     default:
 583       error ("Cannot look up value of a botched symbol.");
 584       break;
 585     }
 586
 587   VALUE_ADDRESS (v) = addr;
 588   VALUE_LAZY (v) = 1;
 589   return v;
 590 }
 591
 592 /* Return a value of type TYPE, stored in register REGNUM, in frame
 593    FRAME.
 594
 595    NOTE: returns NULL if register value is not available.
 596    Caller will check return value or die!  */
 597
 598 struct value *
 599 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 600 {
 601   struct gdbarch *gdbarch = get_frame_arch (frame);
 602   struct value *v = allocate_value (type);
 603   CHECK_TYPEDEF (type);
 604
 605   if (TYPE_LENGTH (type) == 0)
 606     {
 607       /* It doesn't matter much what we return for this: since the
 608          length is zero, it could be anything.  But if allowed to see
 609          a zero-length type, the register-finding loop below will set
 610          neither mem_stor nor reg_stor, and then report an internal
 611          error.
 612
 613          Zero-length types can legitimately arise from declarations
 614          like 'struct {}' (a GCC extension, not valid ISO C).  GDB may
 615          also create them when it finds bogus debugging information;
 616          for example, in GCC 2.95.4 and binutils 2.11.93.0.2, the
 617          STABS BINCL->EXCL compression process can create bad type
 618          numbers.  GDB reads these as TYPE_CODE_UNDEF types, with zero
 619          length.  (That bug is actually the only known way to get a
 620          zero-length value allocated to a register --- which is what
 621          it takes to make it here.)
 622
 623          We'll just attribute the value to the original register.  */
 624       VALUE_LVAL (v) = lval_register;
 625       VALUE_ADDRESS (v) = regnum;
 626       VALUE_REGNUM (v) = regnum;
 627     }
 628   else if (CONVERT_REGISTER_P (regnum, type))
 629     {
 630       /* The ISA/ABI need to something weird when obtaining the
 631          specified value from this register.  It might need to
 632          re-order non-adjacent, starting with REGNUM (see MIPS and
 633          i386).  It might need to convert the [float] register into
 634          the corresponding [integer] type (see Alpha).  The assumption
 635          is that REGISTER_TO_VALUE populates the entire value
 636          including the location.  */
 637       REGISTER_TO_VALUE (frame, regnum, type, VALUE_CONTENTS_RAW (v));
 638       VALUE_LVAL (v) = lval_register;
 639       VALUE_FRAME_ID (v) = get_frame_id (frame);
 640       VALUE_REGNUM (v) = regnum;
 641     }
 642   else
 643     {
 644       int local_regnum;
 645       int mem_stor = 0, reg_stor = 0;
 646       int mem_tracking = 1;
 647       CORE_ADDR last_addr = 0;
 648       CORE_ADDR first_addr = 0;
 649       int first_realnum = regnum;
 650       int len = TYPE_LENGTH (type);
 651       int value_bytes_copied;
 652       int optimized = 0;
 653       char *value_bytes = (char *) alloca (len + MAX_REGISTER_SIZE);
 654
 655       /* Copy all of the data out, whereever it may be.  */
 656       for (local_regnum = regnum, value_bytes_copied = 0;
 657            value_bytes_copied < len;
 658            (value_bytes_copied += register_size (current_gdbarch, local_regnum),
 659             ++local_regnum))
 660         {
 661           int realnum;
 662           int optim;
 663           enum lval_type lval;
 664           CORE_ADDR addr;
 665           frame_register (frame, local_regnum, &optim, &lval, &addr,
 666                           &realnum, value_bytes + value_bytes_copied);
 667           optimized += optim;
 668           if (register_cached (local_regnum) == -1)
 669             return NULL;        /* register value not available */
 670
 671           if (regnum == local_regnum)
 672             {
 673               first_addr = addr;
 674               first_realnum = realnum;
 675             }
 676           if (lval == lval_register)
 677             reg_stor++;
 678           else
 679             {
 680               mem_stor++;
 681
 682               /* FIXME: cagney/2004-11-12: I think this is trying to
 683                  check that the stored registers are adjacent in
 684                  memory.  It isn't doing a good job?  */
 685               mem_tracking = (mem_tracking
 686                               && (regnum == local_regnum
 687                                   || addr == last_addr));
 688             }
 689           last_addr = addr;
 690         }
 691
 692       if (mem_tracking && mem_stor && !reg_stor)
 693         {
 694           VALUE_LVAL (v) = lval_memory;
 695           VALUE_ADDRESS (v) = first_addr;
 696         }
 697       else
 698         {
 699           VALUE_LVAL (v) = lval_register;
 700           VALUE_FRAME_ID (v) = get_frame_id (frame);
 701           VALUE_REGNUM (v) = regnum;
 702         }
 703
 704       VALUE_OPTIMIZED_OUT (v) = optimized;
 705
 706       /* Any structure stored in more than one register will always be
 707          an integral number of registers.  Otherwise, you need to do
 708          some fiddling with the last register copied here for little
 709          endian machines.  */
 710       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
 711           && len < register_size (current_gdbarch, regnum))
 712         /* Big-endian, and we want less than full size.  */
 713         v->offset = register_size (current_gdbarch, regnum) - len;
 714       else
 715         v->offset = 0;
 716       memcpy (VALUE_CONTENTS_RAW (v), value_bytes + value_offset (v), len);
 717     }
 718   return v;
 719 }
 720
 721 \f
 722 /* Given a struct symbol for a variable or function,
 723    and a stack frame id,
 724    return a (pointer to a) struct value containing the properly typed
 725    address.  */
 726
 727 struct value *
 728 locate_var_value (struct symbol *var, struct frame_info *frame)
 729 {
 730   CORE_ADDR addr = 0;
 731   struct type *type = SYMBOL_TYPE (var);
 732   struct value *lazy_value;
 733
 734   /* Evaluate it first; if the result is a memory address, we're fine.
 735      Lazy evaluation pays off here. */
 736
 737   lazy_value = read_var_value (var, frame);
 738   if (lazy_value == 0)
 739     error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var));
 740
 741   if (VALUE_LAZY (lazy_value)
 742       || TYPE_CODE (type) == TYPE_CODE_FUNC)
 743     {
 744       struct value *val;
 745
 746       addr = VALUE_ADDRESS (lazy_value);
 747       val = value_from_pointer (lookup_pointer_type (type), addr);
 748       return val;
 749     }
 750
 751   /* Not a memory address; check what the problem was.  */
 752   switch (VALUE_LVAL (lazy_value))
 753     {
 754     case lval_register:
 755       gdb_assert (REGISTER_NAME (VALUE_REGNUM (lazy_value)) != NULL
 756                   && *REGISTER_NAME (VALUE_REGNUM (lazy_value)) != '\0');
 757       error("Address requested for identifier "
 758             "\"%s\" which is in register $%s",
 759             SYMBOL_PRINT_NAME (var),
 760             REGISTER_NAME (VALUE_REGNUM (lazy_value)));
 761       break;
 762
 763     default:
 764       error ("Can't take address of \"%s\" which isn't an lvalue.",
 765              SYMBOL_PRINT_NAME (var));
 766       break;
 767     }
 768   return 0;                     /* For lint -- never reached */
 769 }