gdb/findvar.c

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