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