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