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