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