gdb/findvar.c

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