gdb/findvar.c

   1 /* Find a variable's value in memory, for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
   3    1996, 1997, 1998, 1999, 2000, 2001
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "frame.h"
  27 #include "value.h"
  28 #include "gdbcore.h"
  29 #include "inferior.h"
  30 #include "target.h"
  31 #include "gdb_string.h"
  32 #include "floatformat.h"
  33 #include "symfile.h"            /* for overlay functions */
  34 #include "regcache.h"
  35
  36 /* This is used to indicate that we don't know the format of the floating point
  37    number.  Typically, this is useful for native ports, where the actual format
  38    is irrelevant, since no conversions will be taking place.  */
  39
  40 const struct floatformat floatformat_unknown;
  41
  42 /* Basic byte-swapping routines.  GDB has needed these for a long time...
  43    All extract a target-format integer at ADDR which is LEN bytes long.  */
  44
  45 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
  46   /* 8 bit characters are a pretty safe assumption these days, so we
  47      assume it throughout all these swapping routines.  If we had to deal with
  48      9 bit characters, we would need to make len be in bits and would have
  49      to re-write these routines...  */
  50 you lose
  51 #endif
  52
  53 LONGEST
  54 extract_signed_integer (void *addr, int len)
  55 {
  56   LONGEST retval;
  57   unsigned char *p;
  58   unsigned char *startaddr = (unsigned char *) addr;
  59   unsigned char *endaddr = startaddr + len;
  60
  61   if (len > (int) sizeof (LONGEST))
  62     error ("\
  63 That operation is not available on integers of more than %d bytes.",
  64            sizeof (LONGEST));
  65
  66   /* Start at the most significant end of the integer, and work towards
  67      the least significant.  */
  68   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
  69     {
  70       p = startaddr;
  71       /* Do the sign extension once at the start.  */
  72       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  73       for (++p; p < endaddr; ++p)
  74         retval = (retval << 8) | *p;
  75     }
  76   else
  77     {
  78       p = endaddr - 1;
  79       /* Do the sign extension once at the start.  */
  80       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  81       for (--p; p >= startaddr; --p)
  82         retval = (retval << 8) | *p;
  83     }
  84   return retval;
  85 }
  86
  87 ULONGEST
  88 extract_unsigned_integer (void *addr, int len)
  89 {
  90   ULONGEST retval;
  91   unsigned char *p;
  92   unsigned char *startaddr = (unsigned char *) addr;
  93   unsigned char *endaddr = startaddr + len;
  94
  95   if (len > (int) sizeof (ULONGEST))
  96     error ("\
  97 That operation is not available on integers of more than %d bytes.",
  98            sizeof (ULONGEST));
  99
 100   /* Start at the most significant end of the integer, and work towards
 101      the least significant.  */
 102   retval = 0;
 103   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 104     {
 105       for (p = startaddr; p < endaddr; ++p)
 106         retval = (retval << 8) | *p;
 107     }
 108   else
 109     {
 110       for (p = endaddr - 1; p >= startaddr; --p)
 111         retval = (retval << 8) | *p;
 112     }
 113   return retval;
 114 }
 115
 116 /* Sometimes a long long unsigned integer can be extracted as a
 117    LONGEST value.  This is done so that we can print these values
 118    better.  If this integer can be converted to a LONGEST, this
 119    function returns 1 and sets *PVAL.  Otherwise it returns 0.  */
 120
 121 int
 122 extract_long_unsigned_integer (void *addr, int orig_len, LONGEST *pval)
 123 {
 124   char *p, *first_addr;
 125   int len;
 126
 127   len = orig_len;
 128   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 129     {
 130       for (p = (char *) addr;
 131            len > (int) sizeof (LONGEST) && p < (char *) 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 = (char *) addr;
 144       for (p = (char *) addr + orig_len - 1;
 145            len > (int) sizeof (LONGEST) && p >= (char *) 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 LEN bytes at ADDR as a target-format address, and return
 167    that address.  ADDR is a buffer in the GDB process, not in the
 168    inferior.
 169
 170    This function should only be used by target-specific code.  It
 171    assumes that a pointer has the same representation as that thing's
 172    address represented as an integer.  Some machines use word
 173    addresses, or similarly munged things, for certain types of
 174    pointers, so that assumption doesn't hold everywhere.
 175
 176    Common code should use extract_typed_address instead, or something
 177    else based on POINTER_TO_ADDRESS.  */
 178
 179 CORE_ADDR
 180 extract_address (void *addr, int len)
 181 {
 182   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
 183      whether we want this to be true eventually.  */
 184   return (CORE_ADDR) extract_unsigned_integer (addr, len);
 185 }
 186
 187
 188 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
 189    address it represents.  */
 190 CORE_ADDR
 191 extract_typed_address (void *buf, struct type *type)
 192 {
 193   if (TYPE_CODE (type) != TYPE_CODE_PTR
 194       && TYPE_CODE (type) != TYPE_CODE_REF)
 195     internal_error (__FILE__, __LINE__,
 196                     "extract_typed_address: "
 197                     "type is not a pointer or reference");
 198
 199   return POINTER_TO_ADDRESS (type, buf);
 200 }
 201
 202
 203 void
 204 store_signed_integer (void *addr, int len, LONGEST val)
 205 {
 206   unsigned char *p;
 207   unsigned char *startaddr = (unsigned char *) addr;
 208   unsigned char *endaddr = startaddr + len;
 209
 210   /* Start at the least significant end of the integer, and work towards
 211      the most significant.  */
 212   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 213     {
 214       for (p = endaddr - 1; p >= startaddr; --p)
 215         {
 216           *p = val & 0xff;
 217           val >>= 8;
 218         }
 219     }
 220   else
 221     {
 222       for (p = startaddr; p < endaddr; ++p)
 223         {
 224           *p = val & 0xff;
 225           val >>= 8;
 226         }
 227     }
 228 }
 229
 230 void
 231 store_unsigned_integer (void *addr, int len, ULONGEST val)
 232 {
 233   unsigned char *p;
 234   unsigned char *startaddr = (unsigned char *) addr;
 235   unsigned char *endaddr = startaddr + len;
 236
 237   /* Start at the least significant end of the integer, and work towards
 238      the most significant.  */
 239   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 240     {
 241       for (p = endaddr - 1; p >= startaddr; --p)
 242         {
 243           *p = val & 0xff;
 244           val >>= 8;
 245         }
 246     }
 247   else
 248     {
 249       for (p = startaddr; p < endaddr; ++p)
 250         {
 251           *p = val & 0xff;
 252           val >>= 8;
 253         }
 254     }
 255 }
 256
 257 /* Store the address VAL as a LEN-byte value in target byte order at
 258    ADDR.  ADDR is a buffer in the GDB process, not in the inferior.
 259
 260    This function should only be used by target-specific code.  It
 261    assumes that a pointer has the same representation as that thing's
 262    address represented as an integer.  Some machines use word
 263    addresses, or similarly munged things, for certain types of
 264    pointers, so that assumption doesn't hold everywhere.
 265
 266    Common code should use store_typed_address instead, or something else
 267    based on ADDRESS_TO_POINTER.  */
 268 void
 269 store_address (void *addr, int len, LONGEST val)
 270 {
 271   store_unsigned_integer (addr, len, val);
 272 }
 273
 274
 275 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
 276    form.  */
 277 void
 278 store_typed_address (void *buf, struct type *type, CORE_ADDR addr)
 279 {
 280   if (TYPE_CODE (type) != TYPE_CODE_PTR
 281       && TYPE_CODE (type) != TYPE_CODE_REF)
 282     internal_error (__FILE__, __LINE__,
 283                     "store_typed_address: "
 284                     "type is not a pointer or reference");
 285
 286   ADDRESS_TO_POINTER (type, buf, addr);
 287 }
 288
 289
 290
 291 \f
 292 /* Extract a floating-point number from a target-order byte-stream at ADDR.
 293    Returns the value as type DOUBLEST.
 294
 295    If the host and target formats agree, we just copy the raw data into the
 296    appropriate type of variable and return, letting the host increase precision
 297    as necessary.  Otherwise, we call the conversion routine and let it do the
 298    dirty work.  */
 299
 300 DOUBLEST
 301 extract_floating (void *addr, int len)
 302 {
 303   DOUBLEST dretval;
 304
 305   if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
 306     {
 307       if (HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT)
 308         {
 309           float retval;
 310
 311           memcpy (&retval, addr, sizeof (retval));
 312           return retval;
 313         }
 314       else
 315         floatformat_to_doublest (TARGET_FLOAT_FORMAT, addr, &dretval);
 316     }
 317   else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
 318     {
 319       if (HOST_DOUBLE_FORMAT == TARGET_DOUBLE_FORMAT)
 320         {
 321           double retval;
 322
 323           memcpy (&retval, addr, sizeof (retval));
 324           return retval;
 325         }
 326       else
 327         floatformat_to_doublest (TARGET_DOUBLE_FORMAT, addr, &dretval);
 328     }
 329   else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
 330     {
 331       if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
 332         {
 333           DOUBLEST retval;
 334
 335           memcpy (&retval, addr, sizeof (retval));
 336           return retval;
 337         }
 338       else
 339         floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT, addr, &dretval);
 340     }
 341   else
 342     {
 343       error ("Can't deal with a floating point number of %d bytes.", len);
 344     }
 345
 346   return dretval;
 347 }
 348
 349 void
 350 store_floating (void *addr, int len, DOUBLEST val)
 351 {
 352   if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
 353     {
 354       if (HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT)
 355         {
 356           float floatval = val;
 357
 358           memcpy (addr, &floatval, sizeof (floatval));
 359         }
 360       else
 361         floatformat_from_doublest (TARGET_FLOAT_FORMAT, &val, addr);
 362     }
 363   else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
 364     {
 365       if (HOST_DOUBLE_FORMAT == TARGET_DOUBLE_FORMAT)
 366         {
 367           double doubleval = val;
 368
 369           memcpy (addr, &doubleval, sizeof (doubleval));
 370         }
 371       else
 372         floatformat_from_doublest (TARGET_DOUBLE_FORMAT, &val, addr);
 373     }
 374   else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
 375     {
 376       if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
 377         memcpy (addr, &val, sizeof (val));
 378       else
 379         floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT, &val, addr);
 380     }
 381   else
 382     {
 383       error ("Can't deal with a floating point number of %d bytes.", len);
 384     }
 385 }
 386
 387 /* Return a `value' with the contents of register REGNUM
 388    in its virtual format, with the type specified by
 389    REGISTER_VIRTUAL_TYPE.
 390
 391    NOTE: returns NULL if register value is not available.
 392    Caller will check return value or die!  */
 393
 394 value_ptr
 395 value_of_register (int regnum)
 396 {
 397   CORE_ADDR addr;
 398   int optim;
 399   register value_ptr reg_val;
 400   char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
 401   enum lval_type lval;
 402
 403   get_saved_register (raw_buffer, &optim, &addr,
 404                       selected_frame, regnum, &lval);
 405
 406   if (register_cached (regnum) < 0)
 407     return NULL;                /* register value not available */
 408
 409   reg_val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
 410
 411   /* Convert raw data to virtual format if necessary.  */
 412
 413   if (REGISTER_CONVERTIBLE (regnum))
 414     {
 415       REGISTER_CONVERT_TO_VIRTUAL (regnum, REGISTER_VIRTUAL_TYPE (regnum),
 416                                    raw_buffer, VALUE_CONTENTS_RAW (reg_val));
 417     }
 418   else if (REGISTER_RAW_SIZE (regnum) == REGISTER_VIRTUAL_SIZE (regnum))
 419     memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
 420             REGISTER_RAW_SIZE (regnum));
 421   else
 422     internal_error (__FILE__, __LINE__,
 423                     "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
 424                     REGISTER_NAME (regnum),
 425                     regnum,
 426                     REGISTER_RAW_SIZE (regnum),
 427                     REGISTER_VIRTUAL_SIZE (regnum));
 428   VALUE_LVAL (reg_val) = lval;
 429   VALUE_ADDRESS (reg_val) = addr;
 430   VALUE_REGNO (reg_val) = regnum;
 431   VALUE_OPTIMIZED_OUT (reg_val) = optim;
 432   return reg_val;
 433 }
 434
 435 /* Given a pointer of type TYPE in target form in BUF, return the
 436    address it represents.  */
 437 CORE_ADDR
 438 unsigned_pointer_to_address (struct type *type, void *buf)
 439 {
 440   return extract_address (buf, TYPE_LENGTH (type));
 441 }
 442
 443 CORE_ADDR
 444 signed_pointer_to_address (struct type *type, void *buf)
 445 {
 446   return extract_signed_integer (buf, TYPE_LENGTH (type));
 447 }
 448
 449 /* Given an address, store it as a pointer of type TYPE in target
 450    format in BUF.  */
 451 void
 452 unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
 453 {
 454   store_address (buf, TYPE_LENGTH (type), addr);
 455 }
 456
 457 void
 458 address_to_signed_pointer (struct type *type, void *buf, CORE_ADDR addr)
 459 {
 460   store_signed_integer (buf, TYPE_LENGTH (type), addr);
 461 }
 462 \f
 463 /* Will calling read_var_value or locate_var_value on SYM end
 464    up caring what frame it is being evaluated relative to?  SYM must
 465    be non-NULL.  */
 466 int
 467 symbol_read_needs_frame (struct symbol *sym)
 468 {
 469   switch (SYMBOL_CLASS (sym))
 470     {
 471       /* All cases listed explicitly so that gcc -Wall will detect it if
 472          we failed to consider one.  */
 473     case LOC_REGISTER:
 474     case LOC_ARG:
 475     case LOC_REF_ARG:
 476     case LOC_REGPARM:
 477     case LOC_REGPARM_ADDR:
 478     case LOC_LOCAL:
 479     case LOC_LOCAL_ARG:
 480     case LOC_BASEREG:
 481     case LOC_BASEREG_ARG:
 482     case LOC_THREAD_LOCAL_STATIC:
 483       return 1;
 484
 485     case LOC_UNDEF:
 486     case LOC_CONST:
 487     case LOC_STATIC:
 488     case LOC_INDIRECT:
 489     case LOC_TYPEDEF:
 490
 491     case LOC_LABEL:
 492       /* Getting the address of a label can be done independently of the block,
 493          even if some *uses* of that address wouldn't work so well without
 494          the right frame.  */
 495
 496     case LOC_BLOCK:
 497     case LOC_CONST_BYTES:
 498     case LOC_UNRESOLVED:
 499     case LOC_OPTIMIZED_OUT:
 500       return 0;
 501     }
 502   return 1;
 503 }
 504
 505 /* Given a struct symbol for a variable,
 506    and a stack frame id, read the value of the variable
 507    and return a (pointer to a) struct value containing the value.
 508    If the variable cannot be found, return a zero pointer.
 509    If FRAME is NULL, use the selected_frame.  */
 510
 511 value_ptr
 512 read_var_value (register struct symbol *var, struct frame_info *frame)
 513 {
 514   register value_ptr v;
 515   struct type *type = SYMBOL_TYPE (var);
 516   CORE_ADDR addr;
 517   register int len;
 518
 519   v = allocate_value (type);
 520   VALUE_LVAL (v) = lval_memory; /* The most likely possibility.  */
 521   VALUE_BFD_SECTION (v) = SYMBOL_BFD_SECTION (var);
 522
 523   len = TYPE_LENGTH (type);
 524
 525   if (frame == NULL)
 526     frame = selected_frame;
 527
 528   switch (SYMBOL_CLASS (var))
 529     {
 530     case LOC_CONST:
 531       /* Put the constant back in target format.  */
 532       store_signed_integer (VALUE_CONTENTS_RAW (v), len,
 533                             (LONGEST) SYMBOL_VALUE (var));
 534       VALUE_LVAL (v) = not_lval;
 535       return v;
 536
 537     case LOC_LABEL:
 538       /* Put the constant back in target format.  */
 539       if (overlay_debugging)
 540         {
 541           CORE_ADDR addr
 542             = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 543                                         SYMBOL_BFD_SECTION (var));
 544           store_typed_address (VALUE_CONTENTS_RAW (v), type, addr);
 545         }
 546       else
 547         store_typed_address (VALUE_CONTENTS_RAW (v), type,
 548                               SYMBOL_VALUE_ADDRESS (var));
 549       VALUE_LVAL (v) = not_lval;
 550       return v;
 551
 552     case LOC_CONST_BYTES:
 553       {
 554         char *bytes_addr;
 555         bytes_addr = SYMBOL_VALUE_BYTES (var);
 556         memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
 557         VALUE_LVAL (v) = not_lval;
 558         return v;
 559       }
 560
 561     case LOC_STATIC:
 562       if (overlay_debugging)
 563         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 564                                          SYMBOL_BFD_SECTION (var));
 565       else
 566         addr = SYMBOL_VALUE_ADDRESS (var);
 567       break;
 568
 569     case LOC_INDIRECT:
 570       /* The import slot does not have a real address in it from the
 571          dynamic loader (dld.sl on HP-UX), if the target hasn't begun
 572          execution yet, so check for that. */
 573       if (!target_has_execution)
 574         error ("\
 575 Attempt to access variable defined in different shared object or load module when\n\
 576 addresses have not been bound by the dynamic loader. Try again when executable is running.");
 577
 578       addr = SYMBOL_VALUE_ADDRESS (var);
 579       addr = read_memory_unsigned_integer
 580         (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
 581       break;
 582
 583     case LOC_ARG:
 584       if (frame == NULL)
 585         return 0;
 586       addr = FRAME_ARGS_ADDRESS (frame);
 587       if (!addr)
 588         return 0;
 589       addr += SYMBOL_VALUE (var);
 590       break;
 591
 592     case LOC_REF_ARG:
 593       if (frame == NULL)
 594         return 0;
 595       addr = FRAME_ARGS_ADDRESS (frame);
 596       if (!addr)
 597         return 0;
 598       addr += SYMBOL_VALUE (var);
 599       addr = read_memory_unsigned_integer
 600         (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
 601       break;
 602
 603     case LOC_LOCAL:
 604     case LOC_LOCAL_ARG:
 605       if (frame == NULL)
 606         return 0;
 607       addr = FRAME_LOCALS_ADDRESS (frame);
 608       addr += SYMBOL_VALUE (var);
 609       break;
 610
 611     case LOC_BASEREG:
 612     case LOC_BASEREG_ARG:
 613       {
 614         char *buf = (char*) alloca (MAX_REGISTER_RAW_SIZE);
 615         get_saved_register (buf, NULL, NULL, frame, SYMBOL_BASEREG (var),
 616                             NULL);
 617         addr = extract_address (buf, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var)));
 618         addr += SYMBOL_VALUE (var);
 619         break;
 620       }
 621
 622     case LOC_THREAD_LOCAL_STATIC:
 623       {
 624         char *buf = (char*) alloca (MAX_REGISTER_RAW_SIZE);
 625
 626         get_saved_register (buf, NULL, NULL, frame, SYMBOL_BASEREG (var),
 627                             NULL);
 628         addr = extract_address (buf, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var)));
 629         addr += SYMBOL_VALUE (var);
 630         break;
 631       }
 632
 633     case LOC_TYPEDEF:
 634       error ("Cannot look up value of a typedef");
 635       break;
 636
 637     case LOC_BLOCK:
 638       if (overlay_debugging)
 639         VALUE_ADDRESS (v) = symbol_overlayed_address
 640           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
 641       else
 642         VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 643       return v;
 644
 645     case LOC_REGISTER:
 646     case LOC_REGPARM:
 647     case LOC_REGPARM_ADDR:
 648       {
 649         struct block *b;
 650         int regno = SYMBOL_VALUE (var);
 651         value_ptr regval;
 652
 653         if (frame == NULL)
 654           return 0;
 655         b = get_frame_block (frame);
 656
 657         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 658           {
 659             regval = value_from_register (lookup_pointer_type (type),
 660                                           regno,
 661                                           frame);
 662
 663             if (regval == NULL)
 664               error ("Value of register variable not available.");
 665
 666             addr = value_as_pointer (regval);
 667             VALUE_LVAL (v) = lval_memory;
 668           }
 669         else
 670           {
 671             regval = value_from_register (type, regno, frame);
 672
 673             if (regval == NULL)
 674               error ("Value of register variable not available.");
 675             return regval;
 676           }
 677       }
 678       break;
 679
 680     case LOC_UNRESOLVED:
 681       {
 682         struct minimal_symbol *msym;
 683
 684         msym = lookup_minimal_symbol (SYMBOL_NAME (var), NULL, NULL);
 685         if (msym == NULL)
 686           return 0;
 687         if (overlay_debugging)
 688           addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
 689                                            SYMBOL_BFD_SECTION (msym));
 690         else
 691           addr = SYMBOL_VALUE_ADDRESS (msym);
 692       }
 693       break;
 694
 695     case LOC_OPTIMIZED_OUT:
 696       VALUE_LVAL (v) = not_lval;
 697       VALUE_OPTIMIZED_OUT (v) = 1;
 698       return v;
 699
 700     default:
 701       error ("Cannot look up value of a botched symbol.");
 702       break;
 703     }
 704
 705   VALUE_ADDRESS (v) = addr;
 706   VALUE_LAZY (v) = 1;
 707   return v;
 708 }
 709
 710 /* Return a value of type TYPE, stored in register REGNUM, in frame
 711    FRAME.
 712
 713    NOTE: returns NULL if register value is not available.
 714    Caller will check return value or die!  */
 715
 716 value_ptr
 717 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 718 {
 719   char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
 720   CORE_ADDR addr;
 721   int optim;
 722   value_ptr v = allocate_value (type);
 723   char *value_bytes = 0;
 724   int value_bytes_copied = 0;
 725   int num_storage_locs;
 726   enum lval_type lval;
 727   int len;
 728
 729   CHECK_TYPEDEF (type);
 730   len = TYPE_LENGTH (type);
 731
 732   VALUE_REGNO (v) = regnum;
 733
 734   num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
 735                       ((len - 1) / REGISTER_RAW_SIZE (regnum)) + 1 :
 736                       1);
 737
 738   if (num_storage_locs > 1
 739 #ifdef GDB_TARGET_IS_H8500
 740       || TYPE_CODE (type) == TYPE_CODE_PTR
 741 #endif
 742     )
 743     {
 744       /* Value spread across multiple storage locations.  */
 745
 746       int local_regnum;
 747       int mem_stor = 0, reg_stor = 0;
 748       int mem_tracking = 1;
 749       CORE_ADDR last_addr = 0;
 750       CORE_ADDR first_addr = 0;
 751
 752       value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE);
 753
 754       /* Copy all of the data out, whereever it may be.  */
 755
 756 #ifdef GDB_TARGET_IS_H8500
 757 /* This piece of hideosity is required because the H8500 treats registers
 758    differently depending upon whether they are used as pointers or not.  As a
 759    pointer, a register needs to have a page register tacked onto the front.
 760    An alternate way to do this would be to have gcc output different register
 761    numbers for the pointer & non-pointer form of the register.  But, it
 762    doesn't, so we're stuck with this.  */
 763
 764       if (TYPE_CODE (type) == TYPE_CODE_PTR
 765           && len > 2)
 766         {
 767           int page_regnum;
 768
 769           switch (regnum)
 770             {
 771             case R0_REGNUM:
 772             case R1_REGNUM:
 773             case R2_REGNUM:
 774             case R3_REGNUM:
 775               page_regnum = SEG_D_REGNUM;
 776               break;
 777             case R4_REGNUM:
 778             case R5_REGNUM:
 779               page_regnum = SEG_E_REGNUM;
 780               break;
 781             case R6_REGNUM:
 782             case R7_REGNUM:
 783               page_regnum = SEG_T_REGNUM;
 784               break;
 785             }
 786
 787           value_bytes[0] = 0;
 788           get_saved_register (value_bytes + 1,
 789                               &optim,
 790                               &addr,
 791                               frame,
 792                               page_regnum,
 793                               &lval);
 794
 795           if (register_cached (page_regnum) == -1)
 796             return NULL;        /* register value not available */
 797
 798           if (lval == lval_register)
 799             reg_stor++;
 800           else
 801             mem_stor++;
 802           first_addr = addr;
 803           last_addr = addr;
 804
 805           get_saved_register (value_bytes + 2,
 806                               &optim,
 807                               &addr,
 808                               frame,
 809                               regnum,
 810                               &lval);
 811
 812           if (register_cached (regnum) == -1)
 813             return NULL;        /* register value not available */
 814
 815           if (lval == lval_register)
 816             reg_stor++;
 817           else
 818             {
 819               mem_stor++;
 820               mem_tracking = mem_tracking && (addr == last_addr);
 821             }
 822           last_addr = addr;
 823         }
 824       else
 825 #endif /* GDB_TARGET_IS_H8500 */
 826         for (local_regnum = regnum;
 827              value_bytes_copied < len;
 828              (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
 829               ++local_regnum))
 830           {
 831             get_saved_register (value_bytes + value_bytes_copied,
 832                                 &optim,
 833                                 &addr,
 834                                 frame,
 835                                 local_regnum,
 836                                 &lval);
 837
 838             if (register_cached (local_regnum) == -1)
 839               return NULL;      /* register value not available */
 840
 841             if (regnum == local_regnum)
 842               first_addr = addr;
 843             if (lval == lval_register)
 844               reg_stor++;
 845             else
 846               {
 847                 mem_stor++;
 848
 849                 mem_tracking =
 850                   (mem_tracking
 851                    && (regnum == local_regnum
 852                        || addr == last_addr));
 853               }
 854             last_addr = addr;
 855           }
 856
 857       if ((reg_stor && mem_stor)
 858           || (mem_stor && !mem_tracking))
 859         /* Mixed storage; all of the hassle we just went through was
 860            for some good purpose.  */
 861         {
 862           VALUE_LVAL (v) = lval_reg_frame_relative;
 863           VALUE_FRAME (v) = FRAME_FP (frame);
 864           VALUE_FRAME_REGNUM (v) = regnum;
 865         }
 866       else if (mem_stor)
 867         {
 868           VALUE_LVAL (v) = lval_memory;
 869           VALUE_ADDRESS (v) = first_addr;
 870         }
 871       else if (reg_stor)
 872         {
 873           VALUE_LVAL (v) = lval_register;
 874           VALUE_ADDRESS (v) = first_addr;
 875         }
 876       else
 877         internal_error (__FILE__, __LINE__,
 878                         "value_from_register: Value not stored anywhere!");
 879
 880       VALUE_OPTIMIZED_OUT (v) = optim;
 881
 882       /* Any structure stored in more than one register will always be
 883          an integral number of registers.  Otherwise, you'd need to do
 884          some fiddling with the last register copied here for little
 885          endian machines.  */
 886
 887       /* Copy into the contents section of the value.  */
 888       memcpy (VALUE_CONTENTS_RAW (v), value_bytes, len);
 889
 890       /* Finally do any conversion necessary when extracting this
 891          type from more than one register.  */
 892 #ifdef REGISTER_CONVERT_TO_TYPE
 893       REGISTER_CONVERT_TO_TYPE (regnum, type, VALUE_CONTENTS_RAW (v));
 894 #endif
 895       return v;
 896     }
 897
 898   /* Data is completely contained within a single register.  Locate the
 899      register's contents in a real register or in core;
 900      read the data in raw format.  */
 901
 902   get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
 903
 904   if (register_cached (regnum) == -1)
 905     return NULL;                /* register value not available */
 906
 907   VALUE_OPTIMIZED_OUT (v) = optim;
 908   VALUE_LVAL (v) = lval;
 909   VALUE_ADDRESS (v) = addr;
 910
 911   /* Convert raw data to virtual format if necessary.  */
 912
 913   if (REGISTER_CONVERTIBLE (regnum))
 914     {
 915       REGISTER_CONVERT_TO_VIRTUAL (regnum, type,
 916                                    raw_buffer, VALUE_CONTENTS_RAW (v));
 917     }
 918   else
 919     {
 920       /* Raw and virtual formats are the same for this register.  */
 921
 922       if (TARGET_BYTE_ORDER == BIG_ENDIAN && len < REGISTER_RAW_SIZE (regnum))
 923         {
 924           /* Big-endian, and we want less than full size.  */
 925           VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
 926         }
 927
 928       memcpy (VALUE_CONTENTS_RAW (v), raw_buffer + VALUE_OFFSET (v), len);
 929     }
 930
 931   return v;
 932 }
 933 \f
 934 /* Given a struct symbol for a variable or function,
 935    and a stack frame id,
 936    return a (pointer to a) struct value containing the properly typed
 937    address.  */
 938
 939 value_ptr
 940 locate_var_value (register struct symbol *var, struct frame_info *frame)
 941 {
 942   CORE_ADDR addr = 0;
 943   struct type *type = SYMBOL_TYPE (var);
 944   value_ptr lazy_value;
 945
 946   /* Evaluate it first; if the result is a memory address, we're fine.
 947      Lazy evaluation pays off here. */
 948
 949   lazy_value = read_var_value (var, frame);
 950   if (lazy_value == 0)
 951     error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
 952
 953   if (VALUE_LAZY (lazy_value)
 954       || TYPE_CODE (type) == TYPE_CODE_FUNC)
 955     {
 956       value_ptr val;
 957
 958       addr = VALUE_ADDRESS (lazy_value);
 959       val = value_from_pointer (lookup_pointer_type (type), addr);
 960       VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value);
 961       return val;
 962     }
 963
 964   /* Not a memory address; check what the problem was.  */
 965   switch (VALUE_LVAL (lazy_value))
 966     {
 967     case lval_register:
 968     case lval_reg_frame_relative:
 969       error ("Address requested for identifier \"%s\" which is in a register.",
 970              SYMBOL_SOURCE_NAME (var));
 971       break;
 972
 973     default:
 974       error ("Can't take address of \"%s\" which isn't an lvalue.",
 975              SYMBOL_SOURCE_NAME (var));
 976       break;
 977     }
 978   return 0;                     /* For lint -- never reached */
 979 }