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 minimal_symbol *result;
 394
 395   /* The objfile in which the symbol was found.  */
 396   struct objfile *objfile;
 397 };
 398
 399 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
 400    It searches by name for a minimal symbol within the given OBJFILE.
 401    The arguments are passed via CB_DATA, which in reality is a pointer
 402    to struct minsym_lookup_data.  */
 403
 404 static int
 405 minsym_lookup_iterator_cb (struct objfile *objfile, void *cb_data)
 406 {
 407   struct minsym_lookup_data *data = (struct minsym_lookup_data *) cb_data;
 408
 409   gdb_assert (data->result == NULL);
 410
 411   data->result = lookup_minimal_symbol (data->name, NULL, objfile);
 412   data->objfile = objfile;
 413
 414   /* The iterator should stop iff a match was found.  */
 415   return (data->result != NULL);
 416 }
 417
 418 /* A default implementation for the "la_read_var_value" hook in
 419    the language vector which should work in most situations.  */
 420
 421 struct value *
 422 default_read_var_value (struct symbol *var, struct frame_info *frame)
 423 {
 424   struct value *v;
 425   struct type *type = SYMBOL_TYPE (var);
 426   CORE_ADDR addr;
 427
 428   /* Call check_typedef on our type to make sure that, if TYPE is
 429      a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
 430      instead of zero.  However, we do not replace the typedef type by the
 431      target type, because we want to keep the typedef in order to be able to
 432      set the returned value type description correctly.  */
 433   check_typedef (type);
 434
 435   if (symbol_read_needs_frame (var))
 436     gdb_assert (frame);
 437
 438   if (SYMBOL_COMPUTED_OPS (var) != NULL)
 439     return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
 440
 441   switch (SYMBOL_CLASS (var))
 442     {
 443     case LOC_CONST:
 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       v = allocate_value (type);
 472       memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
 473               TYPE_LENGTH (type));
 474       VALUE_LVAL (v) = not_lval;
 475       return v;
 476
 477     case LOC_STATIC:
 478       if (overlay_debugging)
 479         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 480                                          SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
 481                                                              var));
 482       else
 483         addr = SYMBOL_VALUE_ADDRESS (var);
 484       break;
 485
 486     case LOC_ARG:
 487       addr = get_frame_args_address (frame);
 488       if (!addr)
 489         error (_("Unknown argument list address for `%s'."),
 490                SYMBOL_PRINT_NAME (var));
 491       addr += SYMBOL_VALUE (var);
 492       break;
 493
 494     case LOC_REF_ARG:
 495       {
 496         struct value *ref;
 497         CORE_ADDR argref;
 498
 499         argref = get_frame_args_address (frame);
 500         if (!argref)
 501           error (_("Unknown argument list address for `%s'."),
 502                  SYMBOL_PRINT_NAME (var));
 503         argref += SYMBOL_VALUE (var);
 504         ref = value_at (lookup_pointer_type (type), argref);
 505         addr = value_as_address (ref);
 506         break;
 507       }
 508
 509     case LOC_LOCAL:
 510       addr = get_frame_locals_address (frame);
 511       addr += SYMBOL_VALUE (var);
 512       break;
 513
 514     case LOC_TYPEDEF:
 515       error (_("Cannot look up value of a typedef `%s'."),
 516              SYMBOL_PRINT_NAME (var));
 517       break;
 518
 519     case LOC_BLOCK:
 520       if (overlay_debugging)
 521         addr = symbol_overlayed_address
 522           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (var),
 523                                                                        var));
 524       else
 525         addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 526       break;
 527
 528     case LOC_REGISTER:
 529     case LOC_REGPARM_ADDR:
 530       {
 531         int regno = SYMBOL_REGISTER_OPS (var)
 532                       ->register_number (var, get_frame_arch (frame));
 533         struct value *regval;
 534
 535         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 536           {
 537             regval = value_from_register (lookup_pointer_type (type),
 538                                           regno,
 539                                           frame);
 540
 541             if (regval == NULL)
 542               error (_("Value of register variable not available for `%s'."),
 543                      SYMBOL_PRINT_NAME (var));
 544
 545             addr = value_as_address (regval);
 546           }
 547         else
 548           {
 549             regval = value_from_register (type, regno, frame);
 550
 551             if (regval == NULL)
 552               error (_("Value of register variable not available for `%s'."),
 553                      SYMBOL_PRINT_NAME (var));
 554             return regval;
 555           }
 556       }
 557       break;
 558
 559     case LOC_COMPUTED:
 560       gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
 561
 562     case LOC_UNRESOLVED:
 563       {
 564         struct minsym_lookup_data lookup_data;
 565         struct minimal_symbol *msym;
 566         struct obj_section *obj_section;
 567
 568         memset (&lookup_data, 0, sizeof (lookup_data));
 569         lookup_data.name = SYMBOL_LINKAGE_NAME (var);
 570
 571         gdbarch_iterate_over_objfiles_in_search_order
 572           (get_objfile_arch (SYMBOL_SYMTAB (var)->objfile),
 573            minsym_lookup_iterator_cb, &lookup_data,
 574            SYMBOL_SYMTAB (var)->objfile);
 575         msym = lookup_data.result;
 576
 577         if (msym == NULL)
 578           error (_("No global symbol \"%s\"."), SYMBOL_LINKAGE_NAME (var));
 579         if (overlay_debugging)
 580           addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
 581                                            SYMBOL_OBJ_SECTION (lookup_data.objfile,
 582                                                                msym));
 583         else
 584           addr = SYMBOL_VALUE_ADDRESS (msym);
 585
 586         obj_section = SYMBOL_OBJ_SECTION (lookup_data.objfile, msym);
 587         if (obj_section
 588             && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
 589           addr = target_translate_tls_address (obj_section->objfile, addr);
 590       }
 591       break;
 592
 593     case LOC_OPTIMIZED_OUT:
 594       return allocate_optimized_out_value (type);
 595
 596     default:
 597       error (_("Cannot look up value of a botched symbol `%s'."),
 598              SYMBOL_PRINT_NAME (var));
 599       break;
 600     }
 601
 602   v = value_at_lazy (type, addr);
 603   return v;
 604 }
 605
 606 /* Calls VAR's language la_read_var_value hook with the given arguments.  */
 607
 608 struct value *
 609 read_var_value (struct symbol *var, struct frame_info *frame)
 610 {
 611   const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var));
 612
 613   gdb_assert (lang != NULL);
 614   gdb_assert (lang->la_read_var_value != NULL);
 615
 616   return lang->la_read_var_value (var, frame);
 617 }
 618
 619 /* Install default attributes for register values.  */
 620
 621 struct value *
 622 default_value_from_register (struct type *type, int regnum,
 623                              struct frame_info *frame)
 624 {
 625   struct gdbarch *gdbarch = get_frame_arch (frame);
 626   int len = TYPE_LENGTH (type);
 627   struct value *value = allocate_value (type);
 628
 629   VALUE_LVAL (value) = lval_register;
 630   VALUE_FRAME_ID (value) = get_frame_id (frame);
 631   VALUE_REGNUM (value) = regnum;
 632
 633   /* Any structure stored in more than one register will always be
 634      an integral number of registers.  Otherwise, you need to do
 635      some fiddling with the last register copied here for little
 636      endian machines.  */
 637   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
 638       && len < register_size (gdbarch, regnum))
 639     /* Big-endian, and we want less than full size.  */
 640     set_value_offset (value, register_size (gdbarch, regnum) - len);
 641   else
 642     set_value_offset (value, 0);
 643
 644   return value;
 645 }
 646
 647 /* VALUE must be an lval_register value.  If regnum is the value's
 648    associated register number, and len the length of the values type,
 649    read one or more registers in FRAME, starting with register REGNUM,
 650    until we've read LEN bytes.
 651
 652    If any of the registers we try to read are optimized out, then mark the
 653    complete resulting value as optimized out.  */
 654
 655 void
 656 read_frame_register_value (struct value *value, struct frame_info *frame)
 657 {
 658   struct gdbarch *gdbarch = get_frame_arch (frame);
 659   int offset = 0;
 660   int reg_offset = value_offset (value);
 661   int regnum = VALUE_REGNUM (value);
 662   int len = TYPE_LENGTH (check_typedef (value_type (value)));
 663
 664   gdb_assert (VALUE_LVAL (value) == lval_register);
 665
 666   /* Skip registers wholly inside of REG_OFFSET.  */
 667   while (reg_offset >= register_size (gdbarch, regnum))
 668     {
 669       reg_offset -= register_size (gdbarch, regnum);
 670       regnum++;
 671     }
 672
 673   /* Copy the data.  */
 674   while (len > 0)
 675     {
 676       struct value *regval = get_frame_register_value (frame, regnum);
 677       int reg_len = TYPE_LENGTH (value_type (regval)) - reg_offset;
 678
 679       if (value_optimized_out (regval))
 680         {
 681           set_value_optimized_out (value, 1);
 682           break;
 683         }
 684
 685       /* If the register length is larger than the number of bytes
 686          remaining to copy, then only copy the appropriate bytes.  */
 687       if (reg_len > len)
 688         reg_len = len;
 689
 690       value_contents_copy (value, offset, regval, reg_offset, reg_len);
 691
 692       offset += reg_len;
 693       len -= reg_len;
 694       reg_offset = 0;
 695       regnum++;
 696     }
 697 }
 698
 699 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME.  */
 700
 701 struct value *
 702 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 703 {
 704   struct gdbarch *gdbarch = get_frame_arch (frame);
 705   struct type *type1 = check_typedef (type);
 706   struct value *v;
 707
 708   if (gdbarch_convert_register_p (gdbarch, regnum, type1))
 709     {
 710       int optim, unavail, ok;
 711
 712       /* The ISA/ABI need to something weird when obtaining the
 713          specified value from this register.  It might need to
 714          re-order non-adjacent, starting with REGNUM (see MIPS and
 715          i386).  It might need to convert the [float] register into
 716          the corresponding [integer] type (see Alpha).  The assumption
 717          is that gdbarch_register_to_value populates the entire value
 718          including the location.  */
 719       v = allocate_value (type);
 720       VALUE_LVAL (v) = lval_register;
 721       VALUE_FRAME_ID (v) = get_frame_id (frame);
 722       VALUE_REGNUM (v) = regnum;
 723       ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
 724                                       value_contents_raw (v), &optim,
 725                                       &unavail);
 726
 727       if (!ok)
 728         {
 729           if (optim)
 730             set_value_optimized_out (v, 1);
 731           if (unavail)
 732             mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
 733         }
 734     }
 735   else
 736     {
 737       /* Construct the value.  */
 738       v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
 739
 740       /* Get the data.  */
 741       read_frame_register_value (v, frame);
 742     }
 743
 744   return v;
 745 }
 746
 747 /* Return contents of register REGNUM in frame FRAME as address,
 748    interpreted as value of type TYPE.   Will abort if register
 749    value is not available.  */
 750
 751 CORE_ADDR
 752 address_from_register (struct type *type, int regnum, struct frame_info *frame)
 753 {
 754   struct value *value;
 755   CORE_ADDR result;
 756
 757   value = value_from_register (type, regnum, frame);
 758   gdb_assert (value);
 759
 760   if (value_optimized_out (value))
 761     {
 762       /* This function is used while computing a location expression.
 763          Complain about the value being optimized out, rather than
 764          letting value_as_address complain about some random register
 765          the expression depends on not being saved.  */
 766       error_value_optimized_out ();
 767     }
 768
 769   result = value_as_address (value);
 770   release_value (value);
 771   value_free (value);
 772
 773   return result;
 774 }
 775