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_REGNO (reg_val) = regnum;
 290   VALUE_OPTIMIZED_OUT (reg_val) = optim;
 291   return reg_val;
 292 }
 293
 294 /* Given a pointer of type TYPE in target form in BUF, return the
 295    address it represents.  */
 296 CORE_ADDR
 297 unsigned_pointer_to_address (struct type *type, const void *buf)
 298 {
 299   return extract_unsigned_integer (buf, TYPE_LENGTH (type));
 300 }
 301
 302 CORE_ADDR
 303 signed_pointer_to_address (struct type *type, const void *buf)
 304 {
 305   return extract_signed_integer (buf, TYPE_LENGTH (type));
 306 }
 307
 308 /* Given an address, store it as a pointer of type TYPE in target
 309    format in BUF.  */
 310 void
 311 unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
 312 {
 313   store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
 314 }
 315
 316 void
 317 address_to_signed_pointer (struct type *type, void *buf, CORE_ADDR addr)
 318 {
 319   store_signed_integer (buf, TYPE_LENGTH (type), addr);
 320 }
 321 \f
 322 /* Will calling read_var_value or locate_var_value on SYM end
 323    up caring what frame it is being evaluated relative to?  SYM must
 324    be non-NULL.  */
 325 int
 326 symbol_read_needs_frame (struct symbol *sym)
 327 {
 328   switch (SYMBOL_CLASS (sym))
 329     {
 330       /* All cases listed explicitly so that gcc -Wall will detect it if
 331          we failed to consider one.  */
 332     case LOC_COMPUTED:
 333     case LOC_COMPUTED_ARG:
 334       /* FIXME: cagney/2004-01-26: It should be possible to
 335          unconditionally call the SYMBOL_OPS method when available.
 336          Unfortunately DWARF 2 stores the frame-base (instead of the
 337          function) location in a function's symbol.  Oops!  For the
 338          moment enable this when/where applicable.  */
 339       return SYMBOL_OPS (sym)->read_needs_frame (sym);
 340
 341     case LOC_REGISTER:
 342     case LOC_ARG:
 343     case LOC_REF_ARG:
 344     case LOC_REGPARM:
 345     case LOC_REGPARM_ADDR:
 346     case LOC_LOCAL:
 347     case LOC_LOCAL_ARG:
 348     case LOC_BASEREG:
 349     case LOC_BASEREG_ARG:
 350     case LOC_HP_THREAD_LOCAL_STATIC:
 351       return 1;
 352
 353     case LOC_UNDEF:
 354     case LOC_CONST:
 355     case LOC_STATIC:
 356     case LOC_INDIRECT:
 357     case LOC_TYPEDEF:
 358
 359     case LOC_LABEL:
 360       /* Getting the address of a label can be done independently of the block,
 361          even if some *uses* of that address wouldn't work so well without
 362          the right frame.  */
 363
 364     case LOC_BLOCK:
 365     case LOC_CONST_BYTES:
 366     case LOC_UNRESOLVED:
 367     case LOC_OPTIMIZED_OUT:
 368       return 0;
 369     }
 370   return 1;
 371 }
 372
 373 /* Given a struct symbol for a variable,
 374    and a stack frame id, read the value of the variable
 375    and return a (pointer to a) struct value containing the value.
 376    If the variable cannot be found, return a zero pointer.
 377    If FRAME is NULL, use the deprecated_selected_frame.  */
 378
 379 struct value *
 380 read_var_value (struct symbol *var, struct frame_info *frame)
 381 {
 382   struct value *v;
 383   struct type *type = SYMBOL_TYPE (var);
 384   CORE_ADDR addr;
 385   int len;
 386
 387   v = allocate_value (type);
 388   VALUE_LVAL (v) = lval_memory; /* The most likely possibility.  */
 389
 390   len = TYPE_LENGTH (type);
 391
 392
 393   /* FIXME drow/2003-09-06: this call to the selected frame should be
 394      pushed upwards to the callers.  */
 395   if (frame == NULL)
 396     frame = deprecated_safe_get_selected_frame ();
 397
 398   switch (SYMBOL_CLASS (var))
 399     {
 400     case LOC_CONST:
 401       /* Put the constant back in target format.  */
 402       store_signed_integer (VALUE_CONTENTS_RAW (v), len,
 403                             (LONGEST) SYMBOL_VALUE (var));
 404       VALUE_LVAL (v) = not_lval;
 405       return v;
 406
 407     case LOC_LABEL:
 408       /* Put the constant back in target format.  */
 409       if (overlay_debugging)
 410         {
 411           CORE_ADDR addr
 412             = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 413                                         SYMBOL_BFD_SECTION (var));
 414           store_typed_address (VALUE_CONTENTS_RAW (v), type, addr);
 415         }
 416       else
 417         store_typed_address (VALUE_CONTENTS_RAW (v), type,
 418                               SYMBOL_VALUE_ADDRESS (var));
 419       VALUE_LVAL (v) = not_lval;
 420       return v;
 421
 422     case LOC_CONST_BYTES:
 423       {
 424         char *bytes_addr;
 425         bytes_addr = SYMBOL_VALUE_BYTES (var);
 426         memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
 427         VALUE_LVAL (v) = not_lval;
 428         return v;
 429       }
 430
 431     case LOC_STATIC:
 432       if (overlay_debugging)
 433         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 434                                          SYMBOL_BFD_SECTION (var));
 435       else
 436         addr = SYMBOL_VALUE_ADDRESS (var);
 437       break;
 438
 439     case LOC_INDIRECT:
 440       {
 441         /* The import slot does not have a real address in it from the
 442            dynamic loader (dld.sl on HP-UX), if the target hasn't
 443            begun execution yet, so check for that. */
 444         CORE_ADDR locaddr;
 445         struct value *loc;
 446         if (!target_has_execution)
 447           error ("\
 448 Attempt to access variable defined in different shared object or load module when\n\
 449 addresses have not been bound by the dynamic loader. Try again when executable is running.");
 450
 451         locaddr = SYMBOL_VALUE_ADDRESS (var);
 452         loc = value_at (lookup_pointer_type (type), locaddr);
 453         addr = value_as_address (loc);
 454       }
 455
 456     case LOC_ARG:
 457       if (frame == NULL)
 458         return 0;
 459       addr = get_frame_args_address (frame);
 460       if (!addr)
 461         return 0;
 462       addr += SYMBOL_VALUE (var);
 463       break;
 464
 465     case LOC_REF_ARG:
 466       {
 467         struct value *ref;
 468         CORE_ADDR argref;
 469         if (frame == NULL)
 470           return 0;
 471         argref = get_frame_args_address (frame);
 472         if (!argref)
 473           return 0;
 474         argref += SYMBOL_VALUE (var);
 475         ref = value_at (lookup_pointer_type (type), argref);
 476         addr = value_as_address (ref);
 477         break;
 478       }
 479
 480     case LOC_LOCAL:
 481     case LOC_LOCAL_ARG:
 482       if (frame == NULL)
 483         return 0;
 484       addr = get_frame_locals_address (frame);
 485       addr += SYMBOL_VALUE (var);
 486       break;
 487
 488     case LOC_BASEREG:
 489     case LOC_BASEREG_ARG:
 490     case LOC_HP_THREAD_LOCAL_STATIC:
 491       {
 492         struct value *regval;
 493
 494         regval = value_from_register (lookup_pointer_type (type),
 495                                       SYMBOL_BASEREG (var), frame);
 496         if (regval == NULL)
 497           error ("Value of base register not available.");
 498         addr = value_as_address (regval);
 499         addr += SYMBOL_VALUE (var);
 500         break;
 501       }
 502
 503     case LOC_TYPEDEF:
 504       error ("Cannot look up value of a typedef");
 505       break;
 506
 507     case LOC_BLOCK:
 508       if (overlay_debugging)
 509         VALUE_ADDRESS (v) = symbol_overlayed_address
 510           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
 511       else
 512         VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 513       return v;
 514
 515     case LOC_REGISTER:
 516     case LOC_REGPARM:
 517     case LOC_REGPARM_ADDR:
 518       {
 519         struct block *b;
 520         int regno = SYMBOL_VALUE (var);
 521         struct value *regval;
 522
 523         if (frame == NULL)
 524           return 0;
 525         b = get_frame_block (frame, 0);
 526
 527         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 528           {
 529             regval = value_from_register (lookup_pointer_type (type),
 530                                           regno,
 531                                           frame);
 532
 533             if (regval == NULL)
 534               error ("Value of register variable not available.");
 535
 536             addr = value_as_address (regval);
 537             VALUE_LVAL (v) = lval_memory;
 538           }
 539         else
 540           {
 541             regval = value_from_register (type, regno, frame);
 542
 543             if (regval == NULL)
 544               error ("Value of register variable not available.");
 545             return regval;
 546           }
 547       }
 548       break;
 549
 550     case LOC_COMPUTED:
 551     case LOC_COMPUTED_ARG:
 552       /* FIXME: cagney/2004-01-26: It should be possible to
 553          unconditionally call the SYMBOL_OPS method when available.
 554          Unfortunately DWARF 2 stores the frame-base (instead of the
 555          function) location in a function's symbol.  Oops!  For the
 556          moment enable this when/where applicable.  */
 557       if (frame == 0 && SYMBOL_OPS (var)->read_needs_frame (var))
 558         return 0;
 559       return SYMBOL_OPS (var)->read_variable (var, frame);
 560
 561     case LOC_UNRESOLVED:
 562       {
 563         struct minimal_symbol *msym;
 564
 565         msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
 566         if (msym == NULL)
 567           return 0;
 568         if (overlay_debugging)
 569           addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
 570                                            SYMBOL_BFD_SECTION (msym));
 571         else
 572           addr = SYMBOL_VALUE_ADDRESS (msym);
 573       }
 574       break;
 575
 576     case LOC_OPTIMIZED_OUT:
 577       VALUE_LVAL (v) = not_lval;
 578       VALUE_OPTIMIZED_OUT (v) = 1;
 579       return v;
 580
 581     default:
 582       error ("Cannot look up value of a botched symbol.");
 583       break;
 584     }
 585
 586   VALUE_ADDRESS (v) = addr;
 587   VALUE_LAZY (v) = 1;
 588   return v;
 589 }
 590
 591 /* Return a value of type TYPE, stored in register REGNUM, in frame
 592    FRAME.
 593
 594    NOTE: returns NULL if register value is not available.
 595    Caller will check return value or die!  */
 596
 597 struct value *
 598 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 599 {
 600   struct gdbarch *gdbarch = get_frame_arch (frame);
 601   struct value *v = allocate_value (type);
 602   CHECK_TYPEDEF (type);
 603
 604   if (TYPE_LENGTH (type) == 0)
 605     {
 606       /* It doesn't matter much what we return for this: since the
 607          length is zero, it could be anything.  But if allowed to see
 608          a zero-length type, the register-finding loop below will set
 609          neither mem_stor nor reg_stor, and then report an internal
 610          error.
 611
 612          Zero-length types can legitimately arise from declarations
 613          like 'struct {}' (a GCC extension, not valid ISO C).  GDB may
 614          also create them when it finds bogus debugging information;
 615          for example, in GCC 2.95.4 and binutils 2.11.93.0.2, the
 616          STABS BINCL->EXCL compression process can create bad type
 617          numbers.  GDB reads these as TYPE_CODE_UNDEF types, with zero
 618          length.  (That bug is actually the only known way to get a
 619          zero-length value allocated to a register --- which is what
 620          it takes to make it here.)
 621
 622          We'll just attribute the value to the original register.  */
 623       VALUE_LVAL (v) = lval_register;
 624       VALUE_ADDRESS (v) = regnum;
 625       VALUE_REGNO (v) = regnum;
 626     }
 627   else if (CONVERT_REGISTER_P (regnum, type))
 628     {
 629       /* The ISA/ABI need to something weird when obtaining the
 630          specified value from this register.  It might need to
 631          re-order non-adjacent, starting with REGNUM (see MIPS and
 632          i386).  It might need to convert the [float] register into
 633          the corresponding [integer] type (see Alpha).  The assumption
 634          is that REGISTER_TO_VALUE populates the entire value
 635          including the location.  */
 636       REGISTER_TO_VALUE (frame, regnum, type, VALUE_CONTENTS_RAW (v));
 637       VALUE_LVAL (v) = lval_reg_frame_relative;
 638       VALUE_FRAME_ID (v) = get_frame_id (frame);
 639       VALUE_FRAME_REGNUM (v) = regnum;
 640     }
 641   else
 642     {
 643       int local_regnum;
 644       int mem_stor = 0, reg_stor = 0;
 645       int mem_tracking = 1;
 646       CORE_ADDR last_addr = 0;
 647       CORE_ADDR first_addr = 0;
 648       int first_realnum = regnum;
 649       int len = TYPE_LENGTH (type);
 650       int value_bytes_copied;
 651       int optimized = 0;
 652       char *value_bytes = (char *) alloca (len + MAX_REGISTER_SIZE);
 653
 654       /* Copy all of the data out, whereever it may be.  */
 655       for (local_regnum = regnum, value_bytes_copied = 0;
 656            value_bytes_copied < len;
 657            (value_bytes_copied += register_size (current_gdbarch, local_regnum),
 658             ++local_regnum))
 659         {
 660           int realnum;
 661           int optim;
 662           enum lval_type lval;
 663           CORE_ADDR addr;
 664           frame_register (frame, local_regnum, &optim, &lval, &addr,
 665                           &realnum, value_bytes + value_bytes_copied);
 666           optimized += optim;
 667           if (register_cached (local_regnum) == -1)
 668             return NULL;        /* register value not available */
 669
 670           if (regnum == local_regnum)
 671             {
 672               first_addr = addr;
 673               first_realnum = realnum;
 674             }
 675           if (lval == lval_register)
 676             reg_stor++;
 677           else
 678             {
 679               mem_stor++;
 680
 681               mem_tracking = (mem_tracking
 682                               && (regnum == local_regnum
 683                                   || addr == last_addr));
 684             }
 685           last_addr = addr;
 686         }
 687
 688       /* FIXME: cagney/2003-06-04: Shouldn't this always use
 689          lval_reg_frame_relative?  If it doesn't and the register's
 690          location changes (say after a resume) then this value is
 691          going to have wrong information.  */
 692       if ((reg_stor && mem_stor)
 693           || (mem_stor && !mem_tracking))
 694         /* Mixed storage; all of the hassle we just went through was
 695            for some good purpose.  */
 696         {
 697           VALUE_LVAL (v) = lval_reg_frame_relative;
 698           VALUE_FRAME_ID (v) = get_frame_id (frame);
 699           VALUE_FRAME_REGNUM (v) = regnum;
 700         }
 701       else if (mem_stor)
 702         {
 703           VALUE_LVAL (v) = lval_memory;
 704           VALUE_ADDRESS (v) = first_addr;
 705         }
 706       else if (reg_stor)
 707         {
 708           VALUE_LVAL (v) = lval_register;
 709           VALUE_ADDRESS (v) = first_addr;
 710           VALUE_REGNO (v) = first_realnum;
 711         }
 712       else
 713         internal_error (__FILE__, __LINE__,
 714                         "value_from_register: Value not stored anywhere!");
 715
 716       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         v->offset = register_size (current_gdbarch, regnum) - len;
 726       else
 727         v->offset = 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_REGNO (lazy_value)) != NULL
 768                     && *REGISTER_NAME (VALUE_REGNO (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_REGNO (lazy_value)));
 773       break;
 774
 775     case lval_reg_frame_relative:
 776         gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != NULL
 777                     && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != '\0');
 778       error("Address requested for identifier "
 779             "\"%s\" which is in frame register $%s",
 780             SYMBOL_PRINT_NAME (var),
 781             REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)));
 782       break;
 783
 784     default:
 785       error ("Can't take address of \"%s\" which isn't an lvalue.",
 786              SYMBOL_PRINT_NAME (var));
 787       break;
 788     }
 789   return 0;                     /* For lint -- never reached */
 790 }