gdb/findvar.c

   1 /* Find a variable's value in memory, for GDB, the GNU debugger.
   2    Copyright 1986, 87, 89, 91, 94, 95, 96, 1998
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "frame.h"
  26 #include "value.h"
  27 #include "gdbcore.h"
  28 #include "inferior.h"
  29 #include "target.h"
  30 #include "gdb_string.h"
  31 #include "floatformat.h"
  32 #include "symfile.h"            /* for overlay functions */
  33
  34 /* This is used to indicate that we don't know the format of the floating point
  35    number.  Typically, this is useful for native ports, where the actual format
  36    is irrelevant, since no conversions will be taking place.  */
  37
  38 const struct floatformat floatformat_unknown;
  39
  40 /* Registers we shouldn't try to store.  */
  41 #if !defined (CANNOT_STORE_REGISTER)
  42 #define CANNOT_STORE_REGISTER(regno) 0
  43 #endif
  44
  45 static void write_register_gen PARAMS ((int, char *));
  46
  47 static int read_relative_register_raw_bytes_for_frame PARAMS ((int regnum, char *myaddr, struct frame_info * frame));
  48
  49 /* Basic byte-swapping routines.  GDB has needed these for a long time...
  50    All extract a target-format integer at ADDR which is LEN bytes long.  */
  51
  52 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
  53   /* 8 bit characters are a pretty safe assumption these days, so we
  54      assume it throughout all these swapping routines.  If we had to deal with
  55      9 bit characters, we would need to make len be in bits and would have
  56      to re-write these routines...  */
  57 you lose
  58 #endif
  59
  60 LONGEST
  61 extract_signed_integer (void *addr, int len)
  62 {
  63   LONGEST retval;
  64   unsigned char *p;
  65   unsigned char *startaddr = (unsigned char *) addr;
  66   unsigned char *endaddr = startaddr + len;
  67
  68   if (len > (int) sizeof (LONGEST))
  69     error ("\
  70 That operation is not available on integers of more than %d bytes.",
  71            sizeof (LONGEST));
  72
  73   /* Start at the most significant end of the integer, and work towards
  74      the least significant.  */
  75   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
  76     {
  77       p = startaddr;
  78       /* Do the sign extension once at the start.  */
  79       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  80       for (++p; p < endaddr; ++p)
  81         retval = (retval << 8) | *p;
  82     }
  83   else
  84     {
  85       p = endaddr - 1;
  86       /* Do the sign extension once at the start.  */
  87       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  88       for (--p; p >= startaddr; --p)
  89         retval = (retval << 8) | *p;
  90     }
  91   return retval;
  92 }
  93
  94 ULONGEST
  95 extract_unsigned_integer (void *addr, int len)
  96 {
  97   ULONGEST retval;
  98   unsigned char *p;
  99   unsigned char *startaddr = (unsigned char *) addr;
 100   unsigned char *endaddr = startaddr + len;
 101
 102   if (len > (int) sizeof (ULONGEST))
 103     error ("\
 104 That operation is not available on integers of more than %d bytes.",
 105            sizeof (ULONGEST));
 106
 107   /* Start at the most significant end of the integer, and work towards
 108      the least significant.  */
 109   retval = 0;
 110   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 111     {
 112       for (p = startaddr; p < endaddr; ++p)
 113         retval = (retval << 8) | *p;
 114     }
 115   else
 116     {
 117       for (p = endaddr - 1; p >= startaddr; --p)
 118         retval = (retval << 8) | *p;
 119     }
 120   return retval;
 121 }
 122
 123 /* Sometimes a long long unsigned integer can be extracted as a
 124    LONGEST value.  This is done so that we can print these values
 125    better.  If this integer can be converted to a LONGEST, this
 126    function returns 1 and sets *PVAL.  Otherwise it returns 0.  */
 127
 128 int
 129 extract_long_unsigned_integer (void *addr, int orig_len, LONGEST *pval)
 130 {
 131   char *p, *first_addr;
 132   int len;
 133
 134   len = orig_len;
 135   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 136     {
 137       for (p = (char *) addr;
 138            len > (int) sizeof (LONGEST) && p < (char *) addr + orig_len;
 139            p++)
 140         {
 141           if (*p == 0)
 142             len--;
 143           else
 144             break;
 145         }
 146       first_addr = p;
 147     }
 148   else
 149     {
 150       first_addr = (char *) addr;
 151       for (p = (char *) addr + orig_len - 1;
 152            len > (int) sizeof (LONGEST) && p >= (char *) addr;
 153            p--)
 154         {
 155           if (*p == 0)
 156             len--;
 157           else
 158             break;
 159         }
 160     }
 161
 162   if (len <= (int) sizeof (LONGEST))
 163     {
 164       *pval = (LONGEST) extract_unsigned_integer (first_addr,
 165                                                   sizeof (LONGEST));
 166       return 1;
 167     }
 168
 169   return 0;
 170 }
 171
 172 CORE_ADDR
 173 extract_address (void *addr, int len)
 174 {
 175   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
 176      whether we want this to be true eventually.  */
 177   return (CORE_ADDR) extract_unsigned_integer (addr, len);
 178 }
 179
 180 void
 181 store_signed_integer (void *addr, int len, LONGEST val)
 182 {
 183   unsigned char *p;
 184   unsigned char *startaddr = (unsigned char *) addr;
 185   unsigned char *endaddr = startaddr + len;
 186
 187   /* Start at the least significant end of the integer, and work towards
 188      the most significant.  */
 189   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 190     {
 191       for (p = endaddr - 1; p >= startaddr; --p)
 192         {
 193           *p = val & 0xff;
 194           val >>= 8;
 195         }
 196     }
 197   else
 198     {
 199       for (p = startaddr; p < endaddr; ++p)
 200         {
 201           *p = val & 0xff;
 202           val >>= 8;
 203         }
 204     }
 205 }
 206
 207 void
 208 store_unsigned_integer (void *addr, int len, ULONGEST val)
 209 {
 210   unsigned char *p;
 211   unsigned char *startaddr = (unsigned char *) addr;
 212   unsigned char *endaddr = startaddr + len;
 213
 214   /* Start at the least significant end of the integer, and work towards
 215      the most significant.  */
 216   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
 217     {
 218       for (p = endaddr - 1; p >= startaddr; --p)
 219         {
 220           *p = val & 0xff;
 221           val >>= 8;
 222         }
 223     }
 224   else
 225     {
 226       for (p = startaddr; p < endaddr; ++p)
 227         {
 228           *p = val & 0xff;
 229           val >>= 8;
 230         }
 231     }
 232 }
 233
 234 /* Store the literal address "val" into
 235    gdb-local memory pointed to by "addr"
 236    for "len" bytes. */
 237 void
 238 store_address (void *addr, int len, LONGEST val)
 239 {
 240   store_unsigned_integer (addr, len, val);
 241 }
 242 \f
 243 /* Extract a floating-point number from a target-order byte-stream at ADDR.
 244    Returns the value as type DOUBLEST.
 245
 246    If the host and target formats agree, we just copy the raw data into the
 247    appropriate type of variable and return, letting the host increase precision
 248    as necessary.  Otherwise, we call the conversion routine and let it do the
 249    dirty work.  */
 250
 251 DOUBLEST
 252 extract_floating (void *addr, int len)
 253 {
 254   DOUBLEST dretval;
 255
 256   if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
 257     {
 258       if (HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT)
 259         {
 260           float retval;
 261
 262           memcpy (&retval, addr, sizeof (retval));
 263           return retval;
 264         }
 265       else
 266         floatformat_to_doublest (TARGET_FLOAT_FORMAT, addr, &dretval);
 267     }
 268   else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
 269     {
 270       if (HOST_DOUBLE_FORMAT == TARGET_DOUBLE_FORMAT)
 271         {
 272           double retval;
 273
 274           memcpy (&retval, addr, sizeof (retval));
 275           return retval;
 276         }
 277       else
 278         floatformat_to_doublest (TARGET_DOUBLE_FORMAT, addr, &dretval);
 279     }
 280   else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
 281     {
 282       if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
 283         {
 284           DOUBLEST retval;
 285
 286           memcpy (&retval, addr, sizeof (retval));
 287           return retval;
 288         }
 289       else
 290         floatformat_to_doublest (TARGET_LONG_DOUBLE_FORMAT, addr, &dretval);
 291     }
 292 #ifdef TARGET_EXTRACT_FLOATING
 293   else if (TARGET_EXTRACT_FLOATING (addr, len, &dretval))
 294     return dretval;
 295 #endif
 296   else
 297     {
 298       error ("Can't deal with a floating point number of %d bytes.", len);
 299     }
 300
 301   return dretval;
 302 }
 303
 304 void
 305 store_floating (void *addr, int len, DOUBLEST val)
 306 {
 307   if (len * TARGET_CHAR_BIT == TARGET_FLOAT_BIT)
 308     {
 309       if (HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT)
 310         {
 311           float floatval = val;
 312
 313           memcpy (addr, &floatval, sizeof (floatval));
 314         }
 315       else
 316         floatformat_from_doublest (TARGET_FLOAT_FORMAT, &val, addr);
 317     }
 318   else if (len * TARGET_CHAR_BIT == TARGET_DOUBLE_BIT)
 319     {
 320       if (HOST_DOUBLE_FORMAT == TARGET_DOUBLE_FORMAT)
 321         {
 322           double doubleval = val;
 323
 324           memcpy (addr, &doubleval, sizeof (doubleval));
 325         }
 326       else
 327         floatformat_from_doublest (TARGET_DOUBLE_FORMAT, &val, addr);
 328     }
 329   else if (len * TARGET_CHAR_BIT == TARGET_LONG_DOUBLE_BIT)
 330     {
 331       if (HOST_LONG_DOUBLE_FORMAT == TARGET_LONG_DOUBLE_FORMAT)
 332         memcpy (addr, &val, sizeof (val));
 333       else
 334         floatformat_from_doublest (TARGET_LONG_DOUBLE_FORMAT, &val, addr);
 335     }
 336 #ifdef TARGET_STORE_FLOATING
 337   else if (TARGET_STORE_FLOATING (addr, len, val))
 338     return;
 339 #endif
 340   else
 341     {
 342       error ("Can't deal with a floating point number of %d bytes.", len);
 343     }
 344 }
 345 \f
 346
 347 /* Return the address in which frame FRAME's value of register REGNUM
 348    has been saved in memory.  Or return zero if it has not been saved.
 349    If REGNUM specifies the SP, the value we return is actually
 350    the SP value, not an address where it was saved.  */
 351
 352 CORE_ADDR
 353 find_saved_register (frame, regnum)
 354      struct frame_info *frame;
 355      int regnum;
 356 {
 357   register struct frame_info *frame1 = NULL;
 358   register CORE_ADDR addr = 0;
 359
 360   if (frame == NULL)            /* No regs saved if want current frame */
 361     return 0;
 362
 363 #ifdef HAVE_REGISTER_WINDOWS
 364   /* We assume that a register in a register window will only be saved
 365      in one place (since the name changes and/or disappears as you go
 366      towards inner frames), so we only call get_frame_saved_regs on
 367      the current frame.  This is directly in contradiction to the
 368      usage below, which assumes that registers used in a frame must be
 369      saved in a lower (more interior) frame.  This change is a result
 370      of working on a register window machine; get_frame_saved_regs
 371      always returns the registers saved within a frame, within the
 372      context (register namespace) of that frame. */
 373
 374   /* However, note that we don't want this to return anything if
 375      nothing is saved (if there's a frame inside of this one).  Also,
 376      callers to this routine asking for the stack pointer want the
 377      stack pointer saved for *this* frame; this is returned from the
 378      next frame.  */
 379
 380   if (REGISTER_IN_WINDOW_P (regnum))
 381     {
 382       frame1 = get_next_frame (frame);
 383       if (!frame1)
 384         return 0;               /* Registers of this frame are active.  */
 385
 386       /* Get the SP from the next frame in; it will be this
 387          current frame.  */
 388       if (regnum != SP_REGNUM)
 389         frame1 = frame;
 390
 391       FRAME_INIT_SAVED_REGS (frame1);
 392       return frame1->saved_regs[regnum];        /* ... which might be zero */
 393     }
 394 #endif /* HAVE_REGISTER_WINDOWS */
 395
 396   /* Note that this next routine assumes that registers used in
 397      frame x will be saved only in the frame that x calls and
 398      frames interior to it.  This is not true on the sparc, but the
 399      above macro takes care of it, so we should be all right. */
 400   while (1)
 401     {
 402       QUIT;
 403       frame1 = get_prev_frame (frame1);
 404       if (frame1 == 0 || frame1 == frame)
 405         break;
 406       FRAME_INIT_SAVED_REGS (frame1);
 407       if (frame1->saved_regs[regnum])
 408         addr = frame1->saved_regs[regnum];
 409     }
 410
 411   return addr;
 412 }
 413
 414 /* Find register number REGNUM relative to FRAME and put its (raw,
 415    target format) contents in *RAW_BUFFER.  Set *OPTIMIZED if the
 416    variable was optimized out (and thus can't be fetched).  Set *LVAL
 417    to lval_memory, lval_register, or not_lval, depending on whether
 418    the value was fetched from memory, from a register, or in a strange
 419    and non-modifiable way (e.g. a frame pointer which was calculated
 420    rather than fetched).  Set *ADDRP to the address, either in memory
 421    on as a REGISTER_BYTE offset into the registers array.
 422
 423    Note that this implementation never sets *LVAL to not_lval.  But
 424    it can be replaced by defining GET_SAVED_REGISTER and supplying
 425    your own.
 426
 427    The argument RAW_BUFFER must point to aligned memory.  */
 428
 429 void
 430 default_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 431      char *raw_buffer;
 432      int *optimized;
 433      CORE_ADDR *addrp;
 434      struct frame_info *frame;
 435      int regnum;
 436      enum lval_type *lval;
 437 {
 438   CORE_ADDR addr;
 439
 440   if (!target_has_registers)
 441     error ("No registers.");
 442
 443   /* Normal systems don't optimize out things with register numbers.  */
 444   if (optimized != NULL)
 445     *optimized = 0;
 446   addr = find_saved_register (frame, regnum);
 447   if (addr != 0)
 448     {
 449       if (lval != NULL)
 450         *lval = lval_memory;
 451       if (regnum == SP_REGNUM)
 452         {
 453           if (raw_buffer != NULL)
 454             {
 455               /* Put it back in target format.  */
 456               store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), (LONGEST) addr);
 457             }
 458           if (addrp != NULL)
 459             *addrp = 0;
 460           return;
 461         }
 462       if (raw_buffer != NULL)
 463         read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
 464     }
 465   else
 466     {
 467       if (lval != NULL)
 468         *lval = lval_register;
 469       addr = REGISTER_BYTE (regnum);
 470       if (raw_buffer != NULL)
 471         read_register_gen (regnum, raw_buffer);
 472     }
 473   if (addrp != NULL)
 474     *addrp = addr;
 475 }
 476
 477 #if !defined (GET_SAVED_REGISTER)
 478 #define GET_SAVED_REGISTER(raw_buffer, optimized, addrp, frame, regnum, lval) \
 479   default_get_saved_register(raw_buffer, optimized, addrp, frame, regnum, lval)
 480 #endif
 481 void
 482 get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 483      char *raw_buffer;
 484      int *optimized;
 485      CORE_ADDR *addrp;
 486      struct frame_info *frame;
 487      int regnum;
 488      enum lval_type *lval;
 489 {
 490   GET_SAVED_REGISTER (raw_buffer, optimized, addrp, frame, regnum, lval);
 491 }
 492
 493 /* Copy the bytes of register REGNUM, relative to the input stack frame,
 494    into our memory at MYADDR, in target byte order.
 495    The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
 496
 497    Returns 1 if could not be read, 0 if could.  */
 498
 499 static int
 500 read_relative_register_raw_bytes_for_frame (regnum, myaddr, frame)
 501      int regnum;
 502      char *myaddr;
 503      struct frame_info *frame;
 504 {
 505   int optim;
 506   if (regnum == FP_REGNUM && frame)
 507     {
 508       /* Put it back in target format. */
 509       store_address (myaddr, REGISTER_RAW_SIZE (FP_REGNUM),
 510                      (LONGEST) FRAME_FP (frame));
 511
 512       return 0;
 513     }
 514
 515   get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, frame,
 516                       regnum, (enum lval_type *) NULL);
 517
 518   if (register_valid[regnum] < 0)
 519     return 1;                   /* register value not available */
 520
 521   return optim;
 522 }
 523
 524 /* Copy the bytes of register REGNUM, relative to the current stack frame,
 525    into our memory at MYADDR, in target byte order.
 526    The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
 527
 528    Returns 1 if could not be read, 0 if could.  */
 529
 530 int
 531 read_relative_register_raw_bytes (regnum, myaddr)
 532      int regnum;
 533      char *myaddr;
 534 {
 535   return read_relative_register_raw_bytes_for_frame (regnum, myaddr,
 536                                                      selected_frame);
 537 }
 538
 539 /* Return a `value' with the contents of register REGNUM
 540    in its virtual format, with the type specified by
 541    REGISTER_VIRTUAL_TYPE.
 542
 543    NOTE: returns NULL if register value is not available.
 544    Caller will check return value or die!  */
 545
 546 value_ptr
 547 value_of_register (regnum)
 548      int regnum;
 549 {
 550   CORE_ADDR addr;
 551   int optim;
 552   register value_ptr reg_val;
 553   char raw_buffer[MAX_REGISTER_RAW_SIZE];
 554   enum lval_type lval;
 555
 556   get_saved_register (raw_buffer, &optim, &addr,
 557                       selected_frame, regnum, &lval);
 558
 559   if (register_valid[regnum] < 0)
 560     return NULL;                /* register value not available */
 561
 562   reg_val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
 563
 564   /* Convert raw data to virtual format if necessary.  */
 565
 566   if (REGISTER_CONVERTIBLE (regnum))
 567     {
 568       REGISTER_CONVERT_TO_VIRTUAL (regnum, REGISTER_VIRTUAL_TYPE (regnum),
 569                                    raw_buffer, VALUE_CONTENTS_RAW (reg_val));
 570     }
 571   else if (REGISTER_RAW_SIZE (regnum) == REGISTER_VIRTUAL_SIZE (regnum))
 572     memcpy (VALUE_CONTENTS_RAW (reg_val), raw_buffer,
 573             REGISTER_RAW_SIZE (regnum));
 574   else
 575     internal_error ("Register \"%s\" (%d) has conflicting raw (%d) and virtual (%d) size",
 576                     REGISTER_NAME (regnum),
 577                     regnum,
 578                     REGISTER_RAW_SIZE (regnum),
 579                     REGISTER_VIRTUAL_SIZE (regnum));
 580   VALUE_LVAL (reg_val) = lval;
 581   VALUE_ADDRESS (reg_val) = addr;
 582   VALUE_REGNO (reg_val) = regnum;
 583   VALUE_OPTIMIZED_OUT (reg_val) = optim;
 584   return reg_val;
 585 }
 586 \f
 587 /* Low level examining and depositing of registers.
 588
 589    The caller is responsible for making
 590    sure that the inferior is stopped before calling the fetching routines,
 591    or it will get garbage.  (a change from GDB version 3, in which
 592    the caller got the value from the last stop).  */
 593
 594 /* Contents and state of the registers (in target byte order). */
 595
 596 char *registers;
 597
 598 /* VALID_REGISTER is non-zero if it has been fetched, -1 if the
 599    register value was not available. */
 600
 601 signed char *register_valid;
 602
 603 /* The thread/process associated with the current set of registers.  For now,
 604    -1 is special, and means `no current process'.  */
 605 int registers_pid = -1;
 606
 607 /* Indicate that registers may have changed, so invalidate the cache.  */
 608
 609 void
 610 registers_changed ()
 611 {
 612   int i;
 613   int numregs = ARCH_NUM_REGS;
 614
 615   registers_pid = -1;
 616
 617   /* Force cleanup of any alloca areas if using C alloca instead of
 618      a builtin alloca.  This particular call is used to clean up
 619      areas allocated by low level target code which may build up
 620      during lengthy interactions between gdb and the target before
 621      gdb gives control to the user (ie watchpoints).  */
 622   alloca (0);
 623
 624   for (i = 0; i < numregs; i++)
 625     register_valid[i] = 0;
 626
 627   if (registers_changed_hook)
 628     registers_changed_hook ();
 629 }
 630
 631 /* Indicate that all registers have been fetched, so mark them all valid.  */
 632 void
 633 registers_fetched ()
 634 {
 635   int i;
 636   int numregs = ARCH_NUM_REGS;
 637   for (i = 0; i < numregs; i++)
 638     register_valid[i] = 1;
 639 }
 640
 641 /* read_register_bytes and write_register_bytes are generally a *BAD*
 642    idea.  They are inefficient because they need to check for partial
 643    updates, which can only be done by scanning through all of the
 644    registers and seeing if the bytes that are being read/written fall
 645    inside of an invalid register.  [The main reason this is necessary
 646    is that register sizes can vary, so a simple index won't suffice.]
 647    It is far better to call read_register_gen and write_register_gen
 648    if you want to get at the raw register contents, as it only takes a
 649    regno as an argument, and therefore can't do a partial register
 650    update.
 651
 652    Prior to the recent fixes to check for partial updates, both read
 653    and write_register_bytes always checked to see if any registers
 654    were stale, and then called target_fetch_registers (-1) to update
 655    the whole set.  This caused really slowed things down for remote
 656    targets.  */
 657
 658 /* Copy INLEN bytes of consecutive data from registers
 659    starting with the INREGBYTE'th byte of register data
 660    into memory at MYADDR.  */
 661
 662 void
 663 read_register_bytes (inregbyte, myaddr, inlen)
 664      int inregbyte;
 665      char *myaddr;
 666      int inlen;
 667 {
 668   int inregend = inregbyte + inlen;
 669   int regno;
 670
 671   if (registers_pid != inferior_pid)
 672     {
 673       registers_changed ();
 674       registers_pid = inferior_pid;
 675     }
 676
 677   /* See if we are trying to read bytes from out-of-date registers.  If so,
 678      update just those registers.  */
 679
 680   for (regno = 0; regno < NUM_REGS; regno++)
 681     {
 682       int regstart, regend;
 683
 684       if (register_valid[regno])
 685         continue;
 686
 687       if (REGISTER_NAME (regno) == NULL || *REGISTER_NAME (regno) == '\0')
 688         continue;
 689
 690       regstart = REGISTER_BYTE (regno);
 691       regend = regstart + REGISTER_RAW_SIZE (regno);
 692
 693       if (regend <= inregbyte || inregend <= regstart)
 694         /* The range the user wants to read doesn't overlap with regno.  */
 695         continue;
 696
 697       /* We've found an invalid register where at least one byte will be read.
 698          Update it from the target.  */
 699       target_fetch_registers (regno);
 700
 701       if (!register_valid[regno])
 702         error ("read_register_bytes:  Couldn't update register %d.", regno);
 703     }
 704
 705   if (myaddr != NULL)
 706     memcpy (myaddr, &registers[inregbyte], inlen);
 707 }
 708
 709 /* Read register REGNO into memory at MYADDR, which must be large enough
 710    for REGISTER_RAW_BYTES (REGNO).  Target byte-order.
 711    If the register is known to be the size of a CORE_ADDR or smaller,
 712    read_register can be used instead.  */
 713 void
 714 read_register_gen (regno, myaddr)
 715      int regno;
 716      char *myaddr;
 717 {
 718   if (registers_pid != inferior_pid)
 719     {
 720       registers_changed ();
 721       registers_pid = inferior_pid;
 722     }
 723
 724   if (!register_valid[regno])
 725     target_fetch_registers (regno);
 726   memcpy (myaddr, &registers[REGISTER_BYTE (regno)],
 727           REGISTER_RAW_SIZE (regno));
 728 }
 729
 730 /* Write register REGNO at MYADDR to the target.  MYADDR points at
 731    REGISTER_RAW_BYTES(REGNO), which must be in target byte-order.  */
 732
 733 static void
 734 write_register_gen (regno, myaddr)
 735      int regno;
 736      char *myaddr;
 737 {
 738   int size;
 739
 740   /* On the sparc, writing %g0 is a no-op, so we don't even want to change
 741      the registers array if something writes to this register.  */
 742   if (CANNOT_STORE_REGISTER (regno))
 743     return;
 744
 745   if (registers_pid != inferior_pid)
 746     {
 747       registers_changed ();
 748       registers_pid = inferior_pid;
 749     }
 750
 751   size = REGISTER_RAW_SIZE (regno);
 752
 753   /* If we have a valid copy of the register, and new value == old value,
 754      then don't bother doing the actual store. */
 755
 756   if (register_valid[regno]
 757       && memcmp (&registers[REGISTER_BYTE (regno)], myaddr, size) == 0)
 758     return;
 759
 760   target_prepare_to_store ();
 761
 762   memcpy (&registers[REGISTER_BYTE (regno)], myaddr, size);
 763
 764   register_valid[regno] = 1;
 765
 766   target_store_registers (regno);
 767 }
 768
 769 /* Copy INLEN bytes of consecutive data from memory at MYADDR
 770    into registers starting with the MYREGSTART'th byte of register data.  */
 771
 772 void
 773 write_register_bytes (myregstart, myaddr, inlen)
 774      int myregstart;
 775      char *myaddr;
 776      int inlen;
 777 {
 778   int myregend = myregstart + inlen;
 779   int regno;
 780
 781   target_prepare_to_store ();
 782
 783   /* Scan through the registers updating any that are covered by the range
 784      myregstart<=>myregend using write_register_gen, which does nice things
 785      like handling threads, and avoiding updates when the new and old contents
 786      are the same.  */
 787
 788   for (regno = 0; regno < NUM_REGS; regno++)
 789     {
 790       int regstart, regend;
 791
 792       regstart = REGISTER_BYTE (regno);
 793       regend = regstart + REGISTER_RAW_SIZE (regno);
 794
 795       /* Is this register completely outside the range the user is writing?  */
 796       if (myregend <= regstart || regend <= myregstart)
 797         /* do nothing */ ;
 798
 799       /* Is this register completely within the range the user is writing?  */
 800       else if (myregstart <= regstart && regend <= myregend)
 801         write_register_gen (regno, myaddr + (regstart - myregstart));
 802
 803       /* The register partially overlaps the range being written.  */
 804       else
 805         {
 806           char regbuf[MAX_REGISTER_RAW_SIZE];
 807           /* What's the overlap between this register's bytes and
 808              those the caller wants to write?  */
 809           int overlapstart = max (regstart, myregstart);
 810           int overlapend   = min (regend,   myregend);
 811
 812           /* We may be doing a partial update of an invalid register.
 813              Update it from the target before scribbling on it.  */
 814           read_register_gen (regno, regbuf);
 815
 816           memcpy (registers + overlapstart,
 817                   myaddr + (overlapstart - myregstart),
 818                   overlapend - overlapstart);
 819
 820           target_store_registers (regno);
 821         }
 822     }
 823 }
 824
 825
 826 /* Return the raw contents of register REGNO, regarding it as an integer.  */
 827 /* This probably should be returning LONGEST rather than CORE_ADDR.  */
 828
 829 CORE_ADDR
 830 read_register (regno)
 831      int regno;
 832 {
 833   if (registers_pid != inferior_pid)
 834     {
 835       registers_changed ();
 836       registers_pid = inferior_pid;
 837     }
 838
 839   if (!register_valid[regno])
 840     target_fetch_registers (regno);
 841
 842   return (CORE_ADDR) extract_address (&registers[REGISTER_BYTE (regno)],
 843                                       REGISTER_RAW_SIZE (regno));
 844 }
 845
 846 CORE_ADDR
 847 read_register_pid (regno, pid)
 848      int regno, pid;
 849 {
 850   int save_pid;
 851   CORE_ADDR retval;
 852
 853   if (pid == inferior_pid)
 854     return read_register (regno);
 855
 856   save_pid = inferior_pid;
 857
 858   inferior_pid = pid;
 859
 860   retval = read_register (regno);
 861
 862   inferior_pid = save_pid;
 863
 864   return retval;
 865 }
 866
 867 /* Store VALUE, into the raw contents of register number REGNO.
 868    This should probably write a LONGEST rather than a CORE_ADDR */
 869
 870 void
 871 write_register (regno, val)
 872      int regno;
 873      LONGEST val;
 874 {
 875   PTR buf;
 876   int size;
 877
 878   /* On the sparc, writing %g0 is a no-op, so we don't even want to change
 879      the registers array if something writes to this register.  */
 880   if (CANNOT_STORE_REGISTER (regno))
 881     return;
 882
 883   if (registers_pid != inferior_pid)
 884     {
 885       registers_changed ();
 886       registers_pid = inferior_pid;
 887     }
 888
 889   size = REGISTER_RAW_SIZE (regno);
 890   buf = alloca (size);
 891   store_signed_integer (buf, size, (LONGEST) val);
 892
 893   /* If we have a valid copy of the register, and new value == old value,
 894      then don't bother doing the actual store. */
 895
 896   if (register_valid[regno]
 897       && memcmp (&registers[REGISTER_BYTE (regno)], buf, size) == 0)
 898     return;
 899
 900   target_prepare_to_store ();
 901
 902   memcpy (&registers[REGISTER_BYTE (regno)], buf, size);
 903
 904   register_valid[regno] = 1;
 905
 906   target_store_registers (regno);
 907 }
 908
 909 void
 910 write_register_pid (regno, val, pid)
 911      int regno;
 912      CORE_ADDR val;
 913      int pid;
 914 {
 915   int save_pid;
 916
 917   if (pid == inferior_pid)
 918     {
 919       write_register (regno, val);
 920       return;
 921     }
 922
 923   save_pid = inferior_pid;
 924
 925   inferior_pid = pid;
 926
 927   write_register (regno, val);
 928
 929   inferior_pid = save_pid;
 930 }
 931
 932 /* Record that register REGNO contains VAL.
 933    This is used when the value is obtained from the inferior or core dump,
 934    so there is no need to store the value there.
 935
 936    If VAL is a NULL pointer, then it's probably an unsupported register.  We
 937    just set it's value to all zeros.  We might want to record this fact, and
 938    report it to the users of read_register and friends.
 939  */
 940
 941 void
 942 supply_register (regno, val)
 943      int regno;
 944      char *val;
 945 {
 946 #if 1
 947   if (registers_pid != inferior_pid)
 948     {
 949       registers_changed ();
 950       registers_pid = inferior_pid;
 951     }
 952 #endif
 953
 954   register_valid[regno] = 1;
 955   if (val)
 956     memcpy (&registers[REGISTER_BYTE (regno)], val, REGISTER_RAW_SIZE (regno));
 957   else
 958     memset (&registers[REGISTER_BYTE (regno)], '\000', REGISTER_RAW_SIZE (regno));
 959
 960   /* On some architectures, e.g. HPPA, there are a few stray bits in some
 961      registers, that the rest of the code would like to ignore.  */
 962 #ifdef CLEAN_UP_REGISTER_VALUE
 963   CLEAN_UP_REGISTER_VALUE (regno, &registers[REGISTER_BYTE (regno)]);
 964 #endif
 965 }
 966
 967
 968 /* This routine is getting awfully cluttered with #if's.  It's probably
 969    time to turn this into READ_PC and define it in the tm.h file.
 970    Ditto for write_pc.
 971
 972    1999-06-08: The following were re-written so that it assumes the
 973    existance of a TARGET_READ_PC et.al. macro.  A default generic
 974    version of that macro is made available where needed.
 975
 976    Since the ``TARGET_READ_PC'' et.al. macro is going to be controlled
 977    by the multi-arch framework, it will eventually be possible to
 978    eliminate the intermediate read_pc_pid().  The client would call
 979    TARGET_READ_PC directly. (cagney). */
 980
 981 #ifndef TARGET_READ_PC
 982 #define TARGET_READ_PC generic_target_read_pc
 983 #endif
 984
 985 CORE_ADDR
 986 generic_target_read_pc (int pid)
 987 {
 988 #ifdef PC_REGNUM
 989   if (PC_REGNUM >= 0)
 990     {
 991       CORE_ADDR pc_val = ADDR_BITS_REMOVE ((CORE_ADDR) read_register_pid (PC_REGNUM, pid));
 992       return pc_val;
 993     }
 994 #endif
 995   internal_error ("generic_target_read_pc");
 996   return 0;
 997 }
 998
 999 CORE_ADDR
1000 read_pc_pid (pid)
1001      int pid;
1002 {
1003   int saved_inferior_pid;
1004   CORE_ADDR pc_val;
1005
1006   /* In case pid != inferior_pid. */
1007   saved_inferior_pid = inferior_pid;
1008   inferior_pid = pid;
1009
1010   pc_val = TARGET_READ_PC (pid);
1011
1012   inferior_pid = saved_inferior_pid;
1013   return pc_val;
1014 }
1015
1016 CORE_ADDR
1017 read_pc ()
1018 {
1019   return read_pc_pid (inferior_pid);
1020 }
1021
1022 #ifndef TARGET_WRITE_PC
1023 #define TARGET_WRITE_PC generic_target_write_pc
1024 #endif
1025
1026 void
1027 generic_target_write_pc (pc, pid)
1028      CORE_ADDR pc;
1029      int pid;
1030 {
1031 #ifdef PC_REGNUM
1032   if (PC_REGNUM >= 0)
1033     write_register_pid (PC_REGNUM, pc, pid);
1034 #ifdef NPC_REGNUM
1035   if (NPC_REGNUM >= 0)
1036     write_register_pid (NPC_REGNUM, pc + 4, pid);
1037 #ifdef NNPC_REGNUM
1038   if (NNPC_REGNUM >= 0)
1039     write_register_pid (NNPC_REGNUM, pc + 8, pid);
1040 #endif
1041 #endif
1042 #else
1043   internal_error ("generic_target_write_pc");
1044 #endif
1045 }
1046
1047 void
1048 write_pc_pid (pc, pid)
1049      CORE_ADDR pc;
1050      int pid;
1051 {
1052   int saved_inferior_pid;
1053
1054   /* In case pid != inferior_pid. */
1055   saved_inferior_pid = inferior_pid;
1056   inferior_pid = pid;
1057
1058   TARGET_WRITE_PC (pc, pid);
1059
1060   inferior_pid = saved_inferior_pid;
1061 }
1062
1063 void
1064 write_pc (pc)
1065      CORE_ADDR pc;
1066 {
1067   write_pc_pid (pc, inferior_pid);
1068 }
1069
1070 /* Cope with strage ways of getting to the stack and frame pointers */
1071
1072 #ifndef TARGET_READ_SP
1073 #define TARGET_READ_SP generic_target_read_sp
1074 #endif
1075
1076 CORE_ADDR
1077 generic_target_read_sp ()
1078 {
1079 #ifdef SP_REGNUM
1080   if (SP_REGNUM >= 0)
1081     return read_register (SP_REGNUM);
1082 #endif
1083   internal_error ("generic_target_read_sp");
1084 }
1085
1086 CORE_ADDR
1087 read_sp ()
1088 {
1089   return TARGET_READ_SP ();
1090 }
1091
1092 #ifndef TARGET_WRITE_SP
1093 #define TARGET_WRITE_SP generic_target_write_sp
1094 #endif
1095
1096 void
1097 generic_target_write_sp (val)
1098      CORE_ADDR val;
1099 {
1100 #ifdef SP_REGNUM
1101   if (SP_REGNUM >= 0)
1102     {
1103       write_register (SP_REGNUM, val);
1104       return;
1105     }
1106 #endif
1107   internal_error ("generic_target_write_sp");
1108 }
1109
1110 void
1111 write_sp (val)
1112      CORE_ADDR val;
1113 {
1114   TARGET_WRITE_SP (val);
1115 }
1116
1117 #ifndef TARGET_READ_FP
1118 #define TARGET_READ_FP generic_target_read_fp
1119 #endif
1120
1121 CORE_ADDR
1122 generic_target_read_fp ()
1123 {
1124 #ifdef FP_REGNUM
1125   if (FP_REGNUM >= 0)
1126     return read_register (FP_REGNUM);
1127 #endif
1128   internal_error ("generic_target_read_fp");
1129 }
1130
1131 CORE_ADDR
1132 read_fp ()
1133 {
1134   return TARGET_READ_FP ();
1135 }
1136
1137 #ifndef TARGET_WRITE_FP
1138 #define TARGET_WRITE_FP generic_target_write_fp
1139 #endif
1140
1141 void
1142 generic_target_write_fp (val)
1143      CORE_ADDR val;
1144 {
1145 #ifdef FP_REGNUM
1146   if (FP_REGNUM >= 0)
1147     {
1148       write_register (FP_REGNUM, val);
1149       return;
1150     }
1151 #endif
1152   internal_error ("generic_target_write_fp");
1153 }
1154
1155 void
1156 write_fp (val)
1157      CORE_ADDR val;
1158 {
1159   TARGET_WRITE_FP (val);
1160 }
1161 \f
1162 /* Will calling read_var_value or locate_var_value on SYM end
1163    up caring what frame it is being evaluated relative to?  SYM must
1164    be non-NULL.  */
1165 int
1166 symbol_read_needs_frame (sym)
1167      struct symbol *sym;
1168 {
1169   switch (SYMBOL_CLASS (sym))
1170     {
1171       /* All cases listed explicitly so that gcc -Wall will detect it if
1172          we failed to consider one.  */
1173     case LOC_REGISTER:
1174     case LOC_ARG:
1175     case LOC_REF_ARG:
1176     case LOC_REGPARM:
1177     case LOC_REGPARM_ADDR:
1178     case LOC_LOCAL:
1179     case LOC_LOCAL_ARG:
1180     case LOC_BASEREG:
1181     case LOC_BASEREG_ARG:
1182     case LOC_THREAD_LOCAL_STATIC:
1183       return 1;
1184
1185     case LOC_UNDEF:
1186     case LOC_CONST:
1187     case LOC_STATIC:
1188     case LOC_INDIRECT:
1189     case LOC_TYPEDEF:
1190
1191     case LOC_LABEL:
1192       /* Getting the address of a label can be done independently of the block,
1193          even if some *uses* of that address wouldn't work so well without
1194          the right frame.  */
1195
1196     case LOC_BLOCK:
1197     case LOC_CONST_BYTES:
1198     case LOC_UNRESOLVED:
1199     case LOC_OPTIMIZED_OUT:
1200       return 0;
1201     }
1202   return 1;
1203 }
1204
1205 /* Given a struct symbol for a variable,
1206    and a stack frame id, read the value of the variable
1207    and return a (pointer to a) struct value containing the value.
1208    If the variable cannot be found, return a zero pointer.
1209    If FRAME is NULL, use the selected_frame.  */
1210
1211 value_ptr
1212 read_var_value (var, frame)
1213      register struct symbol *var;
1214      struct frame_info *frame;
1215 {
1216   register value_ptr v;
1217   struct type *type = SYMBOL_TYPE (var);
1218   CORE_ADDR addr;
1219   register int len;
1220
1221   v = allocate_value (type);
1222   VALUE_LVAL (v) = lval_memory; /* The most likely possibility.  */
1223   VALUE_BFD_SECTION (v) = SYMBOL_BFD_SECTION (var);
1224
1225   len = TYPE_LENGTH (type);
1226
1227   if (frame == NULL)
1228     frame = selected_frame;
1229
1230   switch (SYMBOL_CLASS (var))
1231     {
1232     case LOC_CONST:
1233       /* Put the constant back in target format.  */
1234       store_signed_integer (VALUE_CONTENTS_RAW (v), len,
1235                             (LONGEST) SYMBOL_VALUE (var));
1236       VALUE_LVAL (v) = not_lval;
1237       return v;
1238
1239     case LOC_LABEL:
1240       /* Put the constant back in target format.  */
1241       if (overlay_debugging)
1242         store_address (VALUE_CONTENTS_RAW (v), len,
1243              (LONGEST) symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
1244                                                  SYMBOL_BFD_SECTION (var)));
1245       else
1246         store_address (VALUE_CONTENTS_RAW (v), len,
1247                        (LONGEST) SYMBOL_VALUE_ADDRESS (var));
1248       VALUE_LVAL (v) = not_lval;
1249       return v;
1250
1251     case LOC_CONST_BYTES:
1252       {
1253         char *bytes_addr;
1254         bytes_addr = SYMBOL_VALUE_BYTES (var);
1255         memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
1256         VALUE_LVAL (v) = not_lval;
1257         return v;
1258       }
1259
1260     case LOC_STATIC:
1261       if (overlay_debugging)
1262         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
1263                                          SYMBOL_BFD_SECTION (var));
1264       else
1265         addr = SYMBOL_VALUE_ADDRESS (var);
1266       break;
1267
1268     case LOC_INDIRECT:
1269       /* The import slot does not have a real address in it from the
1270          dynamic loader (dld.sl on HP-UX), if the target hasn't begun
1271          execution yet, so check for that. */
1272       if (!target_has_execution)
1273         error ("\
1274 Attempt to access variable defined in different shared object or load module when\n\
1275 addresses have not been bound by the dynamic loader. Try again when executable is running.");
1276
1277       addr = SYMBOL_VALUE_ADDRESS (var);
1278       addr = read_memory_unsigned_integer
1279         (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
1280       break;
1281
1282     case LOC_ARG:
1283       if (frame == NULL)
1284         return 0;
1285       addr = FRAME_ARGS_ADDRESS (frame);
1286       if (!addr)
1287         return 0;
1288       addr += SYMBOL_VALUE (var);
1289       break;
1290
1291     case LOC_REF_ARG:
1292       if (frame == NULL)
1293         return 0;
1294       addr = FRAME_ARGS_ADDRESS (frame);
1295       if (!addr)
1296         return 0;
1297       addr += SYMBOL_VALUE (var);
1298       addr = read_memory_unsigned_integer
1299         (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
1300       break;
1301
1302     case LOC_LOCAL:
1303     case LOC_LOCAL_ARG:
1304       if (frame == NULL)
1305         return 0;
1306       addr = FRAME_LOCALS_ADDRESS (frame);
1307       addr += SYMBOL_VALUE (var);
1308       break;
1309
1310     case LOC_BASEREG:
1311     case LOC_BASEREG_ARG:
1312       {
1313         char buf[MAX_REGISTER_RAW_SIZE];
1314         get_saved_register (buf, NULL, NULL, frame, SYMBOL_BASEREG (var),
1315                             NULL);
1316         addr = extract_address (buf, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var)));
1317         addr += SYMBOL_VALUE (var);
1318         break;
1319       }
1320
1321     case LOC_THREAD_LOCAL_STATIC:
1322       {
1323         char buf[MAX_REGISTER_RAW_SIZE];
1324
1325         get_saved_register (buf, NULL, NULL, frame, SYMBOL_BASEREG (var),
1326                             NULL);
1327         addr = extract_address (buf, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var)));
1328         addr += SYMBOL_VALUE (var);
1329         break;
1330       }
1331
1332     case LOC_TYPEDEF:
1333       error ("Cannot look up value of a typedef");
1334       break;
1335
1336     case LOC_BLOCK:
1337       if (overlay_debugging)
1338         VALUE_ADDRESS (v) = symbol_overlayed_address
1339           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_BFD_SECTION (var));
1340       else
1341         VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
1342       return v;
1343
1344     case LOC_REGISTER:
1345     case LOC_REGPARM:
1346     case LOC_REGPARM_ADDR:
1347       {
1348         struct block *b;
1349         int regno = SYMBOL_VALUE (var);
1350         value_ptr regval;
1351
1352         if (frame == NULL)
1353           return 0;
1354         b = get_frame_block (frame);
1355
1356         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
1357           {
1358             regval = value_from_register (lookup_pointer_type (type),
1359                                           regno,
1360                                           frame);
1361
1362             if (regval == NULL)
1363               error ("Value of register variable not available.");
1364
1365             addr = value_as_pointer (regval);
1366             VALUE_LVAL (v) = lval_memory;
1367           }
1368         else
1369           {
1370             regval = value_from_register (type, regno, frame);
1371
1372             if (regval == NULL)
1373               error ("Value of register variable not available.");
1374             return regval;
1375           }
1376       }
1377       break;
1378
1379     case LOC_UNRESOLVED:
1380       {
1381         struct minimal_symbol *msym;
1382
1383         msym = lookup_minimal_symbol (SYMBOL_NAME (var), NULL, NULL);
1384         if (msym == NULL)
1385           return 0;
1386         if (overlay_debugging)
1387           addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
1388                                            SYMBOL_BFD_SECTION (msym));
1389         else
1390           addr = SYMBOL_VALUE_ADDRESS (msym);
1391       }
1392       break;
1393
1394     case LOC_OPTIMIZED_OUT:
1395       VALUE_LVAL (v) = not_lval;
1396       VALUE_OPTIMIZED_OUT (v) = 1;
1397       return v;
1398
1399     default:
1400       error ("Cannot look up value of a botched symbol.");
1401       break;
1402     }
1403
1404   VALUE_ADDRESS (v) = addr;
1405   VALUE_LAZY (v) = 1;
1406   return v;
1407 }
1408
1409 /* Return a value of type TYPE, stored in register REGNUM, in frame
1410    FRAME.
1411
1412    NOTE: returns NULL if register value is not available.
1413    Caller will check return value or die!  */
1414
1415 value_ptr
1416 value_from_register (type, regnum, frame)
1417      struct type *type;
1418      int regnum;
1419      struct frame_info *frame;
1420 {
1421   char raw_buffer[MAX_REGISTER_RAW_SIZE];
1422   CORE_ADDR addr;
1423   int optim;
1424   value_ptr v = allocate_value (type);
1425   char *value_bytes = 0;
1426   int value_bytes_copied = 0;
1427   int num_storage_locs;
1428   enum lval_type lval;
1429   int len;
1430
1431   CHECK_TYPEDEF (type);
1432   len = TYPE_LENGTH (type);
1433
1434   /* Pointers on D10V are really only 16 bits, but we lie to gdb elsewhere... */
1435   if (GDB_TARGET_IS_D10V && TYPE_CODE (type) == TYPE_CODE_PTR)
1436     len = 2;
1437
1438   VALUE_REGNO (v) = regnum;
1439
1440   num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
1441                       ((len - 1) / REGISTER_RAW_SIZE (regnum)) + 1 :
1442                       1);
1443
1444   if (num_storage_locs > 1
1445 #ifdef GDB_TARGET_IS_H8500
1446       || TYPE_CODE (type) == TYPE_CODE_PTR
1447 #endif
1448     )
1449     {
1450       /* Value spread across multiple storage locations.  */
1451
1452       int local_regnum;
1453       int mem_stor = 0, reg_stor = 0;
1454       int mem_tracking = 1;
1455       CORE_ADDR last_addr = 0;
1456       CORE_ADDR first_addr = 0;
1457
1458       value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE);
1459
1460       /* Copy all of the data out, whereever it may be.  */
1461
1462 #ifdef GDB_TARGET_IS_H8500
1463 /* This piece of hideosity is required because the H8500 treats registers
1464    differently depending upon whether they are used as pointers or not.  As a
1465    pointer, a register needs to have a page register tacked onto the front.
1466    An alternate way to do this would be to have gcc output different register
1467    numbers for the pointer & non-pointer form of the register.  But, it
1468    doesn't, so we're stuck with this.  */
1469
1470       if (TYPE_CODE (type) == TYPE_CODE_PTR
1471           && len > 2)
1472         {
1473           int page_regnum;
1474
1475           switch (regnum)
1476             {
1477             case R0_REGNUM:
1478             case R1_REGNUM:
1479             case R2_REGNUM:
1480             case R3_REGNUM:
1481               page_regnum = SEG_D_REGNUM;
1482               break;
1483             case R4_REGNUM:
1484             case R5_REGNUM:
1485               page_regnum = SEG_E_REGNUM;
1486               break;
1487             case R6_REGNUM:
1488             case R7_REGNUM:
1489               page_regnum = SEG_T_REGNUM;
1490               break;
1491             }
1492
1493           value_bytes[0] = 0;
1494           get_saved_register (value_bytes + 1,
1495                               &optim,
1496                               &addr,
1497                               frame,
1498                               page_regnum,
1499                               &lval);
1500
1501           if (register_valid[page_regnum] == -1)
1502             return NULL;        /* register value not available */
1503
1504           if (lval == lval_register)
1505             reg_stor++;
1506           else
1507             mem_stor++;
1508           first_addr = addr;
1509           last_addr = addr;
1510
1511           get_saved_register (value_bytes + 2,
1512                               &optim,
1513                               &addr,
1514                               frame,
1515                               regnum,
1516                               &lval);
1517
1518           if (register_valid[regnum] == -1)
1519             return NULL;        /* register value not available */
1520
1521           if (lval == lval_register)
1522             reg_stor++;
1523           else
1524             {
1525               mem_stor++;
1526               mem_tracking = mem_tracking && (addr == last_addr);
1527             }
1528           last_addr = addr;
1529         }
1530       else
1531 #endif /* GDB_TARGET_IS_H8500 */
1532         for (local_regnum = regnum;
1533              value_bytes_copied < len;
1534              (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
1535               ++local_regnum))
1536           {
1537             get_saved_register (value_bytes + value_bytes_copied,
1538                                 &optim,
1539                                 &addr,
1540                                 frame,
1541                                 local_regnum,
1542                                 &lval);
1543
1544             if (register_valid[local_regnum] == -1)
1545               return NULL;      /* register value not available */
1546
1547             if (regnum == local_regnum)
1548               first_addr = addr;
1549             if (lval == lval_register)
1550               reg_stor++;
1551             else
1552               {
1553                 mem_stor++;
1554
1555                 mem_tracking =
1556                   (mem_tracking
1557                    && (regnum == local_regnum
1558                        || addr == last_addr));
1559               }
1560             last_addr = addr;
1561           }
1562
1563       if ((reg_stor && mem_stor)
1564           || (mem_stor && !mem_tracking))
1565         /* Mixed storage; all of the hassle we just went through was
1566            for some good purpose.  */
1567         {
1568           VALUE_LVAL (v) = lval_reg_frame_relative;
1569           VALUE_FRAME (v) = FRAME_FP (frame);
1570           VALUE_FRAME_REGNUM (v) = regnum;
1571         }
1572       else if (mem_stor)
1573         {
1574           VALUE_LVAL (v) = lval_memory;
1575           VALUE_ADDRESS (v) = first_addr;
1576         }
1577       else if (reg_stor)
1578         {
1579           VALUE_LVAL (v) = lval_register;
1580           VALUE_ADDRESS (v) = first_addr;
1581         }
1582       else
1583         internal_error ("value_from_register: Value not stored anywhere!");
1584
1585       VALUE_OPTIMIZED_OUT (v) = optim;
1586
1587       /* Any structure stored in more than one register will always be
1588          an integral number of registers.  Otherwise, you'd need to do
1589          some fiddling with the last register copied here for little
1590          endian machines.  */
1591
1592       /* Copy into the contents section of the value.  */
1593       memcpy (VALUE_CONTENTS_RAW (v), value_bytes, len);
1594
1595       /* Finally do any conversion necessary when extracting this
1596          type from more than one register.  */
1597 #ifdef REGISTER_CONVERT_TO_TYPE
1598       REGISTER_CONVERT_TO_TYPE (regnum, type, VALUE_CONTENTS_RAW (v));
1599 #endif
1600       return v;
1601     }
1602
1603   /* Data is completely contained within a single register.  Locate the
1604      register's contents in a real register or in core;
1605      read the data in raw format.  */
1606
1607   get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
1608
1609   if (register_valid[regnum] == -1)
1610     return NULL;                /* register value not available */
1611
1612   VALUE_OPTIMIZED_OUT (v) = optim;
1613   VALUE_LVAL (v) = lval;
1614   VALUE_ADDRESS (v) = addr;
1615
1616   /* Convert raw data to virtual format if necessary.  */
1617
1618   if (REGISTER_CONVERTIBLE (regnum))
1619     {
1620       REGISTER_CONVERT_TO_VIRTUAL (regnum, type,
1621                                    raw_buffer, VALUE_CONTENTS_RAW (v));
1622     }
1623   else
1624     {
1625       /* Raw and virtual formats are the same for this register.  */
1626
1627       if (TARGET_BYTE_ORDER == BIG_ENDIAN && len < REGISTER_RAW_SIZE (regnum))
1628         {
1629           /* Big-endian, and we want less than full size.  */
1630           VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
1631         }
1632
1633       memcpy (VALUE_CONTENTS_RAW (v), raw_buffer + VALUE_OFFSET (v), len);
1634     }
1635
1636   if (GDB_TARGET_IS_D10V
1637       && TYPE_CODE (type) == TYPE_CODE_PTR
1638       && TYPE_TARGET_TYPE (type)
1639       && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC))
1640     {
1641       /* pointer to function */
1642       unsigned long num;
1643       unsigned short snum;
1644       snum = (unsigned short) extract_unsigned_integer (VALUE_CONTENTS_RAW (v), 2);
1645       num = D10V_MAKE_IADDR (snum);
1646       store_address (VALUE_CONTENTS_RAW (v), 4, num);
1647     }
1648   else if (GDB_TARGET_IS_D10V
1649            && TYPE_CODE (type) == TYPE_CODE_PTR)
1650     {
1651       /* pointer to data */
1652       unsigned long num;
1653       unsigned short snum;
1654       snum = (unsigned short) extract_unsigned_integer (VALUE_CONTENTS_RAW (v), 2);
1655       num = D10V_MAKE_DADDR (snum);
1656       store_address (VALUE_CONTENTS_RAW (v), 4, num);
1657     }
1658
1659   return v;
1660 }
1661 \f
1662 /* Given a struct symbol for a variable or function,
1663    and a stack frame id,
1664    return a (pointer to a) struct value containing the properly typed
1665    address.  */
1666
1667 value_ptr
1668 locate_var_value (var, frame)
1669      register struct symbol *var;
1670      struct frame_info *frame;
1671 {
1672   CORE_ADDR addr = 0;
1673   struct type *type = SYMBOL_TYPE (var);
1674   value_ptr lazy_value;
1675
1676   /* Evaluate it first; if the result is a memory address, we're fine.
1677      Lazy evaluation pays off here. */
1678
1679   lazy_value = read_var_value (var, frame);
1680   if (lazy_value == 0)
1681     error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
1682
1683   if (VALUE_LAZY (lazy_value)
1684       || TYPE_CODE (type) == TYPE_CODE_FUNC)
1685     {
1686       value_ptr val;
1687
1688       addr = VALUE_ADDRESS (lazy_value);
1689       val = value_from_longest (lookup_pointer_type (type), (LONGEST) addr);
1690       VALUE_BFD_SECTION (val) = VALUE_BFD_SECTION (lazy_value);
1691       return val;
1692     }
1693
1694   /* Not a memory address; check what the problem was.  */
1695   switch (VALUE_LVAL (lazy_value))
1696     {
1697     case lval_register:
1698     case lval_reg_frame_relative:
1699       error ("Address requested for identifier \"%s\" which is in a register.",
1700              SYMBOL_SOURCE_NAME (var));
1701       break;
1702
1703     default:
1704       error ("Can't take address of \"%s\" which isn't an lvalue.",
1705              SYMBOL_SOURCE_NAME (var));
1706       break;
1707     }
1708   return 0;                     /* For lint -- never reached */
1709 }
1710 \f
1711
1712 static void build_findvar PARAMS ((void));
1713 static void
1714 build_findvar ()
1715 {
1716   /* We allocate some extra slop since we do a lot of memcpy's around
1717      `registers', and failing-soft is better than failing hard.  */
1718   int sizeof_registers = REGISTER_BYTES + /* SLOP */ 256;
1719   int sizeof_register_valid = NUM_REGS * sizeof (*register_valid);
1720   registers = xmalloc (sizeof_registers);
1721   memset (registers, 0, sizeof_registers);
1722   register_valid = xmalloc (sizeof_register_valid);
1723   memset (register_valid, 0, sizeof_register_valid);
1724 }
1725
1726 void _initialize_findvar PARAMS ((void));
1727 void
1728 _initialize_findvar ()
1729 {
1730   build_findvar ();
1731
1732   register_gdbarch_swap (&registers, sizeof (registers), NULL);
1733   register_gdbarch_swap (&register_valid, sizeof (register_valid), NULL);
1734   register_gdbarch_swap (NULL, 0, build_findvar);
1735 }