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 <stdio.h>
  21 #include "defs.h"
  22 #include "symtab.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 != NULL)
 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       bcopy (&FRAME_FP(selected_frame), myaddr, sizeof (CORE_ADDR));
 175       SWAP_TARGET_AND_HOST (myaddr, sizeof (CORE_ADDR)); /* 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   target_convert_to_virtual (regnum, raw_buffer, virtual_buffer);
 203   val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
 204   bcopy (virtual_buffer, VALUE_CONTENTS_RAW (val),
 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     bcopy (&registers[regbyte], myaddr, 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   bcopy (&registers[REGISTER_BYTE (regno)], myaddr, REGISTER_RAW_SIZE (regno));
 280 }
 281
 282 /* Copy LEN bytes of consecutive data from memory at MYADDR
 283    into registers starting with the REGBYTE'th byte of register data.  */
 284
 285 void
 286 write_register_bytes (regbyte, myaddr, len)
 287      int regbyte;
 288      char *myaddr;
 289      int len;
 290 {
 291   /* Make sure the entire registers array is valid.  */
 292   read_register_bytes (0, (char *)NULL, REGISTER_BYTES);
 293   bcopy (myaddr, &registers[regbyte], len);
 294   target_store_registers (-1);
 295 }
 296
 297 /* Return the contents of register REGNO, regarding it as an integer.  */
 298
 299 CORE_ADDR
 300 read_register (regno)
 301      int regno;
 302 {
 303   int reg;
 304   if (!register_valid[regno])
 305     target_fetch_registers (regno);
 306   /* FIXME, this loses when REGISTER_RAW_SIZE (regno) != sizeof (int) */
 307   reg = *(int *) &registers[REGISTER_BYTE (regno)];
 308   SWAP_TARGET_AND_HOST (&reg, sizeof (int));
 309   return reg;
 310 }
 311
 312 /* Registers we shouldn't try to store.  */
 313 #if !defined (CANNOT_STORE_REGISTER)
 314 #define CANNOT_STORE_REGISTER(regno) 0
 315 #endif
 316
 317 /* Store VALUE in the register number REGNO, regarded as an integer.  */
 318
 319 void
 320 write_register (regno, val)
 321      int regno, val;
 322 {
 323   /* On the sparc, writing %g0 is a no-op, so we don't even want to change
 324      the registers array if something writes to this register.  */
 325   if (CANNOT_STORE_REGISTER (regno))
 326     return;
 327
 328   SWAP_TARGET_AND_HOST (&val, sizeof (int));
 329
 330   target_prepare_to_store ();
 331
 332   register_valid [regno] = 1;
 333   /* FIXME, this loses when REGISTER_RAW_SIZE (regno) != sizeof (int) */
 334   /* FIXME, this depends on REGISTER_BYTE (regno) being aligned for host */
 335   *(int *) &registers[REGISTER_BYTE (regno)] = val;
 336
 337   target_store_registers (regno);
 338 }
 339
 340 /* Record that register REGNO contains VAL.
 341    This is used when the value is obtained from the inferior or core dump,
 342    so there is no need to store the value there.  */
 343
 344 void
 345 supply_register (regno, val)
 346      int regno;
 347      char *val;
 348 {
 349   register_valid[regno] = 1;
 350   bcopy (val, &registers[REGISTER_BYTE (regno)], REGISTER_RAW_SIZE (regno));
 351 }
 352 \f
 353 /* Given a struct symbol for a variable,
 354    and a stack frame id, read the value of the variable
 355    and return a (pointer to a) struct value containing the value.
 356    If the variable cannot be found, return a zero pointer.
 357    If FRAME is NULL, use the selected_frame.  */
 358
 359 value
 360 read_var_value (var, frame)
 361      register struct symbol *var;
 362      FRAME frame;
 363 {
 364   register value v;
 365   struct frame_info *fi;
 366   struct type *type = SYMBOL_TYPE (var);
 367   CORE_ADDR addr;
 368   register int len;
 369
 370   v = allocate_value (type);
 371   VALUE_LVAL (v) = lval_memory; /* The most likely possibility.  */
 372   len = TYPE_LENGTH (type);
 373
 374   if (frame == 0) frame = selected_frame;
 375
 376   switch (SYMBOL_CLASS (var))
 377     {
 378     case LOC_CONST:
 379       bcopy (&SYMBOL_VALUE (var), VALUE_CONTENTS_RAW (v), len);
 380       SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v), len);
 381       VALUE_LVAL (v) = not_lval;
 382       return v;
 383
 384     case LOC_LABEL:
 385       addr = SYMBOL_VALUE_ADDRESS (var);
 386       bcopy (&addr, VALUE_CONTENTS_RAW (v), len);
 387       SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v), len);
 388       VALUE_LVAL (v) = not_lval;
 389       return v;
 390
 391     case LOC_CONST_BYTES:
 392       {
 393         char *bytes_addr;
 394         bytes_addr = SYMBOL_VALUE_BYTES (var);
 395         bcopy (bytes_addr, VALUE_CONTENTS_RAW (v), len);
 396         VALUE_LVAL (v) = not_lval;
 397         return v;
 398       }
 399
 400     case LOC_STATIC:
 401       addr = SYMBOL_VALUE_ADDRESS (var);
 402       break;
 403
 404 /* Nonzero if a struct which is located in a register or a LOC_ARG
 405    really contains
 406    the address of the struct, not the struct itself.  GCC_P is nonzero
 407    if the function was compiled with GCC.  */
 408 #if !defined (REG_STRUCT_HAS_ADDR)
 409 #define REG_STRUCT_HAS_ADDR(gcc_p) 0
 410 #endif
 411
 412     case LOC_ARG:
 413       fi = get_frame_info (frame);
 414       if (fi == NULL)
 415         return 0;
 416       addr = FRAME_ARGS_ADDRESS (fi);
 417       if (!addr) {
 418         return 0;
 419       }
 420       addr += SYMBOL_VALUE (var);
 421       break;
 422
 423     case LOC_REF_ARG:
 424       fi = get_frame_info (frame);
 425       if (fi == NULL)
 426         return 0;
 427       addr = FRAME_ARGS_ADDRESS (fi);
 428       if (!addr) {
 429         return 0;
 430       }
 431       addr += SYMBOL_VALUE (var);
 432       read_memory (addr, &addr, sizeof (CORE_ADDR));
 433       break;
 434
 435     case LOC_LOCAL:
 436     case LOC_LOCAL_ARG:
 437       fi = get_frame_info (frame);
 438       if (fi == NULL)
 439         return 0;
 440       addr = SYMBOL_VALUE (var) + FRAME_LOCALS_ADDRESS (fi);
 441       break;
 442
 443     case LOC_TYPEDEF:
 444       error ("Cannot look up value of a typedef");
 445       break;
 446
 447     case LOC_BLOCK:
 448       VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 449       return v;
 450
 451     case LOC_REGISTER:
 452     case LOC_REGPARM:
 453       {
 454         struct block *b;
 455
 456         if (frame == NULL)
 457           return 0;
 458         b = get_frame_block (frame);
 459
 460         v = value_from_register (type, SYMBOL_VALUE (var), frame);
 461
 462         if (REG_STRUCT_HAS_ADDR (BLOCK_GCC_COMPILED (b))
 463             && TYPE_CODE (type) == TYPE_CODE_STRUCT)
 464           addr = *(CORE_ADDR *)VALUE_CONTENTS (v);
 465         else
 466           return v;
 467       }
 468       break;
 469
 470     default:
 471       error ("Cannot look up value of a botched symbol.");
 472       break;
 473     }
 474
 475   VALUE_ADDRESS (v) = addr;
 476   VALUE_LAZY (v) = 1;
 477   return v;
 478 }
 479
 480 /* Return a value of type TYPE, stored in register REGNUM, in frame
 481    FRAME. */
 482
 483 value
 484 value_from_register (type, regnum, frame)
 485      struct type *type;
 486      int regnum;
 487      FRAME frame;
 488 {
 489   char raw_buffer [MAX_REGISTER_RAW_SIZE];
 490   char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
 491   CORE_ADDR addr;
 492   int optim;
 493   value v = allocate_value (type);
 494   int len = TYPE_LENGTH (type);
 495   char *value_bytes = 0;
 496   int value_bytes_copied = 0;
 497   int num_storage_locs;
 498   enum lval_type lval;
 499
 500   VALUE_REGNO (v) = regnum;
 501
 502   num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
 503                       ((len - 1) / REGISTER_RAW_SIZE (regnum)) + 1 :
 504                       1);
 505
 506   if (num_storage_locs > 1)
 507     {
 508       /* Value spread across multiple storage locations.  */
 509
 510       int local_regnum;
 511       int mem_stor = 0, reg_stor = 0;
 512       int mem_tracking = 1;
 513       CORE_ADDR last_addr = 0;
 514       CORE_ADDR first_addr;
 515
 516       value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE);
 517
 518       /* Copy all of the data out, whereever it may be.  */
 519
 520       for (local_regnum = regnum;
 521            value_bytes_copied < len;
 522            (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
 523             ++local_regnum))
 524         {
 525           get_saved_register (value_bytes + value_bytes_copied,
 526                               &optim,
 527                               &addr,
 528                               frame,
 529                               local_regnum,
 530                               &lval);
 531           if (lval == lval_register)
 532             reg_stor++;
 533           else
 534             {
 535               mem_stor++;
 536
 537               if (regnum == local_regnum)
 538                 first_addr = addr;
 539
 540               mem_tracking =
 541                 (mem_tracking
 542                  && (regnum == local_regnum
 543                      || addr == last_addr));
 544             }
 545           last_addr = addr;
 546         }
 547
 548       if ((reg_stor && mem_stor)
 549           || (mem_stor && !mem_tracking))
 550         /* Mixed storage; all of the hassle we just went through was
 551            for some good purpose.  */
 552         {
 553           VALUE_LVAL (v) = lval_reg_frame_relative;
 554           VALUE_FRAME (v) = FRAME_FP (frame);
 555           VALUE_FRAME_REGNUM (v) = regnum;
 556         }
 557       else if (mem_stor)
 558         {
 559           VALUE_LVAL (v) = lval_memory;
 560           VALUE_ADDRESS (v) = first_addr;
 561         }
 562       else if (reg_stor)
 563         {
 564           VALUE_LVAL (v) = lval_register;
 565           VALUE_ADDRESS (v) = first_addr;
 566         }
 567       else
 568         fatal ("value_from_register: Value not stored anywhere!");
 569
 570       VALUE_OPTIMIZED_OUT (v) = optim;
 571
 572       /* Any structure stored in more than one register will always be
 573          an integral number of registers.  Otherwise, you'd need to do
 574          some fiddling with the last register copied here for little
 575          endian machines.  */
 576
 577       /* Copy into the contents section of the value.  */
 578       bcopy (value_bytes, VALUE_CONTENTS_RAW (v), len);
 579
 580       return v;
 581     }
 582
 583   /* Data is completely contained within a single register.  Locate the
 584      register's contents in a real register or in core;
 585      read the data in raw format.  */
 586
 587   get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
 588   VALUE_OPTIMIZED_OUT (v) = optim;
 589   VALUE_LVAL (v) = lval;
 590   VALUE_ADDRESS (v) = addr;
 591
 592   /* Convert the raw contents to virtual contents.
 593      (Just copy them if the formats are the same.)  */
 594
 595   target_convert_to_virtual (regnum, raw_buffer, virtual_buffer);
 596
 597   if (REGISTER_CONVERTIBLE (regnum))
 598     {
 599       /* When the raw and virtual formats differ, the virtual format
 600          corresponds to a specific data type.  If we want that type,
 601          copy the data into the value.
 602          Otherwise, do a type-conversion.  */
 603
 604       if (type != REGISTER_VIRTUAL_TYPE (regnum))
 605         {
 606           /* eg a variable of type `float' in a 68881 register
 607              with raw type `extended' and virtual type `double'.
 608              Fetch it as a `double' and then convert to `float'.  */
 609           v = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
 610           bcopy (virtual_buffer, VALUE_CONTENTS_RAW (v), len);
 611           v = value_cast (type, v);
 612         }
 613       else
 614         bcopy (virtual_buffer, VALUE_CONTENTS_RAW (v), len);
 615     }
 616   else
 617     {
 618       /* Raw and virtual formats are the same for this register.  */
 619
 620 #if TARGET_BYTE_ORDER == BIG_ENDIAN
 621       if (len < REGISTER_RAW_SIZE (regnum))
 622         {
 623           /* Big-endian, and we want less than full size.  */
 624           VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
 625         }
 626 #endif
 627
 628       bcopy (virtual_buffer + VALUE_OFFSET (v),
 629              VALUE_CONTENTS_RAW (v), len);
 630     }
 631
 632   return v;
 633 }
 634 \f
 635 /* Given a struct symbol for a variable or function,
 636    and a stack frame id,
 637    return a (pointer to a) struct value containing the properly typed
 638    address.  */
 639
 640 value
 641 locate_var_value (var, frame)
 642      register struct symbol *var;
 643      FRAME frame;
 644 {
 645   CORE_ADDR addr = 0;
 646   struct type *type = SYMBOL_TYPE (var);
 647   value lazy_value;
 648
 649   /* Evaluate it first; if the result is a memory address, we're fine.
 650      Lazy evaluation pays off here. */
 651
 652   lazy_value = read_var_value (var, frame);
 653   if (lazy_value == 0)
 654     error ("Address of \"%s\" is unknown.", SYMBOL_NAME (var));
 655
 656   if (VALUE_LAZY (lazy_value)
 657       || TYPE_CODE (type) == TYPE_CODE_FUNC)
 658     {
 659       addr = VALUE_ADDRESS (lazy_value);
 660
 661       /* C++: The "address" of a reference should yield the address
 662        * of the object pointed to. So force an extra de-reference. */
 663
 664       if (TYPE_CODE (type) == TYPE_CODE_REF)
 665         {
 666           char *buf = alloca (TYPE_LENGTH (type));
 667           read_memory (addr, buf, TYPE_LENGTH (type));
 668           addr = unpack_pointer (type, buf);
 669           type = TYPE_TARGET_TYPE (type);
 670         }
 671
 672       return value_from_longest (lookup_pointer_type (type), (LONGEST) addr);
 673     }
 674
 675   /* Not a memory address; check what the problem was.  */
 676   switch (VALUE_LVAL (lazy_value))
 677     {
 678     case lval_register:
 679     case lval_reg_frame_relative:
 680       error ("Address requested for identifier \"%s\" which is in a register.",
 681              SYMBOL_NAME (var));
 682       break;
 683
 684     default:
 685       error ("Can't take address of \"%s\" which isn't an lvalue.",
 686              SYMBOL_NAME (var));
 687       break;
 688     }
 689   return 0;  /* For lint -- never reached */
 690 }