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