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   VALUE_BFD_SECTION (v) = SYMBOL_BFD_SECTION (var);
 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, NULL);
 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, NULL);
 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_REGNO (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_reg_frame_relative;
 639       VALUE_FRAME_ID (v) = get_frame_id (frame);
 640       VALUE_FRAME_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               mem_tracking = (mem_tracking
 683                               && (regnum == local_regnum
 684                                   || addr == last_addr));
 685             }
 686           last_addr = addr;
 687         }
 688
 689       /* FIXME: cagney/2003-06-04: Shouldn't this always use
 690          lval_reg_frame_relative?  If it doesn't and the register's
 691          location changes (say after a resume) then this value is
 692          going to have wrong information.  */
 693       if ((reg_stor && mem_stor)
 694           || (mem_stor && !mem_tracking))
 695         /* Mixed storage; all of the hassle we just went through was
 696            for some good purpose.  */
 697         {
 698           VALUE_LVAL (v) = lval_reg_frame_relative;
 699           VALUE_FRAME_ID (v) = get_frame_id (frame);
 700           VALUE_FRAME_REGNUM (v) = regnum;
 701         }
 702       else if (mem_stor)
 703         {
 704           VALUE_LVAL (v) = lval_memory;
 705           VALUE_ADDRESS (v) = first_addr;
 706         }
 707       else if (reg_stor)
 708         {
 709           VALUE_LVAL (v) = lval_register;
 710           VALUE_ADDRESS (v) = first_addr;
 711           VALUE_REGNO (v) = first_realnum;
 712         }
 713       else
 714         internal_error (__FILE__, __LINE__,
 715                         "value_from_register: Value not stored anywhere!");
 716
 717       VALUE_OPTIMIZED_OUT (v) = optimized;
 718
 719       /* Any structure stored in more than one register will always be
 720          an integral number of registers.  Otherwise, you need to do
 721          some fiddling with the last register copied here for little
 722          endian machines.  */
 723       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG
 724           && len < register_size (current_gdbarch, regnum))
 725         /* Big-endian, and we want less than full size.  */
 726         VALUE_OFFSET (v) = register_size (current_gdbarch, regnum) - len;
 727       else
 728         VALUE_OFFSET (v) = 0;
 729       memcpy (VALUE_CONTENTS_RAW (v), value_bytes + VALUE_OFFSET (v), len);
 730     }
 731   return v;
 732 }
 733
 734 \f
 735 /* Given a struct symbol for a variable or function,
 736    and a stack frame id,
 737    return a (pointer to a) struct value containing the properly typed
 738    address.  */
 739
 740 struct value *
 741 locate_var_value (struct symbol *var, struct frame_info *frame)
 742 {
 743   CORE_ADDR addr = 0;
 744   struct type *type = SYMBOL_TYPE (var);
 745   struct value *lazy_value;
 746
 747   /* Evaluate it first; if the result is a memory address, we're fine.
 748      Lazy evaluation pays off here. */
 749
 750   lazy_value = read_var_value (var, frame);
 751   if (lazy_value == 0)
 752     error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var));
 753
 754   if (VALUE_LAZY (lazy_value)
 755       || TYPE_CODE (type) == TYPE_CODE_FUNC)
 756     {
 757       struct value *val;
 758
 759       addr = VALUE_ADDRESS (lazy_value);
 760       val = value_from_pointer (lookup_pointer_type (type), addr);
 761       VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value);
 762       return val;
 763     }
 764
 765   /* Not a memory address; check what the problem was.  */
 766   switch (VALUE_LVAL (lazy_value))
 767     {
 768     case lval_register:
 769         gdb_assert (REGISTER_NAME (VALUE_REGNO (lazy_value)) != NULL
 770                     && *REGISTER_NAME (VALUE_REGNO (lazy_value)) != '\0');
 771       error("Address requested for identifier "
 772             "\"%s\" which is in register $%s",
 773             SYMBOL_PRINT_NAME (var),
 774             REGISTER_NAME (VALUE_REGNO (lazy_value)));
 775       break;
 776
 777     case lval_reg_frame_relative:
 778         gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != NULL
 779                     && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != '\0');
 780       error("Address requested for identifier "
 781             "\"%s\" which is in frame register $%s",
 782             SYMBOL_PRINT_NAME (var),
 783             REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)));
 784       break;
 785
 786     default:
 787       error ("Can't take address of \"%s\" which isn't an lvalue.",
 788              SYMBOL_PRINT_NAME (var));
 789       break;
 790     }
 791   return 0;                     /* For lint -- never reached */
 792 }