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