gdb/findvar.c

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