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 ADDR as a pointer of type TYPE at BUF, in target
 256    form.  */
 257 void
 258 store_typed_address (void *buf, struct type *type, CORE_ADDR addr)
 259 {
 260   if (TYPE_CODE (type) != TYPE_CODE_PTR
 261       && TYPE_CODE (type) != TYPE_CODE_REF)
 262     internal_error (__FILE__, __LINE__,
 263                     "store_typed_address: "
 264                     "type is not a pointer or reference");
 265
 266   ADDRESS_TO_POINTER (type, buf, addr);
 267 }
 268
 269
 270
 271 /* Return a `value' with the contents of (virtual or cooked) register
 272    REGNUM as found in the specified FRAME.  The register's type is
 273    determined by register_type().
 274
 275    NOTE: returns NULL if register value is not available.  Caller will
 276    check return value or die!  */
 277
 278 struct value *
 279 value_of_register (int regnum, struct frame_info *frame)
 280 {
 281   CORE_ADDR addr;
 282   int optim;
 283   struct value *reg_val;
 284   int realnum;
 285   char raw_buffer[MAX_REGISTER_SIZE];
 286   enum lval_type lval;
 287
 288   /* Builtin registers lie completly outside of the range of normal
 289      registers.  Catch them early so that the target never sees them.  */
 290   if (regnum >= NUM_REGS + NUM_PSEUDO_REGS)
 291     return value_of_builtin_reg (regnum, frame);
 292
 293   frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
 294
 295   /* FIXME: cagney/2002-05-15: This test is just bogus.
 296
 297      It indicates that the target failed to supply a value for a
 298      register because it was "not available" at this time.  Problem
 299      is, the target still has the register and so get saved_register()
 300      may be returning a value saved on the stack.  */
 301
 302   if (register_cached (regnum) < 0)
 303     return NULL;                /* register value not available */
 304
 305   reg_val = allocate_value (register_type (current_gdbarch, regnum));
 306
 307   /* Convert raw data to virtual format if necessary.  */
 308
 309   if (REGISTER_CONVERTIBLE (regnum))
 310     {
 311       REGISTER_CONVERT_TO_VIRTUAL (regnum, register_type (current_gdbarch, regnum),
 312                                    raw_buffer, VALUE_CONTENTS_RAW (reg_val));
 313     }
 314   else if (REGISTER_RAW_SIZE (regnum) == REGISTER_VIRTUAL_SIZE (regnum))
 315     memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
 316             REGISTER_RAW_SIZE (regnum));
 317   else
 318     internal_error (__FILE__, __LINE__,
 319                     "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
 320                     REGISTER_NAME (regnum),
 321                     regnum,
 322                     REGISTER_RAW_SIZE (regnum),
 323                     REGISTER_VIRTUAL_SIZE (regnum));
 324   VALUE_LVAL (reg_val) = lval;
 325   VALUE_ADDRESS (reg_val) = addr;
 326   VALUE_REGNO (reg_val) = regnum;
 327   VALUE_OPTIMIZED_OUT (reg_val) = optim;
 328   return reg_val;
 329 }
 330
 331 /* Given a pointer of type TYPE in target form in BUF, return the
 332    address it represents.  */
 333 CORE_ADDR
 334 unsigned_pointer_to_address (struct type *type, const void *buf)
 335 {
 336   return extract_unsigned_integer (buf, TYPE_LENGTH (type));
 337 }
 338
 339 CORE_ADDR
 340 signed_pointer_to_address (struct type *type, const void *buf)
 341 {
 342   return extract_signed_integer (buf, TYPE_LENGTH (type));
 343 }
 344
 345 /* Given an address, store it as a pointer of type TYPE in target
 346    format in BUF.  */
 347 void
 348 unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
 349 {
 350   store_unsigned_integer (buf, TYPE_LENGTH (type), addr);
 351 }
 352
 353 void
 354 address_to_signed_pointer (struct type *type, void *buf, CORE_ADDR addr)
 355 {
 356   store_signed_integer (buf, TYPE_LENGTH (type), addr);
 357 }
 358 \f
 359 /* Will calling read_var_value or locate_var_value on SYM end
 360    up caring what frame it is being evaluated relative to?  SYM must
 361    be non-NULL.  */
 362 int
 363 symbol_read_needs_frame (struct symbol *sym)
 364 {
 365   switch (SYMBOL_CLASS (sym))
 366     {
 367       /* All cases listed explicitly so that gcc -Wall will detect it if
 368          we failed to consider one.  */
 369     case LOC_COMPUTED:
 370     case LOC_COMPUTED_ARG:
 371       {
 372         struct location_funcs *symfuncs = SYMBOL_LOCATION_FUNCS (sym);
 373         return (symfuncs->read_needs_frame) (sym);
 374       }
 375       break;
 376
 377     case LOC_REGISTER:
 378     case LOC_ARG:
 379     case LOC_REF_ARG:
 380     case LOC_REGPARM:
 381     case LOC_REGPARM_ADDR:
 382     case LOC_LOCAL:
 383     case LOC_LOCAL_ARG:
 384     case LOC_BASEREG:
 385     case LOC_BASEREG_ARG:
 386     case LOC_HP_THREAD_LOCAL_STATIC:
 387       return 1;
 388
 389     case LOC_UNDEF:
 390     case LOC_CONST:
 391     case LOC_STATIC:
 392     case LOC_INDIRECT:
 393     case LOC_TYPEDEF:
 394
 395     case LOC_LABEL:
 396       /* Getting the address of a label can be done independently of the block,
 397          even if some *uses* of that address wouldn't work so well without
 398          the right frame.  */
 399
 400     case LOC_BLOCK:
 401     case LOC_CONST_BYTES:
 402     case LOC_UNRESOLVED:
 403     case LOC_OPTIMIZED_OUT:
 404       return 0;
 405     }
 406   return 1;
 407 }
 408
 409 /* Given a struct symbol for a variable,
 410    and a stack frame id, read the value of the variable
 411    and return a (pointer to a) struct value containing the value.
 412    If the variable cannot be found, return a zero pointer.
 413    If FRAME is NULL, use the deprecated_selected_frame.  */
 414
 415 struct value *
 416 read_var_value (register struct symbol *var, struct frame_info *frame)
 417 {
 418   register struct value *v;
 419   struct type *type = SYMBOL_TYPE (var);
 420   CORE_ADDR addr;
 421   register int len;
 422
 423   v = allocate_value (type);
 424   VALUE_LVAL (v) = lval_memory; /* The most likely possibility.  */
 425   VALUE_BFD_SECTION (v) = SYMBOL_BFD_SECTION (var);
 426
 427   len = TYPE_LENGTH (type);
 428
 429   if (frame == NULL)
 430     frame = deprecated_selected_frame;
 431
 432   switch (SYMBOL_CLASS (var))
 433     {
 434     case LOC_CONST:
 435       /* Put the constant back in target format.  */
 436       store_signed_integer (VALUE_CONTENTS_RAW (v), len,
 437                             (LONGEST) SYMBOL_VALUE (var));
 438       VALUE_LVAL (v) = not_lval;
 439       return v;
 440
 441     case LOC_LABEL:
 442       /* Put the constant back in target format.  */
 443       if (overlay_debugging)
 444         {
 445           CORE_ADDR addr
 446             = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 447                                         SYMBOL_BFD_SECTION (var));
 448           store_typed_address (VALUE_CONTENTS_RAW (v), type, addr);
 449         }
 450       else
 451         store_typed_address (VALUE_CONTENTS_RAW (v), type,
 452                               SYMBOL_VALUE_ADDRESS (var));
 453       VALUE_LVAL (v) = not_lval;
 454       return v;
 455
 456     case LOC_CONST_BYTES:
 457       {
 458         char *bytes_addr;
 459         bytes_addr = SYMBOL_VALUE_BYTES (var);
 460         memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
 461         VALUE_LVAL (v) = not_lval;
 462         return v;
 463       }
 464
 465     case LOC_STATIC:
 466       if (overlay_debugging)
 467         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 468                                          SYMBOL_BFD_SECTION (var));
 469       else
 470         addr = SYMBOL_VALUE_ADDRESS (var);
 471       break;
 472
 473     case LOC_INDIRECT:
 474       {
 475         /* The import slot does not have a real address in it from the
 476            dynamic loader (dld.sl on HP-UX), if the target hasn't
 477            begun execution yet, so check for that. */
 478         CORE_ADDR locaddr;
 479         struct value *loc;
 480         if (!target_has_execution)
 481           error ("\
 482 Attempt to access variable defined in different shared object or load module when\n\
 483 addresses have not been bound by the dynamic loader. Try again when executable is running.");
 484
 485         locaddr = SYMBOL_VALUE_ADDRESS (var);
 486         loc = value_at (lookup_pointer_type (type), locaddr, NULL);
 487         addr = value_as_address (loc);
 488       }
 489
 490     case LOC_ARG:
 491       if (frame == NULL)
 492         return 0;
 493       addr = get_frame_args_address (frame);
 494       if (!addr)
 495         return 0;
 496       addr += SYMBOL_VALUE (var);
 497       break;
 498
 499     case LOC_REF_ARG:
 500       {
 501         struct value *ref;
 502         CORE_ADDR argref;
 503         if (frame == NULL)
 504           return 0;
 505         argref = get_frame_args_address (frame);
 506         if (!argref)
 507           return 0;
 508         argref += SYMBOL_VALUE (var);
 509         ref = value_at (lookup_pointer_type (type), argref, NULL);
 510         addr = value_as_address (ref);
 511         break;
 512       }
 513
 514     case LOC_LOCAL:
 515     case LOC_LOCAL_ARG:
 516       if (frame == NULL)
 517         return 0;
 518       addr = get_frame_locals_address (frame);
 519       addr += SYMBOL_VALUE (var);
 520       break;
 521
 522     case LOC_BASEREG:
 523     case LOC_BASEREG_ARG:
 524     case LOC_HP_THREAD_LOCAL_STATIC:
 525       {
 526         struct value *regval;
 527
 528         regval = value_from_register (lookup_pointer_type (type),
 529                                       SYMBOL_BASEREG (var), frame);
 530         if (regval == NULL)
 531           error ("Value of base register not available.");
 532         addr = value_as_address (regval);
 533         addr += SYMBOL_VALUE (var);
 534         break;
 535       }
 536
 537     case LOC_THREAD_LOCAL_STATIC:
 538       {
 539         if (target_get_thread_local_address_p ())
 540           addr = target_get_thread_local_address (inferior_ptid,
 541                                                   SYMBOL_OBJFILE (var),
 542                                                   SYMBOL_VALUE_ADDRESS (var));
 543         /* It wouldn't be wrong here to try a gdbarch method, too;
 544            finding TLS is an ABI-specific thing.  But we don't do that
 545            yet.  */
 546         else
 547           error ("Cannot find thread-local variables on this target");
 548         break;
 549       }
 550
 551     case LOC_TYPEDEF:
 552       error ("Cannot look up value of a typedef");
 553       break;
 554
 555     case LOC_BLOCK:
 556       if (overlay_debugging)
 557         VALUE_ADDRESS (v) = symbol_overlayed_address
 558           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
 559       else
 560         VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 561       return v;
 562
 563     case LOC_REGISTER:
 564     case LOC_REGPARM:
 565     case LOC_REGPARM_ADDR:
 566       {
 567         struct block *b;
 568         int regno = SYMBOL_VALUE (var);
 569         struct value *regval;
 570
 571         if (frame == NULL)
 572           return 0;
 573         b = get_frame_block (frame, 0);
 574
 575         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 576           {
 577             regval = value_from_register (lookup_pointer_type (type),
 578                                           regno,
 579                                           frame);
 580
 581             if (regval == NULL)
 582               error ("Value of register variable not available.");
 583
 584             addr = value_as_address (regval);
 585             VALUE_LVAL (v) = lval_memory;
 586           }
 587         else
 588           {
 589             regval = value_from_register (type, regno, frame);
 590
 591             if (regval == NULL)
 592               error ("Value of register variable not available.");
 593             return regval;
 594           }
 595       }
 596       break;
 597
 598     case LOC_COMPUTED:
 599     case LOC_COMPUTED_ARG:
 600       {
 601         struct location_funcs *funcs = SYMBOL_LOCATION_FUNCS (var);
 602
 603         if (frame == 0 && (funcs->read_needs_frame) (var))
 604           return 0;
 605         return (funcs->read_variable) (var, frame);
 606
 607       }
 608       break;
 609
 610     case LOC_UNRESOLVED:
 611       {
 612         struct minimal_symbol *msym;
 613
 614         msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (var), NULL, NULL);
 615         if (msym == NULL)
 616           return 0;
 617         if (overlay_debugging)
 618           addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
 619                                            SYMBOL_BFD_SECTION (msym));
 620         else
 621           addr = SYMBOL_VALUE_ADDRESS (msym);
 622       }
 623       break;
 624
 625     case LOC_OPTIMIZED_OUT:
 626       VALUE_LVAL (v) = not_lval;
 627       VALUE_OPTIMIZED_OUT (v) = 1;
 628       return v;
 629
 630     default:
 631       error ("Cannot look up value of a botched symbol.");
 632       break;
 633     }
 634
 635   VALUE_ADDRESS (v) = addr;
 636   VALUE_LAZY (v) = 1;
 637   return v;
 638 }
 639
 640 /* Return a value of type TYPE, stored in register REGNUM, in frame
 641    FRAME.
 642
 643    NOTE: returns NULL if register value is not available.
 644    Caller will check return value or die!  */
 645
 646 struct value *
 647 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 648 {
 649   char raw_buffer[MAX_REGISTER_SIZE];
 650   CORE_ADDR addr;
 651   int optim;
 652   struct value *v = allocate_value (type);
 653   char *value_bytes = 0;
 654   int value_bytes_copied = 0;
 655   int num_storage_locs;
 656   enum lval_type lval;
 657   int len;
 658
 659   CHECK_TYPEDEF (type);
 660   len = TYPE_LENGTH (type);
 661
 662   VALUE_REGNO (v) = regnum;
 663
 664   num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
 665                       ((len - 1) / REGISTER_RAW_SIZE (regnum)) + 1 :
 666                       1);
 667
 668   if (num_storage_locs > 1
 669 #if 0
 670       // OBSOLETE #ifdef GDB_TARGET_IS_H8500
 671       // OBSOLETE       || TYPE_CODE (type) == TYPE_CODE_PTR
 672       // OBSOLETE #endif
 673 #endif
 674     )
 675     {
 676       /* Value spread across multiple storage locations.  */
 677
 678       int local_regnum;
 679       int mem_stor = 0, reg_stor = 0;
 680       int mem_tracking = 1;
 681       CORE_ADDR last_addr = 0;
 682       CORE_ADDR first_addr = 0;
 683
 684       value_bytes = (char *) alloca (len + MAX_REGISTER_SIZE);
 685
 686       /* Copy all of the data out, whereever it may be.  */
 687
 688 #if 0
 689       // OBSOLETE #ifdef GDB_TARGET_IS_H8500
 690       // OBSOLETE /* This piece of hideosity is required because the H8500 treats registers
 691       // OBSOLETE    differently depending upon whether they are used as pointers or not.  As a
 692       // OBSOLETE    pointer, a register needs to have a page register tacked onto the front.
 693       // OBSOLETE    An alternate way to do this would be to have gcc output different register
 694       // OBSOLETE    numbers for the pointer & non-pointer form of the register.  But, it
 695       // OBSOLETE    doesn't, so we're stuck with this.  */
 696       // OBSOLETE
 697       // OBSOLETE       if (TYPE_CODE (type) == TYPE_CODE_PTR
 698       // OBSOLETE         && len > 2)
 699       // OBSOLETE       {
 700       // OBSOLETE         int page_regnum;
 701       // OBSOLETE
 702       // OBSOLETE         switch (regnum)
 703       // OBSOLETE           {
 704       // OBSOLETE           case R0_REGNUM:
 705       // OBSOLETE           case R1_REGNUM:
 706       // OBSOLETE           case R2_REGNUM:
 707       // OBSOLETE           case R3_REGNUM:
 708       // OBSOLETE             page_regnum = SEG_D_REGNUM;
 709       // OBSOLETE             break;
 710       // OBSOLETE           case R4_REGNUM:
 711       // OBSOLETE           case R5_REGNUM:
 712       // OBSOLETE             page_regnum = SEG_E_REGNUM;
 713       // OBSOLETE             break;
 714       // OBSOLETE           case R6_REGNUM:
 715       // OBSOLETE           case R7_REGNUM:
 716       // OBSOLETE             page_regnum = SEG_T_REGNUM;
 717       // OBSOLETE             break;
 718       // OBSOLETE           }
 719       // OBSOLETE
 720       // OBSOLETE         value_bytes[0] = 0;
 721       // OBSOLETE         get_saved_register (value_bytes + 1,
 722       // OBSOLETE                             &optim,
 723       // OBSOLETE                             &addr,
 724       // OBSOLETE                             frame,
 725       // OBSOLETE                             page_regnum,
 726       // OBSOLETE                             &lval);
 727       // OBSOLETE
 728       // OBSOLETE         if (register_cached (page_regnum) == -1)
 729       // OBSOLETE           return NULL;        /* register value not available */
 730       // OBSOLETE
 731       // OBSOLETE         if (lval == lval_register)
 732       // OBSOLETE           reg_stor++;
 733       // OBSOLETE         else
 734       // OBSOLETE           mem_stor++;
 735       // OBSOLETE         first_addr = addr;
 736       // OBSOLETE         last_addr = addr;
 737       // OBSOLETE
 738       // OBSOLETE         get_saved_register (value_bytes + 2,
 739       // OBSOLETE                             &optim,
 740       // OBSOLETE                             &addr,
 741       // OBSOLETE                             frame,
 742       // OBSOLETE                             regnum,
 743       // OBSOLETE                             &lval);
 744       // OBSOLETE
 745       // OBSOLETE         if (register_cached (regnum) == -1)
 746       // OBSOLETE           return NULL;        /* register value not available */
 747       // OBSOLETE
 748       // OBSOLETE         if (lval == lval_register)
 749       // OBSOLETE           reg_stor++;
 750       // OBSOLETE         else
 751       // OBSOLETE           {
 752       // OBSOLETE             mem_stor++;
 753       // OBSOLETE             mem_tracking = mem_tracking && (addr == last_addr);
 754       // OBSOLETE           }
 755       // OBSOLETE         last_addr = addr;
 756       // OBSOLETE       }
 757       // OBSOLETE       else
 758       // OBSOLETE #endif /* GDB_TARGET_IS_H8500 */
 759 #endif
 760         for (local_regnum = regnum;
 761              value_bytes_copied < len;
 762              (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
 763               ++local_regnum))
 764           {
 765             int realnum;
 766             frame_register (frame, local_regnum, &optim, &lval, &addr,
 767                             &realnum, value_bytes + value_bytes_copied);
 768
 769             if (register_cached (local_regnum) == -1)
 770               return NULL;      /* register value not available */
 771
 772             if (regnum == local_regnum)
 773               first_addr = addr;
 774             if (lval == lval_register)
 775               reg_stor++;
 776             else
 777               {
 778                 mem_stor++;
 779
 780                 mem_tracking =
 781                   (mem_tracking
 782                    && (regnum == local_regnum
 783                        || addr == last_addr));
 784               }
 785             last_addr = addr;
 786           }
 787
 788       if ((reg_stor && mem_stor)
 789           || (mem_stor && !mem_tracking))
 790         /* Mixed storage; all of the hassle we just went through was
 791            for some good purpose.  */
 792         {
 793           VALUE_LVAL (v) = lval_reg_frame_relative;
 794           VALUE_FRAME (v) = get_frame_base (frame);
 795           VALUE_FRAME_REGNUM (v) = regnum;
 796         }
 797       else if (mem_stor)
 798         {
 799           VALUE_LVAL (v) = lval_memory;
 800           VALUE_ADDRESS (v) = first_addr;
 801         }
 802       else if (reg_stor)
 803         {
 804           VALUE_LVAL (v) = lval_register;
 805           VALUE_ADDRESS (v) = first_addr;
 806         }
 807       else
 808         internal_error (__FILE__, __LINE__,
 809                         "value_from_register: Value not stored anywhere!");
 810
 811       VALUE_OPTIMIZED_OUT (v) = optim;
 812
 813       /* Any structure stored in more than one register will always be
 814          an integral number of registers.  Otherwise, you'd need to do
 815          some fiddling with the last register copied here for little
 816          endian machines.  */
 817
 818       /* Copy into the contents section of the value.  */
 819       memcpy (VALUE_CONTENTS_RAW (v), value_bytes, len);
 820
 821       /* Finally do any conversion necessary when extracting this
 822          type from more than one register.  */
 823 #ifdef REGISTER_CONVERT_TO_TYPE
 824       REGISTER_CONVERT_TO_TYPE (regnum, type, VALUE_CONTENTS_RAW (v));
 825 #endif
 826       return v;
 827     }
 828
 829   /* Data is completely contained within a single register.  Locate the
 830      register's contents in a real register or in core;
 831      read the data in raw format.  */
 832
 833   {
 834     int realnum;
 835     frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
 836   }
 837
 838   if (register_cached (regnum) == -1)
 839     return NULL;                /* register value not available */
 840
 841   VALUE_OPTIMIZED_OUT (v) = optim;
 842   VALUE_LVAL (v) = lval;
 843   VALUE_ADDRESS (v) = addr;
 844
 845   /* Convert the raw register to the corresponding data value's memory
 846      format, if necessary.  */
 847
 848   if (CONVERT_REGISTER_P (regnum))
 849     {
 850       REGISTER_TO_VALUE (regnum, type, raw_buffer, VALUE_CONTENTS_RAW (v));
 851     }
 852   else
 853     {
 854       /* Raw and virtual formats are the same for this register.  */
 855
 856       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG && len < REGISTER_RAW_SIZE (regnum))
 857         {
 858           /* Big-endian, and we want less than full size.  */
 859           VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
 860         }
 861
 862       memcpy (VALUE_CONTENTS_RAW (v), raw_buffer + VALUE_OFFSET (v), len);
 863     }
 864
 865   return v;
 866 }
 867 \f
 868 /* Given a struct symbol for a variable or function,
 869    and a stack frame id,
 870    return a (pointer to a) struct value containing the properly typed
 871    address.  */
 872
 873 struct value *
 874 locate_var_value (register struct symbol *var, struct frame_info *frame)
 875 {
 876   CORE_ADDR addr = 0;
 877   struct type *type = SYMBOL_TYPE (var);
 878   struct value *lazy_value;
 879
 880   /* Evaluate it first; if the result is a memory address, we're fine.
 881      Lazy evaluation pays off here. */
 882
 883   lazy_value = read_var_value (var, frame);
 884   if (lazy_value == 0)
 885     error ("Address of \"%s\" is unknown.", SYMBOL_PRINT_NAME (var));
 886
 887   if (VALUE_LAZY (lazy_value)
 888       || TYPE_CODE (type) == TYPE_CODE_FUNC)
 889     {
 890       struct value *val;
 891
 892       addr = VALUE_ADDRESS (lazy_value);
 893       val = value_from_pointer (lookup_pointer_type (type), addr);
 894       VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value);
 895       return val;
 896     }
 897
 898   /* Not a memory address; check what the problem was.  */
 899   switch (VALUE_LVAL (lazy_value))
 900     {
 901     case lval_register:
 902         gdb_assert (REGISTER_NAME (VALUE_REGNO (lazy_value)) != NULL
 903                     && *REGISTER_NAME (VALUE_REGNO (lazy_value)) != '\0');
 904       error("Address requested for identifier "
 905             "\"%s\" which is in register $%s",
 906             SYMBOL_PRINT_NAME (var),
 907             REGISTER_NAME (VALUE_REGNO (lazy_value)));
 908       break;
 909
 910     case lval_reg_frame_relative:
 911         gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != NULL
 912                     && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != '\0');
 913       error("Address requested for identifier "
 914             "\"%s\" which is in frame register $%s",
 915             SYMBOL_PRINT_NAME (var),
 916             REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)));
 917       break;
 918
 919     default:
 920       error ("Can't take address of \"%s\" which isn't an lvalue.",
 921              SYMBOL_PRINT_NAME (var));
 922       break;
 923     }
 924   return 0;                     /* For lint -- never reached */
 925 }