gdb/findvar.c

   1 /* Find a variable's value in memory, for GDB, the GNU debugger.
   2    Copyright 1986, 87, 89, 91, 94, 95, 96, 1998
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "frame.h"
  26 #include "value.h"
  27 #include "gdbcore.h"
  28 #include "inferior.h"
  29 #include "target.h"
  30 #include "gdb_string.h"
  31 #include "floatformat.h"
  32 #include "symfile.h"            /* for overlay functions */
  33
  34 /* This is used to indicate that we don't know the format of the floating point
  35    number.  Typically, this is useful for native ports, where the actual format
  36    is irrelevant, since no conversions will be taking place.  */
  37
  38 const struct floatformat floatformat_unknown;
  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 (void *addr, int len)
  53 {
  54   LONGEST retval;
  55   unsigned char *p;
  56   unsigned char *startaddr = (unsigned char *) addr;
  57   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            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 == BIG_ENDIAN)
  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 (void *addr, int len)
  87 {
  88   ULONGEST retval;
  89   unsigned char *p;
  90   unsigned char *startaddr = (unsigned char *) addr;
  91   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            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 == BIG_ENDIAN)
 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 (void *addr, int orig_len, LONGEST *pval)
 121 {
 122   char *p, *first_addr;
 123   int len;
 124
 125   len = orig_len;
 126   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 127     {
 128       for (p = (char *) addr;
 129            len > (int) sizeof (LONGEST) && p < (char *) addr + orig_len;
 130            p++)
 131         {
 132           if (*p == 0)
 133             len--;
 134           else
 135             break;
 136         }
 137       first_addr = p;
 138     }
 139   else
 140     {
 141       first_addr = (char *) addr;
 142       for (p = (char *) addr + orig_len - 1;
 143            len > (int) sizeof (LONGEST) && p >= (char *) addr;
 144            p--)
 145         {
 146           if (*p == 0)
 147             len--;
 148           else
 149             break;
 150         }
 151     }
 152
 153   if (len <= (int) sizeof (LONGEST))
 154     {
 155       *pval = (LONGEST) extract_unsigned_integer (first_addr,
 156                                                   sizeof (LONGEST));
 157       return 1;
 158     }
 159
 160   return 0;
 161 }
 162
 163
 164 /* Treat the LEN bytes at ADDR as a target-format address, and return
 165    that address.  ADDR is a buffer in the GDB process, not in the
 166    inferior.
 167
 168    This function should only be used by target-specific code.  It
 169    assumes that a pointer has the same representation as that thing's
 170    address represented as an integer.  Some machines use word
 171    addresses, or similarly munged things, for certain types of
 172    pointers, so that assumption doesn't hold everywhere.
 173
 174    Common code should use extract_typed_address instead, or something
 175    else based on POINTER_TO_ADDRESS.  */
 176
 177 CORE_ADDR
 178 extract_address (void *addr, int len)
 179 {
 180   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
 181      whether we want this to be true eventually.  */
 182   return (CORE_ADDR) extract_unsigned_integer (addr, len);
 183 }
 184
 185
 186 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
 187    address it represents.  */
 188 CORE_ADDR
 189 extract_typed_address (void *buf, struct type *type)
 190 {
 191   if (TYPE_CODE (type) != TYPE_CODE_PTR
 192       && TYPE_CODE (type) != TYPE_CODE_REF)
 193     internal_error ("findvar.c (extract_typed_address): "
 194                     "type is not a pointer or reference");
 195
 196   return POINTER_TO_ADDRESS (type, buf);
 197 }
 198
 199
 200 void
 201 store_signed_integer (void *addr, int len, LONGEST val)
 202 {
 203   unsigned char *p;
 204   unsigned char *startaddr = (unsigned char *) addr;
 205   unsigned char *endaddr = startaddr + len;
 206
 207   /* Start at the least significant end of the integer, and work towards
 208      the most significant.  */
 209   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 210     {
 211       for (p = endaddr - 1; p >= startaddr; --p)
 212         {
 213           *p = val & 0xff;
 214           val >>= 8;
 215         }
 216     }
 217   else
 218     {
 219       for (p = startaddr; p < endaddr; ++p)
 220         {
 221           *p = val & 0xff;
 222           val >>= 8;
 223         }
 224     }
 225 }
 226
 227 void
 228 store_unsigned_integer (void *addr, int len, ULONGEST val)
 229 {
 230   unsigned char *p;
 231   unsigned char *startaddr = (unsigned char *) addr;
 232   unsigned char *endaddr = startaddr + len;
 233
 234   /* Start at the least significant end of the integer, and work towards
 235      the most significant.  */
 236   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 237     {
 238       for (p = endaddr - 1; p >= startaddr; --p)
 239         {
 240           *p = val & 0xff;
 241           val >>= 8;
 242         }
 243     }
 244   else
 245     {
 246       for (p = startaddr; p < endaddr; ++p)
 247         {
 248           *p = val & 0xff;
 249           val >>= 8;
 250         }
 251     }
 252 }
 253
 254 /* Store the address VAL as a LEN-byte value in target byte order at
 255    ADDR.  ADDR is a buffer in the GDB process, not in the inferior.
 256
 257    This function should only be used by target-specific code.  It
 258    assumes that a pointer has the same representation as that thing's
 259    address represented as an integer.  Some machines use word
 260    addresses, or similarly munged things, for certain types of
 261    pointers, so that assumption doesn't hold everywhere.
 262
 263    Common code should use store_typed_address instead, or something else
 264    based on ADDRESS_TO_POINTER.  */
 265 void
 266 store_address (void *addr, int len, LONGEST val)
 267 {
 268   store_unsigned_integer (addr, len, val);
 269 }
 270
 271
 272 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
 273    form.  */
 274 void
 275 store_typed_address (void *buf, struct type *type, CORE_ADDR addr)
 276 {
 277   if (TYPE_CODE (type) != TYPE_CODE_PTR
 278       && TYPE_CODE (type) != TYPE_CODE_REF)
 279     internal_error ("findvar.c (store_typed_address): "
 280                     "type is not a pointer or reference");
 281
 282   ADDRESS_TO_POINTER (type, buf, addr);
 283 }
 284
 285
 286
 287 \f
 288 /* Extract a floating-point number from a target-order byte-stream at ADDR.
 289    Returns the value as type DOUBLEST.
 290
 291    If the host and target formats agree, we just copy the raw data into the
 292    appropriate type of variable and return, letting the host increase precision
 293    as necessary.  Otherwise, we call the conversion routine and let it do the
 294    dirty work.  */
 295
 296 DOUBLEST
 297 extract_floating (void *addr, int len)
 298 {
 299   DOUBLEST dretval;
 300
 301   if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
 302     {
 303       if (HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT)
 304         {
 305           float retval;
 306
 307           memcpy (&retval, addr, sizeof (retval));
 308           return retval;
 309         }
 310       else
 311         floatformat_to_doublest (TARGET_FLOAT_FORMAT, addr, &dretval);
 312     }
 313   else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
 314     {
 315       if (HOST_DOUBLE_FORMAT == TARGET_DOUBLE_FORMAT)
 316         {
 317           double retval;
 318
 319           memcpy (&retval, addr, sizeof (retval));
 320           return retval;
 321         }
 322       else
 323         floatformat_to_doublest (TARGET_DOUBLE_FORMAT, addr, &dretval);
 324     }
 325   else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
 326     {
 327       if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
 328         {
 329           DOUBLEST retval;
 330
 331           memcpy (&retval, addr, sizeof (retval));
 332           return retval;
 333         }
 334       else
 335         floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT, addr, &dretval);
 336     }
 337   else
 338     {
 339       error ("Can't deal with a floating point number of %d bytes.", len);
 340     }
 341
 342   return dretval;
 343 }
 344
 345 void
 346 store_floating (void *addr, int len, DOUBLEST val)
 347 {
 348   if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
 349     {
 350       if (HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT)
 351         {
 352           float floatval = val;
 353
 354           memcpy (addr, &floatval, sizeof (floatval));
 355         }
 356       else
 357         floatformat_from_doublest (TARGET_FLOAT_FORMAT, &val, addr);
 358     }
 359   else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
 360     {
 361       if (HOST_DOUBLE_FORMAT == TARGET_DOUBLE_FORMAT)
 362         {
 363           double doubleval = val;
 364
 365           memcpy (addr, &doubleval, sizeof (doubleval));
 366         }
 367       else
 368         floatformat_from_doublest (TARGET_DOUBLE_FORMAT, &val, addr);
 369     }
 370   else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
 371     {
 372       if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
 373         memcpy (addr, &val, sizeof (val));
 374       else
 375         floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT, &val, addr);
 376     }
 377   else
 378     {
 379       error ("Can't deal with a floating point number of %d bytes.", len);
 380     }
 381 }
 382
 383 /* Return a `value' with the contents of register REGNUM
 384    in its virtual format, with the type specified by
 385    REGISTER_VIRTUAL_TYPE.
 386
 387    NOTE: returns NULL if register value is not available.
 388    Caller will check return value or die!  */
 389
 390 value_ptr
 391 value_of_register (int regnum)
 392 {
 393   CORE_ADDR addr;
 394   int optim;
 395   register value_ptr reg_val;
 396   char raw_buffer[MAX_REGISTER_RAW_SIZE];
 397   enum lval_type lval;
 398
 399   get_saved_register (raw_buffer, &optim, &addr,
 400                       selected_frame, regnum, &lval);
 401
 402   if (register_cached (regnum) < 0)
 403     return NULL;                /* register value not available */
 404
 405   reg_val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
 406
 407   /* Convert raw data to virtual format if necessary.  */
 408
 409   if (REGISTER_CONVERTIBLE (regnum))
 410     {
 411       REGISTER_CONVERT_TO_VIRTUAL (regnum, REGISTER_VIRTUAL_TYPE (regnum),
 412                                    raw_buffer, VALUE_CONTENTS_RAW (reg_val));
 413     }
 414   else if (REGISTER_RAW_SIZE (regnum) == REGISTER_VIRTUAL_SIZE (regnum))
 415     memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
 416             REGISTER_RAW_SIZE (regnum));
 417   else
 418     internal_error ("Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
 419                     REGISTER_NAME (regnum),
 420                     regnum,
 421                     REGISTER_RAW_SIZE (regnum),
 422                     REGISTER_VIRTUAL_SIZE (regnum));
 423   VALUE_LVAL (reg_val) = lval;
 424   VALUE_ADDRESS (reg_val) = addr;
 425   VALUE_REGNO (reg_val) = regnum;
 426   VALUE_OPTIMIZED_OUT (reg_val) = optim;
 427   return reg_val;
 428 }
 429
 430 /* Given a pointer of type TYPE in target form in BUF, return the
 431    address it represents.  */
 432 CORE_ADDR
 433 unsigned_pointer_to_address (struct type *type, void *buf)
 434 {
 435   return extract_address (buf, TYPE_LENGTH (type));
 436 }
 437
 438 CORE_ADDR
 439 signed_pointer_to_address (struct type *type, void *buf)
 440 {
 441   return extract_signed_integer (buf, TYPE_LENGTH (type));
 442 }
 443
 444 /* Given an address, store it as a pointer of type TYPE in target
 445    format in BUF.  */
 446 void
 447 unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
 448 {
 449   store_address (buf, TYPE_LENGTH (type), addr);
 450 }
 451
 452 void
 453 address_to_signed_pointer (struct type *type, void *buf, CORE_ADDR addr)
 454 {
 455   store_signed_integer (buf, TYPE_LENGTH (type), addr);
 456 }
 457 \f
 458 /* Will calling read_var_value or locate_var_value on SYM end
 459    up caring what frame it is being evaluated relative to?  SYM must
 460    be non-NULL.  */
 461 int
 462 symbol_read_needs_frame (struct symbol *sym)
 463 {
 464   switch (SYMBOL_CLASS (sym))
 465     {
 466       /* All cases listed explicitly so that gcc -Wall will detect it if
 467          we failed to consider one.  */
 468     case LOC_REGISTER:
 469     case LOC_ARG:
 470     case LOC_REF_ARG:
 471     case LOC_REGPARM:
 472     case LOC_REGPARM_ADDR:
 473     case LOC_LOCAL:
 474     case LOC_LOCAL_ARG:
 475     case LOC_BASEREG:
 476     case LOC_BASEREG_ARG:
 477     case LOC_THREAD_LOCAL_STATIC:
 478       return 1;
 479
 480     case LOC_UNDEF:
 481     case LOC_CONST:
 482     case LOC_STATIC:
 483     case LOC_INDIRECT:
 484     case LOC_TYPEDEF:
 485
 486     case LOC_LABEL:
 487       /* Getting the address of a label can be done independently of the block,
 488          even if some *uses* of that address wouldn't work so well without
 489          the right frame.  */
 490
 491     case LOC_BLOCK:
 492     case LOC_CONST_BYTES:
 493     case LOC_UNRESOLVED:
 494     case LOC_OPTIMIZED_OUT:
 495       return 0;
 496     }
 497   return 1;
 498 }
 499
 500 /* Given a struct symbol for a variable,
 501    and a stack frame id, read the value of the variable
 502    and return a (pointer to a) struct value containing the value.
 503    If the variable cannot be found, return a zero pointer.
 504    If FRAME is NULL, use the selected_frame.  */
 505
 506 value_ptr
 507 read_var_value (register struct symbol *var, struct frame_info *frame)
 508 {
 509   register value_ptr v;
 510   struct type *type = SYMBOL_TYPE (var);
 511   CORE_ADDR addr;
 512   register int len;
 513
 514   v = allocate_value (type);
 515   VALUE_LVAL (v) = lval_memory; /* The most likely possibility.  */
 516   VALUE_BFD_SECTION (v) = SYMBOL_BFD_SECTION (var);
 517
 518   len = TYPE_LENGTH (type);
 519
 520   if (frame == NULL)
 521     frame = selected_frame;
 522
 523   switch (SYMBOL_CLASS (var))
 524     {
 525     case LOC_CONST:
 526       /* Put the constant back in target format.  */
 527       store_signed_integer (VALUE_CONTENTS_RAW (v), len,
 528                             (LONGEST) SYMBOL_VALUE (var));
 529       VALUE_LVAL (v) = not_lval;
 530       return v;
 531
 532     case LOC_LABEL:
 533       /* Put the constant back in target format.  */
 534       if (overlay_debugging)
 535         {
 536           CORE_ADDR addr
 537             = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 538                                         SYMBOL_BFD_SECTION (var));
 539           store_typed_address (VALUE_CONTENTS_RAW (v), type, addr);
 540         }
 541       else
 542         store_typed_address (VALUE_CONTENTS_RAW (v), type,
 543                               SYMBOL_VALUE_ADDRESS (var));
 544       VALUE_LVAL (v) = not_lval;
 545       return v;
 546
 547     case LOC_CONST_BYTES:
 548       {
 549         char *bytes_addr;
 550         bytes_addr = SYMBOL_VALUE_BYTES (var);
 551         memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
 552         VALUE_LVAL (v) = not_lval;
 553         return v;
 554       }
 555
 556     case LOC_STATIC:
 557       if (overlay_debugging)
 558         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 559                                          SYMBOL_BFD_SECTION (var));
 560       else
 561         addr = SYMBOL_VALUE_ADDRESS (var);
 562       break;
 563
 564     case LOC_INDIRECT:
 565       /* The import slot does not have a real address in it from the
 566          dynamic loader (dld.sl on HP-UX), if the target hasn't begun
 567          execution yet, so check for that. */
 568       if (!target_has_execution)
 569         error ("\
 570 Attempt to access variable defined in different shared object or load module when\n\
 571 addresses have not been bound by the dynamic loader. Try again when executable is running.");
 572
 573       addr = SYMBOL_VALUE_ADDRESS (var);
 574       addr = read_memory_unsigned_integer
 575         (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
 576       break;
 577
 578     case LOC_ARG:
 579       if (frame == NULL)
 580         return 0;
 581       addr = FRAME_ARGS_ADDRESS (frame);
 582       if (!addr)
 583         return 0;
 584       addr += SYMBOL_VALUE (var);
 585       break;
 586
 587     case LOC_REF_ARG:
 588       if (frame == NULL)
 589         return 0;
 590       addr = FRAME_ARGS_ADDRESS (frame);
 591       if (!addr)
 592         return 0;
 593       addr += SYMBOL_VALUE (var);
 594       addr = read_memory_unsigned_integer
 595         (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
 596       break;
 597
 598     case LOC_LOCAL:
 599     case LOC_LOCAL_ARG:
 600       if (frame == NULL)
 601         return 0;
 602       addr = FRAME_LOCALS_ADDRESS (frame);
 603       addr += SYMBOL_VALUE (var);
 604       break;
 605
 606     case LOC_BASEREG:
 607     case LOC_BASEREG_ARG:
 608       {
 609         char buf[MAX_REGISTER_RAW_SIZE];
 610         get_saved_register (buf, NULL, NULL, frame, SYMBOL_BASEREG (var),
 611                             NULL);
 612         addr = extract_address (buf, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var)));
 613         addr += SYMBOL_VALUE (var);
 614         break;
 615       }
 616
 617     case LOC_THREAD_LOCAL_STATIC:
 618       {
 619         char buf[MAX_REGISTER_RAW_SIZE];
 620
 621         get_saved_register (buf, NULL, NULL, frame, SYMBOL_BASEREG (var),
 622                             NULL);
 623         addr = extract_address (buf, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var)));
 624         addr += SYMBOL_VALUE (var);
 625         break;
 626       }
 627
 628     case LOC_TYPEDEF:
 629       error ("Cannot look up value of a typedef");
 630       break;
 631
 632     case LOC_BLOCK:
 633       if (overlay_debugging)
 634         VALUE_ADDRESS (v) = symbol_overlayed_address
 635           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
 636       else
 637         VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 638       return v;
 639
 640     case LOC_REGISTER:
 641     case LOC_REGPARM:
 642     case LOC_REGPARM_ADDR:
 643       {
 644         struct block *b;
 645         int regno = SYMBOL_VALUE (var);
 646         value_ptr regval;
 647
 648         if (frame == NULL)
 649           return 0;
 650         b = get_frame_block (frame);
 651
 652         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 653           {
 654             regval = value_from_register (lookup_pointer_type (type),
 655                                           regno,
 656                                           frame);
 657
 658             if (regval == NULL)
 659               error ("Value of register variable not available.");
 660
 661             addr = value_as_pointer (regval);
 662             VALUE_LVAL (v) = lval_memory;
 663           }
 664         else
 665           {
 666             regval = value_from_register (type, regno, frame);
 667
 668             if (regval == NULL)
 669               error ("Value of register variable not available.");
 670             return regval;
 671           }
 672       }
 673       break;
 674
 675     case LOC_UNRESOLVED:
 676       {
 677         struct minimal_symbol *msym;
 678
 679         msym = lookup_minimal_symbol (SYMBOL_NAME (var), NULL, NULL);
 680         if (msym == NULL)
 681           return 0;
 682         if (overlay_debugging)
 683           addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
 684                                            SYMBOL_BFD_SECTION (msym));
 685         else
 686           addr = SYMBOL_VALUE_ADDRESS (msym);
 687       }
 688       break;
 689
 690     case LOC_OPTIMIZED_OUT:
 691       VALUE_LVAL (v) = not_lval;
 692       VALUE_OPTIMIZED_OUT (v) = 1;
 693       return v;
 694
 695     default:
 696       error ("Cannot look up value of a botched symbol.");
 697       break;
 698     }
 699
 700   VALUE_ADDRESS (v) = addr;
 701   VALUE_LAZY (v) = 1;
 702   return v;
 703 }
 704
 705 /* Return a value of type TYPE, stored in register REGNUM, in frame
 706    FRAME.
 707
 708    NOTE: returns NULL if register value is not available.
 709    Caller will check return value or die!  */
 710
 711 value_ptr
 712 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 713 {
 714   char raw_buffer[MAX_REGISTER_RAW_SIZE];
 715   CORE_ADDR addr;
 716   int optim;
 717   value_ptr v = allocate_value (type);
 718   char *value_bytes = 0;
 719   int value_bytes_copied = 0;
 720   int num_storage_locs;
 721   enum lval_type lval;
 722   int len;
 723
 724   CHECK_TYPEDEF (type);
 725   len = TYPE_LENGTH (type);
 726
 727   /* Pointers on D10V are really only 16 bits,
 728      but we lie to gdb elsewhere... */
 729   if (GDB_TARGET_IS_D10V && TYPE_CODE (type) == TYPE_CODE_PTR)
 730     len = 2;
 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 ("value_from_register: Value not stored anywhere!");
 878
 879       VALUE_OPTIMIZED_OUT (v) = optim;
 880
 881       /* Any structure stored in more than one register will always be
 882          an integral number of registers.  Otherwise, you'd need to do
 883          some fiddling with the last register copied here for little
 884          endian machines.  */
 885
 886       /* Copy into the contents section of the value.  */
 887       memcpy (VALUE_CONTENTS_RAW (v), value_bytes, len);
 888
 889       /* Finally do any conversion necessary when extracting this
 890          type from more than one register.  */
 891 #ifdef REGISTER_CONVERT_TO_TYPE
 892       REGISTER_CONVERT_TO_TYPE (regnum, type, VALUE_CONTENTS_RAW (v));
 893 #endif
 894       return v;
 895     }
 896
 897   /* Data is completely contained within a single register.  Locate the
 898      register's contents in a real register or in core;
 899      read the data in raw format.  */
 900
 901   get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
 902
 903   if (register_cached (regnum) == -1)
 904     return NULL;                /* register value not available */
 905
 906   VALUE_OPTIMIZED_OUT (v) = optim;
 907   VALUE_LVAL (v) = lval;
 908   VALUE_ADDRESS (v) = addr;
 909
 910   /* Convert raw data to virtual format if necessary.  */
 911
 912   if (REGISTER_CONVERTIBLE (regnum))
 913     {
 914       REGISTER_CONVERT_TO_VIRTUAL (regnum, type,
 915                                    raw_buffer, VALUE_CONTENTS_RAW (v));
 916     }
 917   else
 918     {
 919       /* Raw and virtual formats are the same for this register.  */
 920
 921       if (TARGET_BYTE_ORDER == BIG_ENDIAN && len < REGISTER_RAW_SIZE (regnum))
 922         {
 923           /* Big-endian, and we want less than full size.  */
 924           VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
 925         }
 926
 927       memcpy (VALUE_CONTENTS_RAW (v), raw_buffer + VALUE_OFFSET (v), len);
 928     }
 929
 930   if (GDB_TARGET_IS_D10V
 931       && TYPE_CODE (type) == TYPE_CODE_PTR)
 932     {
 933       unsigned long num;
 934       unsigned short snum;
 935
 936       snum = (unsigned short)
 937         extract_unsigned_integer (VALUE_CONTENTS_RAW (v), 2);
 938
 939       if (TYPE_TARGET_TYPE (type)         /* pointer to function */
 940           && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
 941         num = D10V_MAKE_IADDR (snum);
 942       else                                /* pointer to data */
 943         num = D10V_MAKE_DADDR (snum);
 944
 945       store_address (VALUE_CONTENTS_RAW (v), 4, num);
 946     }
 947
 948   return v;
 949 }
 950 \f
 951 /* Given a struct symbol for a variable or function,
 952    and a stack frame id,
 953    return a (pointer to a) struct value containing the properly typed
 954    address.  */
 955
 956 value_ptr
 957 locate_var_value (register struct symbol *var, struct frame_info *frame)
 958 {
 959   CORE_ADDR addr = 0;
 960   struct type *type = SYMBOL_TYPE (var);
 961   value_ptr lazy_value;
 962
 963   /* Evaluate it first; if the result is a memory address, we're fine.
 964      Lazy evaluation pays off here. */
 965
 966   lazy_value = read_var_value (var, frame);
 967   if (lazy_value == 0)
 968     error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
 969
 970   if (VALUE_LAZY (lazy_value)
 971       || TYPE_CODE (type) == TYPE_CODE_FUNC)
 972     {
 973       value_ptr val;
 974
 975       addr = VALUE_ADDRESS (lazy_value);
 976       val = value_from_pointer (lookup_pointer_type (type), addr);
 977       VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value);
 978       return val;
 979     }
 980
 981   /* Not a memory address; check what the problem was.  */
 982   switch (VALUE_LVAL (lazy_value))
 983     {
 984     case lval_register:
 985     case lval_reg_frame_relative:
 986       error ("Address requested for identifier \"%s\" which is in a register.",
 987              SYMBOL_SOURCE_NAME (var));
 988       break;
 989
 990     default:
 991       error ("Can't take address of \"%s\" which isn't an lvalue.",
 992              SYMBOL_SOURCE_NAME (var));
 993       break;
 994     }
 995   return 0;                     /* For lint -- never reached */
 996 }