gdb/findvar.c

   1 /* Find a variable's value in memory, for GDB, the GNU debugger.
   2    Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 GDB 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 1, or (at your option)
   9 any later version.
  10
  11 GDB 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 GDB; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include <stdio.h>
  21 #include "defs.h"
  22 #include "param.h"
  23 #include "symtab.h"
  24 #include "frame.h"
  25 #include "value.h"
  26 #include "gdbcore.h"
  27 #include "inferior.h"
  28 #include "target.h"
  29
  30 #if !defined (GET_SAVED_REGISTER)
  31
  32 /* Return the address in which frame FRAME's value of register REGNUM
  33    has been saved in memory.  Or return zero if it has not been saved.
  34    If REGNUM specifies the SP, the value we return is actually
  35    the SP value, not an address where it was saved.  */
  36
  37 CORE_ADDR
  38 find_saved_register (frame, regnum)
  39      FRAME frame;
  40      int regnum;
  41 {
  42   struct frame_info *fi;
  43   struct frame_saved_regs saved_regs;
  44
  45   register FRAME frame1 = 0;
  46   register CORE_ADDR addr = 0;
  47
  48   if (frame == 0)               /* No regs saved if want current frame */
  49     return 0;
  50
  51 #ifdef HAVE_REGISTER_WINDOWS
  52   /* We assume that a register in a register window will only be saved
  53      in one place (since the name changes and/or disappears as you go
  54      towards inner frames), so we only call get_frame_saved_regs on
  55      the current frame.  This is directly in contradiction to the
  56      usage below, which assumes that registers used in a frame must be
  57      saved in a lower (more interior) frame.  This change is a result
  58      of working on a register window machine; get_frame_saved_regs
  59      always returns the registers saved within a frame, within the
  60      context (register namespace) of that frame. */
  61
  62   /* However, note that we don't want this to return anything if
  63      nothing is saved (if there's a frame inside of this one).  Also,
  64      callers to this routine asking for the stack pointer want the
  65      stack pointer saved for *this* frame; this is returned from the
  66      next frame.  */
  67
  68
  69   if (REGISTER_IN_WINDOW_P(regnum))
  70     {
  71       frame1 = get_next_frame (frame);
  72       if (!frame1) return 0;    /* Registers of this frame are
  73                                    active.  */
  74
  75       /* Get the SP from the next frame in; it will be this
  76          current frame.  */
  77       if (regnum != SP_REGNUM)
  78         frame1 = frame;
  79
  80       fi = get_frame_info (frame1);
  81       get_frame_saved_regs (fi, &saved_regs);
  82       return saved_regs.regs[regnum];   /* ... which might be zero */
  83     }
  84 #endif /* HAVE_REGISTER_WINDOWS */
  85
  86   /* Note that this next routine assumes that registers used in
  87      frame x will be saved only in the frame that x calls and
  88      frames interior to it.  This is not true on the sparc, but the
  89      above macro takes care of it, so we should be all right. */
  90   while (1)
  91     {
  92       QUIT;
  93       frame1 = get_prev_frame (frame1);
  94       if (frame1 == 0 || frame1 == frame)
  95         break;
  96       fi = get_frame_info (frame1);
  97       get_frame_saved_regs (fi, &saved_regs);
  98       if (saved_regs.regs[regnum])
  99         addr = saved_regs.regs[regnum];
 100     }
 101
 102   return addr;
 103 }
 104
 105 /* Find register number REGNUM relative to FRAME and put its
 106    (raw) contents in *RAW_BUFFER.  Set *OPTIMIZED if the variable
 107    was optimized out (and thus can't be fetched).  Set *LVAL to
 108    lval_memory, lval_register, or not_lval, depending on whether the
 109    value was fetched from memory, from a register, or in a strange
 110    and non-modifiable way (e.g. a frame pointer which was calculated
 111    rather than fetched).  Set *ADDRP to the address, either in memory
 112    on as a REGISTER_BYTE offset into the registers array.
 113
 114    Note that this implementation never sets *LVAL to not_lval.  But
 115    it can be replaced by defining GET_SAVED_REGISTER and supplying
 116    your own.
 117
 118    The argument RAW_BUFFER must point to aligned memory.  */
 119 void
 120 get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 121      char *raw_buffer;
 122      int *optimized;
 123      CORE_ADDR *addrp;
 124      FRAME frame;
 125      int regnum;
 126      enum lval_type *lval;
 127 {
 128   CORE_ADDR addr;
 129   /* Normal systems don't optimize out things with register numbers.  */
 130   if (optimized != NULL)
 131     *optimized = 0;
 132   addr = find_saved_register (frame, regnum);
 133   if (addr != NULL)
 134     {
 135       if (lval != NULL)
 136         *lval = lval_memory;
 137       if (regnum == SP_REGNUM)
 138         {
 139           if (raw_buffer != NULL)
 140             *(CORE_ADDR *)raw_buffer = addr;
 141           if (addrp != NULL)
 142             *addrp = 0;
 143           return;
 144         }
 145       if (raw_buffer != NULL)
 146         read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
 147     }
 148   else
 149     {
 150       if (lval != NULL)
 151         *lval = lval_register;
 152       addr = REGISTER_BYTE (regnum);
 153       if (raw_buffer != NULL)
 154         read_register_gen (regnum, raw_buffer);
 155     }
 156   if (addrp != NULL)
 157     *addrp = addr;
 158 }
 159 #endif /* GET_SAVED_REGISTER.  */
 160
 161 /* Copy the bytes of register REGNUM, relative to the current stack frame,
 162    into our memory at MYADDR, in target byte order.
 163    The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
 164
 165    Returns 1 if could not be read, 0 if could.  */
 166
 167 int
 168 read_relative_register_raw_bytes (regnum, myaddr)
 169      int regnum;
 170      char *myaddr;
 171 {
 172   int optim;
 173   if (regnum == FP_REGNUM && selected_frame)
 174     {
 175       bcopy (&FRAME_FP(selected_frame), myaddr, sizeof (CORE_ADDR));
 176       SWAP_TARGET_AND_HOST (myaddr, sizeof (CORE_ADDR)); /* in target order */
 177       return 0;
 178     }
 179
 180   get_saved_register (myaddr, &optim, (CORE_ADDR) NULL, selected_frame,
 181                       regnum, (enum lval_type *)NULL);
 182   return optim;
 183 }
 184
 185 /* Return a `value' with the contents of register REGNUM
 186    in its virtual format, with the type specified by
 187    REGISTER_VIRTUAL_TYPE.  */
 188
 189 value
 190 value_of_register (regnum)
 191      int regnum;
 192 {
 193   CORE_ADDR addr;
 194   int optim;
 195   register value val;
 196   char raw_buffer[MAX_REGISTER_RAW_SIZE];
 197   char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
 198   enum lval_type lval;
 199
 200   get_saved_register (raw_buffer, &optim, &addr,
 201                       selected_frame, regnum, &lval);
 202
 203   target_convert_to_virtual (regnum, raw_buffer, virtual_buffer);
 204   val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
 205   bcopy (virtual_buffer, VALUE_CONTENTS_RAW (val),
 206          REGISTER_VIRTUAL_SIZE (regnum));
 207   VALUE_LVAL (val) = lval;
 208   VALUE_ADDRESS (val) = addr;
 209   VALUE_REGNO (val) = regnum;
 210   VALUE_OPTIMIZED_OUT (val) = optim;
 211   return val;
 212 }
 213 \f
 214 /* Low level examining and depositing of registers.
 215
 216    The caller is responsible for making
 217    sure that the inferior is stopped before calling the fetching routines,
 218    or it will get garbage.  (a change from GDB version 3, in which
 219    the caller got the value from the last stop).  */
 220
 221 /* Contents of the registers in target byte order.
 222    We allocate some extra slop since we do a lot of bcopy's around `registers',
 223    and failing-soft is better than failing hard.  */
 224 char registers[REGISTER_BYTES + /* SLOP */ 256];
 225
 226 /* Nonzero if that register has been fetched.  */
 227 char register_valid[NUM_REGS];
 228
 229 /* Indicate that registers may have changed, so invalidate the cache.  */
 230 void
 231 registers_changed ()
 232 {
 233   int i;
 234   for (i = 0; i < NUM_REGS; i++)
 235     register_valid[i] = 0;
 236 }
 237
 238 /* Indicate that all registers have been fetched, so mark them all valid.  */
 239 void
 240 registers_fetched ()
 241 {
 242   int i;
 243   for (i = 0; i < NUM_REGS; i++)
 244     register_valid[i] = 1;
 245 }
 246
 247 /* Copy LEN bytes of consecutive data from registers
 248    starting with the REGBYTE'th byte of register data
 249    into memory at MYADDR.  */
 250
 251 void
 252 read_register_bytes (regbyte, myaddr, len)
 253      int regbyte;
 254      char *myaddr;
 255      int len;
 256 {
 257   /* Fetch all registers.  */
 258   int i;
 259   for (i = 0; i < NUM_REGS; i++)
 260     if (!register_valid[i])
 261       {
 262         target_fetch_registers (-1);
 263         break;
 264       }
 265   if (myaddr != NULL)
 266     bcopy (&registers[regbyte], myaddr, len);
 267 }
 268
 269 /* Read register REGNO into memory at MYADDR, which must be large enough
 270    for REGISTER_RAW_BYTES (REGNO).  Target byte-order.
 271    If the register is known to be the size of a CORE_ADDR or smaller,
 272    read_register can be used instead.  */
 273 void
 274 read_register_gen (regno, myaddr)
 275      int regno;
 276      char *myaddr;
 277 {
 278   if (!register_valid[regno])
 279     target_fetch_registers (regno);
 280   bcopy (&registers[REGISTER_BYTE (regno)], myaddr, 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   bcopy (myaddr, &registers[regbyte], len);
 295   target_store_registers (-1);
 296 }
 297
 298 /* Return the contents of register REGNO, regarding it as an integer.  */
 299
 300 CORE_ADDR
 301 read_register (regno)
 302      int regno;
 303 {
 304   int reg;
 305   if (!register_valid[regno])
 306     target_fetch_registers (regno);
 307   /* FIXME, this loses when REGISTER_RAW_SIZE (regno) != sizeof (int) */
 308   reg = *(int *) &registers[REGISTER_BYTE (regno)];
 309   SWAP_TARGET_AND_HOST (&reg, sizeof (int));
 310   return reg;
 311 }
 312
 313 /* Registers we shouldn't try to store.  */
 314 #if !defined (CANNOT_STORE_REGISTER)
 315 #define CANNOT_STORE_REGISTER(regno) 0
 316 #endif
 317
 318 /* Store VALUE in the register number REGNO, regarded as an integer.  */
 319
 320 void
 321 write_register (regno, val)
 322      int regno, val;
 323 {
 324   /* On the sparc, writing %g0 is a no-op, so we don't even want to change
 325      the registers array if something writes to this register.  */
 326   if (CANNOT_STORE_REGISTER (regno))
 327     return;
 328
 329   SWAP_TARGET_AND_HOST (&val, sizeof (int));
 330
 331   target_prepare_to_store ();
 332
 333   register_valid [regno] = 1;
 334   /* FIXME, this loses when REGISTER_RAW_SIZE (regno) != sizeof (int) */
 335   /* FIXME, this depends on REGISTER_BYTE (regno) being aligned for host */
 336   *(int *) &registers[REGISTER_BYTE (regno)] = val;
 337
 338   target_store_registers (regno);
 339 }
 340
 341 /* Record that register REGNO contains VAL.
 342    This is used when the value is obtained from the inferior or core dump,
 343    so there is no need to store the value there.  */
 344
 345 void
 346 supply_register (regno, val)
 347      int regno;
 348      char *val;
 349 {
 350   register_valid[regno] = 1;
 351   bcopy (val, &registers[REGISTER_BYTE (regno)], REGISTER_RAW_SIZE (regno));
 352 }
 353 \f
 354 /* Given a struct symbol for a variable,
 355    and a stack frame id, read the value of the variable
 356    and return a (pointer to a) struct value containing the value.
 357    If the variable cannot be found, return a zero pointer.  */
 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   int val;
 369   register int len;
 370
 371   v = allocate_value (type);
 372   VALUE_LVAL (v) = lval_memory; /* The most likely possibility.  */
 373   len = TYPE_LENGTH (type);
 374
 375   if (frame == 0) frame = selected_frame;
 376
 377   switch (SYMBOL_CLASS (var))
 378     {
 379     case LOC_CONST:
 380       val = SYMBOL_VALUE (var);
 381       bcopy (&val, VALUE_CONTENTS_RAW (v), len);
 382       SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v), len);
 383       VALUE_LVAL (v) = not_lval;
 384       return v;
 385
 386     case LOC_LABEL:
 387       addr = SYMBOL_VALUE_ADDRESS (var);
 388       bcopy (&addr, VALUE_CONTENTS_RAW (v), len);
 389       SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v), len);
 390       VALUE_LVAL (v) = not_lval;
 391       return v;
 392
 393     case LOC_CONST_BYTES:
 394       addr = SYMBOL_VALUE_ADDRESS (var);
 395       bcopy (addr, VALUE_CONTENTS_RAW (v), len);
 396       VALUE_LVAL (v) = not_lval;
 397       return v;
 398
 399     case LOC_STATIC:
 400     case LOC_EXTERNAL:
 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       addr = FRAME_ARGS_ADDRESS (fi);
 415       if (!addr) {
 416         return 0;
 417       }
 418       addr += SYMBOL_VALUE (var);
 419       break;
 420
 421     case LOC_REF_ARG:
 422       fi = get_frame_info (frame);
 423       addr = FRAME_ARGS_ADDRESS (fi);
 424       if (!addr) {
 425         return 0;
 426       }
 427       addr += SYMBOL_VALUE (var);
 428       addr = read_memory_integer (addr, sizeof (CORE_ADDR));
 429       break;
 430
 431     case LOC_LOCAL:
 432     case LOC_LOCAL_ARG:
 433       fi = get_frame_info (frame);
 434       addr = SYMBOL_VALUE (var) + FRAME_LOCALS_ADDRESS (fi);
 435       break;
 436
 437     case LOC_TYPEDEF:
 438       error ("Cannot look up value of a typedef");
 439       break;
 440
 441     case LOC_BLOCK:
 442       VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 443       return v;
 444
 445     case LOC_REGISTER:
 446     case LOC_REGPARM:
 447       {
 448         struct block *b = get_frame_block (frame);
 449
 450         v = value_from_register (type, SYMBOL_VALUE (var), frame);
 451
 452         if (REG_STRUCT_HAS_ADDR(b->gcc_compile_flag)
 453             && TYPE_CODE (type) == TYPE_CODE_STRUCT)
 454           addr = *(CORE_ADDR *)VALUE_CONTENTS (v);
 455         else
 456           return v;
 457       }
 458       break;
 459
 460     default:
 461       error ("Cannot look up value of a botched symbol.");
 462       break;
 463     }
 464
 465   VALUE_ADDRESS (v) = addr;
 466   VALUE_LAZY (v) = 1;
 467   return v;
 468 }
 469
 470 /* Return a value of type TYPE, stored in register REGNUM, in frame
 471    FRAME. */
 472
 473 value
 474 value_from_register (type, regnum, frame)
 475      struct type *type;
 476      int regnum;
 477      FRAME frame;
 478 {
 479   char raw_buffer [MAX_REGISTER_RAW_SIZE];
 480   char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
 481   CORE_ADDR addr;
 482   int optim;
 483   value v = allocate_value (type);
 484   int len = TYPE_LENGTH (type);
 485   char *value_bytes = 0;
 486   int value_bytes_copied = 0;
 487   int num_storage_locs;
 488   enum lval_type lval;
 489
 490   VALUE_REGNO (v) = regnum;
 491
 492   num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
 493                       ((len - 1) / REGISTER_RAW_SIZE (regnum)) + 1 :
 494                       1);
 495
 496   if (num_storage_locs > 1)
 497     {
 498       /* Value spread across multiple storage locations.  */
 499
 500       int local_regnum;
 501       int mem_stor = 0, reg_stor = 0;
 502       int mem_tracking = 1;
 503       CORE_ADDR last_addr = 0;
 504       CORE_ADDR first_addr;
 505
 506       value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE);
 507
 508       /* Copy all of the data out, whereever it may be.  */
 509
 510       for (local_regnum = regnum;
 511            value_bytes_copied < len;
 512            (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
 513             ++local_regnum))
 514         {
 515           get_saved_register (value_bytes + value_bytes_copied,
 516                               &optim,
 517                               &addr,
 518                               frame,
 519                               local_regnum,
 520                               &lval);
 521           if (lval == lval_register)
 522             reg_stor++;
 523           else
 524             {
 525               mem_stor++;
 526
 527               if (regnum == local_regnum)
 528                 first_addr = addr;
 529
 530               mem_tracking =
 531                 (mem_tracking
 532                  && (regnum == local_regnum
 533                      || addr == last_addr));
 534             }
 535           last_addr = addr;
 536         }
 537
 538       if ((reg_stor && mem_stor)
 539           || (mem_stor && !mem_tracking))
 540         /* Mixed storage; all of the hassle we just went through was
 541            for some good purpose.  */
 542         {
 543           VALUE_LVAL (v) = lval_reg_frame_relative;
 544           VALUE_FRAME (v) = FRAME_FP (frame);
 545           VALUE_FRAME_REGNUM (v) = regnum;
 546         }
 547       else if (mem_stor)
 548         {
 549           VALUE_LVAL (v) = lval_memory;
 550           VALUE_ADDRESS (v) = first_addr;
 551         }
 552       else if (reg_stor)
 553         {
 554           VALUE_LVAL (v) = lval_register;
 555           VALUE_ADDRESS (v) = first_addr;
 556         }
 557       else
 558         fatal ("value_from_register: Value not stored anywhere!");
 559
 560       VALUE_OPTIMIZED_OUT (v) = optim;
 561
 562       /* Any structure stored in more than one register will always be
 563          an integral number of registers.  Otherwise, you'd need to do
 564          some fiddling with the last register copied here for little
 565          endian machines.  */
 566
 567       /* Copy into the contents section of the value.  */
 568       bcopy (value_bytes, VALUE_CONTENTS_RAW (v), len);
 569
 570       return v;
 571     }
 572
 573   /* Data is completely contained within a single register.  Locate the
 574      register's contents in a real register or in core;
 575      read the data in raw format.  */
 576
 577   get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
 578   VALUE_OPTIMIZED_OUT (v) = optim;
 579   VALUE_LVAL (v) = lval;
 580   VALUE_ADDRESS (v) = addr;
 581
 582   /* Convert the raw contents to virtual contents.
 583      (Just copy them if the formats are the same.)  */
 584
 585   target_convert_to_virtual (regnum, raw_buffer, virtual_buffer);
 586
 587   if (REGISTER_CONVERTIBLE (regnum))
 588     {
 589       /* When the raw and virtual formats differ, the virtual format
 590          corresponds to a specific data type.  If we want that type,
 591          copy the data into the value.
 592          Otherwise, do a type-conversion.  */
 593
 594       if (type != REGISTER_VIRTUAL_TYPE (regnum))
 595         {
 596           /* eg a variable of type `float' in a 68881 register
 597              with raw type `extended' and virtual type `double'.
 598              Fetch it as a `double' and then convert to `float'.  */
 599           v = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
 600           bcopy (virtual_buffer, VALUE_CONTENTS_RAW (v), len);
 601           v = value_cast (type, v);
 602         }
 603       else
 604         bcopy (virtual_buffer, VALUE_CONTENTS_RAW (v), len);
 605     }
 606   else
 607     {
 608       /* Raw and virtual formats are the same for this register.  */
 609
 610 #if TARGET_BYTE_ORDER == BIG_ENDIAN
 611       if (len < REGISTER_RAW_SIZE (regnum))
 612         {
 613           /* Big-endian, and we want less than full size.  */
 614           VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
 615         }
 616 #endif
 617
 618       bcopy (virtual_buffer + VALUE_OFFSET (v),
 619              VALUE_CONTENTS_RAW (v), len);
 620     }
 621
 622   return v;
 623 }
 624 \f
 625 /* Given a struct symbol for a variable,
 626    and a stack frame id,
 627    return a (pointer to a) struct value containing the variable's address.  */
 628
 629 value
 630 locate_var_value (var, frame)
 631      register struct symbol *var;
 632      FRAME frame;
 633 {
 634   CORE_ADDR addr = 0;
 635   struct type *type = SYMBOL_TYPE (var);
 636   struct type *result_type;
 637   value lazy_value;
 638
 639   /* Evaluate it first; if the result is a memory address, we're fine.
 640      Lazy evaluation pays off here. */
 641
 642   lazy_value = read_var_value (var, frame);
 643   if (lazy_value == 0)
 644     error ("Address of \"%s\" is unknown.", SYMBOL_NAME (var));
 645
 646   if (VALUE_LAZY (lazy_value))
 647     {
 648       addr = VALUE_ADDRESS (lazy_value);
 649
 650       /* C++: The "address" of a reference should yield the address
 651        * of the object pointed to. So force an extra de-reference. */
 652
 653       if (TYPE_CODE (type) == TYPE_CODE_REF)
 654         {
 655           char *buf = alloca (TYPE_LENGTH (type));
 656           read_memory (addr, buf, TYPE_LENGTH (type));
 657           addr = unpack_long (type, buf);
 658           type = TYPE_TARGET_TYPE (type);
 659         }
 660
 661       /* Address of an array is of the type of address of it's elements.  */
 662       result_type =
 663         lookup_pointer_type (TYPE_CODE (type) == TYPE_CODE_ARRAY ?
 664                              TYPE_TARGET_TYPE (type) : type);
 665
 666       return value_cast (result_type,
 667                          value_from_long (builtin_type_long, (LONGEST) addr));
 668     }
 669
 670   /* Not a memory address; check what the problem was.  */
 671   switch (VALUE_LVAL (lazy_value))
 672     {
 673     case lval_register:
 674     case lval_reg_frame_relative:
 675       error ("Address requested for identifier \"%s\" which is in a register.",
 676              SYMBOL_NAME (var));
 677       break;
 678
 679     default:
 680       error ("Can't take address of \"%s\" which isn't an lvalue.",
 681              SYMBOL_NAME (var));
 682       break;
 683     }
 684   return 0;  /* For lint -- never reached */
 685 }