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    If FRAME is NULL, use the selected_frame.  */
 359
 360 value
 361 read_var_value (var, frame)
 362      register struct symbol *var;
 363      FRAME frame;
 364 {
 365   register value v;
 366   struct frame_info *fi;
 367   struct type *type = SYMBOL_TYPE (var);
 368   CORE_ADDR addr;
 369   int val;
 370   register int len;
 371
 372   v = allocate_value (type);
 373   VALUE_LVAL (v) = lval_memory; /* The most likely possibility.  */
 374   len = TYPE_LENGTH (type);
 375
 376   if (frame == 0) frame = selected_frame;
 377
 378   switch (SYMBOL_CLASS (var))
 379     {
 380     case LOC_CONST:
 381       val = SYMBOL_VALUE (var);
 382       bcopy (&val, VALUE_CONTENTS_RAW (v), len);
 383       SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v), len);
 384       VALUE_LVAL (v) = not_lval;
 385       return v;
 386
 387     case LOC_LABEL:
 388       addr = SYMBOL_VALUE_ADDRESS (var);
 389       bcopy (&addr, VALUE_CONTENTS_RAW (v), len);
 390       SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (v), len);
 391       VALUE_LVAL (v) = not_lval;
 392       return v;
 393
 394     case LOC_CONST_BYTES:
 395       addr = SYMBOL_VALUE_ADDRESS (var);
 396       bcopy (addr, VALUE_CONTENTS_RAW (v), len);
 397       VALUE_LVAL (v) = not_lval;
 398       return v;
 399
 400     case LOC_STATIC:
 401     case LOC_EXTERNAL:
 402       addr = SYMBOL_VALUE_ADDRESS (var);
 403       break;
 404
 405 /* Nonzero if a struct which is located in a register or a LOC_ARG
 406    really contains
 407    the address of the struct, not the struct itself.  GCC_P is nonzero
 408    if the function was compiled with GCC.  */
 409 #if !defined (REG_STRUCT_HAS_ADDR)
 410 #define REG_STRUCT_HAS_ADDR(gcc_p) 0
 411 #endif
 412
 413     case LOC_ARG:
 414       fi = get_frame_info (frame);
 415       if (fi == NULL)
 416         return 0;
 417       addr = FRAME_ARGS_ADDRESS (fi);
 418       if (!addr) {
 419         return 0;
 420       }
 421       addr += SYMBOL_VALUE (var);
 422       break;
 423
 424     case LOC_REF_ARG:
 425       fi = get_frame_info (frame);
 426       if (fi == NULL)
 427         return 0;
 428       addr = FRAME_ARGS_ADDRESS (fi);
 429       if (!addr) {
 430         return 0;
 431       }
 432       addr += SYMBOL_VALUE (var);
 433       addr = read_memory_integer (addr, sizeof (CORE_ADDR));
 434       break;
 435
 436     case LOC_LOCAL:
 437     case LOC_LOCAL_ARG:
 438       fi = get_frame_info (frame);
 439       if (fi == NULL)
 440         return 0;
 441       addr = SYMBOL_VALUE (var) + FRAME_LOCALS_ADDRESS (fi);
 442       break;
 443
 444     case LOC_TYPEDEF:
 445       error ("Cannot look up value of a typedef");
 446       break;
 447
 448     case LOC_BLOCK:
 449       VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 450       return v;
 451
 452     case LOC_REGISTER:
 453     case LOC_REGPARM:
 454       {
 455         struct block *b;
 456
 457         if (frame == NULL)
 458           return 0;
 459         b = get_frame_block (frame);
 460
 461         v = value_from_register (type, SYMBOL_VALUE (var), frame);
 462
 463         if (REG_STRUCT_HAS_ADDR(b->gcc_compile_flag)
 464             && TYPE_CODE (type) == TYPE_CODE_STRUCT)
 465           addr = *(CORE_ADDR *)VALUE_CONTENTS (v);
 466         else
 467           return v;
 468       }
 469       break;
 470
 471     default:
 472       error ("Cannot look up value of a botched symbol.");
 473       break;
 474     }
 475
 476   VALUE_ADDRESS (v) = addr;
 477   VALUE_LAZY (v) = 1;
 478   return v;
 479 }
 480
 481 /* Return a value of type TYPE, stored in register REGNUM, in frame
 482    FRAME. */
 483
 484 value
 485 value_from_register (type, regnum, frame)
 486      struct type *type;
 487      int regnum;
 488      FRAME frame;
 489 {
 490   char raw_buffer [MAX_REGISTER_RAW_SIZE];
 491   char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
 492   CORE_ADDR addr;
 493   int optim;
 494   value v = allocate_value (type);
 495   int len = TYPE_LENGTH (type);
 496   char *value_bytes = 0;
 497   int value_bytes_copied = 0;
 498   int num_storage_locs;
 499   enum lval_type lval;
 500
 501   VALUE_REGNO (v) = regnum;
 502
 503   num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
 504                       ((len - 1) / REGISTER_RAW_SIZE (regnum)) + 1 :
 505                       1);
 506
 507   if (num_storage_locs > 1)
 508     {
 509       /* Value spread across multiple storage locations.  */
 510
 511       int local_regnum;
 512       int mem_stor = 0, reg_stor = 0;
 513       int mem_tracking = 1;
 514       CORE_ADDR last_addr = 0;
 515       CORE_ADDR first_addr;
 516
 517       value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE);
 518
 519       /* Copy all of the data out, whereever it may be.  */
 520
 521       for (local_regnum = regnum;
 522            value_bytes_copied < len;
 523            (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
 524             ++local_regnum))
 525         {
 526           get_saved_register (value_bytes + value_bytes_copied,
 527                               &optim,
 528                               &addr,
 529                               frame,
 530                               local_regnum,
 531                               &lval);
 532           if (lval == lval_register)
 533             reg_stor++;
 534           else
 535             {
 536               mem_stor++;
 537
 538               if (regnum == local_regnum)
 539                 first_addr = addr;
 540
 541               mem_tracking =
 542                 (mem_tracking
 543                  && (regnum == local_regnum
 544                      || addr == last_addr));
 545             }
 546           last_addr = addr;
 547         }
 548
 549       if ((reg_stor && mem_stor)
 550           || (mem_stor && !mem_tracking))
 551         /* Mixed storage; all of the hassle we just went through was
 552            for some good purpose.  */
 553         {
 554           VALUE_LVAL (v) = lval_reg_frame_relative;
 555           VALUE_FRAME (v) = FRAME_FP (frame);
 556           VALUE_FRAME_REGNUM (v) = regnum;
 557         }
 558       else if (mem_stor)
 559         {
 560           VALUE_LVAL (v) = lval_memory;
 561           VALUE_ADDRESS (v) = first_addr;
 562         }
 563       else if (reg_stor)
 564         {
 565           VALUE_LVAL (v) = lval_register;
 566           VALUE_ADDRESS (v) = first_addr;
 567         }
 568       else
 569         fatal ("value_from_register: Value not stored anywhere!");
 570
 571       VALUE_OPTIMIZED_OUT (v) = optim;
 572
 573       /* Any structure stored in more than one register will always be
 574          an integral number of registers.  Otherwise, you'd need to do
 575          some fiddling with the last register copied here for little
 576          endian machines.  */
 577
 578       /* Copy into the contents section of the value.  */
 579       bcopy (value_bytes, VALUE_CONTENTS_RAW (v), len);
 580
 581       return v;
 582     }
 583
 584   /* Data is completely contained within a single register.  Locate the
 585      register's contents in a real register or in core;
 586      read the data in raw format.  */
 587
 588   get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
 589   VALUE_OPTIMIZED_OUT (v) = optim;
 590   VALUE_LVAL (v) = lval;
 591   VALUE_ADDRESS (v) = addr;
 592
 593   /* Convert the raw contents to virtual contents.
 594      (Just copy them if the formats are the same.)  */
 595
 596   target_convert_to_virtual (regnum, raw_buffer, virtual_buffer);
 597
 598   if (REGISTER_CONVERTIBLE (regnum))
 599     {
 600       /* When the raw and virtual formats differ, the virtual format
 601          corresponds to a specific data type.  If we want that type,
 602          copy the data into the value.
 603          Otherwise, do a type-conversion.  */
 604
 605       if (type != REGISTER_VIRTUAL_TYPE (regnum))
 606         {
 607           /* eg a variable of type `float' in a 68881 register
 608              with raw type `extended' and virtual type `double'.
 609              Fetch it as a `double' and then convert to `float'.  */
 610           v = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
 611           bcopy (virtual_buffer, VALUE_CONTENTS_RAW (v), len);
 612           v = value_cast (type, v);
 613         }
 614       else
 615         bcopy (virtual_buffer, VALUE_CONTENTS_RAW (v), len);
 616     }
 617   else
 618     {
 619       /* Raw and virtual formats are the same for this register.  */
 620
 621 #if TARGET_BYTE_ORDER == BIG_ENDIAN
 622       if (len < REGISTER_RAW_SIZE (regnum))
 623         {
 624           /* Big-endian, and we want less than full size.  */
 625           VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
 626         }
 627 #endif
 628
 629       bcopy (virtual_buffer + VALUE_OFFSET (v),
 630              VALUE_CONTENTS_RAW (v), len);
 631     }
 632
 633   return v;
 634 }
 635 \f
 636 /* Given a struct symbol for a variable,
 637    and a stack frame id,
 638    return a (pointer to a) struct value containing the variable's 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   struct type *result_type;
 648   value lazy_value;
 649
 650   /* Evaluate it first; if the result is a memory address, we're fine.
 651      Lazy evaluation pays off here. */
 652
 653   lazy_value = read_var_value (var, frame);
 654   if (lazy_value == 0)
 655     error ("Address of \"%s\" is unknown.", SYMBOL_NAME (var));
 656
 657   if (VALUE_LAZY (lazy_value))
 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_long (type, buf);
 669           type = TYPE_TARGET_TYPE (type);
 670         }
 671
 672       /* Address of an array is of the type of address of it's elements.  */
 673       result_type =
 674         lookup_pointer_type (TYPE_CODE (type) == TYPE_CODE_ARRAY ?
 675                              TYPE_TARGET_TYPE (type) : type);
 676
 677       return value_cast (result_type,
 678                          value_from_long (builtin_type_long, (LONGEST) addr));
 679     }
 680
 681   /* Not a memory address; check what the problem was.  */
 682   switch (VALUE_LVAL (lazy_value))
 683     {
 684     case lval_register:
 685     case lval_reg_frame_relative:
 686       error ("Address requested for identifier \"%s\" which is in a register.",
 687              SYMBOL_NAME (var));
 688       break;
 689
 690     default:
 691       error ("Can't take address of \"%s\" which isn't an lvalue.",
 692              SYMBOL_NAME (var));
 693       break;
 694     }
 695   return 0;  /* For lint -- never reached */
 696 }