gdb/findvar.c

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