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   /* Pointers on D10V are really only 16 bits,
 733      but we lie to gdb elsewhere... */
 734   if (GDB_TARGET_IS_D10V && TYPE_CODE (type) == TYPE_CODE_PTR)
 735     len = 2;
 736
 737   VALUE_REGNO (v) = regnum;
 738
 739   num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
 740                       ((len - 1) / REGISTER_RAW_SIZE (regnum)) + 1 :
 741                       1);
 742
 743   if (num_storage_locs > 1
 744 #ifdef GDB_TARGET_IS_H8500
 745       || TYPE_CODE (type) == TYPE_CODE_PTR
 746 #endif
 747     )
 748     {
 749       /* Value spread across multiple storage locations.  */
 750
 751       int local_regnum;
 752       int mem_stor = 0, reg_stor = 0;
 753       int mem_tracking = 1;
 754       CORE_ADDR last_addr = 0;
 755       CORE_ADDR first_addr = 0;
 756
 757       value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE);
 758
 759       /* Copy all of the data out, whereever it may be.  */
 760
 761 #ifdef GDB_TARGET_IS_H8500
 762 /* This piece of hideosity is required because the H8500 treats registers
 763    differently depending upon whether they are used as pointers or not.  As a
 764    pointer, a register needs to have a page register tacked onto the front.
 765    An alternate way to do this would be to have gcc output different register
 766    numbers for the pointer & non-pointer form of the register.  But, it
 767    doesn't, so we're stuck with this.  */
 768
 769       if (TYPE_CODE (type) == TYPE_CODE_PTR
 770           && len > 2)
 771         {
 772           int page_regnum;
 773
 774           switch (regnum)
 775             {
 776             case R0_REGNUM:
 777             case R1_REGNUM:
 778             case R2_REGNUM:
 779             case R3_REGNUM:
 780               page_regnum = SEG_D_REGNUM;
 781               break;
 782             case R4_REGNUM:
 783             case R5_REGNUM:
 784               page_regnum = SEG_E_REGNUM;
 785               break;
 786             case R6_REGNUM:
 787             case R7_REGNUM:
 788               page_regnum = SEG_T_REGNUM;
 789               break;
 790             }
 791
 792           value_bytes[0] = 0;
 793           get_saved_register (value_bytes + 1,
 794                               &optim,
 795                               &addr,
 796                               frame,
 797                               page_regnum,
 798                               &lval);
 799
 800           if (register_cached (page_regnum) == -1)
 801             return NULL;        /* register value not available */
 802
 803           if (lval == lval_register)
 804             reg_stor++;
 805           else
 806             mem_stor++;
 807           first_addr = addr;
 808           last_addr = addr;
 809
 810           get_saved_register (value_bytes + 2,
 811                               &optim,
 812                               &addr,
 813                               frame,
 814                               regnum,
 815                               &lval);
 816
 817           if (register_cached (regnum) == -1)
 818             return NULL;        /* register value not available */
 819
 820           if (lval == lval_register)
 821             reg_stor++;
 822           else
 823             {
 824               mem_stor++;
 825               mem_tracking = mem_tracking && (addr == last_addr);
 826             }
 827           last_addr = addr;
 828         }
 829       else
 830 #endif /* GDB_TARGET_IS_H8500 */
 831         for (local_regnum = regnum;
 832              value_bytes_copied < len;
 833              (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
 834               ++local_regnum))
 835           {
 836             get_saved_register (value_bytes + value_bytes_copied,
 837                                 &optim,
 838                                 &addr,
 839                                 frame,
 840                                 local_regnum,
 841                                 &lval);
 842
 843             if (register_cached (local_regnum) == -1)
 844               return NULL;      /* register value not available */
 845
 846             if (regnum == local_regnum)
 847               first_addr = addr;
 848             if (lval == lval_register)
 849               reg_stor++;
 850             else
 851               {
 852                 mem_stor++;
 853
 854                 mem_tracking =
 855                   (mem_tracking
 856                    && (regnum == local_regnum
 857                        || addr == last_addr));
 858               }
 859             last_addr = addr;
 860           }
 861
 862       if ((reg_stor && mem_stor)
 863           || (mem_stor && !mem_tracking))
 864         /* Mixed storage; all of the hassle we just went through was
 865            for some good purpose.  */
 866         {
 867           VALUE_LVAL (v) = lval_reg_frame_relative;
 868           VALUE_FRAME (v) = FRAME_FP (frame);
 869           VALUE_FRAME_REGNUM (v) = regnum;
 870         }
 871       else if (mem_stor)
 872         {
 873           VALUE_LVAL (v) = lval_memory;
 874           VALUE_ADDRESS (v) = first_addr;
 875         }
 876       else if (reg_stor)
 877         {
 878           VALUE_LVAL (v) = lval_register;
 879           VALUE_ADDRESS (v) = first_addr;
 880         }
 881       else
 882         internal_error (__FILE__, __LINE__,
 883                         "value_from_register: Value not stored anywhere!");
 884
 885       VALUE_OPTIMIZED_OUT (v) = optim;
 886
 887       /* Any structure stored in more than one register will always be
 888          an integral number of registers.  Otherwise, you'd need to do
 889          some fiddling with the last register copied here for little
 890          endian machines.  */
 891
 892       /* Copy into the contents section of the value.  */
 893       memcpy (VALUE_CONTENTS_RAW (v), value_bytes, len);
 894
 895       /* Finally do any conversion necessary when extracting this
 896          type from more than one register.  */
 897 #ifdef REGISTER_CONVERT_TO_TYPE
 898       REGISTER_CONVERT_TO_TYPE (regnum, type, VALUE_CONTENTS_RAW (v));
 899 #endif
 900       return v;
 901     }
 902
 903   /* Data is completely contained within a single register.  Locate the
 904      register's contents in a real register or in core;
 905      read the data in raw format.  */
 906
 907   get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
 908
 909   if (register_cached (regnum) == -1)
 910     return NULL;                /* register value not available */
 911
 912   VALUE_OPTIMIZED_OUT (v) = optim;
 913   VALUE_LVAL (v) = lval;
 914   VALUE_ADDRESS (v) = addr;
 915
 916   /* Convert raw data to virtual format if necessary.  */
 917
 918   if (REGISTER_CONVERTIBLE (regnum))
 919     {
 920       REGISTER_CONVERT_TO_VIRTUAL (regnum, type,
 921                                    raw_buffer, VALUE_CONTENTS_RAW (v));
 922     }
 923   else
 924     {
 925       /* Raw and virtual formats are the same for this register.  */
 926
 927       if (TARGET_BYTE_ORDER == BIG_ENDIAN && len < REGISTER_RAW_SIZE (regnum))
 928         {
 929           /* Big-endian, and we want less than full size.  */
 930           VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
 931         }
 932
 933       memcpy (VALUE_CONTENTS_RAW (v), raw_buffer + VALUE_OFFSET (v), len);
 934     }
 935
 936   if (GDB_TARGET_IS_D10V
 937       && TYPE_CODE (type) == TYPE_CODE_PTR)
 938     {
 939       unsigned long num;
 940       unsigned short snum;
 941
 942       snum = (unsigned short)
 943         extract_unsigned_integer (VALUE_CONTENTS_RAW (v), 2);
 944
 945       if (TYPE_TARGET_TYPE (type)         /* pointer to function */
 946           && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
 947         num = D10V_MAKE_IADDR (snum);
 948       else                                /* pointer to data */
 949         num = D10V_MAKE_DADDR (snum);
 950
 951       store_address (VALUE_CONTENTS_RAW (v), 4, num);
 952     }
 953
 954   return v;
 955 }
 956 \f
 957 /* Given a struct symbol for a variable or function,
 958    and a stack frame id,
 959    return a (pointer to a) struct value containing the properly typed
 960    address.  */
 961
 962 value_ptr
 963 locate_var_value (register struct symbol *var, struct frame_info *frame)
 964 {
 965   CORE_ADDR addr = 0;
 966   struct type *type = SYMBOL_TYPE (var);
 967   value_ptr lazy_value;
 968
 969   /* Evaluate it first; if the result is a memory address, we're fine.
 970      Lazy evaluation pays off here. */
 971
 972   lazy_value = read_var_value (var, frame);
 973   if (lazy_value == 0)
 974     error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
 975
 976   if (VALUE_LAZY (lazy_value)
 977       || TYPE_CODE (type) == TYPE_CODE_FUNC)
 978     {
 979       value_ptr val;
 980
 981       addr = VALUE_ADDRESS (lazy_value);
 982       val = value_from_pointer (lookup_pointer_type (type), addr);
 983       VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value);
 984       return val;
 985     }
 986
 987   /* Not a memory address; check what the problem was.  */
 988   switch (VALUE_LVAL (lazy_value))
 989     {
 990     case lval_register:
 991     case lval_reg_frame_relative:
 992       error ("Address requested for identifier \"%s\" which is in a register.",
 993              SYMBOL_SOURCE_NAME (var));
 994       break;
 995
 996     default:
 997       error ("Can't take address of \"%s\" which isn't an lvalue.",
 998              SYMBOL_SOURCE_NAME (var));
 999       break;
1000     }
1001   return 0;                     /* For lint -- never reached */
1002 }