gdb/findvar.c

   1 /* Find a variable's value in memory, for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
   4    1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2007, 2008, 2009,
   5    2010 Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "frame.h"
  26 #include "value.h"
  27 #include "gdbcore.h"
  28 #include "inferior.h"
  29 #include "target.h"
  30 #include "gdb_string.h"
  31 #include "gdb_assert.h"
  32 #include "floatformat.h"
  33 #include "symfile.h"            /* for overlay functions */
  34 #include "regcache.h"
  35 #include "user-regs.h"
  36 #include "block.h"
  37 #include "objfiles.h"
  38
  39 /* Basic byte-swapping routines.  All 'extract' functions return a
  40    host-format integer from a target-format integer at ADDR which is
  41    LEN bytes long.  */
  42
  43 #if TARGET_CHAR_BIT != 8 || HOST_CHAR_BIT != 8
  44   /* 8 bit characters are a pretty safe assumption these days, so we
  45      assume it throughout all these swapping routines.  If we had to deal with
  46      9 bit characters, we would need to make len be in bits and would have
  47      to re-write these routines...  */
  48 you lose
  49 #endif
  50
  51 LONGEST
  52 extract_signed_integer (const gdb_byte *addr, int len,
  53                         enum bfd_endian byte_order)
  54 {
  55   LONGEST retval;
  56   const unsigned char *p;
  57   const unsigned char *startaddr = addr;
  58   const unsigned char *endaddr = startaddr + len;
  59
  60   if (len > (int) sizeof (LONGEST))
  61     error (_("\
  62 That operation is not available on integers of more than %d bytes."),
  63            (int) sizeof (LONGEST));
  64
  65   /* Start at the most significant end of the integer, and work towards
  66      the least significant.  */
  67   if (byte_order == BFD_ENDIAN_BIG)
  68     {
  69       p = startaddr;
  70       /* Do the sign extension once at the start.  */
  71       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  72       for (++p; p < endaddr; ++p)
  73         retval = (retval << 8) | *p;
  74     }
  75   else
  76     {
  77       p = endaddr - 1;
  78       /* Do the sign extension once at the start.  */
  79       retval = ((LONGEST) * p ^ 0x80) - 0x80;
  80       for (--p; p >= startaddr; --p)
  81         retval = (retval << 8) | *p;
  82     }
  83   return retval;
  84 }
  85
  86 ULONGEST
  87 extract_unsigned_integer (const gdb_byte *addr, int len,
  88                           enum bfd_endian byte_order)
  89 {
  90   ULONGEST retval;
  91   const unsigned char *p;
  92   const unsigned char *startaddr = addr;
  93   const unsigned char *endaddr = startaddr + len;
  94
  95   if (len > (int) sizeof (ULONGEST))
  96     error (_("\
  97 That operation is not available on integers of more than %d bytes."),
  98            (int) sizeof (ULONGEST));
  99
 100   /* Start at the most significant end of the integer, and work towards
 101      the least significant.  */
 102   retval = 0;
 103   if (byte_order == BFD_ENDIAN_BIG)
 104     {
 105       for (p = startaddr; p < endaddr; ++p)
 106         retval = (retval << 8) | *p;
 107     }
 108   else
 109     {
 110       for (p = endaddr - 1; p >= startaddr; --p)
 111         retval = (retval << 8) | *p;
 112     }
 113   return retval;
 114 }
 115
 116 /* Sometimes a long long unsigned integer can be extracted as a
 117    LONGEST value.  This is done so that we can print these values
 118    better.  If this integer can be converted to a LONGEST, this
 119    function returns 1 and sets *PVAL.  Otherwise it returns 0.  */
 120
 121 int
 122 extract_long_unsigned_integer (const gdb_byte *addr, int orig_len,
 123                                enum bfd_endian byte_order, LONGEST *pval)
 124 {
 125   const gdb_byte *p;
 126   const gdb_byte *first_addr;
 127   int len;
 128
 129   len = orig_len;
 130   if (byte_order == BFD_ENDIAN_BIG)
 131     {
 132       for (p = addr;
 133            len > (int) sizeof (LONGEST) && p < addr + orig_len;
 134            p++)
 135         {
 136           if (*p == 0)
 137             len--;
 138           else
 139             break;
 140         }
 141       first_addr = p;
 142     }
 143   else
 144     {
 145       first_addr = addr;
 146       for (p = addr + orig_len - 1;
 147            len > (int) sizeof (LONGEST) && p >= addr;
 148            p--)
 149         {
 150           if (*p == 0)
 151             len--;
 152           else
 153             break;
 154         }
 155     }
 156
 157   if (len <= (int) sizeof (LONGEST))
 158     {
 159       *pval = (LONGEST) extract_unsigned_integer (first_addr,
 160                                                   sizeof (LONGEST),
 161                                                   byte_order);
 162       return 1;
 163     }
 164
 165   return 0;
 166 }
 167
 168
 169 /* Treat the bytes at BUF as a pointer of type TYPE, and return the
 170    address it represents.  */
 171 CORE_ADDR
 172 extract_typed_address (const gdb_byte *buf, struct type *type)
 173 {
 174   if (TYPE_CODE (type) != TYPE_CODE_PTR
 175       && TYPE_CODE (type) != TYPE_CODE_REF)
 176     internal_error (__FILE__, __LINE__,
 177                     _("extract_typed_address: "
 178                     "type is not a pointer or reference"));
 179
 180   return gdbarch_pointer_to_address (get_type_arch (type), type, buf);
 181 }
 182
 183 /* All 'store' functions accept a host-format integer and store a
 184    target-format integer at ADDR which is LEN bytes long.  */
 185
 186 void
 187 store_signed_integer (gdb_byte *addr, int len,
 188                       enum bfd_endian byte_order, LONGEST val)
 189 {
 190   gdb_byte *p;
 191   gdb_byte *startaddr = addr;
 192   gdb_byte *endaddr = startaddr + len;
 193
 194   /* Start at the least significant end of the integer, and work towards
 195      the most significant.  */
 196   if (byte_order == BFD_ENDIAN_BIG)
 197     {
 198       for (p = endaddr - 1; p >= startaddr; --p)
 199         {
 200           *p = val & 0xff;
 201           val >>= 8;
 202         }
 203     }
 204   else
 205     {
 206       for (p = startaddr; p < endaddr; ++p)
 207         {
 208           *p = val & 0xff;
 209           val >>= 8;
 210         }
 211     }
 212 }
 213
 214 void
 215 store_unsigned_integer (gdb_byte *addr, int len,
 216                         enum bfd_endian byte_order, ULONGEST val)
 217 {
 218   unsigned char *p;
 219   unsigned char *startaddr = (unsigned char *) addr;
 220   unsigned char *endaddr = startaddr + len;
 221
 222   /* Start at the least significant end of the integer, and work towards
 223      the most significant.  */
 224   if (byte_order == BFD_ENDIAN_BIG)
 225     {
 226       for (p = endaddr - 1; p >= startaddr; --p)
 227         {
 228           *p = val & 0xff;
 229           val >>= 8;
 230         }
 231     }
 232   else
 233     {
 234       for (p = startaddr; p < endaddr; ++p)
 235         {
 236           *p = val & 0xff;
 237           val >>= 8;
 238         }
 239     }
 240 }
 241
 242 /* Store the address ADDR as a pointer of type TYPE at BUF, in target
 243    form.  */
 244 void
 245 store_typed_address (gdb_byte *buf, struct type *type, CORE_ADDR addr)
 246 {
 247   if (TYPE_CODE (type) != TYPE_CODE_PTR
 248       && TYPE_CODE (type) != TYPE_CODE_REF)
 249     internal_error (__FILE__, __LINE__,
 250                     _("store_typed_address: "
 251                     "type is not a pointer or reference"));
 252
 253   gdbarch_address_to_pointer (get_type_arch (type), type, buf, addr);
 254 }
 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   CORE_ADDR addr;
 267   int optim;
 268   struct value *reg_val;
 269   int realnum;
 270   gdb_byte raw_buffer[MAX_REGISTER_SIZE];
 271   enum lval_type lval;
 272
 273   /* User registers lie completely outside of the range of normal
 274      registers.  Catch them early so that the target never sees them.  */
 275   if (regnum >= gdbarch_num_regs (gdbarch)
 276                 + gdbarch_num_pseudo_regs (gdbarch))
 277     return value_of_user_reg (regnum, frame);
 278
 279   frame_register (frame, regnum, &optim, &lval, &addr, &realnum, raw_buffer);
 280
 281   reg_val = allocate_value (register_type (gdbarch, regnum));
 282
 283   memcpy (value_contents_raw (reg_val), raw_buffer,
 284           register_size (gdbarch, regnum));
 285   VALUE_LVAL (reg_val) = lval;
 286   set_value_address (reg_val, addr);
 287   VALUE_REGNUM (reg_val) = regnum;
 288   set_value_optimized_out (reg_val, optim);
 289   VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
 290   return reg_val;
 291 }
 292
 293 /* Return a `value' with the contents of (virtual or cooked) register
 294    REGNUM as found in the specified FRAME.  The register's type is
 295    determined by register_type().  The value is not fetched.  */
 296
 297 struct value *
 298 value_of_register_lazy (struct frame_info *frame, int regnum)
 299 {
 300   struct gdbarch *gdbarch = get_frame_arch (frame);
 301   struct value *reg_val;
 302
 303   gdb_assert (regnum < (gdbarch_num_regs (gdbarch)
 304                         + gdbarch_num_pseudo_regs (gdbarch)));
 305
 306   /* We should have a valid (i.e. non-sentinel) frame.  */
 307   gdb_assert (frame_id_p (get_frame_id (frame)));
 308
 309   reg_val = allocate_value (register_type (gdbarch, regnum));
 310   VALUE_LVAL (reg_val) = lval_register;
 311   VALUE_REGNUM (reg_val) = regnum;
 312   VALUE_FRAME_ID (reg_val) = get_frame_id (frame);
 313   set_value_lazy (reg_val, 1);
 314   return reg_val;
 315 }
 316
 317 /* Given a pointer of type TYPE in target form in BUF, return the
 318    address it represents.  */
 319 CORE_ADDR
 320 unsigned_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   return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order);
 325 }
 326
 327 CORE_ADDR
 328 signed_pointer_to_address (struct gdbarch *gdbarch,
 329                            struct type *type, const gdb_byte *buf)
 330 {
 331   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 332   return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order);
 333 }
 334
 335 /* Given an address, store it as a pointer of type TYPE in target
 336    format in BUF.  */
 337 void
 338 unsigned_address_to_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   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 = gdbarch_byte_order (gdbarch);
 350   store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr);
 351 }
 352 \f
 353 /* Will calling read_var_value or locate_var_value on SYM end
 354    up caring what frame it is being evaluated relative to?  SYM must
 355    be non-NULL.  */
 356 int
 357 symbol_read_needs_frame (struct symbol *sym)
 358 {
 359   switch (SYMBOL_CLASS (sym))
 360     {
 361       /* All cases listed explicitly so that gcc -Wall will detect it if
 362          we failed to consider one.  */
 363     case LOC_COMPUTED:
 364       /* FIXME: cagney/2004-01-26: It should be possible to
 365          unconditionally call the SYMBOL_COMPUTED_OPS method when available.
 366          Unfortunately DWARF 2 stores the frame-base (instead of the
 367          function) location in a function's symbol.  Oops!  For the
 368          moment enable this when/where applicable.  */
 369       return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym);
 370
 371     case LOC_REGISTER:
 372     case LOC_ARG:
 373     case LOC_REF_ARG:
 374     case LOC_REGPARM_ADDR:
 375     case LOC_LOCAL:
 376       return 1;
 377
 378     case LOC_UNDEF:
 379     case LOC_CONST:
 380     case LOC_STATIC:
 381     case LOC_TYPEDEF:
 382
 383     case LOC_LABEL:
 384       /* Getting the address of a label can be done independently of the block,
 385          even if some *uses* of that address wouldn't work so well without
 386          the right frame.  */
 387
 388     case LOC_BLOCK:
 389     case LOC_CONST_BYTES:
 390     case LOC_UNRESOLVED:
 391     case LOC_OPTIMIZED_OUT:
 392       return 0;
 393     }
 394   return 1;
 395 }
 396
 397 /* Given a struct symbol for a variable,
 398    and a stack frame id, read the value of the variable
 399    and return a (pointer to a) struct value containing the value.
 400    If the variable cannot be found, return a zero pointer.  */
 401
 402 struct value *
 403 read_var_value (struct symbol *var, struct frame_info *frame)
 404 {
 405   struct value *v;
 406   struct type *type = SYMBOL_TYPE (var);
 407   CORE_ADDR addr;
 408   int len;
 409
 410   if (SYMBOL_CLASS (var) == LOC_COMPUTED
 411       || SYMBOL_CLASS (var) == LOC_REGISTER)
 412     /* These cases do not use V.  */
 413     v = NULL;
 414   else
 415     {
 416       v = allocate_value (type);
 417       VALUE_LVAL (v) = lval_memory;     /* The most likely possibility.  */
 418     }
 419
 420   len = TYPE_LENGTH (type);
 421
 422   if (symbol_read_needs_frame (var))
 423     gdb_assert (frame);
 424
 425   switch (SYMBOL_CLASS (var))
 426     {
 427     case LOC_CONST:
 428       /* Put the constant back in target format.  */
 429       store_signed_integer (value_contents_raw (v), len,
 430                             gdbarch_byte_order (get_type_arch (type)),
 431                             (LONGEST) SYMBOL_VALUE (var));
 432       VALUE_LVAL (v) = not_lval;
 433       return v;
 434
 435     case LOC_LABEL:
 436       /* Put the constant back in target format.  */
 437       if (overlay_debugging)
 438         {
 439           CORE_ADDR addr
 440             = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 441                                         SYMBOL_OBJ_SECTION (var));
 442           store_typed_address (value_contents_raw (v), type, addr);
 443         }
 444       else
 445         store_typed_address (value_contents_raw (v), type,
 446                               SYMBOL_VALUE_ADDRESS (var));
 447       VALUE_LVAL (v) = not_lval;
 448       return v;
 449
 450     case LOC_CONST_BYTES:
 451       {
 452         memcpy (value_contents_raw (v), SYMBOL_VALUE_BYTES (var), len);
 453         VALUE_LVAL (v) = not_lval;
 454         return v;
 455       }
 456
 457     case LOC_STATIC:
 458       if (overlay_debugging)
 459         addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (var),
 460                                          SYMBOL_OBJ_SECTION (var));
 461       else
 462         addr = SYMBOL_VALUE_ADDRESS (var);
 463       break;
 464
 465     case LOC_ARG:
 466       addr = get_frame_args_address (frame);
 467       if (!addr)
 468         return 0;
 469       addr += SYMBOL_VALUE (var);
 470       break;
 471
 472     case LOC_REF_ARG:
 473       {
 474         struct value *ref;
 475         CORE_ADDR argref;
 476         argref = get_frame_args_address (frame);
 477         if (!argref)
 478           return 0;
 479         argref += SYMBOL_VALUE (var);
 480         ref = value_at (lookup_pointer_type (type), argref);
 481         addr = value_as_address (ref);
 482         break;
 483       }
 484
 485     case LOC_LOCAL:
 486       addr = get_frame_locals_address (frame);
 487       addr += SYMBOL_VALUE (var);
 488       break;
 489
 490     case LOC_TYPEDEF:
 491       error (_("Cannot look up value of a typedef"));
 492       break;
 493
 494     case LOC_BLOCK:
 495       if (overlay_debugging)
 496         set_value_address (v, symbol_overlayed_address
 497           (BLOCK_START (SYMBOL_BLOCK_VALUE (var)), SYMBOL_OBJ_SECTION (var)));
 498       else
 499         set_value_address (v, BLOCK_START (SYMBOL_BLOCK_VALUE (var)));
 500       return v;
 501
 502     case LOC_REGISTER:
 503     case LOC_REGPARM_ADDR:
 504       {
 505         int regno = SYMBOL_REGISTER_OPS (var)
 506                       ->register_number (var, get_frame_arch (frame));
 507         struct value *regval;
 508
 509         if (SYMBOL_CLASS (var) == LOC_REGPARM_ADDR)
 510           {
 511             regval = value_from_register (lookup_pointer_type (type),
 512                                           regno,
 513                                           frame);
 514
 515             if (regval == NULL)
 516               error (_("Value of register variable not available."));
 517
 518             addr = value_as_address (regval);
 519             VALUE_LVAL (v) = lval_memory;
 520           }
 521         else
 522           {
 523             regval = value_from_register (type, regno, frame);
 524
 525             if (regval == NULL)
 526               error (_("Value of register variable not available."));
 527             return regval;
 528           }
 529       }
 530       break;
 531
 532     case LOC_COMPUTED:
 533       /* FIXME: cagney/2004-01-26: It should be possible to
 534          unconditionally call the SYMBOL_COMPUTED_OPS method when available.
 535          Unfortunately DWARF 2 stores the frame-base (instead of the
 536          function) location in a function's symbol.  Oops!  For the
 537          moment enable this when/where applicable.  */
 538       return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
 539
 540     case LOC_UNRESOLVED:
 541       {
 542         struct minimal_symbol *msym;
 543         struct obj_section *obj_section;
 544
 545         msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (var), NULL, NULL);
 546         if (msym == NULL)
 547           return 0;
 548         if (overlay_debugging)
 549           addr = symbol_overlayed_address (SYMBOL_VALUE_ADDRESS (msym),
 550                                            SYMBOL_OBJ_SECTION (msym));
 551         else
 552           addr = SYMBOL_VALUE_ADDRESS (msym);
 553
 554         obj_section = SYMBOL_OBJ_SECTION (msym);
 555         if (obj_section
 556             && (obj_section->the_bfd_section->flags & SEC_THREAD_LOCAL) != 0)
 557           addr = target_translate_tls_address (obj_section->objfile, addr);
 558       }
 559       break;
 560
 561     case LOC_OPTIMIZED_OUT:
 562       VALUE_LVAL (v) = not_lval;
 563       set_value_optimized_out (v, 1);
 564       return v;
 565
 566     default:
 567       error (_("Cannot look up value of a botched symbol."));
 568       break;
 569     }
 570
 571   set_value_address (v, addr);
 572   set_value_lazy (v, 1);
 573   return v;
 574 }
 575
 576 /* Install default attributes for register values.  */
 577
 578 struct value *
 579 default_value_from_register (struct type *type, int regnum,
 580                              struct frame_info *frame)
 581 {
 582   struct gdbarch *gdbarch = get_frame_arch (frame);
 583   int len = TYPE_LENGTH (type);
 584   struct value *value = allocate_value (type);
 585
 586   VALUE_LVAL (value) = lval_register;
 587   VALUE_FRAME_ID (value) = get_frame_id (frame);
 588   VALUE_REGNUM (value) = regnum;
 589
 590   /* Any structure stored in more than one register will always be
 591      an integral number of registers.  Otherwise, you need to do
 592      some fiddling with the last register copied here for little
 593      endian machines.  */
 594   if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG
 595       && len < register_size (gdbarch, regnum))
 596     /* Big-endian, and we want less than full size.  */
 597     set_value_offset (value, register_size (gdbarch, regnum) - len);
 598   else
 599     set_value_offset (value, 0);
 600
 601   return value;
 602 }
 603
 604 /* Return a value of type TYPE, stored in register REGNUM, in frame FRAME.  */
 605
 606 struct value *
 607 value_from_register (struct type *type, int regnum, struct frame_info *frame)
 608 {
 609   struct gdbarch *gdbarch = get_frame_arch (frame);
 610   struct type *type1 = check_typedef (type);
 611   struct value *v;
 612
 613   if (gdbarch_convert_register_p (gdbarch, regnum, type1))
 614     {
 615       /* The ISA/ABI need to something weird when obtaining the
 616          specified value from this register.  It might need to
 617          re-order non-adjacent, starting with REGNUM (see MIPS and
 618          i386).  It might need to convert the [float] register into
 619          the corresponding [integer] type (see Alpha).  The assumption
 620          is that gdbarch_register_to_value populates the entire value
 621          including the location.  */
 622       v = allocate_value (type);
 623       VALUE_LVAL (v) = lval_register;
 624       VALUE_FRAME_ID (v) = get_frame_id (frame);
 625       VALUE_REGNUM (v) = regnum;
 626       gdbarch_register_to_value (gdbarch,
 627                                  frame, regnum, type1, value_contents_raw (v));
 628     }
 629   else
 630     {
 631       int len = TYPE_LENGTH (type);
 632
 633       /* Construct the value.  */
 634       v = gdbarch_value_from_register (gdbarch, type, regnum, frame);
 635
 636       /* Get the data.  */
 637       if (!get_frame_register_bytes (frame, regnum, value_offset (v), len,
 638                                      value_contents_raw (v)))
 639         set_value_optimized_out (v, 1);
 640     }
 641   return v;
 642 }
 643
 644 /* Return contents of register REGNUM in frame FRAME as address,
 645    interpreted as value of type TYPE.   Will abort if register
 646    value is not available.  */
 647
 648 CORE_ADDR
 649 address_from_register (struct type *type, int regnum, struct frame_info *frame)
 650 {
 651   struct value *value;
 652   CORE_ADDR result;
 653
 654   value = value_from_register (type, regnum, frame);
 655   gdb_assert (value);
 656
 657   result = value_as_address (value);
 658   release_value (value);
 659   value_free (value);
 660
 661   return result;
 662 }