gdb/findvar.c

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