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