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 ("Can't handle register size of %d for register %d\n",
 326              REGISTER_RAW_SIZE(regno), 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     }
 371
 372   target_store_registers (regno);
 373 }
 374
 375 /* Record that register REGNO contains VAL.
 376    This is used when the value is obtained from the inferior or core dump,
 377    so there is no need to store the value there.  */
 378
 379 void
 380 supply_register (regno, val)
 381      int regno;
 382      char *val;
 383 {
 384   register_valid[regno] = 1;
 385   memcpy (&registers[REGISTER_BYTE (regno)], val, REGISTER_RAW_SIZE (regno));
 386
 387   /* On some architectures, e.g. HPPA, there are a few stray bits in some
 388      registers, that the rest of the code would like to ignore.  */
 389 #ifdef CLEAN_UP_REGISTER_VALUE
 390   CLEAN_UP_REGISTER_VALUE(regno, &registers[REGISTER_BYTE(regno)]);
 391 #endif
 392 }
 393 \f
 394 /* Given a struct symbol for a variable,
 395    and a stack frame id, read the value of the variable
 396    and return a (pointer to a) struct value containing the value.
 397    If the variable cannot be found, return a zero pointer.
 398    If FRAME is NULL, use the selected_frame.  */
 399
 400 value
 401 read_var_value (var, frame)
 402      register struct symbol *var;
 403      FRAME frame;
 404 {
 405   register value v;
 406   struct frame_info *fi;
 407   struct type *type = SYMBOL_TYPE (var);
 408   CORE_ADDR addr;
 409   register int len;
 410
 411   v = allocate_value (type);
 412   VALUE_LVAL (v) = lval_memory; /* The most likely possibility.  */
 413   len = TYPE_LENGTH (type);
 414
 415   if (frame == 0) frame = selected_frame;
 416
 417   switch (SYMBOL_CLASS (var))
 418     {
 419     case LOC_CONST:
 420       memcpy (VALUE_CONTENTS_RAW (v), &SYMBOL_VALUE (var), len);
 421       SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v), len);
 422       VALUE_LVAL (v) = not_lval;
 423       return v;
 424
 425     case LOC_LABEL:
 426       addr = SYMBOL_VALUE_ADDRESS (var);
 427       memcpy (VALUE_CONTENTS_RAW (v), &addr, len);
 428       SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v), len);
 429       VALUE_LVAL (v) = not_lval;
 430       return v;
 431
 432     case LOC_CONST_BYTES:
 433       {
 434         char *bytes_addr;
 435         bytes_addr = SYMBOL_VALUE_BYTES (var);
 436         memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
 437         VALUE_LVAL (v) = not_lval;
 438         return v;
 439       }
 440
 441     case LOC_STATIC:
 442       addr = SYMBOL_VALUE_ADDRESS (var);
 443       break;
 444
 445     case LOC_ARG:
 446       if (SYMBOL_BASEREG_VALID (var))
 447         {
 448           addr = FRAME_GET_BASEREG_VALUE (frame, SYMBOL_BASEREG (var));
 449         }
 450       else
 451         {
 452           fi = get_frame_info (frame);
 453           if (fi == NULL)
 454             return 0;
 455           addr = FRAME_ARGS_ADDRESS (fi);
 456         }
 457       if (!addr)
 458         {
 459           return 0;
 460         }
 461       addr += SYMBOL_VALUE (var);
 462       break;
 463
 464     case LOC_REF_ARG:
 465       if (SYMBOL_BASEREG_VALID (var))
 466         {
 467           addr = FRAME_GET_BASEREG_VALUE (frame, SYMBOL_BASEREG (var));
 468         }
 469       else
 470         {
 471           fi = get_frame_info (frame);
 472           if (fi == NULL)
 473             return 0;
 474           addr = FRAME_ARGS_ADDRESS (fi);
 475         }
 476       if (!addr)
 477         {
 478           return 0;
 479         }
 480       addr += SYMBOL_VALUE (var);
 481       read_memory (addr, (char *) &addr, sizeof (CORE_ADDR));
 482       break;
 483
 484     case LOC_LOCAL:
 485     case LOC_LOCAL_ARG:
 486       if (SYMBOL_BASEREG_VALID (var))
 487         {
 488           addr = FRAME_GET_BASEREG_VALUE (frame, SYMBOL_BASEREG (var));
 489         }
 490       else
 491         {
 492           fi = get_frame_info (frame);
 493           if (fi == NULL)
 494             return 0;
 495           addr = FRAME_LOCALS_ADDRESS (fi);
 496         }
 497       addr += SYMBOL_VALUE (var);
 498       break;
 499
 500     case LOC_TYPEDEF:
 501       error ("Cannot look up value of a typedef");
 502       break;
 503
 504     case LOC_BLOCK:
 505       VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 506       return v;
 507
 508     case LOC_REGISTER:
 509     case LOC_REGPARM:
 510       {
 511         struct block *b;
 512
 513         if (frame == NULL)
 514           return 0;
 515         b = get_frame_block (frame);
 516
 517         v = value_from_register (type, SYMBOL_VALUE (var), frame);
 518
 519         /* Nonzero if a struct which is located in a register or a LOC_ARG
 520            really contains
 521            the address of the struct, not the struct itself.  GCC_P is nonzero
 522            if the function was compiled with GCC.  */
 523         /* A cleaner way to do this would be to add LOC_REGISTER_ADDR
 524            (register contains the address of the value) and LOC_REGPARM_ADDR,
 525            and have the symbol-reading code set them -kingdon.  */
 526 #if !defined (REG_STRUCT_HAS_ADDR)
 527 #define REG_STRUCT_HAS_ADDR(gcc_p) 0
 528 #endif
 529
 530         if (REG_STRUCT_HAS_ADDR (BLOCK_GCC_COMPILED (b))
 531             && (   (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 532                 || (TYPE_CODE (type) == TYPE_CODE_UNION)))
 533           {
 534             addr = *(CORE_ADDR *)VALUE_CONTENTS (v);
 535             VALUE_LVAL (v) = lval_memory;
 536           }
 537         else
 538           return v;
 539       }
 540       break;
 541
 542     default:
 543       error ("Cannot look up value of a botched symbol.");
 544       break;
 545     }
 546
 547   VALUE_ADDRESS (v) = addr;
 548   VALUE_LAZY (v) = 1;
 549   return v;
 550 }
 551
 552 /* Return a value of type TYPE, stored in register REGNUM, in frame
 553    FRAME. */
 554
 555 value
 556 value_from_register (type, regnum, frame)
 557      struct type *type;
 558      int regnum;
 559      FRAME frame;
 560 {
 561   char raw_buffer [MAX_REGISTER_RAW_SIZE];
 562   char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
 563   CORE_ADDR addr;
 564   int optim;
 565   value v = allocate_value (type);
 566   int len = TYPE_LENGTH (type);
 567   char *value_bytes = 0;
 568   int value_bytes_copied = 0;
 569   int num_storage_locs;
 570   enum lval_type lval;
 571
 572   VALUE_REGNO (v) = regnum;
 573
 574   num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
 575                       ((len - 1) / REGISTER_RAW_SIZE (regnum)) + 1 :
 576                       1);
 577
 578   if (num_storage_locs > 1
 579 #ifdef GDB_TARGET_IS_H8500
 580       || TYPE_CODE (type) == TYPE_CODE_PTR
 581 #endif
 582       )
 583     {
 584       /* Value spread across multiple storage locations.  */
 585
 586       int local_regnum;
 587       int mem_stor = 0, reg_stor = 0;
 588       int mem_tracking = 1;
 589       CORE_ADDR last_addr = 0;
 590       CORE_ADDR first_addr;
 591
 592       value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE);
 593
 594       /* Copy all of the data out, whereever it may be.  */
 595
 596 #ifdef GDB_TARGET_IS_H8500
 597 /* This piece of hideosity is required because the H8500 treats registers
 598    differently depending upon whether they are used as pointers or not.  As a
 599    pointer, a register needs to have a page register tacked onto the front.
 600    An alternate way to do this would be to have gcc output different register
 601    numbers for the pointer & non-pointer form of the register.  But, it
 602    doesn't, so we're stuck with this.  */
 603
 604       if (TYPE_CODE (type) == TYPE_CODE_PTR)
 605         {
 606           int page_regnum;
 607
 608           switch (regnum)
 609             {
 610             case R0_REGNUM: case R1_REGNUM: case R2_REGNUM: case R3_REGNUM:
 611               page_regnum = SEG_D_REGNUM;
 612               break;
 613             case R4_REGNUM: case R5_REGNUM:
 614               page_regnum = SEG_E_REGNUM;
 615               break;
 616             case R6_REGNUM: case R7_REGNUM:
 617               page_regnum = SEG_T_REGNUM;
 618               break;
 619             }
 620
 621           value_bytes[0] = 0;
 622           get_saved_register (value_bytes + 1,
 623                               &optim,
 624                               &addr,
 625                               frame,
 626                               page_regnum,
 627                               &lval);
 628
 629           if (lval == lval_register)
 630             reg_stor++;
 631           else
 632             {
 633               mem_stor++;
 634               first_addr = addr;
 635             }
 636           last_addr = addr;
 637
 638           get_saved_register (value_bytes + 2,
 639                               &optim,
 640                               &addr,
 641                               frame,
 642                               regnum,
 643                               &lval);
 644
 645           if (lval == lval_register)
 646             reg_stor++;
 647           else
 648             {
 649               mem_stor++;
 650               mem_tracking = mem_tracking && (addr == last_addr);
 651             }
 652           last_addr = addr;
 653         }
 654       else
 655 #endif                          /* GDB_TARGET_IS_H8500 */
 656         for (local_regnum = regnum;
 657              value_bytes_copied < len;
 658              (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
 659               ++local_regnum))
 660           {
 661             get_saved_register (value_bytes + value_bytes_copied,
 662                                 &optim,
 663                                 &addr,
 664                                 frame,
 665                                 local_regnum,
 666                                 &lval);
 667             if (lval == lval_register)
 668               reg_stor++;
 669             else
 670               {
 671                 mem_stor++;
 672
 673                 if (regnum == local_regnum)
 674                   first_addr = addr;
 675
 676                 mem_tracking =
 677                   (mem_tracking
 678                    && (regnum == local_regnum
 679                        || addr == last_addr));
 680               }
 681             last_addr = addr;
 682           }
 683
 684       if ((reg_stor && mem_stor)
 685           || (mem_stor && !mem_tracking))
 686         /* Mixed storage; all of the hassle we just went through was
 687            for some good purpose.  */
 688         {
 689           VALUE_LVAL (v) = lval_reg_frame_relative;
 690           VALUE_FRAME (v) = FRAME_FP (frame);
 691           VALUE_FRAME_REGNUM (v) = regnum;
 692         }
 693       else if (mem_stor)
 694         {
 695           VALUE_LVAL (v) = lval_memory;
 696           VALUE_ADDRESS (v) = first_addr;
 697         }
 698       else if (reg_stor)
 699         {
 700           VALUE_LVAL (v) = lval_register;
 701           VALUE_ADDRESS (v) = first_addr;
 702         }
 703       else
 704         fatal ("value_from_register: Value not stored anywhere!");
 705
 706       VALUE_OPTIMIZED_OUT (v) = optim;
 707
 708       /* Any structure stored in more than one register will always be
 709          an integral number of registers.  Otherwise, you'd need to do
 710          some fiddling with the last register copied here for little
 711          endian machines.  */
 712
 713       /* Copy into the contents section of the value.  */
 714       memcpy (VALUE_CONTENTS_RAW (v), value_bytes, len);
 715
 716       return v;
 717     }
 718
 719   /* Data is completely contained within a single register.  Locate the
 720      register's contents in a real register or in core;
 721      read the data in raw format.  */
 722
 723   get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
 724   VALUE_OPTIMIZED_OUT (v) = optim;
 725   VALUE_LVAL (v) = lval;
 726   VALUE_ADDRESS (v) = addr;
 727
 728   /* Convert the raw contents to virtual contents.
 729      (Just copy them if the formats are the same.)  */
 730
 731   REGISTER_CONVERT_TO_VIRTUAL (regnum, raw_buffer, virtual_buffer);
 732
 733   if (REGISTER_CONVERTIBLE (regnum))
 734     {
 735       /* When the raw and virtual formats differ, the virtual format
 736          corresponds to a specific data type.  If we want that type,
 737          copy the data into the value.
 738          Otherwise, do a type-conversion.  */
 739
 740       if (type != REGISTER_VIRTUAL_TYPE (regnum))
 741         {
 742           /* eg a variable of type `float' in a 68881 register
 743              with raw type `extended' and virtual type `double'.
 744              Fetch it as a `double' and then convert to `float'.  */
 745           v = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
 746           memcpy (VALUE_CONTENTS_RAW (v), virtual_buffer, len);
 747           v = value_cast (type, v);
 748         }
 749       else
 750         memcpy (VALUE_CONTENTS_RAW (v), virtual_buffer, len);
 751     }
 752   else
 753     {
 754       /* Raw and virtual formats are the same for this register.  */
 755
 756 #if TARGET_BYTE_ORDER == BIG_ENDIAN
 757       if (len < REGISTER_RAW_SIZE (regnum))
 758         {
 759           /* Big-endian, and we want less than full size.  */
 760           VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
 761         }
 762 #endif
 763
 764       memcpy (VALUE_CONTENTS_RAW (v), virtual_buffer + VALUE_OFFSET (v), len);
 765     }
 766
 767   return v;
 768 }
 769 \f
 770 /* Given a struct symbol for a variable or function,
 771    and a stack frame id,
 772    return a (pointer to a) struct value containing the properly typed
 773    address.  */
 774
 775 value
 776 locate_var_value (var, frame)
 777      register struct symbol *var;
 778      FRAME frame;
 779 {
 780   CORE_ADDR addr = 0;
 781   struct type *type = SYMBOL_TYPE (var);
 782   value lazy_value;
 783
 784   /* Evaluate it first; if the result is a memory address, we're fine.
 785      Lazy evaluation pays off here. */
 786
 787   lazy_value = read_var_value (var, frame);
 788   if (lazy_value == 0)
 789     error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
 790
 791   if (VALUE_LAZY (lazy_value)
 792       || TYPE_CODE (type) == TYPE_CODE_FUNC)
 793     {
 794       addr = VALUE_ADDRESS (lazy_value);
 795       return value_from_longest (lookup_pointer_type (type), (LONGEST) addr);
 796     }
 797
 798   /* Not a memory address; check what the problem was.  */
 799   switch (VALUE_LVAL (lazy_value))
 800     {
 801     case lval_register:
 802     case lval_reg_frame_relative:
 803       error ("Address requested for identifier \"%s\" which is in a register.",
 804              SYMBOL_SOURCE_NAME (var));
 805       break;
 806
 807     default:
 808       error ("Can't take address of \"%s\" which isn't an lvalue.",
 809              SYMBOL_SOURCE_NAME (var));
 810       break;
 811     }
 812   return 0;  /* For lint -- never reached */
 813 }