gdb/findvar.c

   1 /* Find a variable's value in memory, for GDB, the GNU debugger.
   2    Copyright 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "gdbtypes.h"
  23 #include "frame.h"
  24 #include "value.h"
  25 #include "gdbcore.h"
  26 #include "inferior.h"
  27 #include "target.h"
  28
  29 /* Basic byte-swapping routines.  GDB has needed these for a long time...
  30    All extract a target-format integer at ADDR which is LEN bytes long.  */
  31
  32 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
  33   /* 8 bit characters are a pretty safe assumption these days, so we
  34      assume it throughout all these swapping routines.  If we had to deal with
  35      9 bit characters, we would need to make len be in bits and would have
  36      to re-write these routines...  */
  37   you lose
  38 #endif
  39
  40 LONGEST
  41 extract_signed_integer (addr, len)
  42      PTR addr;
  43      int len;
  44 {
  45   LONGEST retval;
  46   unsigned char *p;
  47   unsigned char *startaddr = (unsigned char *)addr;
  48   unsigned char *endaddr = startaddr + len;
  49
  50   if (len > sizeof (LONGEST))
  51     error ("\
  52 That operation is not available on integers of more than %d bytes.",
  53            sizeof (LONGEST));
  54
  55   /* Start at the most significant end of the integer, and work towards
  56      the least significant.  */
  57 #if TARGET_BYTE_ORDER == BIG_ENDIAN
  58   p = startaddr;
  59 #else
  60   p = endaddr - 1;
  61 #endif
  62   /* Do the sign extension once at the start.  */
  63   retval = ((LONGEST)*p ^ 0x80) - 0x80;
  64 #if TARGET_BYTE_ORDER == BIG_ENDIAN
  65   for (++p; p < endaddr; ++p)
  66 #else
  67   for (--p; p >= startaddr; --p)
  68 #endif
  69     {
  70       retval = (retval << 8) | *p;
  71     }
  72   return retval;
  73 }
  74
  75 unsigned LONGEST
  76 extract_unsigned_integer (addr, len)
  77      PTR addr;
  78      int len;
  79 {
  80   unsigned LONGEST retval;
  81   unsigned char *p;
  82   unsigned char *startaddr = (unsigned char *)addr;
  83   unsigned char *endaddr = startaddr + len;
  84
  85   if (len > sizeof (unsigned LONGEST))
  86     error ("\
  87 That operation is not available on integers of more than %d bytes.",
  88            sizeof (unsigned LONGEST));
  89
  90   /* Start at the most significant end of the integer, and work towards
  91      the least significant.  */
  92   retval = 0;
  93 #if TARGET_BYTE_ORDER == BIG_ENDIAN
  94   for (p = startaddr; p < endaddr; ++p)
  95 #else
  96   for (p = endaddr - 1; p >= startaddr; --p)
  97 #endif
  98     {
  99       retval = (retval << 8) | *p;
 100     }
 101   return retval;
 102 }
 103
 104 CORE_ADDR
 105 extract_address (addr, len)
 106      PTR addr;
 107      int len;
 108 {
 109   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
 110      whether we want this to be true eventually.  */
 111   return extract_unsigned_integer (addr, len);
 112 }
 113
 114 void
 115 store_signed_integer (addr, len, val)
 116      PTR addr;
 117      int len;
 118      LONGEST val;
 119 {
 120   unsigned char *p;
 121   unsigned char *startaddr = (unsigned char *)addr;
 122   unsigned char *endaddr = startaddr + len;
 123
 124   /* Start at the least significant end of the integer, and work towards
 125      the most significant.  */
 126 #if TARGET_BYTE_ORDER == BIG_ENDIAN
 127   for (p = endaddr - 1; p >= startaddr; --p)
 128 #else
 129   for (p = startaddr; p < endaddr; ++p)
 130 #endif
 131     {
 132       *p = val & 0xff;
 133       val >>= 8;
 134     }
 135 }
 136
 137 void
 138 store_unsigned_integer (addr, len, val)
 139      PTR addr;
 140      int len;
 141      unsigned LONGEST val;
 142 {
 143   unsigned char *p;
 144   unsigned char *startaddr = (unsigned char *)addr;
 145   unsigned char *endaddr = startaddr + len;
 146
 147   /* Start at the least significant end of the integer, and work towards
 148      the most significant.  */
 149 #if TARGET_BYTE_ORDER == BIG_ENDIAN
 150   for (p = endaddr - 1; p >= startaddr; --p)
 151 #else
 152   for (p = startaddr; p < endaddr; ++p)
 153 #endif
 154     {
 155       *p = val & 0xff;
 156       val >>= 8;
 157     }
 158 }
 159
 160 void
 161 store_address (addr, len, val)
 162      PTR addr;
 163      int len;
 164      CORE_ADDR val;
 165 {
 166   /* Assume a CORE_ADDR can fit in a LONGEST (for now).  Not sure
 167      whether we want this to be true eventually.  */
 168   store_unsigned_integer (addr, len, (LONGEST)val);
 169 }
 170 \f
 171 #if !defined (GET_SAVED_REGISTER)
 172
 173 /* Return the address in which frame FRAME's value of register REGNUM
 174    has been saved in memory.  Or return zero if it has not been saved.
 175    If REGNUM specifies the SP, the value we return is actually
 176    the SP value, not an address where it was saved.  */
 177
 178 CORE_ADDR
 179 find_saved_register (frame, regnum)
 180      FRAME frame;
 181      int regnum;
 182 {
 183   struct frame_info *fi;
 184   struct frame_saved_regs saved_regs;
 185
 186   register FRAME frame1 = 0;
 187   register CORE_ADDR addr = 0;
 188
 189   if (frame == 0)               /* No regs saved if want current frame */
 190     return 0;
 191
 192 #ifdef HAVE_REGISTER_WINDOWS
 193   /* We assume that a register in a register window will only be saved
 194      in one place (since the name changes and/or disappears as you go
 195      towards inner frames), so we only call get_frame_saved_regs on
 196      the current frame.  This is directly in contradiction to the
 197      usage below, which assumes that registers used in a frame must be
 198      saved in a lower (more interior) frame.  This change is a result
 199      of working on a register window machine; get_frame_saved_regs
 200      always returns the registers saved within a frame, within the
 201      context (register namespace) of that frame. */
 202
 203   /* However, note that we don't want this to return anything if
 204      nothing is saved (if there's a frame inside of this one).  Also,
 205      callers to this routine asking for the stack pointer want the
 206      stack pointer saved for *this* frame; this is returned from the
 207      next frame.  */
 208
 209
 210   if (REGISTER_IN_WINDOW_P(regnum))
 211     {
 212       frame1 = get_next_frame (frame);
 213       if (!frame1) return 0;    /* Registers of this frame are
 214                                    active.  */
 215
 216       /* Get the SP from the next frame in; it will be this
 217          current frame.  */
 218       if (regnum != SP_REGNUM)
 219         frame1 = frame;
 220
 221       fi = get_frame_info (frame1);
 222       get_frame_saved_regs (fi, &saved_regs);
 223       return saved_regs.regs[regnum];   /* ... which might be zero */
 224     }
 225 #endif /* HAVE_REGISTER_WINDOWS */
 226
 227   /* Note that this next routine assumes that registers used in
 228      frame x will be saved only in the frame that x calls and
 229      frames interior to it.  This is not true on the sparc, but the
 230      above macro takes care of it, so we should be all right. */
 231   while (1)
 232     {
 233       QUIT;
 234       frame1 = get_prev_frame (frame1);
 235       if (frame1 == 0 || frame1 == frame)
 236         break;
 237       fi = get_frame_info (frame1);
 238       get_frame_saved_regs (fi, &saved_regs);
 239       if (saved_regs.regs[regnum])
 240         addr = saved_regs.regs[regnum];
 241     }
 242
 243   return addr;
 244 }
 245
 246 /* Find register number REGNUM relative to FRAME and put its (raw,
 247    target format) contents in *RAW_BUFFER.  Set *OPTIMIZED if the
 248    variable was optimized out (and thus can't be fetched).  Set *LVAL
 249    to lval_memory, lval_register, or not_lval, depending on whether
 250    the value was fetched from memory, from a register, or in a strange
 251    and non-modifiable way (e.g. a frame pointer which was calculated
 252    rather than fetched).  Set *ADDRP to the address, either in memory
 253    on as a REGISTER_BYTE offset into the registers array.
 254
 255    Note that this implementation never sets *LVAL to not_lval.  But
 256    it can be replaced by defining GET_SAVED_REGISTER and supplying
 257    your own.
 258
 259    The argument RAW_BUFFER must point to aligned memory.  */
 260
 261 void
 262 get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
 263      char *raw_buffer;
 264      int *optimized;
 265      CORE_ADDR *addrp;
 266      FRAME frame;
 267      int regnum;
 268      enum lval_type *lval;
 269 {
 270   CORE_ADDR addr;
 271   /* Normal systems don't optimize out things with register numbers.  */
 272   if (optimized != NULL)
 273     *optimized = 0;
 274   addr = find_saved_register (frame, regnum);
 275   if (addr != 0)
 276     {
 277       if (lval != NULL)
 278         *lval = lval_memory;
 279       if (regnum == SP_REGNUM)
 280         {
 281           if (raw_buffer != NULL)
 282             {
 283               /* Put it back in target format.  */
 284               store_address (raw_buffer, REGISTER_RAW_SIZE (regnum), addr);
 285             }
 286           if (addrp != NULL)
 287             *addrp = 0;
 288           return;
 289         }
 290       if (raw_buffer != NULL)
 291         read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
 292     }
 293   else
 294     {
 295       if (lval != NULL)
 296         *lval = lval_register;
 297       addr = REGISTER_BYTE (regnum);
 298       if (raw_buffer != NULL)
 299         read_register_gen (regnum, raw_buffer);
 300     }
 301   if (addrp != NULL)
 302     *addrp = addr;
 303 }
 304 #endif /* GET_SAVED_REGISTER.  */
 305
 306 /* Copy the bytes of register REGNUM, relative to the current stack frame,
 307    into our memory at MYADDR, in target byte order.
 308    The number of bytes copied is REGISTER_RAW_SIZE (REGNUM).
 309
 310    Returns 1 if could not be read, 0 if could.  */
 311
 312 int
 313 read_relative_register_raw_bytes (regnum, myaddr)
 314      int regnum;
 315      char *myaddr;
 316 {
 317   int optim;
 318   if (regnum == FP_REGNUM && selected_frame)
 319     {
 320       /* Put it back in target format.  */
 321       store_address (myaddr, REGISTER_RAW_SIZE(FP_REGNUM),
 322                      FRAME_FP(selected_frame));
 323       return 0;
 324     }
 325
 326   get_saved_register (myaddr, &optim, (CORE_ADDR *) NULL, selected_frame,
 327                       regnum, (enum lval_type *)NULL);
 328   return optim;
 329 }
 330
 331 /* Return a `value' with the contents of register REGNUM
 332    in its virtual format, with the type specified by
 333    REGISTER_VIRTUAL_TYPE.  */
 334
 335 value
 336 value_of_register (regnum)
 337      int regnum;
 338 {
 339   CORE_ADDR addr;
 340   int optim;
 341   register value val;
 342   char raw_buffer[MAX_REGISTER_RAW_SIZE];
 343   char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
 344   enum lval_type lval;
 345
 346   get_saved_register (raw_buffer, &optim, &addr,
 347                       selected_frame, regnum, &lval);
 348
 349   REGISTER_CONVERT_TO_VIRTUAL (regnum, raw_buffer, virtual_buffer);
 350   val = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
 351   memcpy (VALUE_CONTENTS_RAW (val), virtual_buffer,
 352           REGISTER_VIRTUAL_SIZE (regnum));
 353   VALUE_LVAL (val) = lval;
 354   VALUE_ADDRESS (val) = addr;
 355   VALUE_REGNO (val) = regnum;
 356   VALUE_OPTIMIZED_OUT (val) = optim;
 357   return val;
 358 }
 359 \f
 360 /* Low level examining and depositing of registers.
 361
 362    The caller is responsible for making
 363    sure that the inferior is stopped before calling the fetching routines,
 364    or it will get garbage.  (a change from GDB version 3, in which
 365    the caller got the value from the last stop).  */
 366
 367 /* Contents of the registers in target byte order.
 368    We allocate some extra slop since we do a lot of memcpy's around `registers',
 369    and failing-soft is better than failing hard.  */
 370 char registers[REGISTER_BYTES + /* SLOP */ 256];
 371
 372 /* Nonzero if that register has been fetched.  */
 373 char register_valid[NUM_REGS];
 374
 375 /* Indicate that registers may have changed, so invalidate the cache.  */
 376 void
 377 registers_changed ()
 378 {
 379   int i;
 380   for (i = 0; i < NUM_REGS; i++)
 381     register_valid[i] = 0;
 382 }
 383
 384 /* Indicate that all registers have been fetched, so mark them all valid.  */
 385 void
 386 registers_fetched ()
 387 {
 388   int i;
 389   for (i = 0; i < NUM_REGS; i++)
 390     register_valid[i] = 1;
 391 }
 392
 393 /* Copy LEN bytes of consecutive data from registers
 394    starting with the REGBYTE'th byte of register data
 395    into memory at MYADDR.  */
 396
 397 void
 398 read_register_bytes (regbyte, myaddr, len)
 399      int regbyte;
 400      char *myaddr;
 401      int len;
 402 {
 403   /* Fetch all registers.  */
 404   int i;
 405   for (i = 0; i < NUM_REGS; i++)
 406     if (!register_valid[i])
 407       {
 408         target_fetch_registers (-1);
 409         break;
 410       }
 411   if (myaddr != NULL)
 412     memcpy (myaddr, &registers[regbyte], len);
 413 }
 414
 415 /* Read register REGNO into memory at MYADDR, which must be large enough
 416    for REGISTER_RAW_BYTES (REGNO).  Target byte-order.
 417    If the register is known to be the size of a CORE_ADDR or smaller,
 418    read_register can be used instead.  */
 419 void
 420 read_register_gen (regno, myaddr)
 421      int regno;
 422      char *myaddr;
 423 {
 424   if (!register_valid[regno])
 425     target_fetch_registers (regno);
 426   memcpy (myaddr, &registers[REGISTER_BYTE (regno)],
 427           REGISTER_RAW_SIZE (regno));
 428 }
 429
 430 /* Copy LEN bytes of consecutive data from memory at MYADDR
 431    into registers starting with the REGBYTE'th byte of register data.  */
 432
 433 void
 434 write_register_bytes (regbyte, myaddr, len)
 435      int regbyte;
 436      char *myaddr;
 437      int len;
 438 {
 439   /* Make sure the entire registers array is valid.  */
 440   read_register_bytes (0, (char *)NULL, REGISTER_BYTES);
 441   memcpy (&registers[regbyte], myaddr, len);
 442   target_store_registers (-1);
 443 }
 444
 445 /* Return the raw contents of register REGNO, regarding it as an integer.  */
 446 /* This probably should be returning LONGEST rather than CORE_ADDR.  */
 447
 448 CORE_ADDR
 449 read_register (regno)
 450      int regno;
 451 {
 452   if (!register_valid[regno])
 453     target_fetch_registers (regno);
 454
 455   return extract_address (&registers[REGISTER_BYTE (regno)],
 456                           REGISTER_RAW_SIZE(regno));
 457 }
 458
 459 /* Registers we shouldn't try to store.  */
 460 #if !defined (CANNOT_STORE_REGISTER)
 461 #define CANNOT_STORE_REGISTER(regno) 0
 462 #endif
 463
 464 /* Store VALUE, into the raw contents of register number REGNO.  */
 465 /* FIXME: The val arg should probably be a LONGEST.  */
 466
 467 void
 468 write_register (regno, val)
 469      int regno;
 470      LONGEST val;
 471 {
 472   PTR buf;
 473   int size;
 474
 475   /* On the sparc, writing %g0 is a no-op, so we don't even want to change
 476      the registers array if something writes to this register.  */
 477   if (CANNOT_STORE_REGISTER (regno))
 478     return;
 479
 480   size = REGISTER_RAW_SIZE(regno);
 481   buf = alloca (size);
 482   store_signed_integer (buf, size, (LONGEST) val);
 483
 484   /* If we have a valid copy of the register, and new value == old value,
 485      then don't bother doing the actual store. */
 486
 487   if (register_valid [regno])
 488     {
 489       if (memcmp (&registers[REGISTER_BYTE (regno)], buf, size) == 0)
 490         return;
 491     }
 492
 493   target_prepare_to_store ();
 494
 495   memcpy (&registers[REGISTER_BYTE (regno)], buf, size);
 496
 497   register_valid [regno] = 1;
 498
 499   target_store_registers (regno);
 500 }
 501
 502 /* Record that register REGNO contains VAL.
 503    This is used when the value is obtained from the inferior or core dump,
 504    so there is no need to store the value there.  */
 505
 506 void
 507 supply_register (regno, val)
 508      int regno;
 509      char *val;
 510 {
 511   register_valid[regno] = 1;
 512   memcpy (&registers[REGISTER_BYTE (regno)], val, REGISTER_RAW_SIZE (regno));
 513
 514   /* On some architectures, e.g. HPPA, there are a few stray bits in some
 515      registers, that the rest of the code would like to ignore.  */
 516 #ifdef CLEAN_UP_REGISTER_VALUE
 517   CLEAN_UP_REGISTER_VALUE(regno, &registers[REGISTER_BYTE(regno)]);
 518 #endif
 519 }
 520 \f
 521 /* Will calling read_var_value or locate_var_value on SYM end
 522    up caring what frame it is being evaluated relative to?  SYM must
 523    be non-NULL.  */
 524 int
 525 symbol_read_needs_frame (sym)
 526      struct symbol *sym;
 527 {
 528   switch (SYMBOL_CLASS (sym))
 529     {
 530       /* All cases listed explicitly so that gcc -Wall will detect it if
 531          we failed to consider one.  */
 532     case LOC_REGISTER:
 533     case LOC_ARG:
 534     case LOC_REF_ARG:
 535     case LOC_REGPARM:
 536     case LOC_REGPARM_ADDR:
 537     case LOC_LOCAL:
 538     case LOC_LOCAL_ARG:
 539     case LOC_BASEREG:
 540     case LOC_BASEREG_ARG:
 541       return 1;
 542
 543     case LOC_UNDEF:
 544     case LOC_CONST:
 545     case LOC_STATIC:
 546     case LOC_TYPEDEF:
 547
 548     case LOC_LABEL:
 549       /* Getting the address of a label can be done independently of the block,
 550          even if some *uses* of that address wouldn't work so well without
 551          the right frame.  */
 552
 553     case LOC_BLOCK:
 554     case LOC_CONST_BYTES:
 555     case LOC_OPTIMIZED_OUT:
 556       return 0;
 557     }
 558 }
 559
 560 /* Given a struct symbol for a variable,
 561    and a stack frame id, read the value of the variable
 562    and return a (pointer to a) struct value containing the value.
 563    If the variable cannot be found, return a zero pointer.
 564    If FRAME is NULL, use the selected_frame.  */
 565
 566 value
 567 read_var_value (var, frame)
 568      register struct symbol *var;
 569      FRAME frame;
 570 {
 571   register value v;
 572   struct frame_info *fi;
 573   struct type *type = SYMBOL_TYPE (var);
 574   CORE_ADDR addr;
 575   register int len;
 576
 577   v = allocate_value (type);
 578   VALUE_LVAL (v) = lval_memory; /* The most likely possibility.  */
 579   len = TYPE_LENGTH (type);
 580
 581   if (frame == 0) frame = selected_frame;
 582
 583   switch (SYMBOL_CLASS (var))
 584     {
 585     case LOC_CONST:
 586       /* Put the constant back in target format.  */
 587       store_signed_integer (VALUE_CONTENTS_RAW (v), len,
 588                             (LONGEST) SYMBOL_VALUE (var));
 589       VALUE_LVAL (v) = not_lval;
 590       return v;
 591
 592     case LOC_LABEL:
 593       /* Put the constant back in target format.  */
 594       store_address (VALUE_CONTENTS_RAW (v), len, SYMBOL_VALUE_ADDRESS (var));
 595       VALUE_LVAL (v) = not_lval;
 596       return v;
 597
 598     case LOC_CONST_BYTES:
 599       {
 600         char *bytes_addr;
 601         bytes_addr = SYMBOL_VALUE_BYTES (var);
 602         memcpy (VALUE_CONTENTS_RAW (v), bytes_addr, len);
 603         VALUE_LVAL (v) = not_lval;
 604         return v;
 605       }
 606
 607     case LOC_STATIC:
 608       addr = SYMBOL_VALUE_ADDRESS (var);
 609       break;
 610
 611     case LOC_ARG:
 612       fi = get_frame_info (frame);
 613       if (fi == NULL)
 614         return 0;
 615       addr = FRAME_ARGS_ADDRESS (fi);
 616       if (!addr)
 617         {
 618           return 0;
 619         }
 620       addr += SYMBOL_VALUE (var);
 621       break;
 622
 623     case LOC_REF_ARG:
 624       fi = get_frame_info (frame);
 625       if (fi == NULL)
 626         return 0;
 627       addr = FRAME_ARGS_ADDRESS (fi);
 628       if (!addr)
 629         {
 630           return 0;
 631         }
 632       addr += SYMBOL_VALUE (var);
 633       addr = read_memory_unsigned_integer
 634         (addr, TARGET_PTR_BIT / TARGET_CHAR_BIT);
 635       break;
 636
 637     case LOC_LOCAL:
 638     case LOC_LOCAL_ARG:
 639       fi = get_frame_info (frame);
 640       if (fi == NULL)
 641         return 0;
 642       addr = FRAME_LOCALS_ADDRESS (fi);
 643       addr += SYMBOL_VALUE (var);
 644       break;
 645
 646     case LOC_BASEREG:
 647     case LOC_BASEREG_ARG:
 648       {
 649         char buf[MAX_REGISTER_RAW_SIZE];
 650         get_saved_register (buf, NULL, NULL, frame, SYMBOL_BASEREG (var),
 651                             NULL);
 652         addr = extract_address (buf, REGISTER_RAW_SIZE (SYMBOL_BASEREG (var)));
 653         addr += SYMBOL_VALUE (var);
 654         break;
 655       }
 656
 657     case LOC_TYPEDEF:
 658       error ("Cannot look up value of a typedef");
 659       break;
 660
 661     case LOC_BLOCK:
 662       VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 663       return v;
 664
 665     case LOC_REGISTER:
 666     case LOC_REGPARM:
 667     case LOC_REGPARM_ADDR:
 668       {
 669         struct block *b;
 670
 671         if (frame == NULL)
 672           return 0;
 673         b = get_frame_block (frame);
 674
 675         v = value_from_register (type, SYMBOL_VALUE (var), frame);
 676
 677         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 678           {
 679             addr = *(CORE_ADDR *)VALUE_CONTENTS (v);
 680             VALUE_LVAL (v) = lval_memory;
 681           }
 682         else
 683           return v;
 684       }
 685       break;
 686
 687     case LOC_OPTIMIZED_OUT:
 688       VALUE_LVAL (v) = not_lval;
 689       VALUE_OPTIMIZED_OUT (v) = 1;
 690       return v;
 691
 692     default:
 693       error ("Cannot look up value of a botched symbol.");
 694       break;
 695     }
 696
 697   VALUE_ADDRESS (v) = addr;
 698   VALUE_LAZY (v) = 1;
 699   return v;
 700 }
 701
 702 /* Return a value of type TYPE, stored in register REGNUM, in frame
 703    FRAME. */
 704
 705 value
 706 value_from_register (type, regnum, frame)
 707      struct type *type;
 708      int regnum;
 709      FRAME frame;
 710 {
 711   char raw_buffer [MAX_REGISTER_RAW_SIZE];
 712   char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
 713   CORE_ADDR addr;
 714   int optim;
 715   value v = allocate_value (type);
 716   int len = TYPE_LENGTH (type);
 717   char *value_bytes = 0;
 718   int value_bytes_copied = 0;
 719   int num_storage_locs;
 720   enum lval_type lval;
 721
 722   VALUE_REGNO (v) = regnum;
 723
 724   num_storage_locs = (len > REGISTER_VIRTUAL_SIZE (regnum) ?
 725                       ((len - 1) / REGISTER_RAW_SIZE (regnum)) + 1 :
 726                       1);
 727
 728   if (num_storage_locs > 1
 729 #ifdef GDB_TARGET_IS_H8500
 730       || TYPE_CODE (type) == TYPE_CODE_PTR
 731 #endif
 732       )
 733     {
 734       /* Value spread across multiple storage locations.  */
 735
 736       int local_regnum;
 737       int mem_stor = 0, reg_stor = 0;
 738       int mem_tracking = 1;
 739       CORE_ADDR last_addr = 0;
 740       CORE_ADDR first_addr = 0;
 741
 742       value_bytes = (char *) alloca (len + MAX_REGISTER_RAW_SIZE);
 743
 744       /* Copy all of the data out, whereever it may be.  */
 745
 746 #ifdef GDB_TARGET_IS_H8500
 747 /* This piece of hideosity is required because the H8500 treats registers
 748    differently depending upon whether they are used as pointers or not.  As a
 749    pointer, a register needs to have a page register tacked onto the front.
 750    An alternate way to do this would be to have gcc output different register
 751    numbers for the pointer & non-pointer form of the register.  But, it
 752    doesn't, so we're stuck with this.  */
 753
 754       if (TYPE_CODE (type) == TYPE_CODE_PTR
 755           && len > 2)
 756         {
 757           int page_regnum;
 758
 759           switch (regnum)
 760             {
 761             case R0_REGNUM: case R1_REGNUM: case R2_REGNUM: case R3_REGNUM:
 762               page_regnum = SEG_D_REGNUM;
 763               break;
 764             case R4_REGNUM: case R5_REGNUM:
 765               page_regnum = SEG_E_REGNUM;
 766               break;
 767             case R6_REGNUM: case R7_REGNUM:
 768               page_regnum = SEG_T_REGNUM;
 769               break;
 770             }
 771
 772           value_bytes[0] = 0;
 773           get_saved_register (value_bytes + 1,
 774                               &optim,
 775                               &addr,
 776                               frame,
 777                               page_regnum,
 778                               &lval);
 779
 780           if (lval == lval_register)
 781             reg_stor++;
 782           else
 783             mem_stor++;
 784           first_addr = addr;
 785           last_addr = addr;
 786
 787           get_saved_register (value_bytes + 2,
 788                               &optim,
 789                               &addr,
 790                               frame,
 791                               regnum,
 792                               &lval);
 793
 794           if (lval == lval_register)
 795             reg_stor++;
 796           else
 797             {
 798               mem_stor++;
 799               mem_tracking = mem_tracking && (addr == last_addr);
 800             }
 801           last_addr = addr;
 802         }
 803       else
 804 #endif                          /* GDB_TARGET_IS_H8500 */
 805         for (local_regnum = regnum;
 806              value_bytes_copied < len;
 807              (value_bytes_copied += REGISTER_RAW_SIZE (local_regnum),
 808               ++local_regnum))
 809           {
 810             get_saved_register (value_bytes + value_bytes_copied,
 811                                 &optim,
 812                                 &addr,
 813                                 frame,
 814                                 local_regnum,
 815                                 &lval);
 816
 817             if (regnum == local_regnum)
 818               first_addr = addr;
 819             if (lval == lval_register)
 820               reg_stor++;
 821             else
 822               {
 823                 mem_stor++;
 824
 825                 mem_tracking =
 826                   (mem_tracking
 827                    && (regnum == local_regnum
 828                        || addr == last_addr));
 829               }
 830             last_addr = addr;
 831           }
 832
 833       if ((reg_stor && mem_stor)
 834           || (mem_stor && !mem_tracking))
 835         /* Mixed storage; all of the hassle we just went through was
 836            for some good purpose.  */
 837         {
 838           VALUE_LVAL (v) = lval_reg_frame_relative;
 839           VALUE_FRAME (v) = FRAME_FP (frame);
 840           VALUE_FRAME_REGNUM (v) = regnum;
 841         }
 842       else if (mem_stor)
 843         {
 844           VALUE_LVAL (v) = lval_memory;
 845           VALUE_ADDRESS (v) = first_addr;
 846         }
 847       else if (reg_stor)
 848         {
 849           VALUE_LVAL (v) = lval_register;
 850           VALUE_ADDRESS (v) = first_addr;
 851         }
 852       else
 853         fatal ("value_from_register: Value not stored anywhere!");
 854
 855       VALUE_OPTIMIZED_OUT (v) = optim;
 856
 857       /* Any structure stored in more than one register will always be
 858          an integral number of registers.  Otherwise, you'd need to do
 859          some fiddling with the last register copied here for little
 860          endian machines.  */
 861
 862       /* Copy into the contents section of the value.  */
 863       memcpy (VALUE_CONTENTS_RAW (v), value_bytes, len);
 864
 865       /* Finally do any conversion necessary when extracting this
 866          type from more than one register.  */
 867 #ifdef REGISTER_CONVERT_TO_TYPE
 868       REGISTER_CONVERT_TO_TYPE(regnum, type, VALUE_CONTENTS_RAW(v));
 869 #endif
 870       return v;
 871     }
 872
 873   /* Data is completely contained within a single register.  Locate the
 874      register's contents in a real register or in core;
 875      read the data in raw format.  */
 876
 877   get_saved_register (raw_buffer, &optim, &addr, frame, regnum, &lval);
 878   VALUE_OPTIMIZED_OUT (v) = optim;
 879   VALUE_LVAL (v) = lval;
 880   VALUE_ADDRESS (v) = addr;
 881
 882   /* Convert the raw contents to virtual contents.
 883      (Just copy them if the formats are the same.)  */
 884
 885   REGISTER_CONVERT_TO_VIRTUAL (regnum, raw_buffer, virtual_buffer);
 886
 887   if (REGISTER_CONVERTIBLE (regnum))
 888     {
 889       /* When the raw and virtual formats differ, the virtual format
 890          corresponds to a specific data type.  If we want that type,
 891          copy the data into the value.
 892          Otherwise, do a type-conversion.  */
 893
 894       if (type != REGISTER_VIRTUAL_TYPE (regnum))
 895         {
 896           /* eg a variable of type `float' in a 68881 register
 897              with raw type `extended' and virtual type `double'.
 898              Fetch it as a `double' and then convert to `float'.  */
 899           v = allocate_value (REGISTER_VIRTUAL_TYPE (regnum));
 900           memcpy (VALUE_CONTENTS_RAW (v), virtual_buffer, len);
 901           v = value_cast (type, v);
 902         }
 903       else
 904         memcpy (VALUE_CONTENTS_RAW (v), virtual_buffer, len);
 905     }
 906   else
 907     {
 908       /* Raw and virtual formats are the same for this register.  */
 909
 910 #if TARGET_BYTE_ORDER == BIG_ENDIAN
 911       if (len < REGISTER_RAW_SIZE (regnum))
 912         {
 913           /* Big-endian, and we want less than full size.  */
 914           VALUE_OFFSET (v) = REGISTER_RAW_SIZE (regnum) - len;
 915         }
 916 #endif
 917
 918       memcpy (VALUE_CONTENTS_RAW (v), virtual_buffer + VALUE_OFFSET (v), len);
 919     }
 920
 921   return v;
 922 }
 923 \f
 924 /* Given a struct symbol for a variable or function,
 925    and a stack frame id,
 926    return a (pointer to a) struct value containing the properly typed
 927    address.  */
 928
 929 value
 930 locate_var_value (var, frame)
 931      register struct symbol *var;
 932      FRAME frame;
 933 {
 934   CORE_ADDR addr = 0;
 935   struct type *type = SYMBOL_TYPE (var);
 936   value lazy_value;
 937
 938   /* Evaluate it first; if the result is a memory address, we're fine.
 939      Lazy evaluation pays off here. */
 940
 941   lazy_value = read_var_value (var, frame);
 942   if (lazy_value == 0)
 943     error ("Address of \"%s\" is unknown.", SYMBOL_SOURCE_NAME (var));
 944
 945   if (VALUE_LAZY (lazy_value)
 946       || TYPE_CODE (type) == TYPE_CODE_FUNC)
 947     {
 948       addr = VALUE_ADDRESS (lazy_value);
 949       return value_from_longest (lookup_pointer_type (type), (LONGEST) addr);
 950     }
 951
 952   /* Not a memory address; check what the problem was.  */
 953   switch (VALUE_LVAL (lazy_value))
 954     {
 955     case lval_register:
 956     case lval_reg_frame_relative:
 957       error ("Address requested for identifier \"%s\" which is in a register.",
 958              SYMBOL_SOURCE_NAME (var));
 959       break;
 960
 961     default:
 962       error ("Can't take address of \"%s\" which isn't an lvalue.",
 963              SYMBOL_SOURCE_NAME (var));
 964       break;
 965     }
 966   return 0;  /* For lint -- never reached */
 967 }