gdb/findvar.c

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