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)->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 we can't find the minsym there's a problem in the symbol info.
 741            The symbol exists in the debug info, but it's missing in the minsym
 742            table.  */
 743         if (msym == NULL)
 744           {
 745             const char *flavour_name
 746               = objfile_flavour_name (symbol_objfile (var));
 747
 748             /* We can't get here unless we've opened the file, so flavour_name
 749                can't be NULL.  */
 750             gdb_assert (flavour_name != NULL);
 751             error (_("Missing %s symbol \"%s\"."),
 752                    flavour_name, SYMBOL_LINKAGE_NAME (var));
 753           }
 754         obj_section = MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, msym);
 755         /* Relocate address, unless there is no section or the variable is
 756            a TLS variable. */
 757         if (obj_section == NULL
 758             || (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
 759            addr = MSYMBOL_VALUE_RAW_ADDRESS (msym);
 760         else
 761            addr = BMSYMBOL_VALUE_ADDRESS (lookup_data.result);
 762         if (overlay_debugging)
 763           addr = symbol_overlayed_address (addr, obj_section);
 764         /* Determine address of TLS variable. */
 765         if (obj_section
 766             && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
 767           addr = target_translate_tls_address (obj_section->objfile, addr);
 768       }
 769       break;
 770
 771     case LOC_OPTIMIZED_OUT:
 772       return allocate_optimized_out_value (type);
 773
 774     default:
 775       error (_("Cannot look up value of a botched symbol `%s'."),
 776              SYMBOL_PRINT_NAME (var));
 777       break;
 778     }
 779
 780   v = value_at_lazy (type, addr);
 781   return v;
 782 }
 783
 784 /* Calls VAR's language la_read_var_value hook with the given arguments.  */
 785
 786 struct value *
 787 read_var_value (struct symbol *var, const struct block *var_block,
 788                 struct frame_info *frame)
 789 {
 790   const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var));
 791
 792   gdb_assert (lang != NULL);
 793   gdb_assert (lang->la_read_var_value != NULL);
 794
 795   return lang->la_read_var_value (var, var_block, frame);
 796 }
 797
 798 /* Install default attributes for register values.  */
 799
 800 struct value *
 801 default_value_from_register (struct gdbarch *gdbarch, struct type *type,
 802                              int regnum, struct frame_id frame_id)
 803 {
 804   int len = TYPE_LENGTH (type);
 805   struct value *value = allocate_value (type);
 806
 807   VALUE_LVAL (value) = lval_register;
 808   VALUE_FRAME_ID (value) = frame_id;
 809   VALUE_REGNUM (value) = regnum;
 810
 811   /* Any structure stored in more than one register will always be
 812      an integral number of registers.  Otherwise, you need to do
 813      some fiddling with the last register copied here for little
 814      endian machines.  */
 815   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
 816       && len < register_size (gdbarch, regnum))
 817     /* Big-endian, and we want less than full size.  */
 818     set_value_offset (value, register_size (gdbarch, regnum) - len);
 819   else
 820     set_value_offset (value, 0);
 821
 822   return value;
 823 }
 824
 825 /* VALUE must be an lval_register value.  If regnum is the value's
 826    associated register number, and len the length of the values type,
 827    read one or more registers in FRAME, starting with register REGNUM,
 828    until we've read LEN bytes.
 829
 830    If any of the registers we try to read are optimized out, then mark the
 831    complete resulting value as optimized out.  */
 832
 833 void
 834 read_frame_register_value (struct value *value, struct frame_info *frame)
 835 {
 836   struct gdbarch *gdbarch = get_frame_arch (frame);
 837   int offset = 0;
 838   int reg_offset = value_offset (value);
 839   int regnum = VALUE_REGNUM (value);
 840   int len = type_length_units (check_typedef (value_type (value)));
 841
 842   gdb_assert (VALUE_LVAL (value) == lval_register);
 843
 844   /* Skip registers wholly inside of REG_OFFSET.  */
 845   while (reg_offset >= register_size (gdbarch, regnum))
 846     {
 847       reg_offset -= register_size (gdbarch, regnum);
 848       regnum++;
 849     }
 850
 851   /* Copy the data.  */
 852   while (len > 0)
 853     {
 854       struct value *regval = get_frame_register_value (frame, regnum);
 855       int reg_len = type_length_units (value_type (regval)) - reg_offset;
 856
 857       /* If the register length is larger than the number of bytes
 858          remaining to copy, then only copy the appropriate bytes.  */
 859       if (reg_len > len)
 860         reg_len = len;
 861
 862       value_contents_copy (value, offset, regval, reg_offset, reg_len);
 863
 864       offset += reg_len;
 865       len -= reg_len;
 866       reg_offset = 0;
 867       regnum++;
 868     }
 869 }
 870
 871 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME.  */
 872
 873 struct value *
 874 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 875 {
 876   struct gdbarch *gdbarch = get_frame_arch (frame);
 877   struct type *type1 = check_typedef (type);
 878   struct value *v;
 879
 880   if (gdbarch_convert_register_p (gdbarch, regnum, type1))
 881     {
 882       int optim, unavail, ok;
 883
 884       /* The ISA/ABI need to something weird when obtaining the
 885          specified value from this register.  It might need to
 886          re-order non-adjacent, starting with REGNUM (see MIPS and
 887          i386).  It might need to convert the [float] register into
 888          the corresponding [integer] type (see Alpha).  The assumption
 889          is that gdbarch_register_to_value populates the entire value
 890          including the location.  */
 891       v = allocate_value (type);
 892       VALUE_LVAL (v) = lval_register;
 893       VALUE_FRAME_ID (v) = get_frame_id (frame);
 894       VALUE_REGNUM (v) = regnum;
 895       ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
 896                                       value_contents_raw (v), &optim,
 897                                       &unavail);
 898
 899       if (!ok)
 900         {
 901           if (optim)
 902             mark_value_bytes_optimized_out (v, 0, TYPE_LENGTH (type));
 903           if (unavail)
 904             mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
 905         }
 906     }
 907   else
 908     {
 909       /* Construct the value.  */
 910       v = gdbarch_value_from_register (gdbarch, type,
 911                                        regnum, get_frame_id (frame));
 912
 913       /* Get the data.  */
 914       read_frame_register_value (v, frame);
 915     }
 916
 917   return v;
 918 }
 919
 920 /* Return contents of register REGNUM in frame FRAME as address.
 921    Will abort if register value is not available.  */
 922
 923 CORE_ADDR
 924 address_from_register (int regnum, struct frame_info *frame)
 925 {
 926   struct gdbarch *gdbarch = get_frame_arch (frame);
 927   struct type *type = builtin_type (gdbarch)->builtin_data_ptr;
 928   struct value *value;
 929   CORE_ADDR result;
 930   int regnum_max_excl = (gdbarch_num_regs (gdbarch)
 931                          + gdbarch_num_pseudo_regs (gdbarch));
 932
 933   if (regnum < 0 || regnum >= regnum_max_excl)
 934     error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum,
 935            regnum_max_excl);
 936
 937   /* This routine may be called during early unwinding, at a time
 938      where the ID of FRAME is not yet known.  Calling value_from_register
 939      would therefore abort in get_frame_id.  However, since we only need
 940      a temporary value that is never used as lvalue, we actually do not
 941      really need to set its VALUE_FRAME_ID.  Therefore, we re-implement
 942      the core of value_from_register, but use the null_frame_id.  */
 943
 944   /* Some targets require a special conversion routine even for plain
 945      pointer types.  Avoid constructing a value object in those cases.  */
 946   if (gdbarch_convert_register_p (gdbarch, regnum, type))
 947     {
 948       gdb_byte *buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
 949       int optim, unavail, ok;
 950
 951       ok = gdbarch_register_to_value (gdbarch, frame, regnum, type,
 952                                       buf, &optim, &unavail);
 953       if (!ok)
 954         {
 955           /* This function is used while computing a location expression.
 956              Complain about the value being optimized out, rather than
 957              letting value_as_address complain about some random register
 958              the expression depends on not being saved.  */
 959           error_value_optimized_out ();
 960         }
 961
 962       return unpack_long (type, buf);
 963     }
 964
 965   value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id);
 966   read_frame_register_value (value, frame);
 967
 968   if (value_optimized_out (value))
 969     {
 970       /* This function is used while computing a location expression.
 971          Complain about the value being optimized out, rather than
 972          letting value_as_address complain about some random register
 973          the expression depends on not being saved.  */
 974       error_value_optimized_out ();
 975     }
 976
 977   result = value_as_address (value);
 978   release_value (value);
 979   value_free (value);
 980
 981   return result;
 982 }
 983