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 #include "selftest.h"
  37
  38 /* Basic byte-swapping routines.  All 'extract' functions return a
  39    host-format integer from a target-format integer at ADDR which is
  40    LEN bytes long.  */
  41
  42 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
  43   /* 8 bit characters are a pretty safe assumption these days, so we
  44      assume it throughout all these swapping routines.  If we had to deal with
  45      9 bit characters, we would need to make len be in bits and would have
  46      to re-write these routines...  */
  47 you lose
  48 #endif
  49
  50 LONGEST
  51 extract_signed_integer (const gdb_byte *addr, int len,
  52                         enum bfd_endian byte_order)
  53 {
  54   LONGEST retval;
  55   const unsigned char *p;
  56   const unsigned char *startaddr = addr;
  57   const unsigned char *endaddr = startaddr + len;
  58
  59   if (len > (int) sizeof (LONGEST))
  60     error (_("\
  61 That operation is not available on integers of more than %d bytes."),
  62            (int) sizeof (LONGEST));
  63
  64   /* Start at the most significant end of the integer, and work towards
  65      the least significant.  */
  66   if (byte_order == BFD_ENDIAN_BIG)
  67     {
  68       p = startaddr;
  69       /* Do the sign extension once at the start.  */
  70       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  71       for (++p; p < endaddr; ++p)
  72         retval = (retval << 8) | *p;
  73     }
  74   else
  75     {
  76       p = endaddr - 1;
  77       /* Do the sign extension once at the start.  */
  78       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  79       for (--p; p >= startaddr; --p)
  80         retval = (retval << 8) | *p;
  81     }
  82   return retval;
  83 }
  84
  85 ULONGEST
  86 extract_unsigned_integer (const gdb_byte *addr, int len,
  87                           enum bfd_endian byte_order)
  88 {
  89   ULONGEST retval;
  90   const unsigned char *p;
  91   const unsigned char *startaddr = addr;
  92   const unsigned char *endaddr = startaddr + len;
  93
  94   if (len > (int) sizeof (ULONGEST))
  95     error (_("\
  96 That operation is not available on integers of more than %d bytes."),
  97            (int) sizeof (ULONGEST));
  98
  99   /* Start at the most significant end of the integer, and work towards
 100      the least significant.  */
 101   retval = 0;
 102   if (byte_order == BFD_ENDIAN_BIG)
 103     {
 104       for (p = startaddr; p < endaddr; ++p)
 105         retval = (retval << 8) | *p;
 106     }
 107   else
 108     {
 109       for (p = endaddr - 1; p >= startaddr; --p)
 110         retval = (retval << 8) | *p;
 111     }
 112   return retval;
 113 }
 114
 115 /* Sometimes a long long unsigned integer can be extracted as a
 116    LONGEST value.  This is done so that we can print these values
 117    better.  If this integer can be converted to a LONGEST, this
 118    function returns 1 and sets *PVAL.  Otherwise it returns 0.  */
 119
 120 int
 121 extract_long_unsigned_integer (const gdb_byte *addr, int orig_len,
 122                                enum bfd_endian byte_order, LONGEST *pval)
 123 {
 124   const gdb_byte *p;
 125   const gdb_byte *first_addr;
 126   int len;
 127
 128   len = orig_len;
 129   if (byte_order == BFD_ENDIAN_BIG)
 130     {
 131       for (p = addr;
 132            len > (int) sizeof (LONGEST) && p < addr + orig_len;
 133            p++)
 134         {
 135           if (*p == 0)
 136             len--;
 137           else
 138             break;
 139         }
 140       first_addr = p;
 141     }
 142   else
 143     {
 144       first_addr = addr;
 145       for (p = addr + orig_len - 1;
 146            len > (int) sizeof (LONGEST) && p >= addr;
 147            p--)
 148         {
 149           if (*p == 0)
 150             len--;
 151           else
 152             break;
 153         }
 154     }
 155
 156   if (len <= (int) sizeof (LONGEST))
 157     {
 158       *pval = (LONGEST) extract_unsigned_integer (first_addr,
 159                                                   sizeof (LONGEST),
 160                                                   byte_order);
 161       return 1;
 162     }
 163
 164   return 0;
 165 }
 166
 167
 168 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
 169    address it represents.  */
 170 CORE_ADDR
 171 extract_typed_address (const gdb_byte *buf, struct type *type)
 172 {
 173   if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
 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 && !TYPE_IS_REFERENCE (type))
 246     internal_error (__FILE__, __LINE__,
 247                     _("store_typed_address: "
 248                     "type is not a pointer or reference"));
 249
 250   gdbarch_address_to_pointer (get_type_arch (type), type, buf, addr);
 251 }
 252
 253 /* Copy a value from SOURCE of size SOURCE_SIZE bytes to DEST of size DEST_SIZE
 254    bytes.  If SOURCE_SIZE is greater than DEST_SIZE, then truncate the most
 255    significant bytes.  If SOURCE_SIZE is less than DEST_SIZE then either sign
 256    or zero extended according to IS_SIGNED.  Values are stored in memory with
 257    endianess BYTE_ORDER.  */
 258
 259 void
 260 copy_integer_to_size (gdb_byte *dest, int dest_size, const gdb_byte *source,
 261                       int source_size, bool is_signed,
 262                       enum bfd_endian byte_order)
 263 {
 264   signed int size_diff = dest_size - source_size;
 265
 266   /* Copy across everything from SOURCE that can fit into DEST.  */
 267
 268   if (byte_order == BFD_ENDIAN_BIG && size_diff > 0)
 269     memcpy (dest + size_diff, source, source_size);
 270   else if (byte_order == BFD_ENDIAN_BIG && size_diff < 0)
 271     memcpy (dest, source - size_diff, dest_size);
 272   else
 273     memcpy (dest, source, std::min (source_size, dest_size));
 274
 275   /* Fill the remaining space in DEST by either zero extending or sign
 276      extending.  */
 277
 278   if (size_diff > 0)
 279     {
 280       gdb_byte extension = 0;
 281       if (is_signed
 282           && ((byte_order != BFD_ENDIAN_BIG && source[source_size - 1] & 0x80)
 283               || (byte_order == BFD_ENDIAN_BIG && source[0] & 0x80)))
 284         extension = 0xff;
 285
 286       /* Extend into MSBs of SOURCE.  */
 287       if (byte_order == BFD_ENDIAN_BIG)
 288         memset (dest, extension, size_diff);
 289       else
 290         memset (dest + source_size, extension, size_diff);
 291     }
 292 }
 293
 294 /* Return a `value' with the contents of (virtual or cooked) register
 295    REGNUM as found in the specified FRAME.  The register's type is
 296    determined by register_type().  */
 297
 298 struct value *
 299 value_of_register (int regnum, struct frame_info *frame)
 300 {
 301   struct gdbarch *gdbarch = get_frame_arch (frame);
 302   struct value *reg_val;
 303
 304   /* User registers lie completely outside of the range of normal
 305      registers.  Catch them early so that the target never sees them.  */
 306   if (regnum >= gdbarch_num_regs (gdbarch)
 307                 + gdbarch_num_pseudo_regs (gdbarch))
 308     return value_of_user_reg (regnum, frame);
 309
 310   reg_val = value_of_register_lazy (frame, regnum);
 311   value_fetch_lazy (reg_val);
 312   return reg_val;
 313 }
 314
 315 /* Return a `value' with the contents of (virtual or cooked) register
 316    REGNUM as found in the specified FRAME.  The register's type is
 317    determined by register_type().  The value is not fetched.  */
 318
 319 struct value *
 320 value_of_register_lazy (struct frame_info *frame, int regnum)
 321 {
 322   struct gdbarch *gdbarch = get_frame_arch (frame);
 323   struct value *reg_val;
 324   struct frame_info *next_frame;
 325
 326   gdb_assert (regnum < (gdbarch_num_regs (gdbarch)
 327                         + gdbarch_num_pseudo_regs (gdbarch)));
 328
 329   gdb_assert (frame != NULL);
 330
 331   next_frame = get_next_frame_sentinel_okay (frame);
 332
 333   /* We should have a valid next frame.  */
 334   gdb_assert (frame_id_p (get_frame_id (next_frame)));
 335
 336   reg_val = allocate_value_lazy (register_type (gdbarch, regnum));
 337   VALUE_LVAL (reg_val) = lval_register;
 338   VALUE_REGNUM (reg_val) = regnum;
 339   VALUE_NEXT_FRAME_ID (reg_val) = get_frame_id (next_frame);
 340
 341   return reg_val;
 342 }
 343
 344 /* Given a pointer of type TYPE in target form in BUF, return the
 345    address it represents.  */
 346 CORE_ADDR
 347 unsigned_pointer_to_address (struct gdbarch *gdbarch,
 348                              struct type *type, const gdb_byte *buf)
 349 {
 350   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 351
 352   return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
 353 }
 354
 355 CORE_ADDR
 356 signed_pointer_to_address (struct gdbarch *gdbarch,
 357                            struct type *type, const gdb_byte *buf)
 358 {
 359   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 360
 361   return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
 362 }
 363
 364 /* Given an address, store it as a pointer of type TYPE in target
 365    format in BUF.  */
 366 void
 367 unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type,
 368                              gdb_byte *buf, CORE_ADDR addr)
 369 {
 370   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 371
 372   store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr);
 373 }
 374
 375 void
 376 address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type,
 377                            gdb_byte *buf, CORE_ADDR addr)
 378 {
 379   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 380
 381   store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr);
 382 }
 383 \f
 384 /* See value.h.  */
 385
 386 enum symbol_needs_kind
 387 symbol_read_needs (struct symbol *sym)
 388 {
 389   if (SYMBOL_COMPUTED_OPS (sym) != NULL)
 390     return SYMBOL_COMPUTED_OPS (sym)->get_symbol_read_needs (sym);
 391
 392   switch (SYMBOL_CLASS (sym))
 393     {
 394       /* All cases listed explicitly so that gcc -Wall will detect it if
 395          we failed to consider one.  */
 396     case LOC_COMPUTED:
 397       gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
 398
 399     case LOC_REGISTER:
 400     case LOC_ARG:
 401     case LOC_REF_ARG:
 402     case LOC_REGPARM_ADDR:
 403     case LOC_LOCAL:
 404       return SYMBOL_NEEDS_FRAME;
 405
 406     case LOC_UNDEF:
 407     case LOC_CONST:
 408     case LOC_STATIC:
 409     case LOC_TYPEDEF:
 410
 411     case LOC_LABEL:
 412       /* Getting the address of a label can be done independently of the block,
 413          even if some *uses* of that address wouldn't work so well without
 414          the right frame.  */
 415
 416     case LOC_BLOCK:
 417     case LOC_CONST_BYTES:
 418     case LOC_UNRESOLVED:
 419     case LOC_OPTIMIZED_OUT:
 420       return SYMBOL_NEEDS_NONE;
 421     }
 422   return SYMBOL_NEEDS_FRAME;
 423 }
 424
 425 /* See value.h.  */
 426
 427 int
 428 symbol_read_needs_frame (struct symbol *sym)
 429 {
 430   return symbol_read_needs (sym) == SYMBOL_NEEDS_FRAME;
 431 }
 432
 433 /* Private data to be used with minsym_lookup_iterator_cb.  */
 434
 435 struct minsym_lookup_data
 436 {
 437   /* The name of the minimal symbol we are searching for.  */
 438   const char *name;
 439
 440   /* The field where the callback should store the minimal symbol
 441      if found.  It should be initialized to NULL before the search
 442      is started.  */
 443   struct bound_minimal_symbol result;
 444 };
 445
 446 /* A callback function for gdbarch_iterate_over_objfiles_in_search_order.
 447    It searches by name for a minimal symbol within the given OBJFILE.
 448    The arguments are passed via CB_DATA, which in reality is a pointer
 449    to struct minsym_lookup_data.  */
 450
 451 static int
 452 minsym_lookup_iterator_cb (struct objfile *objfile, void *cb_data)
 453 {
 454   struct minsym_lookup_data *data = (struct minsym_lookup_data *) cb_data;
 455
 456   gdb_assert (data->result.minsym == NULL);
 457
 458   data->result = lookup_minimal_symbol (data->name, NULL, objfile);
 459
 460   /* The iterator should stop iff a match was found.  */
 461   return (data->result.minsym != NULL);
 462 }
 463
 464 /* Given static link expression and the frame it lives in, look for the frame
 465    the static links points to and return it.  Return NULL if we could not find
 466    such a frame.   */
 467
 468 static struct frame_info *
 469 follow_static_link (struct frame_info *frame,
 470                     const struct dynamic_prop *static_link)
 471 {
 472   CORE_ADDR upper_frame_base;
 473
 474   if (!dwarf2_evaluate_property (static_link, frame, NULL, &upper_frame_base))
 475     return NULL;
 476
 477   /* Now climb up the stack frame until we reach the frame we are interested
 478      in.  */
 479   for (; frame != NULL; frame = get_prev_frame (frame))
 480     {
 481       struct symbol *framefunc = get_frame_function (frame);
 482
 483       /* Stacks can be quite deep: give the user a chance to stop this.  */
 484       QUIT;
 485
 486       /* If we don't know how to compute FRAME's base address, don't give up:
 487          maybe the frame we are looking for is upper in the stace frame.  */
 488       if (framefunc != NULL
 489           && SYMBOL_BLOCK_OPS (framefunc) != NULL
 490           && SYMBOL_BLOCK_OPS (framefunc)->get_frame_base != NULL
 491           && (SYMBOL_BLOCK_OPS (framefunc)->get_frame_base (framefunc, frame)
 492               == upper_frame_base))
 493         break;
 494     }
 495
 496   return frame;
 497 }
 498
 499 /* Assuming VAR is a symbol that can be reached from FRAME thanks to lexical
 500    rules, look for the frame that is actually hosting VAR and return it.  If,
 501    for some reason, we found no such frame, return NULL.
 502
 503    This kind of computation is necessary to correctly handle lexically nested
 504    functions.
 505
 506    Note that in some cases, we know what scope VAR comes from but we cannot
 507    reach the specific frame that hosts the instance of VAR we are looking for.
 508    For backward compatibility purposes (with old compilers), we then look for
 509    the first frame that can host it.  */
 510
 511 static struct frame_info *
 512 get_hosting_frame (struct symbol *var, const struct block *var_block,
 513                    struct frame_info *frame)
 514 {
 515   const struct block *frame_block = NULL;
 516
 517   if (!symbol_read_needs_frame (var))
 518     return NULL;
 519
 520   /* Some symbols for local variables have no block: this happens when they are
 521      not produced by a debug information reader, for instance when GDB creates
 522      synthetic symbols.  Without block information, we must assume they are
 523      local to FRAME. In this case, there is nothing to do.  */
 524   else if (var_block == NULL)
 525     return frame;
 526
 527   /* We currently assume that all symbols with a location list need a frame.
 528      This is true in practice because selecting the location description
 529      requires to compute the CFA, hence requires a frame.  However we have
 530      tests that embed global/static symbols with null location lists.
 531      We want to get <optimized out> instead of <frame required> when evaluating
 532      them so return a frame instead of raising an error.  */
 533   else if (var_block == block_global_block (var_block)
 534            || var_block == block_static_block (var_block))
 535     return frame;
 536
 537   /* We have to handle the "my_func::my_local_var" notation.  This requires us
 538      to look for upper frames when we find no block for the current frame: here
 539      and below, handle when frame_block == NULL.  */
 540   if (frame != NULL)
 541     frame_block = get_frame_block (frame, NULL);
 542
 543   /* Climb up the call stack until reaching the frame we are looking for.  */
 544   while (frame != NULL && frame_block != var_block)
 545     {
 546       /* Stacks can be quite deep: give the user a chance to stop this.  */
 547       QUIT;
 548
 549       if (frame_block == NULL)
 550         {
 551           frame = get_prev_frame (frame);
 552           if (frame == NULL)
 553             break;
 554           frame_block = get_frame_block (frame, NULL);
 555         }
 556
 557       /* If we failed to find the proper frame, fallback to the heuristic
 558          method below.  */
 559       else if (frame_block == block_global_block (frame_block))
 560         {
 561           frame = NULL;
 562           break;
 563         }
 564
 565       /* Assuming we have a block for this frame: if we are at the function
 566          level, the immediate upper lexical block is in an outer function:
 567          follow the static link.  */
 568       else if (BLOCK_FUNCTION (frame_block))
 569         {
 570           const struct dynamic_prop *static_link
 571             = block_static_link (frame_block);
 572           int could_climb_up = 0;
 573
 574           if (static_link != NULL)
 575             {
 576               frame = follow_static_link (frame, static_link);
 577               if (frame != NULL)
 578                 {
 579                   frame_block = get_frame_block (frame, NULL);
 580                   could_climb_up = frame_block != NULL;
 581                 }
 582             }
 583           if (!could_climb_up)
 584             {
 585               frame = NULL;
 586               break;
 587             }
 588         }
 589
 590       else
 591         /* We must be in some function nested lexical block.  Just get the
 592            outer block: both must share the same frame.  */
 593         frame_block = BLOCK_SUPERBLOCK (frame_block);
 594     }
 595
 596   /* Old compilers may not provide a static link, or they may provide an
 597      invalid one.  For such cases, fallback on the old way to evaluate
 598      non-local references: just climb up the call stack and pick the first
 599      frame that contains the variable we are looking for.  */
 600   if (frame == NULL)
 601     {
 602       frame = block_innermost_frame (var_block);
 603       if (frame == NULL)
 604         {
 605           if (BLOCK_FUNCTION (var_block)
 606               && !block_inlined_p (var_block)
 607               && SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block)))
 608             error (_("No frame is currently executing in block %s."),
 609                    SYMBOL_PRINT_NAME (BLOCK_FUNCTION (var_block)));
 610           else
 611             error (_("No frame is currently executing in specified"
 612                      " block"));
 613         }
 614     }
 615
 616   return frame;
 617 }
 618
 619 /* A default implementation for the "la_read_var_value" hook in
 620    the language vector which should work in most situations.  */
 621
 622 struct value *
 623 default_read_var_value (struct symbol *var, const struct block *var_block,
 624                         struct frame_info *frame)
 625 {
 626   struct value *v;
 627   struct type *type = SYMBOL_TYPE (var);
 628   CORE_ADDR addr;
 629   enum symbol_needs_kind sym_need;
 630
 631   /* Call check_typedef on our type to make sure that, if TYPE is
 632      a TYPE_CODE_TYPEDEF, its length is set to the length of the target type
 633      instead of zero.  However, we do not replace the typedef type by the
 634      target type, because we want to keep the typedef in order to be able to
 635      set the returned value type description correctly.  */
 636   check_typedef (type);
 637
 638   sym_need = symbol_read_needs (var);
 639   if (sym_need == SYMBOL_NEEDS_FRAME)
 640     gdb_assert (frame != NULL);
 641   else if (sym_need == SYMBOL_NEEDS_REGISTERS && !target_has_registers)
 642     error (_("Cannot read `%s' without registers"), SYMBOL_PRINT_NAME (var));
 643
 644   if (frame != NULL)
 645     frame = get_hosting_frame (var, var_block, frame);
 646
 647   if (SYMBOL_COMPUTED_OPS (var) != NULL)
 648     return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
 649
 650   switch (SYMBOL_CLASS (var))
 651     {
 652     case LOC_CONST:
 653       if (is_dynamic_type (type))
 654         {
 655           /* Value is a constant byte-sequence and needs no memory access.  */
 656           type = resolve_dynamic_type (type, NULL, /* Unused address.  */ 0);
 657         }
 658       /* Put the constant back in target format. */
 659       v = allocate_value (type);
 660       store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type),
 661                             gdbarch_byte_order (get_type_arch (type)),
 662                             (LONGEST) SYMBOL_VALUE (var));
 663       VALUE_LVAL (v) = not_lval;
 664       return v;
 665
 666     case LOC_LABEL:
 667       /* Put the constant back in target format.  */
 668       v = allocate_value (type);
 669       if (overlay_debugging)
 670         {
 671           CORE_ADDR addr
 672             = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 673                                         SYMBOL_OBJ_SECTION (symbol_objfile (var),
 674                                                             var));
 675
 676           store_typed_address (value_contents_raw (v), type, addr);
 677         }
 678       else
 679         store_typed_address (value_contents_raw (v), type,
 680                               SYMBOL_VALUE_ADDRESS (var));
 681       VALUE_LVAL (v) = not_lval;
 682       return v;
 683
 684     case LOC_CONST_BYTES:
 685       if (is_dynamic_type (type))
 686         {
 687           /* Value is a constant byte-sequence and needs no memory access.  */
 688           type = resolve_dynamic_type (type, NULL, /* Unused address.  */ 0);
 689         }
 690       v = allocate_value (type);
 691       memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var),
 692               TYPE_LENGTH (type));
 693       VALUE_LVAL (v) = not_lval;
 694       return v;
 695
 696     case LOC_STATIC:
 697       if (overlay_debugging)
 698         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 699                                          SYMBOL_OBJ_SECTION (symbol_objfile (var),
 700                                                              var));
 701       else
 702         addr = SYMBOL_VALUE_ADDRESS (var);
 703       break;
 704
 705     case LOC_ARG:
 706       addr = get_frame_args_address (frame);
 707       if (!addr)
 708         error (_("Unknown argument list address for `%s'."),
 709                SYMBOL_PRINT_NAME (var));
 710       addr += SYMBOL_VALUE (var);
 711       break;
 712
 713     case LOC_REF_ARG:
 714       {
 715         struct value *ref;
 716         CORE_ADDR argref;
 717
 718         argref = get_frame_args_address (frame);
 719         if (!argref)
 720           error (_("Unknown argument list address for `%s'."),
 721                  SYMBOL_PRINT_NAME (var));
 722         argref += SYMBOL_VALUE (var);
 723         ref = value_at (lookup_pointer_type (type), argref);
 724         addr = value_as_address (ref);
 725         break;
 726       }
 727
 728     case LOC_LOCAL:
 729       addr = get_frame_locals_address (frame);
 730       addr += SYMBOL_VALUE (var);
 731       break;
 732
 733     case LOC_TYPEDEF:
 734       error (_("Cannot look up value of a typedef `%s'."),
 735              SYMBOL_PRINT_NAME (var));
 736       break;
 737
 738     case LOC_BLOCK:
 739       if (overlay_debugging)
 740         addr = symbol_overlayed_address
 741           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)),
 742            SYMBOL_OBJ_SECTION (symbol_objfile (var), var));
 743       else
 744         addr = BLOCK_START (SYMBOL_BLOCK_VALUE (var));
 745       break;
 746
 747     case LOC_REGISTER:
 748     case LOC_REGPARM_ADDR:
 749       {
 750         int regno = SYMBOL_REGISTER_OPS (var)
 751                       ->register_number (var, get_frame_arch (frame));
 752         struct value *regval;
 753
 754         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 755           {
 756             regval = value_from_register (lookup_pointer_type (type),
 757                                           regno,
 758                                           frame);
 759
 760             if (regval == NULL)
 761               error (_("Value of register variable not available for `%s'."),
 762                      SYMBOL_PRINT_NAME (var));
 763
 764             addr = value_as_address (regval);
 765           }
 766         else
 767           {
 768             regval = value_from_register (type, regno, frame);
 769
 770             if (regval == NULL)
 771               error (_("Value of register variable not available for `%s'."),
 772                      SYMBOL_PRINT_NAME (var));
 773             return regval;
 774           }
 775       }
 776       break;
 777
 778     case LOC_COMPUTED:
 779       gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
 780
 781     case LOC_UNRESOLVED:
 782       {
 783         struct minsym_lookup_data lookup_data;
 784         struct minimal_symbol *msym;
 785         struct obj_section *obj_section;
 786
 787         memset (&lookup_data, 0, sizeof (lookup_data));
 788         lookup_data.name = SYMBOL_LINKAGE_NAME (var);
 789
 790         gdbarch_iterate_over_objfiles_in_search_order
 791           (symbol_arch (var),
 792            minsym_lookup_iterator_cb, &lookup_data,
 793            symbol_objfile (var));
 794         msym = lookup_data.result.minsym;
 795
 796         /* If we can't find the minsym there's a problem in the symbol info.
 797            The symbol exists in the debug info, but it's missing in the minsym
 798            table.  */
 799         if (msym == NULL)
 800           {
 801             const char *flavour_name
 802               = objfile_flavour_name (symbol_objfile (var));
 803
 804             /* We can't get here unless we've opened the file, so flavour_name
 805                can't be NULL.  */
 806             gdb_assert (flavour_name != NULL);
 807             error (_("Missing %s symbol \"%s\"."),
 808                    flavour_name, SYMBOL_LINKAGE_NAME (var));
 809           }
 810         obj_section = MSYMBOL_OBJ_SECTION (lookup_data.result.objfile, msym);
 811         /* Relocate address, unless there is no section or the variable is
 812            a TLS variable. */
 813         if (obj_section == NULL
 814             || (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
 815            addr = MSYMBOL_VALUE_RAW_ADDRESS (msym);
 816         else
 817            addr = BMSYMBOL_VALUE_ADDRESS (lookup_data.result);
 818         if (overlay_debugging)
 819           addr = symbol_overlayed_address (addr, obj_section);
 820         /* Determine address of TLS variable. */
 821         if (obj_section
 822             && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
 823           addr = target_translate_tls_address (obj_section->objfile, addr);
 824       }
 825       break;
 826
 827     case LOC_OPTIMIZED_OUT:
 828       return allocate_optimized_out_value (type);
 829
 830     default:
 831       error (_("Cannot look up value of a botched symbol `%s'."),
 832              SYMBOL_PRINT_NAME (var));
 833       break;
 834     }
 835
 836   v = value_at_lazy (type, addr);
 837   return v;
 838 }
 839
 840 /* Calls VAR's language la_read_var_value hook with the given arguments.  */
 841
 842 struct value *
 843 read_var_value (struct symbol *var, const struct block *var_block,
 844                 struct frame_info *frame)
 845 {
 846   const struct language_defn *lang = language_def (SYMBOL_LANGUAGE (var));
 847
 848   gdb_assert (lang != NULL);
 849   gdb_assert (lang->la_read_var_value != NULL);
 850
 851   return lang->la_read_var_value (var, var_block, frame);
 852 }
 853
 854 /* Install default attributes for register values.  */
 855
 856 struct value *
 857 default_value_from_register (struct gdbarch *gdbarch, struct type *type,
 858                              int regnum, struct frame_id frame_id)
 859 {
 860   int len = TYPE_LENGTH (type);
 861   struct value *value = allocate_value (type);
 862   struct frame_info *frame;
 863
 864   VALUE_LVAL (value) = lval_register;
 865   frame = frame_find_by_id (frame_id);
 866
 867   if (frame == NULL)
 868     frame_id = null_frame_id;
 869   else
 870     frame_id = get_frame_id (get_next_frame_sentinel_okay (frame));
 871
 872   VALUE_NEXT_FRAME_ID (value) = frame_id;
 873   VALUE_REGNUM (value) = regnum;
 874
 875   /* Any structure stored in more than one register will always be
 876      an integral number of registers.  Otherwise, you need to do
 877      some fiddling with the last register copied here for little
 878      endian machines.  */
 879   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
 880       && len < register_size (gdbarch, regnum))
 881     /* Big-endian, and we want less than full size.  */
 882     set_value_offset (value, register_size (gdbarch, regnum) - len);
 883   else
 884     set_value_offset (value, 0);
 885
 886   return value;
 887 }
 888
 889 /* VALUE must be an lval_register value.  If regnum is the value's
 890    associated register number, and len the length of the values type,
 891    read one or more registers in FRAME, starting with register REGNUM,
 892    until we've read LEN bytes.
 893
 894    If any of the registers we try to read are optimized out, then mark the
 895    complete resulting value as optimized out.  */
 896
 897 void
 898 read_frame_register_value (struct value *value, struct frame_info *frame)
 899 {
 900   struct gdbarch *gdbarch = get_frame_arch (frame);
 901   LONGEST offset = 0;
 902   LONGEST reg_offset = value_offset (value);
 903   int regnum = VALUE_REGNUM (value);
 904   int len = type_length_units (check_typedef (value_type (value)));
 905
 906   gdb_assert (VALUE_LVAL (value) == lval_register);
 907
 908   /* Skip registers wholly inside of REG_OFFSET.  */
 909   while (reg_offset >= register_size (gdbarch, regnum))
 910     {
 911       reg_offset -= register_size (gdbarch, regnum);
 912       regnum++;
 913     }
 914
 915   /* Copy the data.  */
 916   while (len > 0)
 917     {
 918       struct value *regval = get_frame_register_value (frame, regnum);
 919       int reg_len = type_length_units (value_type (regval)) - reg_offset;
 920
 921       /* If the register length is larger than the number of bytes
 922          remaining to copy, then only copy the appropriate bytes.  */
 923       if (reg_len > len)
 924         reg_len = len;
 925
 926       value_contents_copy (value, offset, regval, reg_offset, reg_len);
 927
 928       offset += reg_len;
 929       len -= reg_len;
 930       reg_offset = 0;
 931       regnum++;
 932     }
 933 }
 934
 935 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME.  */
 936
 937 struct value *
 938 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 939 {
 940   struct gdbarch *gdbarch = get_frame_arch (frame);
 941   struct type *type1 = check_typedef (type);
 942   struct value *v;
 943
 944   if (gdbarch_convert_register_p (gdbarch, regnum, type1))
 945     {
 946       int optim, unavail, ok;
 947
 948       /* The ISA/ABI need to something weird when obtaining the
 949          specified value from this register.  It might need to
 950          re-order non-adjacent, starting with REGNUM (see MIPS and
 951          i386).  It might need to convert the [float] register into
 952          the corresponding [integer] type (see Alpha).  The assumption
 953          is that gdbarch_register_to_value populates the entire value
 954          including the location.  */
 955       v = allocate_value (type);
 956       VALUE_LVAL (v) = lval_register;
 957       VALUE_NEXT_FRAME_ID (v) = get_frame_id (get_next_frame_sentinel_okay (frame));
 958       VALUE_REGNUM (v) = regnum;
 959       ok = gdbarch_register_to_value (gdbarch, frame, regnum, type1,
 960                                       value_contents_raw (v), &optim,
 961                                       &unavail);
 962
 963       if (!ok)
 964         {
 965           if (optim)
 966             mark_value_bytes_optimized_out (v, 0, TYPE_LENGTH (type));
 967           if (unavail)
 968             mark_value_bytes_unavailable (v, 0, TYPE_LENGTH (type));
 969         }
 970     }
 971   else
 972     {
 973       /* Construct the value.  */
 974       v = gdbarch_value_from_register (gdbarch, type,
 975                                        regnum, get_frame_id (frame));
 976
 977       /* Get the data.  */
 978       read_frame_register_value (v, frame);
 979     }
 980
 981   return v;
 982 }
 983
 984 /* Return contents of register REGNUM in frame FRAME as address.
 985    Will abort if register value is not available.  */
 986
 987 CORE_ADDR
 988 address_from_register (int regnum, struct frame_info *frame)
 989 {
 990   struct gdbarch *gdbarch = get_frame_arch (frame);
 991   struct type *type = builtin_type (gdbarch)->builtin_data_ptr;
 992   struct value *value;
 993   CORE_ADDR result;
 994   int regnum_max_excl = (gdbarch_num_regs (gdbarch)
 995                          + gdbarch_num_pseudo_regs (gdbarch));
 996
 997   if (regnum < 0 || regnum >= regnum_max_excl)
 998     error (_("Invalid register #%d, expecting 0 <= # < %d"), regnum,
 999            regnum_max_excl);
1000
1001   /* This routine may be called during early unwinding, at a time
1002      where the ID of FRAME is not yet known.  Calling value_from_register
1003      would therefore abort in get_frame_id.  However, since we only need
1004      a temporary value that is never used as lvalue, we actually do not
1005      really need to set its VALUE_NEXT_FRAME_ID.  Therefore, we re-implement
1006      the core of value_from_register, but use the null_frame_id.  */
1007
1008   /* Some targets require a special conversion routine even for plain
1009      pointer types.  Avoid constructing a value object in those cases.  */
1010   if (gdbarch_convert_register_p (gdbarch, regnum, type))
1011     {
1012       gdb_byte *buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
1013       int optim, unavail, ok;
1014
1015       ok = gdbarch_register_to_value (gdbarch, frame, regnum, type,
1016                                       buf, &optim, &unavail);
1017       if (!ok)
1018         {
1019           /* This function is used while computing a location expression.
1020              Complain about the value being optimized out, rather than
1021              letting value_as_address complain about some random register
1022              the expression depends on not being saved.  */
1023           error_value_optimized_out ();
1024         }
1025
1026       return unpack_long (type, buf);
1027     }
1028
1029   value = gdbarch_value_from_register (gdbarch, type, regnum, null_frame_id);
1030   read_frame_register_value (value, frame);
1031
1032   if (value_optimized_out (value))
1033     {
1034       /* This function is used while computing a location expression.
1035          Complain about the value being optimized out, rather than
1036          letting value_as_address complain about some random register
1037          the expression depends on not being saved.  */
1038       error_value_optimized_out ();
1039     }
1040
1041   result = value_as_address (value);
1042   release_value (value);
1043   value_free (value);
1044
1045   return result;
1046 }
1047
1048 #if GDB_SELF_TEST
1049 namespace selftests {
1050 namespace findvar_tests {
1051
1052 /* Function to test copy_integer_to_size.  Store SOURCE_VAL with size
1053    SOURCE_SIZE to a buffer, making sure no sign extending happens at this
1054    stage.  Copy buffer to a new buffer using copy_integer_to_size.  Extract
1055    copied value and compare to DEST_VALU.  Copy again with a signed
1056    copy_integer_to_size and compare to DEST_VALS.  Do everything for both
1057    LITTLE and BIG target endians.  Use unsigned values throughout to make
1058    sure there are no implicit sign extensions.  */
1059
1060 static void
1061 do_cint_test (ULONGEST dest_valu, ULONGEST dest_vals, int dest_size,
1062               ULONGEST src_val, int src_size)
1063 {
1064   for (int i = 0; i < 2 ; i++)
1065     {
1066       gdb_byte srcbuf[sizeof (ULONGEST)] = {};
1067       gdb_byte destbuf[sizeof (ULONGEST)] = {};
1068       enum bfd_endian byte_order = i ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
1069
1070       /* Fill the src buffer (and later the dest buffer) with non-zero junk,
1071          to ensure zero extensions aren't hidden.  */
1072       memset (srcbuf, 0xaa, sizeof (srcbuf));
1073
1074       /* Store (and later extract) using unsigned to ensure there are no sign
1075          extensions.  */
1076       store_unsigned_integer (srcbuf, src_size, byte_order, src_val);
1077
1078       /* Test unsigned.  */
1079       memset (destbuf, 0xaa, sizeof (destbuf));
1080       copy_integer_to_size (destbuf, dest_size, srcbuf, src_size, false,
1081                             byte_order);
1082       SELF_CHECK (dest_valu == extract_unsigned_integer (destbuf, dest_size,
1083                                                          byte_order));
1084
1085       /* Test signed.  */
1086       memset (destbuf, 0xaa, sizeof (destbuf));
1087       copy_integer_to_size (destbuf, dest_size, srcbuf, src_size, true,
1088                             byte_order);
1089       SELF_CHECK (dest_vals == extract_unsigned_integer (destbuf, dest_size,
1090                                                          byte_order));
1091     }
1092 }
1093
1094 static void
1095 copy_integer_to_size_test ()
1096 {
1097   /* Destination is bigger than the source, which has the signed bit unset.  */
1098   do_cint_test (0x12345678, 0x12345678, 8, 0x12345678, 4);
1099   do_cint_test (0x345678, 0x345678, 8, 0x12345678, 3);
1100
1101   /* Destination is bigger than the source, which has the signed bit set.  */
1102   do_cint_test (0xdeadbeef, 0xffffffffdeadbeef, 8, 0xdeadbeef, 4);
1103   do_cint_test (0xadbeef, 0xffffffffffadbeef, 8, 0xdeadbeef, 3);
1104
1105   /* Destination is smaller than the source.  */
1106   do_cint_test (0x5678, 0x5678, 2, 0x12345678, 3);
1107   do_cint_test (0xbeef, 0xbeef, 2, 0xdeadbeef, 3);
1108
1109   /* Destination and source are the same size.  */
1110   do_cint_test (0x8765432112345678, 0x8765432112345678, 8, 0x8765432112345678,
1111                 8);
1112   do_cint_test (0x432112345678, 0x432112345678, 6, 0x8765432112345678, 6);
1113   do_cint_test (0xfeedbeaddeadbeef, 0xfeedbeaddeadbeef, 8, 0xfeedbeaddeadbeef,
1114                 8);
1115   do_cint_test (0xbeaddeadbeef, 0xbeaddeadbeef, 6, 0xfeedbeaddeadbeef, 6);
1116
1117   /* Destination is bigger than the source.  Source is bigger than 32bits.  */
1118   do_cint_test (0x3412345678, 0x3412345678, 8, 0x3412345678, 6);
1119   do_cint_test (0xff12345678, 0xff12345678, 8, 0xff12345678, 6);
1120   do_cint_test (0x432112345678, 0x432112345678, 8, 0x8765432112345678, 6);
1121   do_cint_test (0xff2112345678, 0xffffff2112345678, 8, 0xffffff2112345678, 6);
1122 }
1123
1124 } // namespace findvar_test
1125 } // namespace selftests
1126
1127 #endif
1128
1129 void
1130 _initialize_findvar (void)
1131 {
1132 #if GDB_SELF_TEST
1133   register_self_test (selftests::findvar_tests::copy_integer_to_size_test);
1134 #endif
1135 }