gdb/findvar.c

   1 /* Find a variable's value in memory, for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2014 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  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 #include <string.h>
  29 #include "floatformat.h"
  30 #include "symfile.h"            /* for overlay functions */
  31 #include "regcache.h"
  32 #include "user-regs.h"
  33 #include "block.h"
  34 #include "objfiles.h"
  35 #include "language.h"
  36
  37 /* Basic byte-swapping routines.  All 'extract' functions return a
  38    host-format integer from a target-format integer at ADDR which is
  39    LEN bytes long.  */
  40
  41 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
  42   /* 8 bit characters are a pretty safe assumption these days, so we
  43      assume it throughout all these swapping routines.  If we had to deal with
  44      9 bit characters, we would need to make len be in bits and would have
  45      to re-write these routines...  */
  46 you lose
  47 #endif
  48
  49 LONGEST
  50 extract_signed_integer (const gdb_byte *addr, int len,
  51                         enum bfd_endian byte_order)
  52 {
  53   LONGEST retval;
  54   const unsigned char *p;
  55   const unsigned char *startaddr = addr;
  56   const unsigned char *endaddr = startaddr + len;
  57
  58   if (len > (int) sizeof (LONGEST))
  59     error (_("\
  60 That operation is not available on integers of more than %d bytes."),
  61            (int) sizeof (LONGEST));
  62
  63   /* Start at the most significant end of the integer, and work towards
  64      the least significant.  */
  65   if (byte_order == BFD_ENDIAN_BIG)
  66     {
  67       p = startaddr;
  68       /* Do the sign extension once at the start.  */
  69       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  70       for (++p; p < endaddr; ++p)
  71         retval = (retval << 8) | *p;
  72     }
  73   else
  74     {
  75       p = endaddr - 1;
  76       /* Do the sign extension once at the start.  */
  77       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  78       for (--p; p >= startaddr; --p)
  79         retval = (retval << 8) | *p;
  80     }
  81   return retval;
  82 }
  83
  84 ULONGEST
  85 extract_unsigned_integer (const gdb_byte *addr, int len,
  86                           enum bfd_endian byte_order)
  87 {
  88   ULONGEST retval;
  89   const unsigned char *p;
  90   const unsigned char *startaddr = addr;
  91   const unsigned char *endaddr = startaddr + len;
  92
  93   if (len > (int) sizeof (ULONGEST))
  94     error (_("\
  95 That operation is not available on integers of more than %d bytes."),
  96            (int) sizeof (ULONGEST));
  97
  98   /* Start at the most significant end of the integer, and work towards
  99      the least significant.  */
 100   retval = 0;
 101   if (byte_order == BFD_ENDIAN_BIG)
 102     {
 103       for (p = startaddr; p < endaddr; ++p)
 104         retval = (retval << 8) | *p;
 105     }
 106   else
 107     {
 108       for (p = endaddr - 1; p >= startaddr; --p)
 109         retval = (retval << 8) | *p;
 110     }
 111   return retval;
 112 }
 113
 114 /* Sometimes a long long unsigned integer can be extracted as a
 115    LONGEST value.  This is done so that we can print these values
 116    better.  If this integer can be converted to a LONGEST, this
 117    function returns 1 and sets *PVAL.  Otherwise it returns 0.  */
 118
 119 int
 120 extract_long_unsigned_integer (const gdb_byte *addr, int orig_len,
 121                                enum bfd_endian byte_order, LONGEST *pval)
 122 {
 123   const gdb_byte *p;
 124   const gdb_byte *first_addr;
 125   int len;
 126
 127   len = orig_len;
 128   if (byte_order == BFD_ENDIAN_BIG)
 129     {
 130       for (p = addr;
 131            len > (int) sizeof (LONGEST) && p < addr + orig_len;
 132            p++)
 133         {
 134           if (*p == 0)
 135             len--;
 136           else
 137             break;
 138         }
 139       first_addr = p;
 140     }
 141   else
 142     {
 143       first_addr = addr;
 144       for (p = addr + orig_len - 1;
 145            len > (int) sizeof (LONGEST) && p >= addr;
 146            p--)
 147         {
 148           if (*p == 0)
 149             len--;
 150           else
 151             break;
 152         }
 153     }
 154
 155   if (len <= (int) sizeof (LONGEST))
 156     {
 157       *pval = (LONGEST) extract_unsigned_integer (first_addr,
 158                                                   sizeof (LONGEST),
 159                                                   byte_order);
 160       return 1;
 161     }
 162
 163   return 0;
 164 }
 165
 166
 167 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
 168    address it represents.  */
 169 CORE_ADDR
 170 extract_typed_address (const gdb_byte *buf, struct type *type)
 171 {
 172   if (TYPE_CODE (type) != TYPE_CODE_PTR
 173       && TYPE_CODE (type) != TYPE_CODE_REF)
 174     internal_error (__FILE__, __LINE__,
 175                     _("extract_typed_address: "
 176                     "type is not a pointer or reference"));
 177
 178   return gdbarch_pointer_to_address (get_type_arch (type), type, buf);
 179 }
 180
 181 /* All 'store' functions accept a host-format integer and store a
 182    target-format integer at ADDR which is LEN bytes long.  */
 183
 184 void
 185 store_signed_integer (gdb_byte *addr, int len,
 186                       enum bfd_endian byte_order, LONGEST val)
 187 {
 188   gdb_byte *p;
 189   gdb_byte *startaddr = addr;
 190   gdb_byte *endaddr = startaddr + len;
 191
 192   /* Start at the least significant end of the integer, and work towards
 193      the most significant.  */
 194   if (byte_order == BFD_ENDIAN_BIG)
 195     {
 196       for (p = endaddr - 1; p >= startaddr; --p)
 197         {
 198           *p = val & 0xff;
 199           val >>= 8;
 200         }
 201     }
 202   else
 203     {
 204       for (p = startaddr; p < endaddr; ++p)
 205         {
 206           *p = val & 0xff;
 207           val >>= 8;
 208         }
 209     }
 210 }
 211
 212 void
 213 store_unsigned_integer (gdb_byte *addr, int len,
 214                         enum bfd_endian byte_order, ULONGEST val)
 215 {
 216   unsigned char *p;
 217   unsigned char *startaddr = (unsigned char *) addr;
 218   unsigned char *endaddr = startaddr + len;
 219
 220   /* Start at the least significant end of the integer, and work towards
 221      the most significant.  */
 222   if (byte_order == BFD_ENDIAN_BIG)
 223     {
 224       for (p = endaddr - 1; p >= startaddr; --p)
 225         {
 226           *p = val & 0xff;
 227           val >>= 8;
 228         }
 229     }
 230   else
 231     {
 232       for (p = startaddr; p < endaddr; ++p)
 233         {
 234           *p = val & 0xff;
 235           val >>= 8;
 236         }
 237     }
 238 }
 239
 240 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
 241    form.  */
 242 void
 243 store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
 244 {
 245   if (TYPE_CODE (type) != TYPE_CODE_PTR
 246       && TYPE_CODE (type) != TYPE_CODE_REF)
 247     internal_error (__FILE__, __LINE__,
 248                     _("store_typed_address: "
 249                     "type is not a pointer or reference"));
 250
 251   gdbarch_address_to_pointer (get_type_arch (type), type, buf, addr);
 252 }
 253
 254
 255
 256 /* Return a `value' with the contents of (virtual or cooked) register
 257    REGNUM as found in the specified FRAME.  The register's type is
 258    determined by register_type().  */
 259
 260 struct value *
 261 value_of_register (int regnum, struct frame_info *frame)
 262 {
 263   struct gdbarch *gdbarch = get_frame_arch (frame);
 264   struct value *reg_val;
 265
 266   /* User registers lie completely outside of the range of normal
 267      registers.  Catch them early so that the target never sees them.  */
 268   if (regnum >= gdbarch_num_regs (gdbarch)
 269                 + gdbarch_num_pseudo_regs (gdbarch))
 270     return value_of_user_reg (regnum, frame);
 271
 272   reg_val = value_of_register_lazy (frame, regnum);
 273   value_fetch_lazy (reg_val);
 274   return reg_val;
 275 }
 276
 277 /* Return a `value' with the contents of (virtual or cooked) register
 278    REGNUM as found in the specified FRAME.  The register's type is
 279    determined by register_type().  The value is not fetched.  */
 280
 281 struct value *
 282 value_of_register_lazy (struct frame_info *frame, int regnum)
 283 {
 284   struct gdbarch *gdbarch = get_frame_arch (frame);
 285   struct value *reg_val;
 286
 287   gdb_assert (regnum < (gdbarch_num_regs (gdbarch)
 288                         + gdbarch_num_pseudo_regs (gdbarch)));
 289
 290   /* We should have a valid (i.e. non-sentinel) frame.  */
 291   gdb_assert (frame_id_p (get_frame_id (frame)));
 292
 293   reg_val = allocate_value_lazy (register_type (gdbarch, regnum));
 294   VALUE_LVAL (reg_val) = lval_register;
 295   VALUE_REGNUM (reg_val) = regnum;
 296   VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
 297   return reg_val;
 298 }
 299
 300 /* Given a pointer of type TYPE in target form in BUF, return the
 301    address it represents.  */
 302 CORE_ADDR
 303 unsigned_pointer_to_address (struct gdbarch *gdbarch,
 304                              struct type *type, const gdb_byte *buf)
 305 {
 306   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 307
 308   return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
 309 }
 310
 311 CORE_ADDR
 312 signed_pointer_to_address (struct gdbarch *gdbarch,
 313                            struct type *type, const gdb_byte *buf)
 314 {
 315   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 316
 317   return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
 318 }
 319
 320 /* Given an address, store it as a pointer of type TYPE in target
 321    format in BUF.  */
 322 void
 323 unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type,
 324                              gdb_byte *buf, CORE_ADDR addr)
 325 {
 326   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 327
 328   store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
 329 }
 330
 331 void
 332 address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type,
 333                            gdb_byte *buf, CORE_ADDR addr)
 334 {
 335   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 336
 337   store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr);
 338 }
 339 \f
 340 /* Will calling read_var_value or locate_var_value on SYM end
 341    up caring what frame it is being evaluated relative to?  SYM must
 342    be non-NULL.  */
 343 int
 344 symbol_read_needs_frame (struct symbol *sym)
 345 {
 346   if (SYMBOL_COMPUTED_OPS (sym) != NULL)
 347     return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym);
 348
 349   switch (SYMBOL_CLASS (sym))
 350     {
 351       /* All cases listed explicitly so that gcc -Wall will detect it if
 352          we failed to consider one.  */
 353     case LOC_COMPUTED:
 354       gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
 355
 356     case LOC_REGISTER:
 357     case LOC_ARG:
 358     case LOC_REF_ARG:
 359     case LOC_REGPARM_ADDR:
 360     case LOC_LOCAL:
 361       return 1;
 362
 363     case LOC_UNDEF:
 364     case LOC_CONST:
 365     case LOC_STATIC:
 366     case LOC_TYPEDEF:
 367
 368     case LOC_LABEL:
 369       /* Getting the address of a label can be done independently of the block,
 370          even if some *uses* of that address wouldn't work so well without
 371          the right frame.  */
 372
 373     case LOC_BLOCK:
 374     case LOC_CONST_BYTES:
 375     case LOC_UNRESOLVED:
 376     case LOC_OPTIMIZED_OUT:
 377       return 0;
 378     }
 379   return 1;
 380 }
 381
 382 /* Private data to be used with minsym_lookup_iterator_cb.  */
 383
 384 struct minsym_lookup_data
 385 {
 386   /* The name of the minimal symbol we are searching for.  */
 387   const char *name;
 388
 389   /* The field where the callback should store the minimal symbol
 390      if found.  It should be initialized to NULL before the search
 391      is started.  */
 392   struct bound_minimal_symbol result;
 393 };
 394
 395 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
 396    It searches by name for a minimal symbol within the given OBJFILE.
 397    The arguments are passed via CB_DATA, which in reality is a pointer
 398    to struct minsym_lookup_data.  */
 399
 400 static int
 401 minsym_lookup_iterator_cb (struct objfile *objfile, void *cb_data)
 402 {
 403   struct minsym_lookup_data *data = (struct minsym_lookup_data *) cb_data;
 404
 405   gdb_assert (data->result.minsym == NULL);
 406
 407   data->result = lookup_minimal_symbol (data->name, NULL, objfile);
 408
 409   /* The iterator should stop iff a match was found.  */
 410   return (data->result.minsym != NULL);
 411 }
 412
 413 /* A default implementation for the "la_read_var_value" hook in
 414    the language vector which should work in most situations.  */
 415
 416 struct value *
 417 default_read_var_value (struct symbol *var, struct frame_info *frame)
 418 {
 419   struct value *v;
 420   struct type *type = SYMBOL_TYPE (var);
 421   CORE_ADDR addr;
 422
 423   /* Call check_typedef on our type to make sure that, if TYPE is
 424      a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
 425      instead of zero.  However, we do not replace the typedef type by the
 426      target type, because we want to keep the typedef in order to be able to
 427      set the returned value type description correctly.  */
 428   check_typedef (type);
 429
 430   if (symbol_read_needs_frame (var))
 431     gdb_assert (frame);
 432
 433   if (SYMBOL_COMPUTED_OPS (var) != NULL)
 434     return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
 435
 436   switch (SYMBOL_CLASS (var))
 437     {
 438     case LOC_CONST:
 439       if (is_dynamic_type (type))
 440         {
 441           /* Value is a constant byte-sequence and needs no memory access.  */
 442           type = resolve_dynamic_type (type, /* Unused address.  */ 0);
 443         }
 444       /* Put the constant back in target format. */
 445       v = allocate_value (type);
 446       store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type),
 447                             gdbarch_byte_order (get_type_arch (type)),
 448                             (LONGEST) SYMBOL_VALUE (var));
 449       VALUE_LVAL (v) = not_lval;
 450       return v;
 451
 452     case LOC_LABEL:
 453       /* Put the constant back in target format.  */
 454       v = allocate_value (type);
 455       if (overlay_debugging)
 456         {
 457           CORE_ADDR addr
 458             = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 459                                         SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
 460                                                             var));
 461
 462           store_typed_address (value_contents_raw (v), type, addr);
 463         }
 464       else
 465         store_typed_address (value_contents_raw (v), type,
 466                               SYMBOL_VALUE_ADDRESS (var));
 467       VALUE_LVAL (v) = not_lval;
 468       return v;
 469
 470     case LOC_CONST_BYTES:
 471       if (is_dynamic_type (type))
 472         {
 473           /* Value is a constant byte-sequence and needs no memory access.  */
 474           type = resolve_dynamic_type (type, /* Unused address.  */ 0);
 475         }
 476       v = allocate_value (type);
 477       memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
 478               TYPE_LENGTH (type));
 479       VALUE_LVAL (v) = not_lval;
 480       return v;
 481
 482     case LOC_STATIC:
 483       if (overlay_debugging)
 484         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 485                                          SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
 486                                                              var));
 487       else
 488         addr = SYMBOL_VALUE_ADDRESS (var);
 489       break;
 490
 491     case LOC_ARG:
 492       addr = get_frame_args_address (frame);
 493       if (!addr)
 494         error (_("Unknown argument list address for `%s'."),
 495                SYMBOL_PRINT_NAME (var));
 496       addr += SYMBOL_VALUE (var);
 497       break;
 498
 499     case LOC_REF_ARG:
 500       {
 501         struct value *ref;
 502         CORE_ADDR argref;
 503
 504         argref = get_frame_args_address (frame);
 505         if (!argref)
 506           error (_("Unknown argument list address for `%s'."),
 507                  SYMBOL_PRINT_NAME (var));
 508         argref += SYMBOL_VALUE (var);
 509         ref = value_at (lookup_pointer_type (type), argref);
 510         addr = value_as_address (ref);
 511         break;
 512       }
 513
 514     case LOC_LOCAL:
 515       addr = get_frame_locals_address (frame);
 516       addr += SYMBOL_VALUE (var);
 517       break;
 518
 519     case LOC_TYPEDEF:
 520       error (_("Cannot look up value of a typedef `%s'."),
 521              SYMBOL_PRINT_NAME (var));
 522       break;
 523
 524     case LOC_BLOCK:
 525       if (overlay_debugging)
 526         addr = symbol_overlayed_address
 527           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
 528                                                                        var));
 529       else
 530         addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 531       break;
 532
 533     case LOC_REGISTER:
 534     case LOC_REGPARM_ADDR:
 535       {
 536         int regno = SYMBOL_REGISTER_OPS (var)
 537                       ->register_number (var, get_frame_arch (frame));
 538         struct value *regval;
 539
 540         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 541           {
 542             regval = value_from_register (lookup_pointer_type (type),
 543                                           regno,
 544                                           frame);
 545
 546             if (regval == NULL)
 547               error (_("Value of register variable not available for `%s'."),
 548                      SYMBOL_PRINT_NAME (var));
 549
 550             addr = value_as_address (regval);
 551           }
 552         else
 553           {
 554             regval = value_from_register (type, regno, frame);
 555
 556             if (regval == NULL)
 557               error (_("Value of register variable not available for `%s'."),
 558                      SYMBOL_PRINT_NAME (var));
 559             return regval;
 560           }
 561       }
 562       break;
 563
 564     case LOC_COMPUTED:
 565       gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
 566
 567     case LOC_UNRESOLVED:
 568       {
 569         struct minsym_lookup_data lookup_data;
 570         struct minimal_symbol *msym;
 571         struct obj_section *obj_section;
 572
 573         memset (&lookup_data, 0, sizeof (lookup_data));
 574         lookup_data.name = SYMBOL_LINKAGE_NAME (var);
 575
 576         gdbarch_iterate_over_objfiles_in_search_order
 577           (get_objfile_arch (SYMBOL_SYMTAB (var)->objfile),
 578            minsym_lookup_iterator_cb, &lookup_data,
 579            SYMBOL_SYMTAB (var)->objfile);
 580         msym = lookup_data.result.minsym;
 581
 582         if (msym == NULL)
 583           error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var));
 584         if (overlay_debugging)
 585           addr = symbol_overlayed_address (BMSYMBOL_VALUE_ADDRESS (lookup_data.result),
 586                                            MSYMBOL_OBJ_SECTION (lookup_data.result.objfile,
 587                                                                 msym));
 588         else
 589           addr = BMSYMBOL_VALUE_ADDRESS (lookup_data.result);
 590
 591         obj_section = MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, msym);
 592         if (obj_section
 593             && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
 594           addr = target_translate_tls_address (obj_section->objfile, addr);
 595       }
 596       break;
 597
 598     case LOC_OPTIMIZED_OUT:
 599       return allocate_optimized_out_value (type);
 600
 601     default:
 602       error (_("Cannot look up value of a botched symbol `%s'."),
 603              SYMBOL_PRINT_NAME (var));
 604       break;
 605     }
 606
 607   v = value_at_lazy (type, addr);
 608   return v;
 609 }
 610
 611 /* Calls VAR's language la_read_var_value hook with the given arguments.  */
 612
 613 struct value *
 614 read_var_value (struct symbol *var, struct frame_info *frame)
 615 {
 616   const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var));
 617
 618   gdb_assert (lang != NULL);
 619   gdb_assert (lang->la_read_var_value != NULL);
 620
 621   return lang->la_read_var_value (var, frame);
 622 }
 623
 624 /* Install default attributes for register values.  */
 625
 626 struct value *
 627 default_value_from_register (struct gdbarch *gdbarch, struct type *type,
 628                              int regnum, struct frame_id frame_id)
 629 {
 630   int len = TYPE_LENGTH (type);
 631   struct value *value = allocate_value (type);
 632
 633   VALUE_LVAL (value) = lval_register;
 634   VALUE_FRAME_ID (value) = frame_id;
 635   VALUE_REGNUM (value) = regnum;
 636
 637   /* Any structure stored in more than one register will always be
 638      an integral number of registers.  Otherwise, you need to do
 639      some fiddling with the last register copied here for little
 640      endian machines.  */
 641   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
 642       && len < register_size (gdbarch, regnum))
 643     /* Big-endian, and we want less than full size.  */
 644     set_value_offset (value, register_size (gdbarch, regnum) - len);
 645   else
 646     set_value_offset (value, 0);
 647
 648   return value;
 649 }
 650
 651 /* VALUE must be an lval_register value.  If regnum is the value's
 652    associated register number, and len the length of the values type,
 653    read one or more registers in FRAME, starting with register REGNUM,
 654    until we've read LEN bytes.
 655
 656    If any of the registers we try to read are optimized out, then mark the
 657    complete resulting value as optimized out.  */
 658
 659 void
 660 read_frame_register_value (struct value *value, struct frame_info *frame)
 661 {
 662   struct gdbarch *gdbarch = get_frame_arch (frame);
 663   int offset = 0;
 664   int reg_offset = value_offset (value);
 665   int regnum = VALUE_REGNUM (value);
 666   int len = TYPE_LENGTH (check_typedef (value_type (value)));
 667
 668   gdb_assert (VALUE_LVAL (value) == lval_register);
 669
 670   /* Skip registers wholly inside of REG_OFFSET.  */
 671   while (reg_offset >= register_size (gdbarch, regnum))
 672     {
 673       reg_offset -= register_size (gdbarch, regnum);
 674       regnum++;
 675     }
 676
 677   /* Copy the data.  */
 678   while (len > 0)
 679     {
 680       struct value *regval = get_frame_register_value (frame, regnum);
 681       int reg_len = TYPE_LENGTH (value_type (regval)) - reg_offset;
 682
 683       if (value_optimized_out (regval))
 684         {
 685           set_value_optimized_out (value, 1);
 686           break;
 687         }
 688
 689       /* If the register length is larger than the number of bytes
 690          remaining to copy, then only copy the appropriate bytes.  */
 691       if (reg_len > len)
 692         reg_len = len;
 693
 694       value_contents_copy (value, offset, regval, reg_offset, reg_len);
 695
 696       offset += reg_len;
 697       len -= reg_len;
 698       reg_offset = 0;
 699       regnum++;
 700     }
 701 }
 702
 703 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME.  */
 704
 705 struct value *
 706 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 707 {
 708   struct gdbarch *gdbarch = get_frame_arch (frame);
 709   struct type *type1 = check_typedef (type);
 710   struct value *v;
 711
 712   if (gdbarch_convert_register_p (gdbarch, regnum, type1))
 713     {
 714       int optim, unavail, ok;
 715
 716       /* The ISA/ABI need to something weird when obtaining the
 717          specified value from this register.  It might need to
 718          re-order non-adjacent, starting with REGNUM (see MIPS and
 719          i386).  It might need to convert the [float] register into
 720          the corresponding [integer] type (see Alpha).  The assumption
 721          is that gdbarch_register_to_value populates the entire value
 722          including the location.  */
 723       v = allocate_value (type);
 724       VALUE_LVAL (v) = lval_register;
 725       VALUE_FRAME_ID (v) = get_frame_id (frame);
 726       VALUE_REGNUM (v) = regnum;
 727       ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
 728                                       value_contents_raw (v), &optim,
 729                                       &unavail);
 730
 731       if (!ok)
 732         {
 733           if (optim)
 734             set_value_optimized_out (v, 1);
 735           if (unavail)
 736             mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
 737         }
 738     }
 739   else
 740     {
 741       /* Construct the value.  */
 742       v = gdbarch_value_from_register (gdbarch, type,
 743                                        regnum, get_frame_id (frame));
 744
 745       /* Get the data.  */
 746       read_frame_register_value (v, frame);
 747     }
 748
 749   return v;
 750 }
 751
 752 /* Return contents of register REGNUM in frame FRAME as address.
 753    Will abort if register value is not available.  */
 754
 755 CORE_ADDR
 756 address_from_register (int regnum, struct frame_info *frame)
 757 {
 758   struct gdbarch *gdbarch = get_frame_arch (frame);
 759   struct type *type = builtin_type (gdbarch)->builtin_data_ptr;
 760   struct value *value;
 761   CORE_ADDR result;
 762
 763   /* This routine may be called during early unwinding, at a time
 764      where the ID of FRAME is not yet known.  Calling value_from_register
 765      would therefore abort in get_frame_id.  However, since we only need
 766      a temporary value that is never used as lvalue, we actually do not
 767      really need to set its VALUE_FRAME_ID.  Therefore, we re-implement
 768      the core of value_from_register, but use the null_frame_id.
 769
 770      This works only if we do not require a special conversion routine,
 771      which is true for plain pointer types for all current targets.  */
 772   gdb_assert (!gdbarch_convert_register_p (gdbarch, regnum, type));
 773
 774   value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id);
 775   read_frame_register_value (value, frame);
 776
 777   if (value_optimized_out (value))
 778     {
 779       /* This function is used while computing a location expression.
 780          Complain about the value being optimized out, rather than
 781          letting value_as_address complain about some random register
 782          the expression depends on not being saved.  */
 783       error_value_optimized_out ();
 784     }
 785
 786   result = value_as_address (value);
 787   release_value (value);
 788   value_free (value);
 789
 790   return result;
 791 }
 792