gdb/findvar.c

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