gdb/findvar.c

   1 /* Find a variable's value in memory, for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2016 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 "floatformat.h"
  29 #include "symfile.h"            /* for overlay functions */
  30 #include "regcache.h"
  31 #include "user-regs.h"
  32 #include "block.h"
  33 #include "objfiles.h"
  34 #include "language.h"
  35 #include "dwarf2loc.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 /* Given static link expression and the frame it lives in, look for the frame
 414    the static links points to and return it.  Return NULL if we could not find
 415    such a frame.   */
 416
 417 static struct frame_info *
 418 follow_static_link (struct frame_info *frame,
 419                     const struct dynamic_prop *static_link)
 420 {
 421   CORE_ADDR upper_frame_base;
 422
 423   if (!dwarf2_evaluate_property (static_link, frame, NULL, &upper_frame_base))
 424     return NULL;
 425
 426   /* Now climb up the stack frame until we reach the frame we are interested
 427      in.  */
 428   for (; frame != NULL; frame = get_prev_frame (frame))
 429     {
 430       struct symbol *framefunc = get_frame_function (frame);
 431
 432       /* Stacks can be quite deep: give the user a chance to stop this.  */
 433       QUIT;
 434
 435       /* If we don't know how to compute FRAME's base address, don't give up:
 436          maybe the frame we are looking for is upper in the stace frame.  */
 437       if (framefunc != NULL
 438           && SYMBOL_BLOCK_OPS (framefunc) != NULL
 439           && SYMBOL_BLOCK_OPS (framefunc)->get_frame_base != NULL
 440           && (SYMBOL_BLOCK_OPS (framefunc)->get_frame_base (framefunc, frame)
 441               == upper_frame_base))
 442         break;
 443     }
 444
 445   return frame;
 446 }
 447
 448 /* Assuming VAR is a symbol that can be reached from FRAME thanks to lexical
 449    rules, look for the frame that is actually hosting VAR and return it.  If,
 450    for some reason, we found no such frame, return NULL.
 451
 452    This kind of computation is necessary to correctly handle lexically nested
 453    functions.
 454
 455    Note that in some cases, we know what scope VAR comes from but we cannot
 456    reach the specific frame that hosts the instance of VAR we are looking for.
 457    For backward compatibility purposes (with old compilers), we then look for
 458    the first frame that can host it.  */
 459
 460 static struct frame_info *
 461 get_hosting_frame (struct symbol *var, const struct block *var_block,
 462                    struct frame_info *frame)
 463 {
 464   const struct block *frame_block = NULL;
 465
 466   if (!symbol_read_needs_frame (var))
 467     return NULL;
 468
 469   /* Some symbols for local variables have no block: this happens when they are
 470      not produced by a debug information reader, for instance when GDB creates
 471      synthetic symbols.  Without block information, we must assume they are
 472      local to FRAME. In this case, there is nothing to do.  */
 473   else if (var_block == NULL)
 474     return frame;
 475
 476   /* We currently assume that all symbols with a location list need a frame.
 477      This is true in practice because selecting the location description
 478      requires to compute the CFA, hence requires a frame.  However we have
 479      tests that embed global/static symbols with null location lists.
 480      We want to get <optimized out> instead of <frame required> when evaluating
 481      them so return a frame instead of raising an error.  */
 482   else if (var_block == block_global_block (var_block)
 483            || var_block == block_static_block (var_block))
 484     return frame;
 485
 486   /* We have to handle the "my_func::my_local_var" notation.  This requires us
 487      to look for upper frames when we find no block for the current frame: here
 488      and below, handle when frame_block == NULL.  */
 489   if (frame != NULL)
 490     frame_block = get_frame_block (frame, NULL);
 491
 492   /* Climb up the call stack until reaching the frame we are looking for.  */
 493   while (frame != NULL && frame_block != var_block)
 494     {
 495       /* Stacks can be quite deep: give the user a chance to stop this.  */
 496       QUIT;
 497
 498       if (frame_block == NULL)
 499         {
 500           frame = get_prev_frame (frame);
 501           if (frame == NULL)
 502             break;
 503           frame_block = get_frame_block (frame, NULL);
 504         }
 505
 506       /* If we failed to find the proper frame, fallback to the heuristic
 507          method below.  */
 508       else if (frame_block == block_global_block (frame_block))
 509         {
 510           frame = NULL;
 511           break;
 512         }
 513
 514       /* Assuming we have a block for this frame: if we are at the function
 515          level, the immediate upper lexical block is in an outer function:
 516          follow the static link.  */
 517       else if (BLOCK_FUNCTION (frame_block))
 518         {
 519           const struct dynamic_prop *static_link
 520             = block_static_link (frame_block);
 521           int could_climb_up = 0;
 522
 523           if (static_link != NULL)
 524             {
 525               frame = follow_static_link (frame, static_link);
 526               if (frame != NULL)
 527                 {
 528                   frame_block = get_frame_block (frame, NULL);
 529                   could_climb_up = frame_block != NULL;
 530                 }
 531             }
 532           if (!could_climb_up)
 533             {
 534               frame = NULL;
 535               break;
 536             }
 537         }
 538
 539       else
 540         /* We must be in some function nested lexical block.  Just get the
 541            outer block: both must share the same frame.  */
 542         frame_block = BLOCK_SUPERBLOCK (frame_block);
 543     }
 544
 545   /* Old compilers may not provide a static link, or they may provide an
 546      invalid one.  For such cases, fallback on the old way to evaluate
 547      non-local references: just climb up the call stack and pick the first
 548      frame that contains the variable we are looking for.  */
 549   if (frame == NULL)
 550     {
 551       frame = block_innermost_frame (var_block);
 552       if (frame == NULL)
 553         {
 554           if (BLOCK_FUNCTION (var_block)
 555               && !block_inlined_p (var_block)
 556               && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block)))
 557             error (_("No frame is currently executing in block %s."),
 558                    SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block)));
 559           else
 560             error (_("No frame is currently executing in specified"
 561                      " block"));
 562         }
 563     }
 564
 565   return frame;
 566 }
 567
 568 /* A default implementation for the "la_read_var_value" hook in
 569    the language vector which should work in most situations.  */
 570
 571 struct value *
 572 default_read_var_value (struct symbol *var, const struct block *var_block,
 573                         struct frame_info *frame)
 574 {
 575   struct value *v;
 576   struct type *type = SYMBOL_TYPE (var);
 577   CORE_ADDR addr;
 578
 579   /* Call check_typedef on our type to make sure that, if TYPE is
 580      a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
 581      instead of zero.  However, we do not replace the typedef type by the
 582      target type, because we want to keep the typedef in order to be able to
 583      set the returned value type description correctly.  */
 584   check_typedef (type);
 585
 586   if (symbol_read_needs_frame (var))
 587     gdb_assert (frame != NULL);
 588
 589   if (frame != NULL)
 590     frame = get_hosting_frame (var, var_block, frame);
 591
 592   if (SYMBOL_COMPUTED_OPS (var) != NULL)
 593     return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
 594
 595   switch (SYMBOL_CLASS (var))
 596     {
 597     case LOC_CONST:
 598       if (is_dynamic_type (type))
 599         {
 600           /* Value is a constant byte-sequence and needs no memory access.  */
 601           type = resolve_dynamic_type (type, NULL, /* Unused address.  */ 0);
 602         }
 603       /* Put the constant back in target format. */
 604       v = allocate_value (type);
 605       store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type),
 606                             gdbarch_byte_order (get_type_arch (type)),
 607                             (LONGEST) SYMBOL_VALUE (var));
 608       VALUE_LVAL (v) = not_lval;
 609       return v;
 610
 611     case LOC_LABEL:
 612       /* Put the constant back in target format.  */
 613       v = allocate_value (type);
 614       if (overlay_debugging)
 615         {
 616           CORE_ADDR addr
 617             = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 618                                         SYMBOL_OBJ_SECTION (symbol_objfile (var),
 619                                                             var));
 620
 621           store_typed_address (value_contents_raw (v), type, addr);
 622         }
 623       else
 624         store_typed_address (value_contents_raw (v), type,
 625                               SYMBOL_VALUE_ADDRESS (var));
 626       VALUE_LVAL (v) = not_lval;
 627       return v;
 628
 629     case LOC_CONST_BYTES:
 630       if (is_dynamic_type (type))
 631         {
 632           /* Value is a constant byte-sequence and needs no memory access.  */
 633           type = resolve_dynamic_type (type, NULL, /* Unused address.  */ 0);
 634         }
 635       v = allocate_value (type);
 636       memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
 637               TYPE_LENGTH (type));
 638       VALUE_LVAL (v) = not_lval;
 639       return v;
 640
 641     case LOC_STATIC:
 642       if (overlay_debugging)
 643         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 644                                          SYMBOL_OBJ_SECTION (symbol_objfile (var),
 645                                                              var));
 646       else
 647         addr = SYMBOL_VALUE_ADDRESS (var);
 648       break;
 649
 650     case LOC_ARG:
 651       addr = get_frame_args_address (frame);
 652       if (!addr)
 653         error (_("Unknown argument list address for `%s'."),
 654                SYMBOL_PRINT_NAME (var));
 655       addr += SYMBOL_VALUE (var);
 656       break;
 657
 658     case LOC_REF_ARG:
 659       {
 660         struct value *ref;
 661         CORE_ADDR argref;
 662
 663         argref = get_frame_args_address (frame);
 664         if (!argref)
 665           error (_("Unknown argument list address for `%s'."),
 666                  SYMBOL_PRINT_NAME (var));
 667         argref += SYMBOL_VALUE (var);
 668         ref = value_at (lookup_pointer_type (type), argref);
 669         addr = value_as_address (ref);
 670         break;
 671       }
 672
 673     case LOC_LOCAL:
 674       addr = get_frame_locals_address (frame);
 675       addr += SYMBOL_VALUE (var);
 676       break;
 677
 678     case LOC_TYPEDEF:
 679       error (_("Cannot look up value of a typedef `%s'."),
 680              SYMBOL_PRINT_NAME (var));
 681       break;
 682
 683     case LOC_BLOCK:
 684       if (overlay_debugging)
 685         addr = symbol_overlayed_address
 686           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)),
 687            SYMBOL_OBJ_SECTION (symbol_objfile (var), var));
 688       else
 689         addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 690       break;
 691
 692     case LOC_REGISTER:
 693     case LOC_REGPARM_ADDR:
 694       {
 695         int regno = SYMBOL_REGISTER_OPS (var)
 696                       ->register_number (var, get_frame_arch (frame));
 697         struct value *regval;
 698
 699         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 700           {
 701             regval = value_from_register (lookup_pointer_type (type),
 702                                           regno,
 703                                           frame);
 704
 705             if (regval == NULL)
 706               error (_("Value of register variable not available for `%s'."),
 707                      SYMBOL_PRINT_NAME (var));
 708
 709             addr = value_as_address (regval);
 710           }
 711         else
 712           {
 713             regval = value_from_register (type, regno, frame);
 714
 715             if (regval == NULL)
 716               error (_("Value of register variable not available for `%s'."),
 717                      SYMBOL_PRINT_NAME (var));
 718             return regval;
 719           }
 720       }
 721       break;
 722
 723     case LOC_COMPUTED:
 724       gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
 725
 726     case LOC_UNRESOLVED:
 727       {
 728         struct minsym_lookup_data lookup_data;
 729         struct minimal_symbol *msym;
 730         struct obj_section *obj_section;
 731
 732         memset (&lookup_data, 0, sizeof (lookup_data));
 733         lookup_data.name = SYMBOL_LINKAGE_NAME (var);
 734
 735         gdbarch_iterate_over_objfiles_in_search_order
 736           (symbol_arch (var),
 737            minsym_lookup_iterator_cb, &lookup_data,
 738            symbol_objfile (var));
 739         msym = lookup_data.result.minsym;
 740
 741         /* If we can't find the minsym there's a problem in the symbol info.
 742            The symbol exists in the debug info, but it's missing in the minsym
 743            table.  */
 744         if (msym == NULL)
 745           {
 746             const char *flavour_name
 747               = objfile_flavour_name (symbol_objfile (var));
 748
 749             /* We can't get here unless we've opened the file, so flavour_name
 750                can't be NULL.  */
 751             gdb_assert (flavour_name != NULL);
 752             error (_("Missing %s symbol \"%s\"."),
 753                    flavour_name, SYMBOL_LINKAGE_NAME (var));
 754           }
 755         obj_section = MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, msym);
 756         /* Relocate address, unless there is no section or the variable is
 757            a TLS variable. */
 758         if (obj_section == NULL
 759             || (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
 760            addr = MSYMBOL_VALUE_RAW_ADDRESS (msym);
 761         else
 762            addr = BMSYMBOL_VALUE_ADDRESS (lookup_data.result);
 763         if (overlay_debugging)
 764           addr = symbol_overlayed_address (addr, obj_section);
 765         /* Determine address of TLS variable. */
 766         if (obj_section
 767             && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
 768           addr = target_translate_tls_address (obj_section->objfile, addr);
 769       }
 770       break;
 771
 772     case LOC_OPTIMIZED_OUT:
 773       return allocate_optimized_out_value (type);
 774
 775     default:
 776       error (_("Cannot look up value of a botched symbol `%s'."),
 777              SYMBOL_PRINT_NAME (var));
 778       break;
 779     }
 780
 781   v = value_at_lazy (type, addr);
 782   return v;
 783 }
 784
 785 /* Calls VAR's language la_read_var_value hook with the given arguments.  */
 786
 787 struct value *
 788 read_var_value (struct symbol *var, const struct block *var_block,
 789                 struct frame_info *frame)
 790 {
 791   const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var));
 792
 793   gdb_assert (lang != NULL);
 794   gdb_assert (lang->la_read_var_value != NULL);
 795
 796   return lang->la_read_var_value (var, var_block, frame);
 797 }
 798
 799 /* Install default attributes for register values.  */
 800
 801 struct value *
 802 default_value_from_register (struct gdbarch *gdbarch, struct type *type,
 803                              int regnum, struct frame_id frame_id)
 804 {
 805   int len = TYPE_LENGTH (type);
 806   struct value *value = allocate_value (type);
 807
 808   VALUE_LVAL (value) = lval_register;
 809   VALUE_FRAME_ID (value) = frame_id;
 810   VALUE_REGNUM (value) = regnum;
 811
 812   /* Any structure stored in more than one register will always be
 813      an integral number of registers.  Otherwise, you need to do
 814      some fiddling with the last register copied here for little
 815      endian machines.  */
 816   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
 817       && len < register_size (gdbarch, regnum))
 818     /* Big-endian, and we want less than full size.  */
 819     set_value_offset (value, register_size (gdbarch, regnum) - len);
 820   else
 821     set_value_offset (value, 0);
 822
 823   return value;
 824 }
 825
 826 /* VALUE must be an lval_register value.  If regnum is the value's
 827    associated register number, and len the length of the values type,
 828    read one or more registers in FRAME, starting with register REGNUM,
 829    until we've read LEN bytes.
 830
 831    If any of the registers we try to read are optimized out, then mark the
 832    complete resulting value as optimized out.  */
 833
 834 void
 835 read_frame_register_value (struct value *value, struct frame_info *frame)
 836 {
 837   struct gdbarch *gdbarch = get_frame_arch (frame);
 838   LONGEST offset = 0;
 839   LONGEST reg_offset = value_offset (value);
 840   int regnum = VALUE_REGNUM (value);
 841   int len = type_length_units (check_typedef (value_type (value)));
 842
 843   gdb_assert (VALUE_LVAL (value) == lval_register);
 844
 845   /* Skip registers wholly inside of REG_OFFSET.  */
 846   while (reg_offset >= register_size (gdbarch, regnum))
 847     {
 848       reg_offset -= register_size (gdbarch, regnum);
 849       regnum++;
 850     }
 851
 852   /* Copy the data.  */
 853   while (len > 0)
 854     {
 855       struct value *regval = get_frame_register_value (frame, regnum);
 856       int reg_len = type_length_units (value_type (regval)) - reg_offset;
 857
 858       /* If the register length is larger than the number of bytes
 859          remaining to copy, then only copy the appropriate bytes.  */
 860       if (reg_len > len)
 861         reg_len = len;
 862
 863       value_contents_copy (value, offset, regval, reg_offset, reg_len);
 864
 865       offset += reg_len;
 866       len -= reg_len;
 867       reg_offset = 0;
 868       regnum++;
 869     }
 870 }
 871
 872 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME.  */
 873
 874 struct value *
 875 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 876 {
 877   struct gdbarch *gdbarch = get_frame_arch (frame);
 878   struct type *type1 = check_typedef (type);
 879   struct value *v;
 880
 881   if (gdbarch_convert_register_p (gdbarch, regnum, type1))
 882     {
 883       int optim, unavail, ok;
 884
 885       /* The ISA/ABI need to something weird when obtaining the
 886          specified value from this register.  It might need to
 887          re-order non-adjacent, starting with REGNUM (see MIPS and
 888          i386).  It might need to convert the [float] register into
 889          the corresponding [integer] type (see Alpha).  The assumption
 890          is that gdbarch_register_to_value populates the entire value
 891          including the location.  */
 892       v = allocate_value (type);
 893       VALUE_LVAL (v) = lval_register;
 894       VALUE_FRAME_ID (v) = get_frame_id (frame);
 895       VALUE_REGNUM (v) = regnum;
 896       ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
 897                                       value_contents_raw (v), &optim,
 898                                       &unavail);
 899
 900       if (!ok)
 901         {
 902           if (optim)
 903             mark_value_bytes_optimized_out (v, 0, TYPE_LENGTH (type));
 904           if (unavail)
 905             mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
 906         }
 907     }
 908   else
 909     {
 910       /* Construct the value.  */
 911       v = gdbarch_value_from_register (gdbarch, type,
 912                                        regnum, get_frame_id (frame));
 913
 914       /* Get the data.  */
 915       read_frame_register_value (v, frame);
 916     }
 917
 918   return v;
 919 }
 920
 921 /* Return contents of register REGNUM in frame FRAME as address.
 922    Will abort if register value is not available.  */
 923
 924 CORE_ADDR
 925 address_from_register (int regnum, struct frame_info *frame)
 926 {
 927   struct gdbarch *gdbarch = get_frame_arch (frame);
 928   struct type *type = builtin_type (gdbarch)->builtin_data_ptr;
 929   struct value *value;
 930   CORE_ADDR result;
 931   int regnum_max_excl = (gdbarch_num_regs (gdbarch)
 932                          + gdbarch_num_pseudo_regs (gdbarch));
 933
 934   if (regnum < 0 || regnum >= regnum_max_excl)
 935     error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum,
 936            regnum_max_excl);
 937
 938   /* This routine may be called during early unwinding, at a time
 939      where the ID of FRAME is not yet known.  Calling value_from_register
 940      would therefore abort in get_frame_id.  However, since we only need
 941      a temporary value that is never used as lvalue, we actually do not
 942      really need to set its VALUE_FRAME_ID.  Therefore, we re-implement
 943      the core of value_from_register, but use the null_frame_id.  */
 944
 945   /* Some targets require a special conversion routine even for plain
 946      pointer types.  Avoid constructing a value object in those cases.  */
 947   if (gdbarch_convert_register_p (gdbarch, regnum, type))
 948     {
 949       gdb_byte *buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
 950       int optim, unavail, ok;
 951
 952       ok = gdbarch_register_to_value (gdbarch, frame, regnum, type,
 953                                       buf, &optim, &unavail);
 954       if (!ok)
 955         {
 956           /* This function is used while computing a location expression.
 957              Complain about the value being optimized out, rather than
 958              letting value_as_address complain about some random register
 959              the expression depends on not being saved.  */
 960           error_value_optimized_out ();
 961         }
 962
 963       return unpack_long (type, buf);
 964     }
 965
 966   value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id);
 967   read_frame_register_value (value, frame);
 968
 969   if (value_optimized_out (value))
 970     {
 971       /* This function is used while computing a location expression.
 972          Complain about the value being optimized out, rather than
 973          letting value_as_address complain about some random register
 974          the expression depends on not being saved.  */
 975       error_value_optimized_out ();
 976     }
 977
 978   result = value_as_address (value);
 979   release_value (value);
 980   value_free (value);
 981
 982   return result;
 983 }
 984