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
  39 /* Basic byte-swapping routines.  GDB has needed these for a long time...
  40    All extract a target-format integer at ADDR which is LEN bytes long.  */
  41
  42 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
  43   /* 8 bit characters are a pretty safe assumption these days, so we
  44      assume it throughout all these swapping routines.  If we had to deal with
  45      9 bit characters, we would need to make len be in bits and would have
  46      to re-write these routines...  */
  47 you lose
  48 #endif
  49
  50 LONGEST
  51 extract_signed_integer (const void *addr, int len)
  52 {
  53   LONGEST retval;
  54   const unsigned char *p;
  55   const unsigned char *startaddr = addr;
  56   const unsigned char *endaddr = startaddr + len;
  57
  58   if (len > (int) sizeof (LONGEST))
  59     error ("\
  60 That operation is not available on integers of more than %d bytes.",
  61            (int) sizeof (LONGEST));
  62
  63   /* Start at the most significant end of the integer, and work towards
  64      the least significant.  */
  65   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
  66     {
  67       p = startaddr;
  68       /* Do the sign extension once at the start.  */
  69       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  70       for (++p; p < endaddr; ++p)
  71         retval = (retval << 8) | *p;
  72     }
  73   else
  74     {
  75       p = endaddr - 1;
  76       /* Do the sign extension once at the start.  */
  77       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  78       for (--p; p >= startaddr; --p)
  79         retval = (retval << 8) | *p;
  80     }
  81   return retval;
  82 }
  83
  84 ULONGEST
  85 extract_unsigned_integer (const void *addr, int len)
  86 {
  87   ULONGEST retval;
  88   const unsigned char *p;
  89   const unsigned char *startaddr = addr;
  90   const unsigned char *endaddr = startaddr + len;
  91
  92   if (len > (int) sizeof (ULONGEST))
  93     error ("\
  94 That operation is not available on integers of more than %d bytes.",
  95            (int) sizeof (ULONGEST));
  96
  97   /* Start at the most significant end of the integer, and work towards
  98      the least significant.  */
  99   retval = 0;
 100   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 101     {
 102       for (p = startaddr; p < endaddr; ++p)
 103         retval = (retval << 8) | *p;
 104     }
 105   else
 106     {
 107       for (p = endaddr - 1; p >= startaddr; --p)
 108         retval = (retval << 8) | *p;
 109     }
 110   return retval;
 111 }
 112
 113 /* Sometimes a long long unsigned integer can be extracted as a
 114    LONGEST value.  This is done so that we can print these values
 115    better.  If this integer can be converted to a LONGEST, this
 116    function returns 1 and sets *PVAL.  Otherwise it returns 0.  */
 117
 118 int
 119 extract_long_unsigned_integer (const void *addr, int orig_len, LONGEST *pval)
 120 {
 121   char *p, *first_addr;
 122   int len;
 123
 124   len = orig_len;
 125   if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
 126     {
 127       for (p = (char *) addr;
 128            len > (int) sizeof (LONGEST) && p < (char *) addr + orig_len;
 129            p++)
 130         {
 131           if (*p == 0)
 132             len--;
 133           else
 134             break;
 135         }
 136       first_addr = p;
 137     }
 138   else
 139     {
 140       first_addr = (char *) addr;
 141       for (p = (char *) addr + orig_len - 1;
 142            len > (int) sizeof (LONGEST) && p >= (char *) addr;
 143            p--)
 144         {
 145           if (*p == 0)
 146             len--;
 147           else
 148             break;
 149         }
 150     }
 151
 152   if (len <= (int) sizeof (LONGEST))
 153     {
 154       *pval = (LONGEST) extract_unsigned_integer (first_addr,
 155                                                   sizeof (LONGEST));
 156       return 1;
 157     }
 158
 159   return 0;
 160 }
 161
 162
 163 /* Treat the LEN bytes at ADDR as a target-format address, and return
 164    that address.  ADDR is a buffer in the GDB process, not in the
 165    inferior.
 166
 167    This function should only be used by target-specific code.  It
 168    assumes that a pointer has the same representation as that thing's
 169    address represented as an integer.  Some machines use word
 170    addresses, or similarly munged things, for certain types of
 171    pointers, so that assumption doesn't hold everywhere.
 172
 173    Common code should use extract_typed_address instead, or something
 174    else based on POINTER_TO_ADDRESS.  */
 175
 176 CORE_ADDR
 177 extract_address (const void *addr, int len)
 178 {
 179   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
 180      whether we want this to be true eventually.  */
 181   return (CORE_ADDR) extract_unsigned_integer (addr, len);
 182 }
 183
 184
 185 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
 186    address it represents.  */
 187 CORE_ADDR
 188 extract_typed_address (const void *buf, struct type *type)
 189 {
 190   if (TYPE_CODE (type) != TYPE_CODE_PTR
 191       && TYPE_CODE (type) != TYPE_CODE_REF)
 192     internal_error (__FILE__, __LINE__,
 193                     "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 == BFD_ENDIAN_BIG)
 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 == BFD_ENDIAN_BIG)
 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 (__FILE__, __LINE__,
 280                     "store_typed_address: "
 281                     "type is not a pointer or reference");
 282
 283   ADDRESS_TO_POINTER (type, buf, addr);
 284 }
 285
 286
 287
 288 /* Return a `value' with the contents of (virtual or cooked) register
 289    REGNUM as found in the specified FRAME.  The register's type is
 290    determined by REGISTER_VIRTUAL_TYPE.
 291
 292    NOTE: returns NULL if register value is not available.  Caller will
 293    check return value or die!  */
 294
 295 struct value *
 296 value_of_register (int regnum, struct frame_info *frame)
 297 {
 298   CORE_ADDR addr;
 299   int optim;
 300   struct value *reg_val;
 301   char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
 302   enum lval_type lval;
 303
 304   /* Builtin registers lie completly outside of the range of normal
 305      registers.  Catch them early so that the target never sees them.  */
 306   if (regnum >= NUM_REGS + NUM_PSEUDO_REGS)
 307     return value_of_builtin_reg (regnum, deprecated_selected_frame);
 308
 309   get_saved_register (raw_buffer, &optim, &addr,
 310                       frame, regnum, &lval);
 311
 312   /* FIXME: cagney/2002-05-15: This test is just bogus.
 313
 314      It indicates that the target failed to supply a value for a
 315      register because it was "not available" at this time.  Problem
 316      is, the target still has the register and so get saved_register()
 317      may be returning a value saved on the stack.  */
 318
 319   if (register_cached (regnum) < 0)
 320     return NULL;                /* register value not available */
 321
 322   reg_val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
 323
 324   /* Convert raw data to virtual format if necessary.  */
 325
 326   if (REGISTER_CONVERTIBLE (regnum))
 327     {
 328       REGISTER_CONVERT_TO_VIRTUAL (regnum, REGISTER_VIRTUAL_TYPE (regnum),
 329                                    raw_buffer, VALUE_CONTENTS_RAW (reg_val));
 330     }
 331   else if (REGISTER_RAW_SIZE (regnum) == REGISTER_VIRTUAL_SIZE (regnum))
 332     memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
 333             REGISTER_RAW_SIZE (regnum));
 334   else
 335     internal_error (__FILE__, __LINE__,
 336                     "Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
 337                     REGISTER_NAME (regnum),
 338                     regnum,
 339                     REGISTER_RAW_SIZE (regnum),
 340                     REGISTER_VIRTUAL_SIZE (regnum));
 341   VALUE_LVAL (reg_val) = lval;
 342   VALUE_ADDRESS (reg_val) = addr;
 343   VALUE_REGNO (reg_val) = regnum;
 344   VALUE_OPTIMIZED_OUT (reg_val) = optim;
 345   return reg_val;
 346 }
 347
 348 /* Given a pointer of type TYPE in target form in BUF, return the
 349    address it represents.  */
 350 CORE_ADDR
 351 unsigned_pointer_to_address (struct type *type, const void *buf)
 352 {
 353   return extract_address (buf, TYPE_LENGTH (type));
 354 }
 355
 356 CORE_ADDR
 357 signed_pointer_to_address (struct type *type, const void *buf)
 358 {
 359   return extract_signed_integer (buf, TYPE_LENGTH (type));
 360 }
 361
 362 /* Given an address, store it as a pointer of type TYPE in target
 363    format in BUF.  */
 364 void
 365 unsigned_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
 366 {
 367   store_address (buf, TYPE_LENGTH (type), addr);
 368 }
 369
 370 void
 371 address_to_signed_pointer (struct type *type, void *buf, CORE_ADDR addr)
 372 {
 373   store_signed_integer (buf, TYPE_LENGTH (type), addr);
 374 }
 375 \f
 376 /* Will calling read_var_value or locate_var_value on SYM end
 377    up caring what frame it is being evaluated relative to?  SYM must
 378    be non-NULL.  */
 379 int
 380 symbol_read_needs_frame (struct symbol *sym)
 381 {
 382   switch (SYMBOL_CLASS (sym))
 383     {
 384       /* All cases listed explicitly so that gcc -Wall will detect it if
 385          we failed to consider one.  */
 386     case LOC_REGISTER:
 387     case LOC_ARG:
 388     case LOC_REF_ARG:
 389     case LOC_REGPARM:
 390     case LOC_REGPARM_ADDR:
 391     case LOC_LOCAL:
 392     case LOC_LOCAL_ARG:
 393     case LOC_BASEREG:
 394     case LOC_BASEREG_ARG:
 395     case LOC_HP_THREAD_LOCAL_STATIC:
 396       return 1;
 397
 398     case LOC_UNDEF:
 399     case LOC_CONST:
 400     case LOC_STATIC:
 401     case LOC_INDIRECT:
 402     case LOC_TYPEDEF:
 403
 404     case LOC_LABEL:
 405       /* Getting the address of a label can be done independently of the block,
 406          even if some *uses* of that address wouldn't work so well without
 407          the right frame.  */
 408
 409     case LOC_BLOCK:
 410     case LOC_CONST_BYTES:
 411     case LOC_UNRESOLVED:
 412     case LOC_OPTIMIZED_OUT:
 413       return 0;
 414     }
 415   return 1;
 416 }
 417
 418 /* Given a struct symbol for a variable,
 419    and a stack frame id, read the value of the variable
 420    and return a (pointer to a) struct value containing the value.
 421    If the variable cannot be found, return a zero pointer.
 422    If FRAME is NULL, use the deprecated_selected_frame.  */
 423
 424 struct value *
 425 read_var_value (register struct symbol *var, struct frame_info *frame)
 426 {
 427   register struct value *v;
 428   struct type *type = SYMBOL_TYPE (var);
 429   CORE_ADDR addr;
 430   register int len;
 431
 432   v = allocate_value (type);
 433   VALUE_LVAL (v) = lval_memory; /* The most likely possibility.  */
 434   VALUE_BFD_SECTION (v) = SYMBOL_BFD_SECTION (var);
 435
 436   len = TYPE_LENGTH (type);
 437
 438   if (frame == NULL)
 439     frame = deprecated_selected_frame;
 440
 441   switch (SYMBOL_CLASS (var))
 442     {
 443     case LOC_CONST:
 444       /* Put the constant back in target format.  */
 445       store_signed_integer (VALUE_CONTENTS_RAW (v), len,
 446                             (LONGEST) SYMBOL_VALUE (var));
 447       VALUE_LVAL (v) = not_lval;
 448       return v;
 449
 450     case LOC_LABEL:
 451       /* Put the constant back in target format.  */
 452       if (overlay_debugging)
 453         {
 454           CORE_ADDR addr
 455             = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 456                                         SYMBOL_BFD_SECTION (var));
 457           store_typed_address (VALUE_CONTENTS_RAW (v), type, addr);
 458         }
 459       else
 460         store_typed_address (VALUE_CONTENTS_RAW (v), type,
 461                               SYMBOL_VALUE_ADDRESS (var));
 462       VALUE_LVAL (v) = not_lval;
 463       return v;
 464
 465     case LOC_CONST_BYTES:
 466       {
 467         char *bytes_addr;
 468         bytes_addr = SYMBOL_VALUE_BYTES (var);
 469         memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
 470         VALUE_LVAL (v) = not_lval;
 471         return v;
 472       }
 473
 474     case LOC_STATIC:
 475       if (overlay_debugging)
 476         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 477                                          SYMBOL_BFD_SECTION (var));
 478       else
 479         addr = SYMBOL_VALUE_ADDRESS (var);
 480       break;
 481
 482     case LOC_INDIRECT:
 483       {
 484         /* The import slot does not have a real address in it from the
 485            dynamic loader (dld.sl on HP-UX), if the target hasn't
 486            begun execution yet, so check for that. */
 487         CORE_ADDR locaddr;
 488         struct value *loc;
 489         if (!target_has_execution)
 490           error ("\
 491 Attempt to access variable defined in different shared object or load module when\n\
 492 addresses have not been bound by the dynamic loader. Try again when executable is running.");
 493
 494         locaddr = SYMBOL_VALUE_ADDRESS (var);
 495         loc = value_at (lookup_pointer_type (type), locaddr, NULL);
 496         addr = value_as_address (loc);
 497       }
 498
 499     case LOC_ARG:
 500       if (frame == NULL)
 501         return 0;
 502       addr = FRAME_ARGS_ADDRESS (frame);
 503       if (!addr)
 504         return 0;
 505       addr += SYMBOL_VALUE (var);
 506       break;
 507
 508     case LOC_REF_ARG:
 509       {
 510         struct value *ref;
 511         CORE_ADDR argref;
 512         if (frame == NULL)
 513           return 0;
 514         argref = FRAME_ARGS_ADDRESS (frame);
 515         if (!argref)
 516           return 0;
 517         argref += SYMBOL_VALUE (var);
 518         ref = value_at (lookup_pointer_type (type), argref, NULL);
 519         addr = value_as_address (ref);
 520         break;
 521       }
 522
 523     case LOC_LOCAL:
 524     case LOC_LOCAL_ARG:
 525       if (frame == NULL)
 526         return 0;
 527       addr = FRAME_LOCALS_ADDRESS (frame);
 528       addr += SYMBOL_VALUE (var);
 529       break;
 530
 531     case LOC_BASEREG:
 532     case LOC_BASEREG_ARG:
 533     case LOC_HP_THREAD_LOCAL_STATIC:
 534       {
 535         struct value *regval;
 536
 537         regval = value_from_register (lookup_pointer_type (type),
 538                                       SYMBOL_BASEREG (var), frame);
 539         if (regval == NULL)
 540           error ("Value of base register not available.");
 541         addr = value_as_address (regval);
 542         addr += SYMBOL_VALUE (var);
 543         break;
 544       }
 545
 546     case LOC_THREAD_LOCAL_STATIC:
 547       {
 548         if (target_get_thread_local_address_p ())
 549           addr = target_get_thread_local_address (inferior_ptid,
 550                                                   SYMBOL_OBJFILE (var),
 551                                                   SYMBOL_VALUE_ADDRESS (var));
 552         /* It wouldn't be wrong here to try a gdbarch method, too;
 553            finding TLS is an ABI-specific thing.  But we don't do that
 554            yet.  */
 555         else
 556           error ("Cannot find thread-local variables on this target");
 557         break;
 558       }
 559
 560     case LOC_TYPEDEF:
 561       error ("Cannot look up value of a typedef");
 562       break;
 563
 564     case LOC_BLOCK:
 565       if (overlay_debugging)
 566         VALUE_ADDRESS (v) = symbol_overlayed_address
 567           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
 568       else
 569         VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 570       return v;
 571
 572     case LOC_REGISTER:
 573     case LOC_REGPARM:
 574     case LOC_REGPARM_ADDR:
 575       {
 576         struct block *b;
 577         int regno = SYMBOL_VALUE (var);
 578         struct value *regval;
 579
 580         if (frame == NULL)
 581           return 0;
 582         b = get_frame_block (frame, 0);
 583
 584         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 585           {
 586             regval = value_from_register (lookup_pointer_type (type),
 587                                           regno,
 588                                           frame);
 589
 590             if (regval == NULL)
 591               error ("Value of register variable not available.");
 592
 593             addr = value_as_address (regval);
 594             VALUE_LVAL (v) = lval_memory;
 595           }
 596         else
 597           {
 598             regval = value_from_register (type, regno, frame);
 599
 600             if (regval == NULL)
 601               error ("Value of register variable not available.");
 602             return regval;
 603           }
 604       }
 605       break;
 606
 607     case LOC_UNRESOLVED:
 608       {
 609         struct minimal_symbol *msym;
 610
 611         msym = lookup_minimal_symbol (SYMBOL_NAME (var), NULL, NULL);
 612         if (msym == NULL)
 613           return 0;
 614         if (overlay_debugging)
 615           addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
 616                                            SYMBOL_BFD_SECTION (msym));
 617         else
 618           addr = SYMBOL_VALUE_ADDRESS (msym);
 619       }
 620       break;
 621
 622     case LOC_OPTIMIZED_OUT:
 623       VALUE_LVAL (v) = not_lval;
 624       VALUE_OPTIMIZED_OUT (v) = 1;
 625       return v;
 626
 627     default:
 628       error ("Cannot look up value of a botched symbol.");
 629       break;
 630     }
 631
 632   VALUE_ADDRESS (v) = addr;
 633   VALUE_LAZY (v) = 1;
 634   return v;
 635 }
 636
 637 /* Return a value of type TYPE, stored in register REGNUM, in frame
 638    FRAME.
 639
 640    NOTE: returns NULL if register value is not available.
 641    Caller will check return value or die!  */
 642
 643 struct value *
 644 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 645 {
 646   char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
 647   CORE_ADDR addr;
 648   int optim;
 649   struct value *v = allocate_value (type);
 650   char *value_bytes = 0;
 651   int value_bytes_copied = 0;
 652   int num_storage_locs;
 653   enum lval_type lval;
 654   int len;
 655
 656   CHECK_TYPEDEF (type);
 657   len = TYPE_LENGTH (type);
 658
 659   VALUE_REGNO (v) = regnum;
 660
 661   num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
 662                       ((len - 1) / REGISTER_RAW_SIZE (regnum)) + 1 :
 663                       1);
 664
 665   if (num_storage_locs > 1
 666 #if 0
 667       // OBSOLETE #ifdef GDB_TARGET_IS_H8500
 668       // OBSOLETE       || TYPE_CODE (type) == TYPE_CODE_PTR
 669       // OBSOLETE #endif
 670 #endif
 671     )
 672     {
 673       /* Value spread across multiple storage locations.  */
 674
 675       int local_regnum;
 676       int mem_stor = 0, reg_stor = 0;
 677       int mem_tracking = 1;
 678       CORE_ADDR last_addr = 0;
 679       CORE_ADDR first_addr = 0;
 680
 681       value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE);
 682
 683       /* Copy all of the data out, whereever it may be.  */
 684
 685 #if 0
 686       // OBSOLETE #ifdef GDB_TARGET_IS_H8500
 687       // OBSOLETE /* This piece of hideosity is required because the H8500 treats registers
 688       // OBSOLETE    differently depending upon whether they are used as pointers or not.  As a
 689       // OBSOLETE    pointer, a register needs to have a page register tacked onto the front.
 690       // OBSOLETE    An alternate way to do this would be to have gcc output different register
 691       // OBSOLETE    numbers for the pointer & non-pointer form of the register.  But, it
 692       // OBSOLETE    doesn't, so we're stuck with this.  */
 693       // OBSOLETE
 694       // OBSOLETE       if (TYPE_CODE (type) == TYPE_CODE_PTR
 695       // OBSOLETE         && len > 2)
 696       // OBSOLETE       {
 697       // OBSOLETE         int page_regnum;
 698       // OBSOLETE
 699       // OBSOLETE         switch (regnum)
 700       // OBSOLETE           {
 701       // OBSOLETE           case R0_REGNUM:
 702       // OBSOLETE           case R1_REGNUM:
 703       // OBSOLETE           case R2_REGNUM:
 704       // OBSOLETE           case R3_REGNUM:
 705       // OBSOLETE             page_regnum = SEG_D_REGNUM;
 706       // OBSOLETE             break;
 707       // OBSOLETE           case R4_REGNUM:
 708       // OBSOLETE           case R5_REGNUM:
 709       // OBSOLETE             page_regnum = SEG_E_REGNUM;
 710       // OBSOLETE             break;
 711       // OBSOLETE           case R6_REGNUM:
 712       // OBSOLETE           case R7_REGNUM:
 713       // OBSOLETE             page_regnum = SEG_T_REGNUM;
 714       // OBSOLETE             break;
 715       // OBSOLETE           }
 716       // OBSOLETE
 717       // OBSOLETE         value_bytes[0] = 0;
 718       // OBSOLETE         get_saved_register (value_bytes + 1,
 719       // OBSOLETE                             &optim,
 720       // OBSOLETE                             &addr,
 721       // OBSOLETE                             frame,
 722       // OBSOLETE                             page_regnum,
 723       // OBSOLETE                             &lval);
 724       // OBSOLETE
 725       // OBSOLETE         if (register_cached (page_regnum) == -1)
 726       // OBSOLETE           return NULL;        /* register value not available */
 727       // OBSOLETE
 728       // OBSOLETE         if (lval == lval_register)
 729       // OBSOLETE           reg_stor++;
 730       // OBSOLETE         else
 731       // OBSOLETE           mem_stor++;
 732       // OBSOLETE         first_addr = addr;
 733       // OBSOLETE         last_addr = addr;
 734       // OBSOLETE
 735       // OBSOLETE         get_saved_register (value_bytes + 2,
 736       // OBSOLETE                             &optim,
 737       // OBSOLETE                             &addr,
 738       // OBSOLETE                             frame,
 739       // OBSOLETE                             regnum,
 740       // OBSOLETE                             &lval);
 741       // OBSOLETE
 742       // OBSOLETE         if (register_cached (regnum) == -1)
 743       // OBSOLETE           return NULL;        /* register value not available */
 744       // OBSOLETE
 745       // OBSOLETE         if (lval == lval_register)
 746       // OBSOLETE           reg_stor++;
 747       // OBSOLETE         else
 748       // OBSOLETE           {
 749       // OBSOLETE             mem_stor++;
 750       // OBSOLETE             mem_tracking = mem_tracking && (addr == last_addr);
 751       // OBSOLETE           }
 752       // OBSOLETE         last_addr = addr;
 753       // OBSOLETE       }
 754       // OBSOLETE       else
 755       // OBSOLETE #endif /* GDB_TARGET_IS_H8500 */
 756 #endif
 757         for (local_regnum = regnum;
 758              value_bytes_copied < len;
 759              (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
 760               ++local_regnum))
 761           {
 762             get_saved_register (value_bytes + value_bytes_copied,
 763                                 &optim,
 764                                 &addr,
 765                                 frame,
 766                                 local_regnum,
 767                                 &lval);
 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   get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
 834
 835   if (register_cached (regnum) == -1)
 836     return NULL;                /* register value not available */
 837
 838   VALUE_OPTIMIZED_OUT (v) = optim;
 839   VALUE_LVAL (v) = lval;
 840   VALUE_ADDRESS (v) = addr;
 841
 842   /* Convert the raw register to the corresponding data value's memory
 843      format, if necessary.  */
 844
 845   if (CONVERT_REGISTER_P (regnum))
 846     {
 847       REGISTER_TO_VALUE (regnum, type, raw_buffer, VALUE_CONTENTS_RAW (v));
 848     }
 849   else
 850     {
 851       /* Raw and virtual formats are the same for this register.  */
 852
 853       if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG && len < REGISTER_RAW_SIZE (regnum))
 854         {
 855           /* Big-endian, and we want less than full size.  */
 856           VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
 857         }
 858
 859       memcpy (VALUE_CONTENTS_RAW (v), raw_buffer + VALUE_OFFSET (v), len);
 860     }
 861
 862   return v;
 863 }
 864 \f
 865 /* Given a struct symbol for a variable or function,
 866    and a stack frame id,
 867    return a (pointer to a) struct value containing the properly typed
 868    address.  */
 869
 870 struct value *
 871 locate_var_value (register struct symbol *var, struct frame_info *frame)
 872 {
 873   CORE_ADDR addr = 0;
 874   struct type *type = SYMBOL_TYPE (var);
 875   struct value *lazy_value;
 876
 877   /* Evaluate it first; if the result is a memory address, we're fine.
 878      Lazy evaluation pays off here. */
 879
 880   lazy_value = read_var_value (var, frame);
 881   if (lazy_value == 0)
 882     error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
 883
 884   if (VALUE_LAZY (lazy_value)
 885       || TYPE_CODE (type) == TYPE_CODE_FUNC)
 886     {
 887       struct value *val;
 888
 889       addr = VALUE_ADDRESS (lazy_value);
 890       val = value_from_pointer (lookup_pointer_type (type), addr);
 891       VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value);
 892       return val;
 893     }
 894
 895   /* Not a memory address; check what the problem was.  */
 896   switch (VALUE_LVAL (lazy_value))
 897     {
 898     case lval_register:
 899         gdb_assert (REGISTER_NAME (VALUE_REGNO (lazy_value)) != NULL
 900                     && *REGISTER_NAME (VALUE_REGNO (lazy_value)) != '\0');
 901       error("Address requested for identifier "
 902             "\"%s\" which is in register $%s",
 903             SYMBOL_SOURCE_NAME (var),
 904             REGISTER_NAME (VALUE_REGNO (lazy_value)));
 905       break;
 906
 907     case lval_reg_frame_relative:
 908         gdb_assert (REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != NULL
 909                     && *REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)) != '\0');
 910       error("Address requested for identifier "
 911             "\"%s\" which is in frame register $%s",
 912             SYMBOL_SOURCE_NAME (var),
 913             REGISTER_NAME (VALUE_FRAME_REGNUM (lazy_value)));
 914       break;
 915
 916     default:
 917       error ("Can't take address of \"%s\" which isn't an lvalue.",
 918              SYMBOL_SOURCE_NAME (var));
 919       break;
 920     }
 921   return 0;                     /* For lint -- never reached */
 922 }