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