gdb/findvar.c

   1 /* Find a variable's value in memory, for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "gdbtypes.h"
  23 #include "frame.h"
  24 #include "value.h"
  25 #include "gdbcore.h"
  26 #include "inferior.h"
  27 #include "target.h"
  28
  29 #if !defined (GET_SAVED_REGISTER)
  30
  31 /* Return the address in which frame FRAME's value of register REGNUM
  32    has been saved in memory.  Or return zero if it has not been saved.
  33    If REGNUM specifies the SP, the value we return is actually
  34    the SP value, not an address where it was saved.  */
  35
  36 CORE_ADDR
  37 find_saved_register (frame, regnum)
  38      FRAME frame;
  39      int regnum;
  40 {
  41   struct frame_info *fi;
  42   struct frame_saved_regs saved_regs;
  43
  44   register FRAME frame1 = 0;
  45   register CORE_ADDR addr = 0;
  46
  47   if (frame == 0)               /* No regs saved if want current frame */
  48     return 0;
  49
  50 #ifdef HAVE_REGISTER_WINDOWS
  51   /* We assume that a register in a register window will only be saved
  52      in one place (since the name changes and/or disappears as you go
  53      towards inner frames), so we only call get_frame_saved_regs on
  54      the current frame.  This is directly in contradiction to the
  55      usage below, which assumes that registers used in a frame must be
  56      saved in a lower (more interior) frame.  This change is a result
  57      of working on a register window machine; get_frame_saved_regs
  58      always returns the registers saved within a frame, within the
  59      context (register namespace) of that frame. */
  60
  61   /* However, note that we don't want this to return anything if
  62      nothing is saved (if there's a frame inside of this one).  Also,
  63      callers to this routine asking for the stack pointer want the
  64      stack pointer saved for *this* frame; this is returned from the
  65      next frame.  */
  66
  67
  68   if (REGISTER_IN_WINDOW_P(regnum))
  69     {
  70       frame1 = get_next_frame (frame);
  71       if (!frame1) return 0;    /* Registers of this frame are
  72                                    active.  */
  73
  74       /* Get the SP from the next frame in; it will be this
  75          current frame.  */
  76       if (regnum != SP_REGNUM)
  77         frame1 = frame;
  78
  79       fi = get_frame_info (frame1);
  80       get_frame_saved_regs (fi, &saved_regs);
  81       return saved_regs.regs[regnum];   /* ... which might be zero */
  82     }
  83 #endif /* HAVE_REGISTER_WINDOWS */
  84
  85   /* Note that this next routine assumes that registers used in
  86      frame x will be saved only in the frame that x calls and
  87      frames interior to it.  This is not true on the sparc, but the
  88      above macro takes care of it, so we should be all right. */
  89   while (1)
  90     {
  91       QUIT;
  92       frame1 = get_prev_frame (frame1);
  93       if (frame1 == 0 || frame1 == frame)
  94         break;
  95       fi = get_frame_info (frame1);
  96       get_frame_saved_regs (fi, &saved_regs);
  97       if (saved_regs.regs[regnum])
  98         addr = saved_regs.regs[regnum];
  99     }
 100
 101   return addr;
 102 }
 103
 104 /* Find register number REGNUM relative to FRAME and put its
 105    (raw) contents in *RAW_BUFFER.  Set *OPTIMIZED if the variable
 106    was optimized out (and thus can't be fetched).  Set *LVAL to
 107    lval_memory, lval_register, or not_lval, depending on whether the
 108    value was fetched from memory, from a register, or in a strange
 109    and non-modifiable way (e.g. a frame pointer which was calculated
 110    rather than fetched).  Set *ADDRP to the address, either in memory
 111    on as a REGISTER_BYTE offset into the registers array.
 112
 113    Note that this implementation never sets *LVAL to not_lval.  But
 114    it can be replaced by defining GET_SAVED_REGISTER and supplying
 115    your own.
 116
 117    The argument RAW_BUFFER must point to aligned memory.  */
 118 void
 119 get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 120      char *raw_buffer;
 121      int *optimized;
 122      CORE_ADDR *addrp;
 123      FRAME frame;
 124      int regnum;
 125      enum lval_type *lval;
 126 {
 127   CORE_ADDR addr;
 128   /* Normal systems don't optimize out things with register numbers.  */
 129   if (optimized != NULL)
 130     *optimized = 0;
 131   addr = find_saved_register (frame, regnum);
 132   if (addr != 0)
 133     {
 134       if (lval != NULL)
 135         *lval = lval_memory;
 136       if (regnum == SP_REGNUM)
 137         {
 138           if (raw_buffer != NULL)
 139             *(CORE_ADDR *)raw_buffer = addr;
 140           if (addrp != NULL)
 141             *addrp = 0;
 142           return;
 143         }
 144       if (raw_buffer != NULL)
 145         read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
 146     }
 147   else
 148     {
 149       if (lval != NULL)
 150         *lval = lval_register;
 151       addr = REGISTER_BYTE (regnum);
 152       if (raw_buffer != NULL)
 153         read_register_gen (regnum, raw_buffer);
 154     }
 155   if (addrp != NULL)
 156     *addrp = addr;
 157 }
 158 #endif /* GET_SAVED_REGISTER.  */
 159
 160 /* Copy the bytes of register REGNUM, relative to the current stack frame,
 161    into our memory at MYADDR, in target byte order.
 162    The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
 163
 164    Returns 1 if could not be read, 0 if could.  */
 165
 166 int
 167 read_relative_register_raw_bytes (regnum, myaddr)
 168      int regnum;
 169      char *myaddr;
 170 {
 171   int optim;
 172   if (regnum == FP_REGNUM && selected_frame)
 173     {
 174       memcpy (myaddr, &FRAME_FP(selected_frame), REGISTER_RAW_SIZE(FP_REGNUM));
 175       SWAP_TARGET_AND_HOST (myaddr, REGISTER_RAW_SIZE(FP_REGNUM)); /* in target order */
 176       return 0;
 177     }
 178
 179   get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, selected_frame,
 180                       regnum, (enum lval_type *)NULL);
 181   return optim;
 182 }
 183
 184 /* Return a `value' with the contents of register REGNUM
 185    in its virtual format, with the type specified by
 186    REGISTER_VIRTUAL_TYPE.  */
 187
 188 value
 189 value_of_register (regnum)
 190      int regnum;
 191 {
 192   CORE_ADDR addr;
 193   int optim;
 194   register value val;
 195   char raw_buffer[MAX_REGISTER_RAW_SIZE];
 196   char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
 197   enum lval_type lval;
 198
 199   get_saved_register (raw_buffer, &optim, &addr,
 200                       selected_frame, regnum, &lval);
 201
 202   REGISTER_CONVERT_TO_VIRTUAL (regnum, raw_buffer, virtual_buffer);
 203   val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
 204   memcpy (VALUE_CONTENTS_RAW (val), virtual_buffer,
 205           REGISTER_VIRTUAL_SIZE (regnum));
 206   VALUE_LVAL (val) = lval;
 207   VALUE_ADDRESS (val) = addr;
 208   VALUE_REGNO (val) = regnum;
 209   VALUE_OPTIMIZED_OUT (val) = optim;
 210   return val;
 211 }
 212 \f
 213 /* Low level examining and depositing of registers.
 214
 215    The caller is responsible for making
 216    sure that the inferior is stopped before calling the fetching routines,
 217    or it will get garbage.  (a change from GDB version 3, in which
 218    the caller got the value from the last stop).  */
 219
 220 /* Contents of the registers in target byte order.
 221    We allocate some extra slop since we do a lot of bcopy's around `registers',
 222    and failing-soft is better than failing hard.  */
 223 char registers[REGISTER_BYTES + /* SLOP */ 256];
 224
 225 /* Nonzero if that register has been fetched.  */
 226 char register_valid[NUM_REGS];
 227
 228 /* Indicate that registers may have changed, so invalidate the cache.  */
 229 void
 230 registers_changed ()
 231 {
 232   int i;
 233   for (i = 0; i < NUM_REGS; i++)
 234     register_valid[i] = 0;
 235 }
 236
 237 /* Indicate that all registers have been fetched, so mark them all valid.  */
 238 void
 239 registers_fetched ()
 240 {
 241   int i;
 242   for (i = 0; i < NUM_REGS; i++)
 243     register_valid[i] = 1;
 244 }
 245
 246 /* Copy LEN bytes of consecutive data from registers
 247    starting with the REGBYTE'th byte of register data
 248    into memory at MYADDR.  */
 249
 250 void
 251 read_register_bytes (regbyte, myaddr, len)
 252      int regbyte;
 253      char *myaddr;
 254      int len;
 255 {
 256   /* Fetch all registers.  */
 257   int i;
 258   for (i = 0; i < NUM_REGS; i++)
 259     if (!register_valid[i])
 260       {
 261         target_fetch_registers (-1);
 262         break;
 263       }
 264   if (myaddr != NULL)
 265     memcpy (myaddr, &registers[regbyte], len);
 266 }
 267
 268 /* Read register REGNO into memory at MYADDR, which must be large enough
 269    for REGISTER_RAW_BYTES (REGNO).  Target byte-order.
 270    If the register is known to be the size of a CORE_ADDR or smaller,
 271    read_register can be used instead.  */
 272 void
 273 read_register_gen (regno, myaddr)
 274      int regno;
 275      char *myaddr;
 276 {
 277   if (!register_valid[regno])
 278     target_fetch_registers (regno);
 279   memcpy (myaddr, &registers[REGISTER_BYTE (regno)],
 280           REGISTER_RAW_SIZE (regno));
 281 }
 282
 283 /* Copy LEN bytes of consecutive data from memory at MYADDR
 284    into registers starting with the REGBYTE'th byte of register data.  */
 285
 286 void
 287 write_register_bytes (regbyte, myaddr, len)
 288      int regbyte;
 289      char *myaddr;
 290      int len;
 291 {
 292   /* Make sure the entire registers array is valid.  */
 293   read_register_bytes (0, (char *)NULL, REGISTER_BYTES);
 294   memcpy (&registers[regbyte], myaddr, len);
 295   target_store_registers (-1);
 296 }
 297
 298 /* Return the contents of register REGNO, regarding it as an integer.  */
 299 /* FIXME, this loses when the REGISTER_VIRTUAL (REGNO) is true.  Also,
 300    why is the return type CORE_ADDR rather than some integer type?  */
 301
 302 CORE_ADDR
 303 read_register (regno)
 304      int regno;
 305 {
 306   unsigned short sval;
 307   unsigned long lval;
 308
 309   if (!register_valid[regno])
 310     target_fetch_registers (regno);
 311
 312   switch (REGISTER_RAW_SIZE(regno))
 313     {
 314     case sizeof (unsigned char):
 315       return registers[REGISTER_BYTE (regno)];
 316     case sizeof (sval):
 317       memcpy (&sval, &registers[REGISTER_BYTE (regno)], sizeof (sval));
 318       SWAP_TARGET_AND_HOST (&sval, sizeof (sval));
 319       return sval;
 320     case sizeof (lval):
 321       memcpy (&lval, &registers[REGISTER_BYTE (regno)], sizeof (lval));
 322       SWAP_TARGET_AND_HOST (&lval, sizeof (lval));
 323       return lval;
 324     default:
 325       error ("GDB Internal Error in read_register() for register %d, size %d",
 326              regno, RAW_REGISTER_SIZE(regno));
 327     }
 328 }
 329
 330 /* Registers we shouldn't try to store.  */
 331 #if !defined (CANNOT_STORE_REGISTER)
 332 #define CANNOT_STORE_REGISTER(regno) 0
 333 #endif
 334
 335 /* Store VALUE in the register number REGNO, regarded as an integer.  */
 336 /* FIXME, this loses when REGISTER_VIRTUAL (REGNO) is true.  Also,
 337    shouldn't the val arg be a LONGEST or something?  */
 338
 339 void
 340 write_register (regno, val)
 341      int regno, val;
 342 {
 343   unsigned short sval;
 344   unsigned long lval;
 345
 346   /* On the sparc, writing %g0 is a no-op, so we don't even want to change
 347      the registers array if something writes to this register.  */
 348   if (CANNOT_STORE_REGISTER (regno))
 349     return;
 350
 351   target_prepare_to_store ();
 352
 353   register_valid [regno] = 1;
 354
 355   switch (REGISTER_RAW_SIZE(regno))
 356     {
 357     case sizeof (unsigned char):
 358       registers[REGISTER_BYTE (regno)] = val;
 359       break;
 360     case sizeof (sval):
 361       sval = val;
 362       SWAP_TARGET_AND_HOST (&sval, sizeof (sval));
 363       memcpy (&registers[REGISTER_BYTE (regno)], &sval, sizeof (sval));
 364       break;
 365     case sizeof (lval):
 366       lval = val;
 367       SWAP_TARGET_AND_HOST (&lval, sizeof (lval));
 368       memcpy (&registers[REGISTER_BYTE (regno)], &lval, sizeof (lval));
 369       break;
 370     default:
 371       error ("GDB Internal Error in write_register() for register %d, size %d",
 372              regno, RAW_REGISTER_SIZE(regno));
 373     }
 374
 375   target_store_registers (regno);
 376 }
 377
 378 /* Record that register REGNO contains VAL.
 379    This is used when the value is obtained from the inferior or core dump,
 380    so there is no need to store the value there.  */
 381
 382 void
 383 supply_register (regno, val)
 384      int regno;
 385      char *val;
 386 {
 387   register_valid[regno] = 1;
 388   memcpy (&registers[REGISTER_BYTE (regno)], val, REGISTER_RAW_SIZE (regno));
 389
 390   /* On some architectures, e.g. HPPA, there are a few stray bits in some
 391      registers, that the rest of the code would like to ignore.  */
 392 #ifdef CLEAN_UP_REGISTER_VALUE
 393   CLEAN_UP_REGISTER_VALUE(regno, &registers[REGISTER_BYTE(regno)]);
 394 #endif
 395 }
 396 \f
 397 /* Given a struct symbol for a variable,
 398    and a stack frame id, read the value of the variable
 399    and return a (pointer to a) struct value containing the value.
 400    If the variable cannot be found, return a zero pointer.
 401    If FRAME is NULL, use the selected_frame.  */
 402
 403 value
 404 read_var_value (var, frame)
 405      register struct symbol *var;
 406      FRAME frame;
 407 {
 408   register value v;
 409   struct frame_info *fi;
 410   struct type *type = SYMBOL_TYPE (var);
 411   CORE_ADDR addr;
 412   register int len;
 413
 414   v = allocate_value (type);
 415   VALUE_LVAL (v) = lval_memory; /* The most likely possibility.  */
 416   len = TYPE_LENGTH (type);
 417
 418   if (frame == 0) frame = selected_frame;
 419
 420   switch (SYMBOL_CLASS (var))
 421     {
 422     case LOC_CONST:
 423       memcpy (VALUE_CONTENTS_RAW (v), &SYMBOL_VALUE (var), len);
 424       SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v), len);
 425       VALUE_LVAL (v) = not_lval;
 426       return v;
 427
 428     case LOC_LABEL:
 429       addr = SYMBOL_VALUE_ADDRESS (var);
 430       memcpy (VALUE_CONTENTS_RAW (v), &addr, len);
 431       SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v), len);
 432       VALUE_LVAL (v) = not_lval;
 433       return v;
 434
 435     case LOC_CONST_BYTES:
 436       {
 437         char *bytes_addr;
 438         bytes_addr = SYMBOL_VALUE_BYTES (var);
 439         memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
 440         VALUE_LVAL (v) = not_lval;
 441         return v;
 442       }
 443
 444     case LOC_STATIC:
 445       addr = SYMBOL_VALUE_ADDRESS (var);
 446       break;
 447
 448     case LOC_ARG:
 449       if (SYMBOL_BASEREG_VALID (var))
 450         {
 451           addr = FRAME_GET_BASEREG_VALUE (frame, SYMBOL_BASEREG (var));
 452         }
 453       else
 454         {
 455           fi = get_frame_info (frame);
 456           if (fi == NULL)
 457             return 0;
 458           addr = FRAME_ARGS_ADDRESS (fi);
 459         }
 460       if (!addr)
 461         {
 462           return 0;
 463         }
 464       addr += SYMBOL_VALUE (var);
 465       break;
 466
 467     case LOC_REF_ARG:
 468       if (SYMBOL_BASEREG_VALID (var))
 469         {
 470           addr = FRAME_GET_BASEREG_VALUE (frame, SYMBOL_BASEREG (var));
 471         }
 472       else
 473         {
 474           fi = get_frame_info (frame);
 475           if (fi == NULL)
 476             return 0;
 477           addr = FRAME_ARGS_ADDRESS (fi);
 478         }
 479       if (!addr)
 480         {
 481           return 0;
 482         }
 483       addr += SYMBOL_VALUE (var);
 484       read_memory (addr, (char *) &addr, sizeof (CORE_ADDR));
 485       break;
 486
 487     case LOC_LOCAL:
 488     case LOC_LOCAL_ARG:
 489       if (SYMBOL_BASEREG_VALID (var))
 490         {
 491           addr = FRAME_GET_BASEREG_VALUE (frame, SYMBOL_BASEREG (var));
 492         }
 493       else
 494         {
 495           fi = get_frame_info (frame);
 496           if (fi == NULL)
 497             return 0;
 498           addr = FRAME_LOCALS_ADDRESS (fi);
 499         }
 500       addr += SYMBOL_VALUE (var);
 501       break;
 502
 503     case LOC_TYPEDEF:
 504       error ("Cannot look up value of a typedef");
 505       break;
 506
 507     case LOC_BLOCK:
 508       VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 509       return v;
 510
 511     case LOC_REGISTER:
 512     case LOC_REGPARM:
 513     case LOC_REGPARM_ADDR:
 514       {
 515         struct block *b;
 516
 517         if (frame == NULL)
 518           return 0;
 519         b = get_frame_block (frame);
 520
 521         v = value_from_register (type, SYMBOL_VALUE (var), frame);
 522
 523         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 524           {
 525             addr = *(CORE_ADDR *)VALUE_CONTENTS (v);
 526             VALUE_LVAL (v) = lval_memory;
 527           }
 528         else
 529           return v;
 530       }
 531       break;
 532
 533     case LOC_OPTIMIZED_OUT:
 534       VALUE_LVAL (v) = not_lval;
 535       VALUE_OPTIMIZED_OUT (v) = 1;
 536       return v;
 537
 538     default:
 539       error ("Cannot look up value of a botched symbol.");
 540       break;
 541     }
 542
 543   VALUE_ADDRESS (v) = addr;
 544   VALUE_LAZY (v) = 1;
 545   return v;
 546 }
 547
 548 /* Return a value of type TYPE, stored in register REGNUM, in frame
 549    FRAME. */
 550
 551 value
 552 value_from_register (type, regnum, frame)
 553      struct type *type;
 554      int regnum;
 555      FRAME frame;
 556 {
 557   char raw_buffer [MAX_REGISTER_RAW_SIZE];
 558   char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
 559   CORE_ADDR addr;
 560   int optim;
 561   value v = allocate_value (type);
 562   int len = TYPE_LENGTH (type);
 563   char *value_bytes = 0;
 564   int value_bytes_copied = 0;
 565   int num_storage_locs;
 566   enum lval_type lval;
 567
 568   VALUE_REGNO (v) = regnum;
 569
 570   num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
 571                       ((len - 1) / REGISTER_RAW_SIZE (regnum)) + 1 :
 572                       1);
 573
 574   if (num_storage_locs > 1
 575 #ifdef GDB_TARGET_IS_H8500
 576       || TYPE_CODE (type) == TYPE_CODE_PTR
 577 #endif
 578       )
 579     {
 580       /* Value spread across multiple storage locations.  */
 581
 582       int local_regnum;
 583       int mem_stor = 0, reg_stor = 0;
 584       int mem_tracking = 1;
 585       CORE_ADDR last_addr = 0;
 586       CORE_ADDR first_addr;
 587
 588       value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE);
 589
 590       /* Copy all of the data out, whereever it may be.  */
 591
 592 #ifdef GDB_TARGET_IS_H8500
 593 /* This piece of hideosity is required because the H8500 treats registers
 594    differently depending upon whether they are used as pointers or not.  As a
 595    pointer, a register needs to have a page register tacked onto the front.
 596    An alternate way to do this would be to have gcc output different register
 597    numbers for the pointer & non-pointer form of the register.  But, it
 598    doesn't, so we're stuck with this.  */
 599
 600       if (TYPE_CODE (type) == TYPE_CODE_PTR
 601           && len > 2)
 602         {
 603           int page_regnum;
 604
 605           switch (regnum)
 606             {
 607             case R0_REGNUM: case R1_REGNUM: case R2_REGNUM: case R3_REGNUM:
 608               page_regnum = SEG_D_REGNUM;
 609               break;
 610             case R4_REGNUM: case R5_REGNUM:
 611               page_regnum = SEG_E_REGNUM;
 612               break;
 613             case R6_REGNUM: case R7_REGNUM:
 614               page_regnum = SEG_T_REGNUM;
 615               break;
 616             }
 617
 618           value_bytes[0] = 0;
 619           get_saved_register (value_bytes + 1,
 620                               &optim,
 621                               &addr,
 622                               frame,
 623                               page_regnum,
 624                               &lval);
 625
 626           if (lval == lval_register)
 627             reg_stor++;
 628           else
 629             {
 630               mem_stor++;
 631               first_addr = addr;
 632             }
 633           last_addr = addr;
 634
 635           get_saved_register (value_bytes + 2,
 636                               &optim,
 637                               &addr,
 638                               frame,
 639                               regnum,
 640                               &lval);
 641
 642           if (lval == lval_register)
 643             reg_stor++;
 644           else
 645             {
 646               mem_stor++;
 647               mem_tracking = mem_tracking && (addr == last_addr);
 648             }
 649           last_addr = addr;
 650         }
 651       else
 652 #endif                          /* GDB_TARGET_IS_H8500 */
 653         for (local_regnum = regnum;
 654              value_bytes_copied < len;
 655              (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
 656               ++local_regnum))
 657           {
 658             get_saved_register (value_bytes + value_bytes_copied,
 659                                 &optim,
 660                                 &addr,
 661                                 frame,
 662                                 local_regnum,
 663                                 &lval);
 664             if (lval == lval_register)
 665               reg_stor++;
 666             else
 667               {
 668                 mem_stor++;
 669
 670                 if (regnum == local_regnum)
 671                   first_addr = addr;
 672
 673                 mem_tracking =
 674                   (mem_tracking
 675                    && (regnum == local_regnum
 676                        || addr == last_addr));
 677               }
 678             last_addr = addr;
 679           }
 680
 681       if ((reg_stor && mem_stor)
 682           || (mem_stor && !mem_tracking))
 683         /* Mixed storage; all of the hassle we just went through was
 684            for some good purpose.  */
 685         {
 686           VALUE_LVAL (v) = lval_reg_frame_relative;
 687           VALUE_FRAME (v) = FRAME_FP (frame);
 688           VALUE_FRAME_REGNUM (v) = regnum;
 689         }
 690       else if (mem_stor)
 691         {
 692           VALUE_LVAL (v) = lval_memory;
 693           VALUE_ADDRESS (v) = first_addr;
 694         }
 695       else if (reg_stor)
 696         {
 697           VALUE_LVAL (v) = lval_register;
 698           VALUE_ADDRESS (v) = first_addr;
 699         }
 700       else
 701         fatal ("value_from_register: Value not stored anywhere!");
 702
 703       VALUE_OPTIMIZED_OUT (v) = optim;
 704
 705       /* Any structure stored in more than one register will always be
 706          an integral number of registers.  Otherwise, you'd need to do
 707          some fiddling with the last register copied here for little
 708          endian machines.  */
 709
 710       /* Copy into the contents section of the value.  */
 711       memcpy (VALUE_CONTENTS_RAW (v), value_bytes, len);
 712
 713       return v;
 714     }
 715
 716   /* Data is completely contained within a single register.  Locate the
 717      register's contents in a real register or in core;
 718      read the data in raw format.  */
 719
 720   get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
 721   VALUE_OPTIMIZED_OUT (v) = optim;
 722   VALUE_LVAL (v) = lval;
 723   VALUE_ADDRESS (v) = addr;
 724
 725   /* Convert the raw contents to virtual contents.
 726      (Just copy them if the formats are the same.)  */
 727
 728   REGISTER_CONVERT_TO_VIRTUAL (regnum, raw_buffer, virtual_buffer);
 729
 730   if (REGISTER_CONVERTIBLE (regnum))
 731     {
 732       /* When the raw and virtual formats differ, the virtual format
 733          corresponds to a specific data type.  If we want that type,
 734          copy the data into the value.
 735          Otherwise, do a type-conversion.  */
 736
 737       if (type != REGISTER_VIRTUAL_TYPE (regnum))
 738         {
 739           /* eg a variable of type `float' in a 68881 register
 740              with raw type `extended' and virtual type `double'.
 741              Fetch it as a `double' and then convert to `float'.  */
 742           v = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
 743           memcpy (VALUE_CONTENTS_RAW (v), virtual_buffer, len);
 744           v = value_cast (type, v);
 745         }
 746       else
 747         memcpy (VALUE_CONTENTS_RAW (v), virtual_buffer, len);
 748     }
 749   else
 750     {
 751       /* Raw and virtual formats are the same for this register.  */
 752
 753 #if TARGET_BYTE_ORDER == BIG_ENDIAN
 754       if (len < REGISTER_RAW_SIZE (regnum))
 755         {
 756           /* Big-endian, and we want less than full size.  */
 757           VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
 758         }
 759 #endif
 760
 761       memcpy (VALUE_CONTENTS_RAW (v), virtual_buffer + VALUE_OFFSET (v), len);
 762     }
 763
 764   return v;
 765 }
 766 \f
 767 /* Given a struct symbol for a variable or function,
 768    and a stack frame id,
 769    return a (pointer to a) struct value containing the properly typed
 770    address.  */
 771
 772 value
 773 locate_var_value (var, frame)
 774      register struct symbol *var;
 775      FRAME frame;
 776 {
 777   CORE_ADDR addr = 0;
 778   struct type *type = SYMBOL_TYPE (var);
 779   value lazy_value;
 780
 781   /* Evaluate it first; if the result is a memory address, we're fine.
 782      Lazy evaluation pays off here. */
 783
 784   lazy_value = read_var_value (var, frame);
 785   if (lazy_value == 0)
 786     error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
 787
 788   if (VALUE_LAZY (lazy_value)
 789       || TYPE_CODE (type) == TYPE_CODE_FUNC)
 790     {
 791       addr = VALUE_ADDRESS (lazy_value);
 792       return value_from_longest (lookup_pointer_type (type), (LONGEST) addr);
 793     }
 794
 795   /* Not a memory address; check what the problem was.  */
 796   switch (VALUE_LVAL (lazy_value))
 797     {
 798     case lval_register:
 799     case lval_reg_frame_relative:
 800       error ("Address requested for identifier \"%s\" which is in a register.",
 801              SYMBOL_SOURCE_NAME (var));
 802       break;
 803
 804     default:
 805       error ("Can't take address of \"%s\" which isn't an lvalue.",
 806              SYMBOL_SOURCE_NAME (var));
 807       break;
 808     }
 809   return 0;  /* For lint -- never reached */
 810 }